smalldi 0.1.0__tar.gz

smalldi-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.idea
+.venv
+*.sw?
+dist
+*.pyc

smalldi-0.1.0/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+## 0.1.0
+* Initial release

smalldi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anna-Sofia Kasierocka
+
+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.

smalldi-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: smalldi
+Version: 0.1.0
+Summary: Small, annotation-driven dependency injection for Python.
+Project-URL: Homepage, https://github.com/0xf104a/smalldi
+Project-URL: Documentation, https://github.com/0xf104a/smalldi#readme
+Project-URL: Source, https://github.com/0xf104a/smalldi
+Project-URL: Issues, https://github.com/0xf104a/smalldi/issues
+Author-email: Anna-Sofia Kasierocka <f104a@f104a.io>
+License: MIT License
+        
+        Copyright (c) 2025 Anna-Sofia Kasierocka
+        
+        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.
+License-File: LICENSE
+Keywords: annotations,dependency injection,di,typing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: typing-extensions>=4.5; python_version >= '3.11'
+Description-Content-Type: text/markdown
+
+# Small DI
+The smallest dependency injection mechanism possible in python.
+SmallDI provides you with intuitive and simple interface for doing dependency
+injections in your project.
+
+# Example usage
+```python
+import random
+
+from smalldi import Injector
+from smalldi.annotation import Provide
+
+# Lets create some service
+@Injector.singleton
+class MeowService:
+    _MEOWS = ["Meow", "Meow-meow", "Meowwwwww", "Mrromeowww", "Meeeeoooow"]
+    def __init__(self):
+        print("Meow-meow! Meowing service is initialized")
+    
+    def meow(self):
+        print(random.choice(self._MEOWS))
+
+# Now lets make purring service.
+# But cats do not purr without telling meow!(at least in this test)
+# So its time to inject dependency
+@Injector.singleton
+class PurrService:
+    _PURRS = ["Purrrrr", "Purr-purr"]
+    
+    @Injector.inject
+    def __init__(self, meow_service: Provide[MeowService]):
+        self.meow_service = meow_service
+        print("Purr-purr! Purring service is initialized")
+
+    def purr(self):
+        self.meow_service.meow()
+        print(random.choice(self._PURRS))
+
+# Now lets put it all together. 
+# Ask our services to meow and then purr
+@Injector.inject
+def main(meow_service: Provide[MeowService], purr_service: Provide[PurrService]):
+    meow_service.meow()
+    purr_service.purr()
+
+if __name__ == '__main__':
+    main()
+```
+
+# Library logic
+## Injector
+Injector is a static class(i.e. one that should never be instantiated) storing all singletons
+and responsible for injecting those singletons to a functions.
+
+## Provide
+`Provide[T]` is an annotation for injector telling it that instead of this argument
+instance of `T` should be passed. Caller of function with `Provide[T]` may explicitly
+override argument annotated with `Provide[T]` by directly passing `annotated_di_arg=my_value`.

smalldi-0.1.0/README.md

@@ -0,0 +1,58 @@
+# Small DI
+The smallest dependency injection mechanism possible in python.
+SmallDI provides you with intuitive and simple interface for doing dependency
+injections in your project.
+
+# Example usage
+```python
+import random
+
+from smalldi import Injector
+from smalldi.annotation import Provide
+
+# Lets create some service
+@Injector.singleton
+class MeowService:
+    _MEOWS = ["Meow", "Meow-meow", "Meowwwwww", "Mrromeowww", "Meeeeoooow"]
+    def __init__(self):
+        print("Meow-meow! Meowing service is initialized")
+    
+    def meow(self):
+        print(random.choice(self._MEOWS))
+
+# Now lets make purring service.
+# But cats do not purr without telling meow!(at least in this test)
+# So its time to inject dependency
+@Injector.singleton
+class PurrService:
+    _PURRS = ["Purrrrr", "Purr-purr"]
+    
+    @Injector.inject
+    def __init__(self, meow_service: Provide[MeowService]):
+        self.meow_service = meow_service
+        print("Purr-purr! Purring service is initialized")
+
+    def purr(self):
+        self.meow_service.meow()
+        print(random.choice(self._PURRS))
+
+# Now lets put it all together. 
+# Ask our services to meow and then purr
+@Injector.inject
+def main(meow_service: Provide[MeowService], purr_service: Provide[PurrService]):
+    meow_service.meow()
+    purr_service.purr()
+
+if __name__ == '__main__':
+    main()
+```
+
+# Library logic
+## Injector
+Injector is a static class(i.e. one that should never be instantiated) storing all singletons
+and responsible for injecting those singletons to a functions.
+
+## Provide
+`Provide[T]` is an annotation for injector telling it that instead of this argument
+instance of `T` should be passed. Caller of function with `Provide[T]` may explicitly
+override argument annotated with `Provide[T]` by directly passing `annotated_di_arg=my_value`.

