py-autowired 0.2.0__tar.gz

py_autowired-0.2.0/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.2.0
+
+- Restored the original runtime injection rule: self.x_instance = None.
+- Removed provider-based and application-side resolve usage.
+- Reduced the runtime package to autowired.py and container.py.
+- Added layered Console, FastAPI, Flask and Django examples.

py_autowired-0.2.0/KULLANIM_KILAVUZU_TR.md

@@ -0,0 +1,108 @@
+# py-autowired Türkçe Kullanım Kılavuzu
+
+## Temel kural
+
+Runtime bağımlılığı constructor parametresi veya manuel container çağrısı değildir:
+
+```python
+class SiparisServisi:
+    def __init__(self):
+        self.siparis_repository_instance = None
+```
+
+`auto_inject()`, alan adındaki `siparis_repository` bölümünü kayıtlı
+`ISiparisRepository` veya `SiparisRepository` tipiyle eşleştirir ve nesneyi
+çalışma anında yerleştirir.
+
+## Kurulum
+
+```bash
+pip install py-autowired
+```
+
+## Kayıt ve başlangıç
+
+```python
+from py_autowired.autowired import auto_inject
+from py_autowired.container import Container
+
+container = Container()
+container.register_singleton(IClock, SystemClock)
+container.register_scoped(IUserRepository, SqliteUserRepository)
+container.register_transient(UserService)
+
+# Uygulama başlangıcında yalnız bir kez:
+auto_inject(container, root_dir="/uygulamanin/mutlak/yolu")
+```
+
+`auto_inject()` çağrısından önce ilgili soyut ve somut sınıflar import edilmiş
+ve kayıtlar tamamlanmış olmalıdır. Enjekte edilecek uygulama nesnelerini bu
+çağrıdan sonra oluşturun.
+
+## Yaşam süreleri
+
+- `register_singleton`: Uygulama süresince aynı nesne.
+- `register_scoped`: Bir scope içinde aynı, sonraki scope'ta yeni nesne.
+- `register_transient`: Her enjeksiyonda yeni nesne.
+- `register_instance`: Önceden oluşturulmuş nesneyi kullanır.
+- `register_factory`: Parametresiz factory ile nesne oluşturur.
+
+Console, Flask ve Django gibi senkron yollarda:
+
+```python
+with container.create_scope():
+    controller = UserController()
+    result = controller.execute()
+```
+
+FastAPI gibi asenkron yollarda:
+
+```python
+async with container.create_scope():
+    controller = UserController()
+    result = await controller.execute()
+```
+
+## Katmanlı mimari
+
+- Domain: soyut repository/port.
+- Infrastructure: somut repository/adaptör.
+- Application: `self.repository_instance = None` kullanan servis.
+- Composition: kayıtlar ve tek `auto_inject()` çağrısı.
+- Presentation: Console, FastAPI, Flask veya Django controller/view.
+
+Sunum ve uygulama katmanlarında manuel bağımlılık çözümleme çağrısı kullanılmaz. Ayrıntılı, çalışan örnekler `examples/` klasöründedir.
+
+## İsim eşleştirme
+
+Alan mutlaka küçük harfle başlamalı ve `_instance` ile bitmelidir:
+
+- `user_repository_instance` → `IUserRepository`
+- `payment_service_instance` → `PaymentService`
+- `audit_instance` → `ABS_Audit`
+
+Bir ad birden fazla kayda uyuyorsa modül yakınlığı kullanılır. Belirsiz kayıtları
+önlemek için servis adlarını açık ve benzersiz tutun.
+
+## Kırmızı çizgi
+
+Tek geçerli bağımlılık bildirimi: self.repository_instance = None.
+
+## IDLE ile tek tuşla çalıştırma
+
+Terminal komutu yazmanız gerekmez. IDLE içinde aşağıdaki ana dosyalardan birini açın ve **Run > Run Module (F5)** seçin:
+
+- Console: `examples/console_app/main.py`
+- FastAPI: `examples/fastapi_app/app.py` — `http://127.0.0.1:8101/di-demo/Ayhan`
+- Flask: `examples/flask_app/app.py` — `http://127.0.0.1:8102/di-demo/Ayhan`
+- Django: `examples/django_app/manage.py` — `http://127.0.0.1:8103/di-demo/Ayhan`
+
+Web örnekleri için `examples/requirements.txt` içindeki isteğe bağlı framework bağımlılıklarının bir kez kurulmuş olması gerekir. Kaynak klasöründen çalıştırırken ayrıca `PYTHONPATH` ayarlamanız gerekmez.
+
+## Derin klasör kanıtı
+
+`examples/shared` bilinçli olarak düz tutulmamıştır. Domain sözleşmeleri, use-case, repository, formatter, runtime sağlayıcı ve composition root farklı ve iç içe klasörlerdedir. Çalışan enjeksiyon zinciri şöyledir:
+
+`Controller -> GreetingService -> MemoryMessageRepository -> TurkishMessageFormatter -> RuntimeLabelProvider`
+
+Bu zincirdeki her bağımlılık yalnız `self.<ad>_instance = None` bildirimiyle yerleştirilir. Böylece örnekler, klasör ve modül derinliği arttığında da `auto_inject()` mekanizmasının çalıştığını doğrular.

