Add type hinting

Lots of functions were using *args and **kwargs that were kind of
useless with type hinting, so I explicitly named every possible argument
and its type. It breaks backward compatibility (sort of) because you can
pass nonsense arguments anymore.

frida/__init__.py

@@ -1,3 +1,5 @@
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
 try:
     import _frida
 except Exception as ex:
@@ -14,7 +16,7 @@ except Exception as ex:
     raise ex
 from . import core
 
-__version__ = _frida.__version__
+__version__: str = _frida.__version__
 
 get_device_manager = core.get_device_manager
 Relay = _frida.Relay
@@ -40,58 +42,66 @@ TransportError = _frida.TransportError
 OperationCancelledError = _frida.OperationCancelledError
 
 
-def query_system_parameters(**kwargs):
-    return get_local_device().query_system_parameters(**kwargs)
+def query_system_parameters() -> Dict[str, Any]:
+    return get_local_device().query_system_parameters()
 
 
-def spawn(*args, **kwargs):
-    return get_local_device().spawn(*args, **kwargs)
+def spawn(
+    program: Union[str, List[Union[str, bytes]], Tuple[Union[str, bytes]]],
+    argv: Union[None, List[Union[str, bytes]], Tuple[Union[str, bytes]]] = None,
+    envp: Optional[Dict[str, str]] = None,
+    env: Optional[Dict[str, str]] = None,
+    cwd: Optional[str] = None,
+    stdio: Optional[str] = None,
+    **kwargs: Any,
+) -> int:
+    return get_local_device().spawn(program=program, argv=argv, envp=envp, env=env, cwd=cwd, stdio=stdio, **kwargs)
 
 
-def resume(target, **kwargs):
-    get_local_device().resume(target, **kwargs)
+def resume(target: core.ProcessTarget) -> None:
+    get_local_device().resume(target)
 
 
-def kill(target, **kwargs):
-    get_local_device().kill(target, **kwargs)
+def kill(target: core.ProcessTarget) -> None:
+    get_local_device().kill(target)
 
 
-def attach(target, *args, **kwargs):
-    return get_local_device().attach(target, *args, **kwargs)
+def attach(target: Union[int, str], realm: Optional[str] = None, persist_timeout: Optional[int] = None) -> core.Session:
+    return get_local_device().attach(target, realm=realm, persist_timeout=persist_timeout)
 
 
-def inject_library_file(target, path, entrypoint, data, **kwargs):
-    return get_local_device().inject_library_file(target, path, entrypoint, data, **kwargs)
+def inject_library_file(target: Union[int, str], path: str, entrypoint: str, data: str) -> int:
+    return get_local_device().inject_library_file(target, path, entrypoint, data)
 
 
-def inject_library_blob(target, blob, entrypoint, data, **kwargs):
-    return get_local_device().inject_library_blob(target, blob, entrypoint, data, **kwargs)
+def inject_library_blob(target: Union[int, str], blob: bytes, entrypoint: str, data: str) -> int:
+    return get_local_device().inject_library_blob(target, blob, entrypoint, data)
 
 
-def get_local_device(**kwargs):
-    return get_device_matching(lambda d: d.type == "local", timeout=0, **kwargs)
+def get_local_device() -> core.Device:
+    return get_device_matching(lambda d: d.type == "local", timeout=0)
 
 
-def get_remote_device(**kwargs):
-    return get_device_matching(lambda d: d.type == "remote", timeout=0, **kwargs)
+def get_remote_device() -> core.Device:
+    return get_device_matching(lambda d: d.type == "remote", timeout=0)
 
 
-def get_usb_device(timeout=0, **kwargs):
-    return get_device_matching(lambda d: d.type == "usb", timeout, **kwargs)
+def get_usb_device(timeout: int = 0) -> core.Device:
+    return get_device_matching(lambda d: d.type == "usb", timeout)
 
 
-def get_device(id, timeout=0, **kwargs):
-    return get_device_manager().get_device(id, timeout, **kwargs)
+def get_device(id: Optional[str], timeout: int = 0) -> core.Device:
+    return get_device_manager().get_device(id, timeout)
 
 
-def get_device_matching(predicate, timeout=0, **kwargs):
-    return get_device_manager().get_device_matching(predicate, timeout, **kwargs)
+def get_device_matching(predicate: Callable[[core.Device], bool], timeout: int = 0) -> core.Device:
+    return get_device_manager().get_device_matching(predicate, timeout)
 
 
-def enumerate_devices(**kwargs):
-    return get_device_manager().enumerate_devices(**kwargs)
+def enumerate_devices() -> List[core.Device]:
+    return get_device_manager().enumerate_devices()
 
 
 @core.cancellable
-def shutdown():
+def shutdown() -> None:
     get_device_manager()._impl.close()

setup.py

@@ -299,6 +299,7 @@ if __name__ == "__main__":
             "Topic :: Software Development :: Libraries :: Python Modules",
         ],
         packages=["frida"],
+        package_data={"frida": ["py.typed"]},
         ext_modules=[Extension("_frida", [])],
         cmdclass={"build_ext": FridaPrebuiltExt},
         zip_safe=False,