Merge pull request #9 from pomponchik/develop

0.0.8

Author: pomponchik

.gitignore

@@ -5,7 +5,13 @@ test.py
 *.egg-info
 dist
 venv
+.venv
 build
 .ruff_cache
 .mypy_cache
 .coverage
+uv.lock
+.history
+.vscode/
+.idea/
+temp*

.ruff.toml

@@ -1 +1,4 @@
 lint.ignore = ['E501', 'E712']
+
+[format]
+quote-style = "single"

README.md

@@ -8,6 +8,7 @@
 [![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)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
 [![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.
@@ -151,7 +152,7 @@ def template():
 The `get_async_function` method will return an async function that looks like this:
 
 ```python
-def template():
+async def template():
     print('so, ', end='')
     print("it's an async function!")
 ```

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "transfunctions"
-version = "0.0.7"
+version = "0.0.8"
 authors = [
   { name="Evgeniy Blinov", email="[email protected]" },
 ]
@@ -16,6 +16,7 @@ dependencies = [
     'dill==0.4.0',
     'typing_extensions ; python_version <= "3.10"',
 ]
+
 classifiers = [
     "Operating System :: OS Independent",
     'Operating System :: MacOS :: MacOS X',
@@ -52,6 +53,11 @@ keywords = [
 paths_to_mutate="transfunctions"
 runner="pytest"
 
+[tool.pytest.ini_options]
+markers = [
+    "mypy_testing",
+]
+
 [project.urls]
 'Source' = 'https://github.com/pomponchik/transfunctions'
 'Tracker' = 'https://github.com/pomponchik/transfunctions/issues'

requirements_dev.txt

@@ -1,8 +1,9 @@
-pytest==7.4.3
+pytest==8.0.2
 coverage==7.6.1
 build==1.2.2.post1
 twine==6.1.0
 mypy==1.14.1
+pytest-mypy-testing==0.1.3
 ruff==0.9.9
 mutmut==3.2.3
 full_match==0.0.2

tests/typing/__init__.py

@@ -0,0 +1,261 @@
+import sys
+import asyncio
+from contextlib import suppress
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import reveal_type
+else:
+    from typing import reveal_type
+
+import pytest
+
+from transfunctions import superfunction, sync_context, async_context, generator_context, yield_from_it
+
+
+"""
+Что нужно проверить:
+
+1. Что await_it, yield_from_it и yield_it типизированы.
+
+Что проверено:
+
+"""
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_deduced_return_type_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    reveal_type(~typed_superfunction(1.0)) # N: Revealed type is "builtins.int"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_deduced_return_type_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    reveal_type(asyncio.run(typed_superfunction(1.0))) # N: Revealed type is "builtins.int"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_incorrect_arg_type_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    ~typed_superfunction(None, kwarg=1) # E: Argument 1 to "typed_superfunction" has incompatible type "None"; expected "float"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_incorrect_kwarg_type_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    ~typed_superfunction(1.0, kwarg=None) # E: Argument "kwarg" to "typed_superfunction" has incompatible type "None"; expected "int"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_on_correct_args_types_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    ~typed_superfunction(1.0, kwarg=1)
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_incorrect_arg_type_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    asyncio.run(typed_superfunction(None, kwarg=1)) # E: Argument 1 to "typed_superfunction" has incompatible type "None"; expected "float"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_incorrect_kwarg_type_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    asyncio.run(typed_superfunction(1.0, kwarg=None)) # E: Argument "kwarg" to "typed_superfunction" has incompatible type "None"; expected "int"
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_on_correct_args_types_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    asyncio.run(typed_superfunction(1.0, kwarg=1))
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_missing_args_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        ~typed_superfunction() # E: Missing positional argument "arg" in call to "typed_superfunction"  [call-arg]
+
+
+@pytest.mark.mypy_testing
+@pytest.mark.xfail
+def test_superfunction_param_spec_fail_on_extra_args_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        ~typed_superfunction(1.0, 2.0, kwarg=1)
+
+
+@pytest.mark.mypy_testing
+@pytest.mark.xfail
+def test_superfunction_param_spec_fail_on_extra_kwargs_sync() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        ~typed_superfunction(1.0, kwarg=1, kwarg2=1)
+
+
+@pytest.mark.mypy_testing
+def test_superfunction_param_spec_fail_on_missing_args_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        asyncio.run(typed_superfunction()) # E: Missing positional argument "arg" in call to "typed_superfunction"  [call-arg]
+
+
+@pytest.mark.mypy_testing
+@pytest.mark.xfail
+def test_superfunction_param_spec_fail_on_extra_args_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        asyncio.run(typed_superfunction(1.0, 2.0, kwarg=1))
+
+
+@pytest.mark.mypy_testing
+@pytest.mark.xfail
+def test_superfunction_param_spec_fail_on_extra_kwargs_async() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+
+    with suppress(TypeError):
+        asyncio.run(typed_superfunction(1.0, kwarg=1, kwarg2=1))
+
+
+@pytest.mark.mypy_testing
+@pytest.mark.xfail  # it shouldn't work because typed_superfunction is a generator function, gut it's not returning a generator object according to it's typing.
+def test_simple_using_of_generator_function_with_simple_yield_from() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+        with generator_context:
+            yield from [1, 2, 3]
+
+    list(typed_superfunction(1))
+
+
+# TODO: we should understand why it works
+@pytest.mark.xfail
+@pytest.mark.mypy_testing
+def test_wrong_using_of_generator_function_with_simple_yield_from() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+        with generator_context:
+            yield from [1, 2, 3]
+
+    list(typed_superfunction(None))
+
+
+@pytest.mark.mypy_testing
+def test_simple_using_of_generator_function_with_yield_from_it_marker_function() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+        with generator_context:
+            yield_from_it([1, 2, 3])
+
+    list(typed_superfunction(1))
+
+
+# TODO: we should understand why it works
+@pytest.mark.xfail
+@pytest.mark.mypy_testing
+def test_using_of_generator_function_with_yield_from_it_marker_function_with_wrong_return_value() -> None:
+    @superfunction
+    def typed_superfunction(arg: float, *, kwarg: int = 0) -> int:
+        with sync_context:
+            return 1
+        with async_context:
+            return 2
+        with generator_context:
+            yield_from_it(['one', 'two'])
+
+    list(typed_superfunction(1))