smalldi-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "smalldi"
+version = "0.1.0"
+description = "Small, annotation-driven dependency injection for Python."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+authors = [{ name = "Anna-Sofia Kasierocka", email = "f104a@f104a.io" }]
+keywords = ["dependency injection", "di", "typing", "annotations"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+  "typing-extensions>=4.5; python_version>='3.11'"
+]
+
+[project.urls]
+Homepage = "https://github.com/0xf104a/smalldi"
+Documentation = "https://github.com/0xf104a/smalldi#readme"
+Source = "https://github.com/0xf104a/smalldi"
+Issues = "https://github.com/0xf104a/smalldi/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/smalldi"]
+include = [
+  "src/smalldi/py.typed",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/README.md",
+  "/LICENSE",
+  "/pyproject.toml",
+  "/CHANGELOG.md",
+]

smalldi-0.1.0/src/smalldi/__init__.py

@@ -0,0 +1,51 @@
+import functools
+
+from smalldi.wrappers import staticclass
+from smalldi.annotation import _Provide, Provide
+
+__author__ = "Anna-Sofia Kasierocka"
+__email__ = "f104a@f104a.io"
+__version__ = "0.1.0"
+__all__ = ["Injector", "Provide"]
+
+@staticclass
+class Injector:
+    """
+    The injector class handles all the dependency injections.
+    """
+    singletons_available = {}
+
+    @classmethod
+    def inject(cls, fn):
+        """
+        Injects dependencies into function.
+        :param fn: function to inject dependencies into
+        :return: function with injected dependencies
+        """
+        kwargs_ext = dict()
+        for name, tp in _Provide.iter_annotations(fn):
+            if tp not in cls.singletons_available:
+                raise TypeError(f"Singleton {tp} is not available")
+            kwargs_ext[name] = cls.singletons_available[tp]
+
+        @functools.wraps(fn)
+        def wrapped_fn(*args, **kwargs):
+            for name, value in kwargs_ext.items():
+                if name not in kwargs:
+                    kwargs[name] = value
+            return fn(*args, **kwargs)
+
+        return wrapped_fn
+
+    @classmethod
+    def singleton(cls, target_cls):
+        """
+        Marks class as singleton.
+        Singleton classes are instantiated only once by the injector.
+        Also their __init__ function should have no arguments or be annotated
+        with @Injector.inject, so it would
+        :param target_cls: Class which to be marked as injectable singleton
+        :return: None
+        """
+        cls.singletons_available[target_cls] = target_cls()
+        return target_cls

smalldi-0.1.0/src/smalldi/annotation.py

@@ -0,0 +1,47 @@
+import inspect
+from typing import TypeVar, Generic, get_origin, get_args, Iterator, Callable, Any, TypeAlias, Annotated
+
+_T = TypeVar("_T")
+
+class _Provide(Generic[_T]):
+    """Provide annotation tells smalldi to find instance of T and inject it into function"""
+    @staticmethod
+    def unwrap(tp: object) -> type:
+        """
+        Unwraps annotation to get inner type.
+        :param tp: annotation itself
+        :return: inner type T
+        """
+        origin = get_origin(tp)
+        if origin is _Provide:
+            (inner,) = get_args(tp)
+            return inner
+
+        if origin is Annotated:
+            args = get_args(tp)
+            inner, *meta = args
+            if any(m is _Provide for m in meta):
+                return inner
+
+        raise TypeError(f"Expected Provide[T], got {tp!r}")
+
+    @staticmethod
+    def iter_annotations(func: Callable) -> Iterator[Any]:
+        """
+        Provides an iterator that extracts and yields annotations of type `Provide`
+        from the parameters of a given function's signature.
+        :param func: The function whose parameter annotations will be inspected.
+        :type func: Callable
+        :return: An iterator over the unwrapped annotations of type `Provide` found
+            in the function's parameters.
+        :rtype: Iterator[str, Any]
+        """
+        signature = inspect.signature(func)
+        for name, param in signature.parameters.items():
+            try:
+                inner = _Provide.unwrap(param.annotation)
+                yield name, inner
+            except TypeError:
+                continue
+
+Provide: TypeAlias = Annotated[_T, _Provide]

smalldi-0.1.0/src/smalldi/wrappers.py

