Type fix base (#419)

* Remove stubs and add inline typing

Fix ty type checking issues

* Port latest util_static code

* Remove line_profiler.pyi

* Minor type fixes

* Fix Cython test environment issues in dev container

- Set PIP_NO_BINARY=Cython to build Cython from source, avoiding mmap issues
- Fall back to non-editable install if editable install fails due to .so mapping errors
- These changes fix compatibility with container environments that have memory mapping restrictions

This allows the tests to run properly and fail on actual test logic rather than environment issues.

* Fix cython regression

* Fix type errors

* Fix type annotations on 3.8

* Update reqs

* Fix some types

* Add future annots to tests

* Fix type error in 38

* Fix another 38 type error

* Revert test cython changes

* Fix mypy errors

* Fix mypy issues

* Revert ipython types

* Final fixes for mypy and ty checks

* wip

* Add typing ignore lines to coverage

* fix

* Fix

---------

Co-authored-by: Test User <test@example.com>

Author: Erotemic

CHANGELOG.rst

@@ -1,6 +1,12 @@
 Changes
 =======
 
+
+5.0.1
+~~~~~
+* ENH: improved type annotations and moved them inline
+
+
 5.0.1
 ~~~~~
 * FIX: Prevented duplicate or inconsistent profiler output under Python 3.14 when multiprocessing is used.

line_profiler/__main__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from .line_profiler import main
 
 if __name__ == '__main__':

line_profiler/__main__.pyi

@@ -71,10 +71,10 @@ def _boolean_environ(
     """
     # (TODO: migrate to `line_profiler.cli_utils.boolean()` after
     # merging #335)
-    try:
-        value = os.environ.get(envvar).casefold()
-    except AttributeError:  # None
+    value = os.environ.get(envvar)
+    if value is None:
         return default
+    value = value.casefold()
     non_default_values = falsy if default else truey
     if value in {v.casefold() for v in non_default_values}:
         return not default

line_profiler/_diagnostics.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+class LineStats:
+    timings: Mapping[tuple[str, int, str], list[tuple[int, int, int]]]
+    unit: float
+
+    def __init__(
+        self,
+        timings: Mapping[tuple[str, int, str], list[tuple[int, int, int]]],
+        unit: float,
+    ) -> None: ...
+
+
+class LineProfiler:
+    def enable_by_count(self) -> None: ...
+    def disable_by_count(self) -> None: ...
+    def add_function(self, func: Any) -> None: ...
+    def get_stats(self) -> LineStats: ...
+    def dump_stats(self, filename: str) -> None: ...
+
+
+def label(code: Any) -> Any: ...

line_profiler/_line_profiler.pyi

@@ -1,7 +1,12 @@
+from __future__ import annotations
+
 import ast
+from typing import cast, Union, List
 
 
-def ast_create_profile_node(modname, profiler_name='profile', attr='add_imported_function_or_module'):
+def ast_create_profile_node(
+        modname: str, profiler_name: str = 'profile',
+        attr: str = 'add_imported_function_or_module') -> ast.Expr:
     """Create an abstract syntax tree node that adds an object to the profiler to be profiled.
 
     An abstract syntax tree node is created which calls the attr method from profile and
@@ -29,7 +34,7 @@ def ast_create_profile_node(modname, profiler_name='profile', attr='add_imported
     """
     func = ast.Attribute(value=ast.Name(id=profiler_name, ctx=ast.Load()), attr=attr, ctx=ast.Load())
     names = modname.split('.')
-    value = ast.Name(id=names[0], ctx=ast.Load())
+    value: ast.expr = ast.Name(id=names[0], ctx=ast.Load())
     for name in names[1:]:
         value = ast.Attribute(attr=name, ctx=ast.Load(), value=value)
     expr = ast.Expr(value=ast.Call(func=func, args=[value], keywords=[]))
@@ -45,7 +50,9 @@ class AstProfileTransformer(ast.NodeTransformer):
     immediately after the import.
     """
 
-    def __init__(self, profile_imports=False, profiled_imports=None, profiler_name='profile'):
+    def __init__(self, profile_imports: bool = False,
+                 profiled_imports: list[str] | None = None,
+                 profiler_name: str = 'profile') -> None:
         """Initializes the AST transformer with the profiler name.
 
         Args:
@@ -63,7 +70,9 @@ def __init__(self, profile_imports=False, profiled_imports=None, profiler_name='
         self._profiled_imports = profiled_imports if profiled_imports is not None else []
         self._profiler_name = profiler_name
 
-    def _visit_func_def(self, node):
+    def _visit_func_def(
+            self, node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> ast.FunctionDef | ast.AsyncFunctionDef:
         """Decorate functions/methods with profiler.
 
         Checks if the function/method already has a profile_name decorator, if not, it will append
@@ -81,17 +90,19 @@ def _visit_func_def(self, node):
         """
         decor_ids = set()
         for decor in node.decorator_list:
-            try:
+            if isinstance(decor, ast.Name):
                 decor_ids.add(decor.id)
-            except AttributeError:
-                ...
         if self._profiler_name not in decor_ids:
             node.decorator_list.append(ast.Name(id=self._profiler_name, ctx=ast.Load()))
-        return self.generic_visit(node)
+        self.generic_visit(node)
+        return node
 
     visit_FunctionDef = visit_AsyncFunctionDef = _visit_func_def
 
-    def _visit_import(self, node):
+    def _visit_import(
+            self, node: ast.Import | ast.ImportFrom
+    ) -> (ast.Import | ast.ImportFrom
+          | list[ast.Import | ast.ImportFrom | ast.Expr]):
         """Add a node that profiles an import
 
         If profile_imports is True and the import is not in profiled_imports,
@@ -110,8 +121,10 @@ def _visit_import(self, node):
                     returns list containing the import node and the profiling node
         """
         if not self._profile_imports:
-            return self.generic_visit(node)
-        visited = [self.generic_visit(node)]
+            self.generic_visit(node)
+            return node
+        this_visit = cast(Union[ast.Import, ast.ImportFrom], self.generic_visit(node))
+        visited: list[ast.Import | ast.ImportFrom | ast.Expr] = [this_visit]
         for names in node.names:
             node_name = names.name if names.asname is None else names.asname
             if node_name in self._profiled_imports:
@@ -121,7 +134,9 @@ def _visit_import(self, node):
             visited.append(expr)
         return visited
 
-    def visit_Import(self, node):
+    def visit_Import(
+            self, node: ast.Import
+    ) -> ast.Import | list[ast.Import | ast.Expr]:
         """Add a node that profiles an object imported using the "import foo" sytanx
 
         Args:
@@ -135,9 +150,12 @@ def visit_Import(self, node):
                 if profile_imports is True:
                     returns list containing the import node and the profiling node
         """
-        return self._visit_import(node)
+        return cast(Union[ast.Import, List[Union[ast.Import, ast.Expr]]],
+                    self._visit_import(node))
 
-    def visit_ImportFrom(self, node):
+    def visit_ImportFrom(
+            self, node: ast.ImportFrom
+    ) -> ast.ImportFrom | list[ast.ImportFrom | ast.Expr]:
         """Add a node that profiles an object imported using the "from foo import bar" syntax
 
         Args:
@@ -151,4 +169,5 @@ def visit_ImportFrom(self, node):
                 if profile_imports is True:
                     returns list containing the import node and the profiling node
         """
-        return self._visit_import(node)
+        return cast(Union[ast.ImportFrom, List[Union[ast.ImportFrom, ast.Expr]]],
+                    self._visit_import(node))

line_profiler/autoprofile/ast_profile_transformer.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import ast
 import os
+from typing import Type
 
 from .ast_profile_transformer import (AstProfileTransformer,
                                       ast_create_profile_node)
@@ -20,11 +23,11 @@ class AstTreeProfiler:
     """
 
     def __init__(self,
-                 script_file,
-                 prof_mod,
-                 profile_imports,
-                 ast_transformer_class_handler=AstProfileTransformer,
-                 profmod_extractor_class_handler=ProfmodExtractor):
+                 script_file: str,
+                 prof_mod: list[str],
+                 profile_imports: bool,
+                 ast_transformer_class_handler: Type = AstProfileTransformer,
+                 profmod_extractor_class_handler: Type = ProfmodExtractor) -> None:
         """Initializes the AST tree profiler instance with the script file path
 
         Args:
@@ -52,7 +55,8 @@ def __init__(self,
         self._profmod_extractor_class_handler = profmod_extractor_class_handler
 
     @staticmethod
-    def _check_profile_full_script(script_file, prof_mod):
+    def _check_profile_full_script(
+            script_file: str, prof_mod: list[str]) -> bool:
         """Check whether whole script should be profiled.
 
         Checks whether path to script has been passed to prof_mod indicating that
@@ -76,7 +80,7 @@ def _check_profile_full_script(script_file, prof_mod):
         return profile_full_script
 
     @staticmethod
-    def _get_script_ast_tree(script_file):
+    def _get_script_ast_tree(script_file: str) -> ast.Module:
         """Generate an abstract syntax from a script file.
 
         Args:
@@ -93,10 +97,10 @@ def _get_script_ast_tree(script_file):
         return tree
 
     def _profile_ast_tree(self,
-                          tree,
-                          tree_imports_to_profile_dict,
-                          profile_full_script=False,
-                          profile_imports=False):
+                          tree: ast.Module,
+                          tree_imports_to_profile_dict: dict[int, str],
+                          profile_full_script: bool = False,
+                          profile_imports: bool = False) -> ast.Module:
         """Add profiling to an abstract syntax tree.
 
         Adds nodes to the AST that adds the specified objects to the profiler.
@@ -139,7 +143,7 @@ def _profile_ast_tree(self,
         ast.fix_missing_locations(tree)
         return tree
 
-    def profile(self):
+    def profile(self) -> ast.Module:
         """Create an abstract syntax tree of a script and add profiling to it.
 
         Reads a script file and generates an abstract syntax tree.

line_profiler/autoprofile/ast_profile_transformer.pyi

@@ -44,12 +44,16 @@ def main():
     python -m kernprof -p demo.py -l demo.py
     python -m line_profiler -rmt demo.py.lprof
 """
+from __future__ import annotations
 import contextlib
 import functools
 import importlib.util
 import operator
 import sys
 import types
+from collections.abc import MutableMapping
+from typing import Any, cast, Dict, Mapping
+from typing import ContextManager
 from .ast_tree_profiler import AstTreeProfiler
 from .run_module import AstTreeModuleProfiler
 from .line_profiler_utils import add_imported_function_or_module
@@ -58,7 +62,7 @@ def main():
 PROFILER_LOCALS_NAME = 'prof'
 
 
-def _extend_line_profiler_for_profiling_imports(prof):
+def _extend_line_profiler_for_profiling_imports(prof: Any) -> None:
     """Allow profiler to handle functions/methods, classes & modules with a single call.
 
     Add a method to LineProfiler that can identify whether the object is a
@@ -73,7 +77,9 @@ def _extend_line_profiler_for_profiling_imports(prof):
     prof.add_imported_function_or_module = types.MethodType(add_imported_function_or_module, prof)
 
 
-def run(script_file, ns, prof_mod, profile_imports=False, as_module=False):
+def run(script_file: str, ns: MutableMapping[str, Any],
+        prof_mod: list[str], profile_imports: bool = False,
+        as_module: bool = False) -> None:
     """Automatically profile a script and run it.
 
     Profile functions, classes & modules specified in prof_mod without needing to add
@@ -98,21 +104,26 @@ def run(script_file, ns, prof_mod, profile_imports=False, as_module=False):
             Whether we're running script_file as a module
     """
     class restore_dict:
-        def __init__(self, d, target=None):
+        def __init__(self, d: MutableMapping[str, Any], target=None):
             self.d = d
             self.target = target
-            self.copy = None
+            self.copy: Mapping[str, Any] | None = None
 
         def __enter__(self):
             assert self.copy is None
-            self.copy = self.d.copy()
+            self.copy = dict(self.d)
             return self.target
 
         def __exit__(self, *_, **__):
             self.d.clear()
-            self.d.update(self.copy)
+            if self.copy is not None:
+                self.d.update(self.copy)
             self.copy = None
 
+    Profiler: type[AstTreeModuleProfiler] | type[AstTreeProfiler]
+    namespace: MutableMapping[str, Any]
+    ctx: ContextManager
+
     if as_module:
         Profiler = AstTreeModuleProfiler
         module_name = modpath_to_modname(script_file)
@@ -144,4 +155,4 @@ def __exit__(self, *_, **__):
     code_obj = compile(tree_profiled, script_file, 'exec')
     with ctx as callback:
         callback()
-        exec(code_obj, namespace, namespace)
+        exec(code_obj, cast(Dict[str, Any], namespace), namespace)