py_autowired-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ayhan
+
+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.

py_autowired-0.2.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include CHANGELOG.md
+include KULLANIM_KILAVUZU_TR.md
+include USAGE_GUIDE_EN.md
+recursive-include examples *.py *.md *.txt
+recursive-include tests *.py

py_autowired-0.2.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: py-autowired
+Version: 0.2.0
+Summary: Runtime dependency injection through self.x_instance = None
+Author: Ayhan
+License-Expression: MIT
+Keywords: dependency-injection,autowiring,fastapi,flask,django
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Provides-Extra: examples
+Requires-Dist: django>=5.1; extra == "examples"
+Requires-Dist: fastapi>=0.115; extra == "examples"
+Requires-Dist: flask>=3.1; extra == "examples"
+Requires-Dist: uvicorn>=0.30; extra == "examples"
+Dynamic: license-file
+
+# py-autowired
+
+py-autowired injects runtime dependencies into fields declared with one rule:
+
+```python
+class UserService:
+    def __init__(self):
+        self.user_repository_instance = None
+```
+
+Application code contains no manual dependency-resolution calls. Register
+the services once and call `auto_inject()` once during startup.
+
+```python
+from py_autowired.autowired import auto_inject
+from py_autowired.container import Container
+
+container = Container()
+container.register_scoped(IUserRepository, SqliteUserRepository)
+container.register_transient(UserService)
+auto_inject(container, root_dir="/absolute/path/to/project")
+
+with container.create_scope():
+    service = UserService()
+    print(service.user_repository_instance)
+```
+
+## Runtime package
+
+The installed runtime contains only:
+
+```text
+py_autowired/
+  autowired.py
+  container.py
+```
+
+Python namespace packages make `__init__.py` unnecessary.
+
+## Frameworks
+
+The same core works with Console, FastAPI/ASGI, Flask/WSGI and Django. Framework
+examples are under `examples/`; each uses domain, application, infrastructure,
+composition and presentation layers without manual dependency resolution.
+
+See [KULLANIM_KILAVUZU_TR.md](KULLANIM_KILAVUZU_TR.md) and
+[USAGE_GUIDE_EN.md](USAGE_GUIDE_EN.md).

py_autowired-0.2.0/README.md

@@ -0,0 +1,47 @@
+# py-autowired
+
+py-autowired injects runtime dependencies into fields declared with one rule:
+
+```python
+class UserService:
+    def __init__(self):
+        self.user_repository_instance = None
+```
+
+Application code contains no manual dependency-resolution calls. Register
+the services once and call `auto_inject()` once during startup.
+
+```python
+from py_autowired.autowired import auto_inject
+from py_autowired.container import Container
+
+container = Container()
+container.register_scoped(IUserRepository, SqliteUserRepository)
+container.register_transient(UserService)
+auto_inject(container, root_dir="/absolute/path/to/project")
+
+with container.create_scope():
+    service = UserService()
+    print(service.user_repository_instance)
+```
+
+## Runtime package
+
+The installed runtime contains only:
+
+```text
+py_autowired/
+  autowired.py
+  container.py
+```
+
+Python namespace packages make `__init__.py` unnecessary.
+
+## Frameworks
+
+The same core works with Console, FastAPI/ASGI, Flask/WSGI and Django. Framework
+examples are under `examples/`; each uses domain, application, infrastructure,
+composition and presentation layers without manual dependency resolution.
+
+See [KULLANIM_KILAVUZU_TR.md](KULLANIM_KILAVUZU_TR.md) and
+[USAGE_GUIDE_EN.md](USAGE_GUIDE_EN.md).