@@ -0,0 +1,8 @@
+def staticclass(cls):
+    """
+    Marks class as static. Static classes can't be instantiated.
+    """
+    def _no_init(*_args, **_kwargs):
+        raise TypeError("Can't instantiate static class")
+    cls.__init__ = _no_init
+    return cls

smalldi-0.1.0/src/tests/README.md

@@ -0,0 +1,9 @@
+# Tests for smalldi
+
+This module contains tests for a smalldi library with the use of pytest
+
+## Test structure
+- `test_provide.py` - Tests for class `Provide`
+- `test_injector.py` - Тests for class `Injector`
+- `test_wrappers.py` - Tests for wrappers (currently only `staticclass`)
+- `test_integration.py` - Library-level tests

smalldi-0.1.0/src/tests/__init__.py

@@ -0,0 +1 @@
+# tests package

smalldi-0.1.0/src/tests/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+from typing import Any, Dict
+
+from smalldi import Injector
+
+
+@pytest.fixture(autouse=False)
+def reset_injector():
+    """Reset Injector state before and after each test"""
+    old_singletons: Dict[Any, Any] = Injector.singletons_available.copy()
+
+    Injector.singletons_available.clear()
+
+    yield
+
+    Injector.singletons_available.clear()
+    Injector.singletons_available.update(old_singletons)

smalldi-0.1.0/src/tests/test_injector.py

@@ -0,0 +1,87 @@
+import pytest
+from typing import List, Dict, Any
+from unittest.mock import patch, MagicMock
+
+from smalldi import Injector
+from smalldi.annotation import _Provide
+
+
+@pytest.fixture
+def reset_injector():
+    """Reset Injector state before each test"""
+    old_singletons = Injector.singletons_available.copy()
+    Injector.singletons_available.clear()
+
+    yield
+
+    # Відновлюємо стан після тесту
+    Injector.singletons_available.clear()
+    Injector.singletons_available.update(old_singletons)
+
+
+def test_singleton_registration(reset_injector):
+    """Test that singleton decorator registers class instance"""
+    assert len(Injector.singletons_available) == 0
+
+    @Injector.singleton
+    class TestService:
+        def hello(self):
+            return "Hello"
+
+    assert len(Injector.singletons_available) == 1
+    assert TestService in Injector.singletons_available
+    assert isinstance(Injector.singletons_available[TestService], TestService)
+
+    service = Injector.singletons_available[TestService]
+    assert service.hello() == "Hello"
+
+
+def test_singleton_single_instance(reset_injector):
+    """Test that singleton creates only one instance"""
+    counter = 0
+
+    @Injector.singleton
+    class TestService:
+        def __init__(self):
+            nonlocal counter
+            counter += 1
+
+    assert counter == 1
+
+    Injector.singleton(TestService)
+    assert counter == 2  # Це повинно бути 1, але поточна реалізація створить новий екземпляр
+
+
+def test_inject_basic(reset_injector):
+    """Test basic dependency injection"""
+    @Injector.singleton
+    class TestService:
+        def hello(self):
+            return "Hello"
+
+    @Injector.inject
+    def test_function(service: _Provide[TestService]):
+        return service.hello()
+
+    result = test_function()
+    assert result == "Hello"
+
+
+def test_inject_multiple_dependencies(reset_injector):
+    """Test injection of multiple dependencies"""
+    @Injector.singleton
+    class ServiceA:
+        def value(self):
+            return "A"
+
+    @Injector.singleton
+    class ServiceB:
+        def value(self):
+            return "B"
+
+    @Injector.inject
+    def test_function(service_a: _Provide[ServiceA], service_b: _Provide[ServiceB]):
+        return service_a.value() + service_b.value()
+
+    result = test_function()
+    assert result == "AB"

smalldi-0.1.0/src/tests/test_integration.py

