Merge pull request #3 from pomponchik/develop

0.0.3

Author: pomponchik

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "transfunctions"
-version = "0.0.2"
+version = "0.0.3"
 authors = [
   { name="Evgeniy Blinov", email="zheni-b@yandex.ru" },
 ]
@@ -14,6 +14,7 @@ requires-python = ">=3.8"
 dependencies = [
     'displayhooks>=0.0.4',
     'dill==0.4.0',
+    'typing_extensions ; python_version <= "3.10"',
 ]
 classifiers = [
     "Operating System :: OS Independent",
@@ -37,6 +38,9 @@ keywords = [
     'async',
     'sync to async',
     'async to sync',
+    'code generation',
+    'ast manipulation',
+    'magic',
 ]
 
 [tool.setuptools.package-data]

transfunctions/decorators/superfunction.py

@@ -1,6 +1,6 @@
 import sys
 import weakref
-from ast import NodeTransformer, Expr, AST
+from ast import NodeTransformer, Return, AST
 from inspect import currentframe
 from functools import wraps
 from typing import Dict, Any, Optional, Union, List
@@ -42,10 +42,7 @@ def __await__(self) -> Any:  # pragma: no cover
         return self.coroutine.__await__()
 
     def __invert__(self):
-        print(self.finalizer)
-        print(self.finalizer.alive)
         result = self.finalizer()
-        print('result:', result)
         return result
 
     def send(self, value: Any) -> Any:
@@ -73,7 +70,7 @@ async def async_sleep_option(flags: Dict[str, bool], args, kwargs, transformer)
 
 def superfunction(function):
     class NoReturns(NodeTransformer):
-        def visit_Return(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+        def visit_Return(self, node: Return) -> Optional[Union[AST, List[AST]]]:
             raise WrongTransfunctionSyntaxError('A superfunction cannot contain a return statement.')
 
     transformer = FunctionTransformer(

transfunctions/markers.py

@@ -1,24 +1,24 @@
-from typing import Any
+from typing import Any, NoReturn, Generator
 from contextlib import contextmanager
 
 
 @contextmanager
-def create_async_context():
-    yield
+def create_async_context() -> Generator[NoReturn, None, None]:
+    yield  # type: ignore[misc]  # pragma: no cover
 
 @contextmanager
-def create_sync_context():
-    yield
+def create_sync_context() -> Generator[NoReturn, None, None]:
+    yield  # type: ignore[misc]  # pragma: no cover
 
 @contextmanager
-def create_generator_context():
-    yield
+def create_generator_context() -> Generator[NoReturn, None, None]:
+    yield  # type: ignore[misc]  # pragma: no cover
 
 
 async_context = create_async_context()
 sync_context = create_sync_context()
 generator_context = create_generator_context()
 
 
-def await_it(some_expression: Any):
-    pass
+def await_it(some_expression: Any) -> Any:
+    pass   # pragma: no cover

transfunctions/transformer.py

@@ -1,12 +1,12 @@
 from sys import version_info
-from typing import Optional, Union, List, Any
+from typing import Optional, Union, List, Dict, Any
 from types import MethodType, FunctionType
 from collections.abc import Callable
 from inspect import isfunction, iscoroutinefunction, getsource, getfile
-from ast import parse, NodeTransformer, Expr, AST, FunctionDef, AsyncFunctionDef, increment_lineno, Await, Return, Name, Load, Assign, Constant, Store, arguments
+from ast import parse, NodeTransformer, AST, FunctionDef, AsyncFunctionDef, increment_lineno, Await, Call, With, Return, Name, Load, Assign, Constant, Store, arguments
 from functools import wraps, update_wrapper
 
-from dill.source import getsource as dill_getsource
+from dill.source import getsource as dill_getsource  # type: ignore[import-untyped]
 
 from transfunctions.errors import CallTransfunctionDirectlyError, DualUseOfDecoratorError, WrongDecoratorSyntaxError
 
@@ -27,7 +27,7 @@ def __init__(self, function: Callable, decorator_lineno: int, decorator_name: st
         self.decorator_name = decorator_name
         self.extra_transformers = extra_transformers
         self.base_object = None
-        self.cache = {}
+        self.cache: Dict[str, Callable] = {}
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         raise CallTransfunctionDirectlyError("You can't call a transfunction object directly, create a function, a generator function or a coroutine function from it.")
@@ -49,7 +49,7 @@ def get_async_function(self):
         original_function = self.function
 
         class ConvertSyncFunctionToAsync(NodeTransformer):
-            def visit_FunctionDef(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+            def visit_FunctionDef(self, node: FunctionDef) -> Optional[Union[AST, List[AST]]]:
                 if node.name == original_function.__name__:
                     return AsyncFunctionDef(
                         name=original_function.__name__,
@@ -62,7 +62,7 @@ def visit_FunctionDef(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
                 return node
 
         class ExtractAwaitExpressions(NodeTransformer):
-            def visit_Call(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+            def visit_Call(self, node: Call) -> Optional[Union[AST, List[AST]]]:
                 if node.func.id == 'await_it':
                     return Await(
                         value=node.args[0],
@@ -102,7 +102,7 @@ def extract_context(self, context_name: str, addictional_transformers: Optional[
         if context_name in self.cache:
             return self.cache[context_name]
         try:
-            source_code = getsource(self.function)
+            source_code: str = getsource(self.function)
         except OSError:
             source_code = dill_getsource(self.function)
 
@@ -119,15 +119,15 @@ def extract_context(self, context_name: str, addictional_transformers: Optional[
         decorator_name = self.decorator_name
 
         class RewriteContexts(NodeTransformer):
-            def visit_With(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+            def visit_With(self, node: With) -> Optional[Union[AST, List[AST]]]:
                 if len(node.items) == 1 and node.items[0].context_expr.id == context_name:
                     return node.body
                 elif len(node.items) == 1 and node.items[0].context_expr.id != context_name and context_name in ('async_context', 'sync_context', 'generator_context'):
                     return None
                 return node
 
         class DeleteDecorator(NodeTransformer):
-            def visit_FunctionDef(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+            def visit_FunctionDef(self, node: FunctionDef) -> Optional[Union[AST, List[AST]]]:
                 if node.name == original_function.__name__:
                     nonlocal transfunction_decorator
                     transfunction_decorator = None
@@ -161,7 +161,7 @@ def visit_FunctionDef(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
             increment_lineno(tree, n=(self.decorator_lineno - transfunction_decorator.lineno - 1))
 
         code = compile(tree, filename=getfile(self.function), mode='exec')
-        namespace = {}
+        namespace: Dict[str, Callable] = {}
         exec(code, namespace)
         function_factory = namespace['wrapper']
         result = function_factory()