py_autowired-0.2.0/USAGE_GUIDE_EN.md

@@ -0,0 +1,102 @@
+# py-autowired English Usage Guide
+
+## Core rule
+
+Declare every runtime dependency as a field ending in `_instance`:
+
+```python
+class OrderService:
+    def __init__(self):
+        self.order_repository_instance = None
+```
+
+`auto_inject()` matches `order_repository` with a registered
+`IOrderRepository` or `OrderRepository` and assigns the object at runtime.
+Application code does not resolve dependencies manually.
+
+## Setup
+
+```bash
+pip install py-autowired
+```
+
+```python
+from py_autowired.autowired import auto_inject
+from py_autowired.container import Container
+
+container = Container()
+container.register_singleton(IClock, SystemClock)
+container.register_scoped(IUserRepository, SqliteUserRepository)
+container.register_transient(UserService)
+
+# Exactly once during startup:
+auto_inject(container, root_dir="/absolute/path/to/application")
+```
+
+Import implementations and complete registrations before `auto_inject()`.
+Create injectable application objects only after that call.
+
+## Lifetimes
+
+- `register_singleton`: one object for the application lifetime.
+- `register_scoped`: one object per active scope.
+- `register_transient`: a new object per injection.
+- `register_instance`: use an existing object.
+- `register_factory`: create objects through a zero-argument factory.
+
+Synchronous request or operation:
+
+```python
+with container.create_scope():
+    result = UserController().execute()
+```
+
+Asynchronous request or operation:
+
+```python
+async with container.create_scope():
+    result = await UserController().execute()
+```
+
+## Layered architecture
+
+- Domain: repository/port abstractions.
+- Infrastructure: concrete repositories/adapters.
+- Application: services declaring `self.repository_instance = None`.
+- Composition: registrations and the single `auto_inject()` call.
+- Presentation: Console, FastAPI, Flask or Django controller/view.
+
+Presentation and application layers contain no manual dependency-resolution calls. Runnable examples are available under `examples/`.
+
+## Naming
+
+Fields start with a lowercase letter and end with `_instance`:
+
+- `user_repository_instance` → `IUserRepository`
+- `payment_service_instance` → `PaymentService`
+- `audit_instance` → `ABS_Audit`
+
+Keep service names unique to avoid ambiguous name matching.
+
+## Non-negotiable pattern
+
+The only valid dependency declaration is: self.repository_instance = None.
+
+## One-click run from IDLE
+
+No terminal command is required. Open one of these entry-point files in IDLE and choose **Run > Run Module (F5)**:
+
+- Console: `examples/console_app/main.py`
+- FastAPI: `examples/fastapi_app/app.py` — `http://127.0.0.1:8101/di-demo/Ayhan`
+- Flask: `examples/flask_app/app.py` — `http://127.0.0.1:8102/di-demo/Ayhan`
+- Django: `examples/django_app/manage.py` — `http://127.0.0.1:8103/di-demo/Ayhan`
+
+Install the optional framework dependencies listed in `examples/requirements.txt` once before running the web examples. No manual `PYTHONPATH` setting is needed when running from the source tree.
+
+## Deep-folder proof
+
+`examples/shared` is deliberately not flat. Domain contracts, use case, repository, formatter, runtime provider, and composition root live in separate nested folders. The working injection chain is:
+
+`Controller -> GreetingService -> MemoryMessageRepository -> TurkishMessageFormatter -> RuntimeLabelProvider`
+
+Every dependency in this chain is populated only from a `self.<name>_instance = None` declaration. The examples therefore verify that `auto_inject()` continues to work as folder and module depth increases.

py_autowired-0.2.0/examples/README.md

