transfunctions 0.0.1__tar.gz

transfunctions-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 pomponchik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

transfunctions-0.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: transfunctions
+Version: 0.0.1
+Summary: Say NO to Python fragmentation on sync and async
+Author-email: Evgeniy Blinov <zheni-b@yandex.ru>
+Project-URL: Source, https://github.com/pomponchik/transfunctions
+Project-URL: Tracker, https://github.com/pomponchik/transfunctions/issues
+Keywords: async,sync to async,async to sync
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# transfunctions
+
+[![Downloads](https://static.pepy.tech/badge/transfunctions/month)](https://pepy.tech/project/transfunctions)
+[![Downloads](https://static.pepy.tech/badge/transfunctions)](https://pepy.tech/project/transfunctions)
+[![Coverage Status](https://coveralls.io/repos/github/pomponchik/transfunctions/badge.svg?branch=main)](https://coveralls.io/github/pomponchik/transfunctions?branch=develop)
+[![Lines of code](https://sloc.xyz/github/pomponchik/transfunctions/?category=code)](https://github.com/boyter/scc/)
+[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/transfunctions?branch=main)](https://hitsofcode.com/github/pomponchik/transfunctions/view?branch=main)
+[![Test-Package](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/transfunctions.svg)](https://pypi.python.org/pypi/transfunctions)
+[![PyPI version](https://badge.fury.io/py/transfunctions.svg)](https://badge.fury.io/py/transfunctions)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library is designed to solve one of the most important problems in python programming - dividing all written code into 2 camps: sync and async. We get rid of code duplication by using templates.
+
+
+## Table of contents
+
+- [**Quick start**](#quick-start)
+- [**The problem**](#the-problem)
+
+
+## Quick start
+
+Install it:
+
+```bash
+pip install transfunctions
+```
+
+And use:
+
+```python
+from asyncio import run
+from transfunctions import (
+    transfunction,
+    sync_context,
+    async_context,
+    generator_context,
+)
+
+@transfunction
+def template():
+    print('so, ', end='')
+    with sync_context:
+        print("it's just usual function!")
+    with async_context:
+        print("it's an async function!")
+    with generator_context:
+        print("it's a generator function!")
+        yield
+
+function = template.get_usual_function()
+function()
+#> so, it's just usual function!
+
+async_function = template.get_async_function()
+run(async_function())
+#> so, it's an async function!
+
+generator_function = template.get_generator_function()
+list(generator_function())
+#> so, it's a generator function!
+```
+
+As you can see, in this case, 3 different functions were created based on the template, including both common parts and unique ones for a specific type of function.
+
+You can also quickly try out this and other packages without having to install using [instld](https://github.com/pomponchik/instld).
+
+
+## The problem
+
+Since the `asyncio` module appeared in Python more than 10 years ago, many well-known libraries have received their asynchronous alternates. A lot of the code in the Python ecosystem has been [duplicated](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself), and you probably know many such examples.
+
+The reason for this problem is that the Python community has chosen a way to implement asynchrony expressed through syntax. There are new keywords in the language, such as `async` and `await`. Their use makes the code so-called "[multicolored](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)": all the functions in it can be red or blue, and depending on the color, the rules for calling them are different. You can only call blue functions from red ones, but not vice versa.
+
+I must say that implementing asynchronous calls using a special syntax is not the only solution. There are languages like Go where runtime can independently determine "under the hood" where a function should be asynchronous and where not, and choose the correct way to call it. A programmer does not need to manually "colorize" their functions there. Personally, I think that choosing a different path is the mistake of the Python community, but that's not what we're discussing here.

transfunctions-0.0.1/README.md

@@ -0,0 +1,76 @@
+# transfunctions
+
+[![Downloads](https://static.pepy.tech/badge/transfunctions/month)](https://pepy.tech/project/transfunctions)
+[![Downloads](https://static.pepy.tech/badge/transfunctions)](https://pepy.tech/project/transfunctions)
+[![Coverage Status](https://coveralls.io/repos/github/pomponchik/transfunctions/badge.svg?branch=main)](https://coveralls.io/github/pomponchik/transfunctions?branch=develop)
+[![Lines of code](https://sloc.xyz/github/pomponchik/transfunctions/?category=code)](https://github.com/boyter/scc/)
+[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/transfunctions?branch=main)](https://hitsofcode.com/github/pomponchik/transfunctions/view?branch=main)
+[![Test-Package](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/transfunctions.svg)](https://pypi.python.org/pypi/transfunctions)
+[![PyPI version](https://badge.fury.io/py/transfunctions.svg)](https://badge.fury.io/py/transfunctions)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library is designed to solve one of the most important problems in python programming - dividing all written code into 2 camps: sync and async. We get rid of code duplication by using templates.
+
+
+## Table of contents
+
+- [**Quick start**](#quick-start)
+- [**The problem**](#the-problem)
+
+
+## Quick start
+
+Install it:
+
+```bash
+pip install transfunctions
+```
+
+And use:
+
+```python
+from asyncio import run
+from transfunctions import (
+    transfunction,
+    sync_context,
+    async_context,
+    generator_context,
+)
+
+@transfunction
+def template():
+    print('so, ', end='')
+    with sync_context:
+        print("it's just usual function!")
+    with async_context:
+        print("it's an async function!")
+    with generator_context:
+        print("it's a generator function!")
+        yield
+
+function = template.get_usual_function()
+function()
+#> so, it's just usual function!
+
+async_function = template.get_async_function()
+run(async_function())
+#> so, it's an async function!
+
+generator_function = template.get_generator_function()
+list(generator_function())
+#> so, it's a generator function!
+```
+
+As you can see, in this case, 3 different functions were created based on the template, including both common parts and unique ones for a specific type of function.
+
+You can also quickly try out this and other packages without having to install using [instld](https://github.com/pomponchik/instld).
+
+
+## The problem
+
+Since the `asyncio` module appeared in Python more than 10 years ago, many well-known libraries have received their asynchronous alternates. A lot of the code in the Python ecosystem has been [duplicated](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself), and you probably know many such examples.
+
+The reason for this problem is that the Python community has chosen a way to implement asynchrony expressed through syntax. There are new keywords in the language, such as `async` and `await`. Their use makes the code so-called "[multicolored](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)": all the functions in it can be red or blue, and depending on the color, the rules for calling them are different. You can only call blue functions from red ones, but not vice versa.
+
+I must say that implementing asynchronous calls using a special syntax is not the only solution. There are languages like Go where runtime can independently determine "under the hood" where a function should be asynchronous and where not, and choose the correct way to call it. A programmer does not need to manually "colorize" their functions there. Personally, I think that choosing a different path is the mistake of the Python community, but that's not what we're discussing here.

transfunctions-0.0.1/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools==68.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "transfunctions"
+version = "0.0.1"
+authors = [
+  { name="Evgeniy Blinov", email="zheni-b@yandex.ru" },
+]
+description = 'Say NO to Python fragmentation on sync and async'
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Operating System :: OS Independent",
+    'Operating System :: MacOS :: MacOS X',
+    'Operating System :: Microsoft :: Windows',
+    'Operating System :: POSIX',
+    'Operating System :: POSIX :: Linux',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3.8',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'License :: OSI Approved :: MIT License',
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Libraries',
+]
+keywords = [
+    'async',
+    'sync to async',
+    'async to sync',
+]
+
+[tool.setuptools.package-data]
+"transfunctions" = ["py.typed"]
+
+[tool.mutmut]
+paths_to_mutate="transfunctions"
+runner="pytest"
+
+[project.urls]
+'Source' = 'https://github.com/pomponchik/transfunctions'
+'Tracker' = 'https://github.com/pomponchik/transfunctions/issues'

transfunctions-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

transfunctions-0.0.1/transfunctions/__init__.py

@@ -0,0 +1,14 @@
+from transfunctions.decorator import transfunction as transfunction
+
+from transfunctions.markers import (
+    async_context as async_context,
+    sync_context as sync_context,
+    generator_context as generator_context,
+    await_it as await_it,
+)
+
+from transfunctions.errors import (
+    CallTransfunctionDirectlyError as CallTransfunctionDirectlyError,
+    DualUseOfDecoratorError as DualUseOfDecoratorError,
+    WrongDecoratorSyntaxError as WrongDecoratorSyntaxError,
+)

transfunctions-0.0.1/transfunctions/decorator.py

@@ -0,0 +1,6 @@
+from transfunctions.transformer import FunctionTransformer
+from inspect import currentframe
+
+
+def transfunction(function):
+    return FunctionTransformer(function, currentframe().f_back.f_lineno)

transfunctions-0.0.1/transfunctions/errors.py

@@ -0,0 +1,10 @@
+class CallTransfunctionDirectlyError(NotImplementedError):
+    pass
+
+
+class DualUseOfDecoratorError(SyntaxError):
+    pass
+
+
+class WrongDecoratorSyntaxError(SyntaxError):
+    pass

transfunctions-0.0.1/transfunctions/markers.py

@@ -0,0 +1,24 @@
+from typing import Any
+from contextlib import contextmanager
+
+
+@contextmanager
+def create_async_context():
+    yield
+
+@contextmanager
+def create_sync_context():
+    yield
+
+@contextmanager
+def create_generator_context():
+    yield
+
+
+async_context = create_async_context()
+sync_context = create_sync_context()
+generator_context = create_generator_context()
+
+
+def await_it(some_expression: Any):
+    pass

transfunctions-0.0.1/transfunctions/transformer.py

@@ -0,0 +1,196 @@
+from sys import version_info
+from typing import Optional, Union, List, Any
+from types import 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 functools import wraps, update_wrapper
+
+from transfunctions.errors import CallTransfunctionDirectlyError, DualUseOfDecoratorError, WrongDecoratorSyntaxError
+
+
+class FunctionTransformer:
+    def __init__(self, function: Callable, decorator_lineno: int) -> None:
+        if isinstance(function, type(self)):
+            raise DualUseOfDecoratorError("You cannot use the 'transfunction' decorator twice for the same function.")
+        if not isfunction(function):
+            raise ValueError("Only regular or generator functions can be used as a template for @transfunction.")
+        if iscoroutinefunction(function):
+            raise ValueError("Only regular or generator functions can be used as a template for @transfunction. You can't use async functions.")
+        if self.is_lambda(function):
+            raise ValueError("Only regular or generator functions can be used as a template for @transfunction. Don't use lambdas here.")
+
+        self.function = function
+        self.decorator_lineno = decorator_lineno
+
+    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.")
+
+    @staticmethod
+    def is_lambda(function: Callable) -> bool:
+        # https://stackoverflow.com/a/3655857/14522393
+        lambda_example = lambda: 0  # noqa: E731
+        return isinstance(function, type(lambda_example)) and function.__name__ == lambda_example.__name__
+
+    def get_usual_function(self):
+        return self.extract_context('sync_context')
+
+    def get_async_function(self):
+        original_function = self.function
+
+        class ConvertSyncFunctionToAsync(NodeTransformer):
+            def visit_FunctionDef(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+                if node.name == original_function.__name__:
+                    return AsyncFunctionDef(
+                        name=original_function.__name__,
+                        args=node.args,
+                        body=node.body,
+                        decorator_list=node.decorator_list,
+                        lineno=node.lineno,
+                        col_offset=node.col_offset,
+                    )
+                return node
+
+        class ExtractAwaitExpressions(NodeTransformer):
+            def visit_Call(self, node: Expr) -> Optional[Union[AST, List[AST]]]:
+                if node.func.id == 'await_it':
+                    return Await(
+                        value=node.args[0],
+                        lineno=node.lineno,
+                        col_offset=node.col_offset,
+                    )
+                return node
+
+        return self.extract_context(
+            'async_context',
+            addictional_transformers=[
+                ConvertSyncFunctionToAsync(),
+                ExtractAwaitExpressions(),
+            ],
+        )
+
+    def get_generator_function(self):
+        return self.extract_context('generator_context')
+
+    @staticmethod
+    def clear_spaces_from_source_code(source_code: str) -> str:
+        splitted_source_code = source_code.split('\n')
+
+        indent = 0
+        for letter in splitted_source_code[0]:
+            if letter.isspace():
+                indent += 1
+            else:
+                break
+
+        new_splitted_source_code = [x[indent:] for x in splitted_source_code]
+
+        return '\n'.join(new_splitted_source_code)
+
+
+    def extract_context(self, context_name: str, addictional_transformers: Optional[List[NodeTransformer]] = None):
+        source_code = getsource(self.function)
+        converted_source_code = self.clear_spaces_from_source_code(source_code)
+        tree = parse(converted_source_code)
+        original_function = self.function
+        transfunction_decorator = None
+
+        class RewriteContexts(NodeTransformer):
+            def visit_With(self, node: Expr) -> 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]]]:
+                if node.name == original_function.__name__:
+                    nonlocal transfunction_decorator
+                    transfunction_decorator = None
+
+                    if not node.decorator_list:
+                        raise WrongDecoratorSyntaxError("The @transfunction decorator can only be used with the '@' symbol. Don't use it as a regular function. Also, don't rename it.")
+
+                    for decorator in node.decorator_list:
+                        if decorator.id != 'transfunction':
+                            raise WrongDecoratorSyntaxError('The @transfunction decorator cannot be used in conjunction with other decorators.')
+                        else:
+                            if transfunction_decorator is not None:
+                                raise DualUseOfDecoratorError("You cannot use the 'transfunction' decorator twice for the same function.")
+                            transfunction_decorator = decorator
+
+                    node.decorator_list = []
+                return node
+
+
+        RewriteContexts().visit(tree)
+        DeleteDecorator().visit(tree)
+
+        if addictional_transformers is not None:
+            for addictional_transformer in addictional_transformers:
+                addictional_transformer.visit(tree)
+
+        tree = self.wrap_ast_by_closures(tree)
+
+        if version_info.minor > 10:
+            increment_lineno(tree, n=(self.decorator_lineno - transfunction_decorator.lineno))
+        else:
+            increment_lineno(tree, n=(self.decorator_lineno - transfunction_decorator.lineno - 1))
+
+        code = compile(tree, filename=getfile(self.function), mode='exec')
+        namespace = {}
+        exec(code, namespace)
+        function_factory = namespace['wrapper']
+        result = function_factory()
+        result = self.rewrite_globals_and_closure(result)
+        result = wraps(self.function)(result)
+        return result
+
+    def wrap_ast_by_closures(self, tree):
+        old_functiondef = tree.body[0]
+
+        tree.body[0] = FunctionDef(
+            name='wrapper',
+            body=[Assign(targets=[Name(id=name, ctx=Store(), col_offset=0)], value=Constant(value=None, col_offset=0), col_offset=0) for name in self.function.__code__.co_freevars] + [
+                old_functiondef,
+                Return(value=Name(id=self.function.__name__, ctx=Load(), col_offset=0), col_offset=0),
+            ],
+            col_offset=0,
+            args=arguments(
+                posonlyargs=[],
+                args=[],
+                kwonlyargs=[],
+                kw_defaults=[],
+                defaults=[],
+            ),
+            decorator_list=[],
+        )
+
+        return tree
+
+
+    def rewrite_globals_and_closure(self, function):
+        # https://stackoverflow.com/a/13503277/14522393
+        all_new_closure_names = set(self.function.__code__.co_freevars)
+
+        if self.function.__closure__ is not None:
+            old_function_closure_variables = {name: cell for name, cell in zip(self.function.__code__.co_freevars, self.function.__closure__)}
+            filtered_closure = tuple([cell for name, cell in old_function_closure_variables.items() if name in all_new_closure_names])
+            names = tuple([name for name, cell in old_function_closure_variables.items() if name in all_new_closure_names])
+            new_code = function.__code__.replace(co_freevars=names)
+        else:
+            filtered_closure = None
+            new_code = function.__code__
+
+        new_function = FunctionType(
+            new_code,
+            self.function.__globals__,
+            name=self.function.__name__,
+            argdefs=self.function.__defaults__,
+            closure=filtered_closure,
+        )
+
+        new_function = update_wrapper(new_function, function)
+        new_function.__kwdefaults__ = function.__kwdefaults__
+        return new_function

transfunctions-0.0.1/transfunctions.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: transfunctions
+Version: 0.0.1
+Summary: Say NO to Python fragmentation on sync and async
+Author-email: Evgeniy Blinov <zheni-b@yandex.ru>
+Project-URL: Source, https://github.com/pomponchik/transfunctions
+Project-URL: Tracker, https://github.com/pomponchik/transfunctions/issues
+Keywords: async,sync to async,async to sync
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# transfunctions
+
+[![Downloads](https://static.pepy.tech/badge/transfunctions/month)](https://pepy.tech/project/transfunctions)
+[![Downloads](https://static.pepy.tech/badge/transfunctions)](https://pepy.tech/project/transfunctions)
+[![Coverage Status](https://coveralls.io/repos/github/pomponchik/transfunctions/badge.svg?branch=main)](https://coveralls.io/github/pomponchik/transfunctions?branch=develop)
+[![Lines of code](https://sloc.xyz/github/pomponchik/transfunctions/?category=code)](https://github.com/boyter/scc/)
+[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/transfunctions?branch=main)](https://hitsofcode.com/github/pomponchik/transfunctions/view?branch=main)
+[![Test-Package](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/transfunctions/actions/workflows/tests_and_coverage.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/transfunctions.svg)](https://pypi.python.org/pypi/transfunctions)
+[![PyPI version](https://badge.fury.io/py/transfunctions.svg)](https://badge.fury.io/py/transfunctions)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library is designed to solve one of the most important problems in python programming - dividing all written code into 2 camps: sync and async. We get rid of code duplication by using templates.
+
+
+## Table of contents
+
+- [**Quick start**](#quick-start)
+- [**The problem**](#the-problem)
+
+
+## Quick start
+
+Install it:
+
+```bash
+pip install transfunctions
+```
+
+And use:
+
+```python
+from asyncio import run
+from transfunctions import (
+    transfunction,
+    sync_context,
+    async_context,
+    generator_context,
+)
+
+@transfunction
+def template():
+    print('so, ', end='')
+    with sync_context:
+        print("it's just usual function!")
+    with async_context:
+        print("it's an async function!")
+    with generator_context:
+        print("it's a generator function!")
+        yield
+
+function = template.get_usual_function()
+function()
+#> so, it's just usual function!
+
+async_function = template.get_async_function()
+run(async_function())
+#> so, it's an async function!
+
+generator_function = template.get_generator_function()
+list(generator_function())
+#> so, it's a generator function!
+```
+
+As you can see, in this case, 3 different functions were created based on the template, including both common parts and unique ones for a specific type of function.
+
+You can also quickly try out this and other packages without having to install using [instld](https://github.com/pomponchik/instld).
+
+
+## The problem
+
+Since the `asyncio` module appeared in Python more than 10 years ago, many well-known libraries have received their asynchronous alternates. A lot of the code in the Python ecosystem has been [duplicated](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself), and you probably know many such examples.
+
+The reason for this problem is that the Python community has chosen a way to implement asynchrony expressed through syntax. There are new keywords in the language, such as `async` and `await`. Their use makes the code so-called "[multicolored](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)": all the functions in it can be red or blue, and depending on the color, the rules for calling them are different. You can only call blue functions from red ones, but not vice versa.
+
+I must say that implementing asynchronous calls using a special syntax is not the only solution. There are languages like Go where runtime can independently determine "under the hood" where a function should be asynchronous and where not, and choose the correct way to call it. A programmer does not need to manually "colorize" their functions there. Personally, I think that choosing a different path is the mistake of the Python community, but that's not what we're discussing here.

transfunctions-0.0.1/transfunctions.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+transfunctions/__init__.py
+transfunctions/decorator.py
+transfunctions/errors.py
+transfunctions/markers.py
+transfunctions/py.typed
+transfunctions/transformer.py
+transfunctions.egg-info/PKG-INFO
+transfunctions.egg-info/SOURCES.txt
+transfunctions.egg-info/dependency_links.txt
+transfunctions.egg-info/top_level.txt

transfunctions-0.0.1/transfunctions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

transfunctions-0.0.1/transfunctions.egg-info/top_level.txt

@@ -0,0 +1 @@
+transfunctions