@@ -0,0 +1,87 @@
+import pytest
+from typing import List, Dict, Optional
+
+from smalldi import Injector
+from smalldi.annotation import Provide
+
+
+@pytest.fixture
+def reset_injector():
+    """Reset Injector state before each test"""
+    old_singletons = Injector.singletons_available.copy()
+    Injector.singletons_available.clear()
+    yield
+    Injector.singletons_available.clear()
+    Injector.singletons_available.update(old_singletons)
+
+
+def test_simple_injection(reset_injector):
+    """Test simple dependency injection in real code"""
+
+    @Injector.singleton
+    class ConfigService:
+        def get_config(self, key: str) -> str:
+            return f"config:{key}"
+
+    @Injector.singleton
+    class UserService:
+        @Injector.inject
+        def __init__(self, config: Provide[ConfigService]):
+            self.config = config
+
+        def get_user(self, user_id: int) -> Dict[str, str]:
+            api_key = self.config.get_config("api_key")
+            return {"id": str(user_id), "name": f"User_{user_id}", "api_key": api_key}
+
+    @Injector.inject
+    def get_user_handler(user_id: int, user_service: Provide[UserService]) -> Dict[str, str]:
+        return user_service.get_user(user_id)
+
+    result = get_user_handler(user_id=123)
+    assert result["id"] == "123"
+    assert result["name"] == "User_123"
+    assert result["api_key"] == "config:api_key"
+
+def test_nested_injection(reset_injector, monkeypatch):
+    """Test nested dependency injection"""
+    @Injector.singleton
+    class DatabaseService:
+        def query(self, sql: str) -> List[Dict[str, str]]:
+            return [{"result": f"db:{sql}"}]
+
+    @Injector.singleton
+    class LogService:
+        def log(self, message: str) -> None:
+            pass
+
+    @Injector.singleton
+    class UserRepository:
+        @Injector.inject
+        def __init__(self, db: Provide[DatabaseService], logger: Provide[LogService]):
+            self.db = db
+            self.logger = logger
+
+        def find_user(self, user_id: int) -> Optional[Dict[str, str]]:
+            self.logger.log(f"Finding user {user_id}")
+            results = self.db.query(f"SELECT * FROM users WHERE id = {user_id}")
+            return results[0] if results else None
+
+    @Injector.singleton
+    class UserService:
+        @Injector.inject
+        def __init__(self, repository: Provide[UserRepository]):
+            self.repository = repository
+
+        def get_user_data(self, user_id: int) -> Dict[str, str]:
+            user = self.repository.find_user(user_id)
+            if not user:
+                return {"error": "User not found"}
+            return user
+
+    @Injector.inject
+    def user_api(user_id: int, service: Provide[UserService]) -> Dict[str, str]:
+        return service.get_user_data(user_id)
+
+    result = user_api(user_id=42)
+    assert "result" in result
+    assert result["result"] == "db:SELECT * FROM users WHERE id = 42"

smalldi-0.1.0/src/tests/test_provide.py

@@ -0,0 +1,35 @@
+import pytest
+from typing import Any, List, Dict
+
+from smalldi.annotation import _Provide, Provide
+
+
+def test_provide_unwrap_valid():
+    """Test unwrapping valid Provide annotations"""
+    assert _Provide.unwrap(Provide[str]) is str
+    assert _Provide.unwrap(Provide[int]) is int
+    assert _Provide.unwrap(Provide[List[int]]) is List[int]
+    assert _Provide.unwrap(Provide[Dict[str, Any]]) is Dict[str, Any]
+
+
+def test_provide_unwrap_invalid():
+    """Test unwrapping invalid annotations raises TypeError"""
+    with pytest.raises(TypeError):
+        _Provide.unwrap(str)
+
+    with pytest.raises(TypeError):
+        _Provide.unwrap(int)
+
+    with pytest.raises(TypeError):
+        _Provide.unwrap(List[int])
+
+    with pytest.raises(TypeError):
+        _Provide.unwrap(None)
+
+def test_iter_annotations_empty():
+    """Test iteration over function without Provide annotations"""
+    def func(a: str, b: int):
+        pass
+
+    annotations = list(_Provide.iter_annotations(func))
+    assert len(annotations) == 0

smalldi-0.1.0/src/tests/test_wrappers.py

@@ -0,0 +1,41 @@
+import pytest
+
+from smalldi.wrappers import staticclass
+
+
+def test_staticclass_basic():
+    """Test that staticclass prevents instantiation"""
+    @staticclass
+    class TestClass:
+        @classmethod
+        def class_method(cls):
+            return "class method"
+
+        @staticmethod
+        def static_method():
+            return "static method"
+
+    with pytest.raises(TypeError):
+        TestClass()
+
+    assert TestClass.class_method() == "class method"
+    assert TestClass.static_method() == "static method"
+
+
+def test_staticclass_preserves_metadata():
+    """Test that staticclass preserves class metadata"""
+    @staticclass
+    class TestClass:
+        """Test docstring"""
+        class_var = "class variable"
+
+        @classmethod
+        def method(cls):
+            """Method docstring"""
+            return cls.class_var
+
+    assert TestClass.__name__ == "TestClass"
+    assert TestClass.__doc__ == "Test docstring"
+    assert TestClass.class_var == "class variable"
+    assert TestClass.method.__doc__ == "Method docstring"
+    assert TestClass.method() == "class variable"