@@ -0,0 +1,51 @@
+# Deep layered examples
+
+All four presentation technologies use the same deliberately deep application tree. The depth is intentional: it proves that `auto_inject()` discovers and patches runtime dependencies across nested folders instead of working only when classes share one directory.
+
+```text
+examples/
+  shared/
+    domain/contracts/
+      messaging/message_repository.py
+      formatting/message_formatter.py
+      metadata/runtime_label_provider.py
+    application/use_cases/greetings/
+      greeting_service.py
+    infrastructure/
+      persistence/adapters/memory/repositories/message_repository.py
+      presentation/formatting/turkish_message_formatter.py
+      runtime/environment/metadata/providers/runtime_label_provider.py
+    bootstrap/dependency_injection/
+      composition.py
+  console_app/main.py
+  fastapi_app/app.py
+  flask_app/app.py
+  django_app/manage.py
+```
+
+The injected chain crosses all those layers:
+
+```text
+Presentation controller
+  -> GreetingService
+    -> MemoryMessageRepository
+      -> TurkishMessageFormatter
+        -> RuntimeLabelProvider
+```
+
+Every consumer declares dependencies only as `self.<name>_instance = None`. Application and presentation code contains no manual dependency-resolution calls. No `__init__.py` files are required for this namespace-package example.
+
+## Run directly from IDLE or an editor
+
+Open one of these entry-point files and choose **Run > Run Module (F5)** in IDLE:
+
+- `console_app/main.py`: prints the complete chain's result in the IDLE shell.
+- `fastapi_app/app.py`: starts at `http://127.0.0.1:8101/di-demo/Ayhan`.
+- `flask_app/app.py`: starts at `http://127.0.0.1:8102/di-demo/Ayhan`.
+- `django_app/manage.py`: starts at `http://127.0.0.1:8103/di-demo/Ayhan`.
+
+No terminal command or manual `PYTHONPATH` setting is required. Install the optional framework dependencies from `examples/requirements.txt` once before running the web examples.
+
+## Visible proof in every output
+
+Console prints every chain level line by line. FastAPI, Flask, and Django return the same five entries in the `injection_trace` JSON field. Each entry includes `module`, `module_depth`, `class`, `injected_field`, `injected_type`, `method`, `result`, and `instance_id`, so successful deep auto-injection is directly observable instead of inferred from one greeting.

py_autowired-0.2.0/examples/console_app/main.py

@@ -0,0 +1,56 @@
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from examples.shared.bootstrap.dependency_injection.composition import configure_dependencies
+
+
+class ConsoleController:
+    def __init__(self):
+        self.greeting_service_instance = None
+
+    def execute(self, name: str) -> dict[str, object]:
+        message = self.greeting_service_instance.greet(name)
+        controller_trace = {
+            "chain_level": 1,
+            "module_depth": len(type(self).__module__.split(".")),
+            "module": type(self).__module__,
+            "class": type(self).__name__,
+            "injected_field": "greeting_service_instance",
+            "injected_type": type(self.greeting_service_instance).__name__,
+            "method": "execute()",
+            "result": message,
+            "instance_id": id(self),
+        }
+        return {
+            "message": message,
+            "injection_trace": [
+                controller_trace,
+                *self.greeting_service_instance.injection_trace(name),
+            ],
+        }
+
+
+def main() -> None:
+    container = configure_dependencies()
+    with container.create_scope():
+        result = ConsoleController().execute("Console")
+        print(result["message"])
+        print("\nAUTO_INJECT DERINLIK ZINCIRI")
+        for step in result["injection_trace"]:
+            print(
+                f"[{step['chain_level']}] {step['module']} "
+                f"(modul derinligi={step['module_depth']})"
+            )
+            print(
+                f"    {step['class']}.{step['method']} -> {step['result']} "
+                f"| inject: {step['injected_field']} = {step['injected_type']} "
+                f"| instance_id={step['instance_id']}"
+            )
+
+
+if __name__ == "__main__":
+    main()

py_autowired-0.2.0/examples/django_app/manage.py

@@ -0,0 +1,25 @@
+import os
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "examples.django_app.runtime_di_demo.settings")
+
+from django.core.management import execute_from_command_line
+
+
+def main() -> None:
+    arguments = sys.argv
+    if len(arguments) == 1:
+        arguments = [arguments[0], "runserver", "127.0.0.1:8103", "--noreload"]
+        print("py-autowired: 5 katmanli Runtime DI demosu")
+        print("Tarayicida acin: http://127.0.0.1:8103/di-demo/Ayhan")
+        print("JSON cevabinda injection_trace alanini inceleyin.")
+    execute_from_command_line(arguments)
+
+
+if __name__ == "__main__":
+    main()

py_autowired-0.2.0/examples/django_app/runtime_di_demo/settings.py

@@ -0,0 +1,6 @@
+SECRET_KEY = "local-demo-only"
+DEBUG = True
+ROOT_URLCONF = "examples.django_app.runtime_di_demo.urls"
+ALLOWED_HOSTS = ["127.0.0.1", "localhost", "testserver"]
+MIDDLEWARE = []
+INSTALLED_APPS = []

py_autowired-0.2.0/examples/django_app/runtime_di_demo/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+from examples.django_app.runtime_di_demo.views import di_demo, index
+
+
+urlpatterns = [
+    path("", index),
+    path("di-demo/<str:name>", di_demo),
+    path("hello/<str:name>/", di_demo),
+]

py_autowired-0.2.0/examples/django_app/runtime_di_demo/views.py

@@ -0,0 +1,45 @@
+from django.http import HttpResponse, JsonResponse
+
+from examples.shared.bootstrap.dependency_injection.composition import configure_dependencies
+
+
+DEMO_HOME_HTML = """<!doctype html>
+<html lang="tr"><head><meta charset="utf-8"><title>py-autowired DI Demo</title></head>
+<body><h1>py-autowired Runtime DI Demo</h1>
+<p>Beş katmanlı auto-inject zincirini JSON olarak görmek için bağlantıyı açın.</p>
+<p><a href="/di-demo/Ayhan">/di-demo/Ayhan</a></p></body></html>"""
+
+
+class DjangoController:
+    def __init__(self):
+        self.greeting_service_instance = None
+
+    def execute(self, name: str) -> dict[str, object]:
+        message = self.greeting_service_instance.greet(name)
+        return {
+            "message": message,
+            "injection_trace": [
+                {
+                    "chain_level": 1,
+                    "module_depth": len(type(self).__module__.split(".")),
+                    "module": type(self).__module__,
+                    "class": type(self).__name__,
+                    "injected_field": "greeting_service_instance",
+                    "injected_type": type(self.greeting_service_instance).__name__,
+                    "method": "execute()",
+                    "result": message,
+                    "instance_id": id(self),
+                },
+                *self.greeting_service_instance.injection_trace(name),
+            ],
+        }
+
+
+def index(_request):
+    return HttpResponse(DEMO_HOME_HTML)
+
+
+def di_demo(_request, name: str):
+    container = configure_dependencies()
+    with container.create_scope():
+        return JsonResponse(DjangoController().execute(name))

py_autowired-0.2.0/examples/fastapi_app/app.py

@@ -0,0 +1,78 @@
+from contextlib import asynccontextmanager
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from examples.shared.bootstrap.dependency_injection.composition import configure_dependencies
+
+
+DEMO_HOME_HTML = """<!doctype html>
+<html lang="tr"><head><meta charset="utf-8"><title>py-autowired DI Demo</title></head>
+<body><h1>py-autowired Runtime DI Demo</h1>
+<p>Beş katmanlı auto-inject zincirini JSON olarak görmek için bağlantıyı açın.</p>
+<p><a href="/di-demo/Ayhan">/di-demo/Ayhan</a></p></body></html>"""
+
+
+class FastApiController:
+    def __init__(self):
+        self.greeting_service_instance = None
+
+    def execute(self, name: str) -> dict[str, object]:
+        message = self.greeting_service_instance.greet(name)
+        return {
+            "message": message,
+            "injection_trace": [
+                {
+                    "chain_level": 1,
+                    "module_depth": len(type(self).__module__.split(".")),
+                    "module": type(self).__module__,
+                    "class": type(self).__name__,
+                    "injected_field": "greeting_service_instance",
+                    "injected_type": type(self.greeting_service_instance).__name__,
+                    "method": "execute()",
+                    "result": message,
+                    "instance_id": id(self),
+                },
+                *self.greeting_service_instance.injection_trace(name),
+            ],
+        }
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    configure_dependencies()
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    return HTMLResponse(DEMO_HOME_HTML)
+
+
+@app.get("/di-demo/{name}")
+async def di_demo(name: str):
+    container = configure_dependencies()
+    async with container.create_scope():
+        return FastApiController().execute(name)
+
+
+@app.get("/hello/{name}", include_in_schema=False)
+async def hello(name: str):
+    return await di_demo(name)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    print("py-autowired: 5 katmanli Runtime DI demosu")
+    print("Tarayicida acin: http://127.0.0.1:8101/di-demo/Ayhan")
+    print("JSON cevabinda injection_trace alanini inceleyin.")
+    uvicorn.run(app, host="127.0.0.1", port=8101)