forge-core-di 0.2.0__tar.gz

forge_core_di-0.2.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.coverage
+dist/
+build/
+.venv/

forge_core_di-0.2.0/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to ForgeCore will be documented here.
+
+---
+
+## [0.2.0] - 2026-06-28
+
+### Added
+- Scoped lifecycle (`ServiceScope.SCOPED`) — one instance per scope context
+- Thread-safe scope via `threading.local()` — safe for concurrent applications
+- Circular dependency detection with clear error messages (`CircularDependencyError`)
+- Optional injection support (`Cache | None = None`)
+- `ServiceProvider` system connected to `ForgeApp` boot pipeline
+- `LifecycleManager` hooks — `on_start` and `on_stop` (LIFO order)
+- `EventBus` connected to `ForgeApp` lifecycle — automatic lifecycle events
+- `EventBus.unsubscribe()`, `has_listeners()`, and `clear()`
+- `ForgeApp` boot guards — prevents double boot, double run, and stop without run
+- Unified resolution pipeline — `get()` and `resolve()` now use the same path
+- Public API — all core classes importable directly from `forgecore`
+- Examples — `trading_bot.py`, `automation.py`, `event_driven.py`
+
+### Changed
+- `ServiceContainer` now enforces explicit registration — no implicit auto-registration
+- `ForgeApp.run()` now calls `boot()` automatically if not already booted
+- `Development Status` classifier updated from Pre-Alpha to Alpha
+
+### Fixed
+- `container.get()` now resolves bindings correctly (previously bypassed binding system)
+- Duplicate `ServiceNotFoundError` definition in `exceptions.py`
+- Forward reference string annotations now resolved correctly in autowiring
+
+---
+
+## [0.1.0] - 2025-01-01
+
+### Added
+- Initial release
+- DI container with singleton and transient lifecycle
+- Constructor autowiring via type hints
+- Service binding — abstraction to implementation mapping
+- Custom factory support
+- `ForgeApp` application kernel
+- `EventBus` runtime event system
+- `LifecycleManager` state machine
+- `Registry` key-value store
+- `PluginManager` runtime extension system

forge_core_di-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+# Contributing to ForgeCore
+
+Thank you for your interest in contributing to ForgeCore.
+
+---
+
+## Requirements
+
+- Python 3.12+
+- Git
+
+---
+
+## Setup
+
+```bash
+git clone https://github.com/akmalmaulana/forgecore
+cd forgecore
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"

forge_core_di-0.2.0/LICENSE

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

forge_core_di-0.2.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: forge-core-di
+Version: 0.2.0
+Summary: Lightweight Dependency Injection and Application Runtime Core for Python.
+Project-URL: Homepage, https://github.com/akmallmline/forgecore
+Project-URL: Repository, https://github.com/akmallmline/forgecore
+Author-email: Akmal Maulana <akmallmline@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: application-kernel,autowiring,dependency-injection,di-container,framework,lifecycle,plugin,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# ForgeCore
+
+Lightweight Dependency Injection and Application Runtime Core for Python.
+
+ForgeCore is a framework engine — not just a DI container. It provides the
+foundation for building web frameworks, CLI tools, bots, trading systems,
+and AI agents in Python.
+
+---
+
+## Features
+
+- Explicit DI container — no magic auto-registration
+- Constructor autowiring via type hints
+- Singleton, Transient, and Scoped lifecycles
+- Thread-safe scoped instances via `threading.local()`
+- Circular dependency detection with clear error messages
+- Optional injection (`Cache | None = None`)
+- Service binding — abstraction to implementation mapping
+- Custom factory support
+- Application kernel with boot pipeline
+- Service provider system for modular registration
+- Lifecycle hooks (`on_start`, `on_stop`)
+- Event system with subscribe, emit, and unsubscribe
+- Plugin system for runtime extension
+
+---
+
+## Requirements
+
+- Python 3.12+
+
+---
+
+## Installation
+
+```bash
+pip install forgecore

forge_core_di-0.2.0/README.md

@@ -0,0 +1,38 @@
+# ForgeCore
+
+Lightweight Dependency Injection and Application Runtime Core for Python.
+
+ForgeCore is a framework engine — not just a DI container. It provides the
+foundation for building web frameworks, CLI tools, bots, trading systems,
+and AI agents in Python.
+
+---
+
+## Features
+
+- Explicit DI container — no magic auto-registration
+- Constructor autowiring via type hints
+- Singleton, Transient, and Scoped lifecycles
+- Thread-safe scoped instances via `threading.local()`
+- Circular dependency detection with clear error messages
+- Optional injection (`Cache | None = None`)
+- Service binding — abstraction to implementation mapping
+- Custom factory support
+- Application kernel with boot pipeline
+- Service provider system for modular registration
+- Lifecycle hooks (`on_start`, `on_stop`)
+- Event system with subscribe, emit, and unsubscribe
+- Plugin system for runtime extension
+
+---
+
+## Requirements
+
+- Python 3.12+
+
+---
+
+## Installation
+
+```bash
+pip install forgecore

forge_core_di-0.2.0/daftar_test.txt

@@ -0,0 +1,22 @@
+./tests/test_application.py
+./tests/test_autowire.py
+./tests/test_binding.py
+./tests/test_binding_resolver.py
+./tests/test_config.py
+./tests/test_context.py
+./tests/test_descriptor.py
+./tests/test_factory.py
+./tests/test_lifecycle.py
+./tests/test_metadata.py
+./tests/test_plugin.py
+./tests/test_plugin_manager.py
+./tests/test_provider.py
+./tests/test_registry.py
+./tests/test_resolver.py
+./tests/test_runtime.py
+./tests/test_scope.py
+./tests/test_service_descriptor_container.py
+./tests/test_services.py
+./tests/test_singleton.py
+./tests/test_validation.py
+./tests/test_version.py

forge_core_di-0.2.0/examples/automation.py

@@ -0,0 +1,75 @@
+from forgecore import (
+    ApplicationMetadata,
+    ForgeApp,
+    ServiceContainer,
+    ServiceProvider,
+)
+
+
+class Config:
+    def __init__(self) -> None:
+        self.base_url = "https://api.example.com"
+        self.hub_id = "prajekan"
+
+
+class SessionManager:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.token = ""
+
+    def login(self) -> None:
+        print(f"Login ke {self.config.base_url}...")
+        self.token = "secret-token-123"
+        print("Login berhasil.")
+
+
+class DataFetcher:
+    def __init__(self, config: Config, session: SessionManager) -> None:
+        self.config = config
+        self.session = session
+
+    def fetch(self, item_id: str) -> dict:
+        return {
+            "id": item_id,
+            "hub": self.config.hub_id,
+            "status": "FOUND",
+            "token_used": self.session.token,
+        }
+
+
+class ReportGenerator:
+    def __init__(self, fetcher: DataFetcher) -> None:
+        self.fetcher = fetcher
+
+    def run(self, ids: list[str]) -> None:
+        print("\n=== REPORT ===")
+        for item_id in ids:
+            result = self.fetcher.fetch(item_id)
+            print(f"{result['id']} → {result['status']}")
+        print("==============")
+
+
+class AppProvider(ServiceProvider):
+    def register(self, container: ServiceContainer) -> None:
+        container.singleton(Config)
+        container.singleton(SessionManager)
+        container.singleton(DataFetcher)
+        container.singleton(ReportGenerator)
+
+    def boot(self, container: ServiceContainer) -> None:
+        session = container.get(SessionManager)
+        session.login()
+
+
+app = ForgeApp(
+    metadata=ApplicationMetadata(
+        name="Automation Example",
+        version="1.0.0",
+    )
+)
+
+app.register_provider(AppProvider())
+app.boot()
+
+report = app.services.get(ReportGenerator)
+report.run(["ID-001", "ID-002", "ID-003"])

forge_core_di-0.2.0/examples/event_driven.py

@@ -0,0 +1,54 @@
+from forgecore import (
+    ApplicationMetadata,
+    Event,
+    EventBus,
+    ForgeApp,
+    ServiceContainer,
+    ServiceProvider,
+)
+
+
+class OrderService:
+    def __init__(self, bus: EventBus) -> None:
+        self.bus = bus
+
+    def place_order(self, item: str, qty: int) -> None:
+        print(f"Order ditempatkan: {qty}x {item}")
+        self.bus.emit(Event(
+            name="order.placed",
+            payload={"item": item, "qty": qty},
+        ))
+
+
+class NotificationService:
+    def on_order_placed(self, event: Event) -> None:
+        item = event.payload["item"]
+        qty = event.payload["qty"]
+        print(f"[Notifikasi] Order baru: {qty}x {item}")
+
+
+class AppProvider(ServiceProvider):
+    def register(self, container: ServiceContainer) -> None:
+        container.singleton(EventBus)
+        container.singleton(OrderService)
+        container.singleton(NotificationService)
+
+    def boot(self, container: ServiceContainer) -> None:
+        bus = container.get(EventBus)
+        notif = container.get(NotificationService)
+        bus.subscribe("order.placed", notif.on_order_placed)
+
+
+app = ForgeApp(
+    metadata=ApplicationMetadata(
+        name="Event Driven Example",
+        version="1.0.0",
+    )
+)
+
+app.register_provider(AppProvider())
+app.boot()
+
+order_service = app.services.get(OrderService)
+order_service.place_order("XAUUSD Contract", 2)
+order_service.place_order("Bitcoin Futures", 1)

forge_core_di-0.2.0/examples/trading_bot.py

@@ -0,0 +1,92 @@
+from forgecore import (
+    ApplicationMetadata,
+    Event,
+    ForgeApp,
+    ServiceContainer,
+    ServiceProvider,
+)
+
+
+class Config:
+    def __init__(self) -> None:
+        self.symbol = "XAUUSD"
+        self.timeframe = "M5"
+        self.risk_percent = 1.0
+
+
+class Logger:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def log(self, msg: str) -> None:
+        print(f"[{self.config.symbol}] {msg}")
+
+
+class MarketData:
+    def __init__(self, config: Config, logger: Logger) -> None:
+        self.config = config
+        self.logger = logger
+
+    def fetch(self) -> dict:
+        self.logger.log("Fetching market data...")
+        return {"price": 2345.50, "trend": "bullish"}
+
+
+class SignalEngine:
+    def __init__(self, data: MarketData, logger: Logger) -> None:
+        self.data = data
+        self.logger = logger
+
+    def analyze(self) -> str | None:
+        market = self.data.fetch()
+        if market["trend"] == "bullish":
+            self.logger.log(f"Signal: BUY at {market['price']}")
+            return "BUY"
+        return None
+
+
+class TelegramNotifier:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def send(self, message: str) -> None:
+        print(f"[Telegram] {message}")
+
+
+class BotProvider(ServiceProvider):
+    def register(self, container: ServiceContainer) -> None:
+        container.singleton(Config)
+        container.singleton(Logger)
+        container.singleton(MarketData)
+        container.singleton(SignalEngine)
+        container.singleton(TelegramNotifier)
+
+    def boot(self, container: ServiceContainer) -> None:
+        pass
+
+
+app = ForgeApp(
+    metadata=ApplicationMetadata(
+        name="XAUUSD Signal Bot",
+        version="1.0.0",
+    )
+)
+
+app.register_provider(BotProvider())
+
+app.events.subscribe("app.running", lambda e: print("Bot aktif..."))
+app.events.subscribe("app.stopped", lambda e: print("Bot dimatikan."))
+
+app.lifecycle.on_start(lambda: print("Koneksi broker dibuka"))
+app.lifecycle.on_stop(lambda: print("Koneksi broker ditutup"))
+
+app.run()
+
+engine = app.services.get(SignalEngine)
+notifier = app.services.get(TelegramNotifier)
+
+signal = engine.analyze()
+if signal:
+    notifier.send(f"Signal: {signal} XAUUSD @ 2345.50")
+
+app.stop()

forge_core_di-0.2.0/grep_scope.txt

@@ -0,0 +1,63 @@
+./src/forgecore/services/__init__.py:7:from .scope import ServiceScope
+./src/forgecore/services/__init__.py:12:    "ServiceScope",
+./src/forgecore/services/container.py:9:from .scope import ServiceScope
+./src/forgecore/services/container.py:22:        scope: ServiceScope = ServiceScope.SINGLETON,
+./src/forgecore/services/container.py:29:            scope=scope,
+./src/forgecore/services/container.py:48:            scope=ServiceScope.SINGLETON,
+./src/forgecore/services/container.py:64:            scope=ServiceScope.TRANSIENT,
+./src/forgecore/services/container.py:80:        if descriptor.scope is ServiceScope.SINGLETON:
+./src/forgecore/services/scope.py:4:class ServiceScope(str, Enum):
+./src/forgecore/services/descriptor.py:7:from .scope import ServiceScope
+./src/forgecore/services/descriptor.py:14:    scope: ServiceScope = ServiceScope.SINGLETON
+./src/forgecore/services/resolver.py:7:from .scope import ServiceScope
+./src/forgecore/services/resolver.py:33:            and descriptor.scope is ServiceScope.SINGLETON
+./src/forgecore/services/resolver.py:72:                scope=ServiceScope.SINGLETON,
+./src/forgecore/services/resolver.py:75:        elif descriptor.scope is ServiceScope.SINGLETON:
+./src/forgecore/lifecycle/__init__.py:1:from .manager import LifecycleManager
+./src/forgecore/lifecycle/__init__.py:2:from .state import LifecycleState
+./src/forgecore/lifecycle/__init__.py:5:    "LifecycleManager",
+./src/forgecore/lifecycle/__init__.py:6:    "LifecycleState",
+./src/forgecore/lifecycle/manager.py:3:from .state import LifecycleState
+./src/forgecore/lifecycle/manager.py:6:class LifecycleManager:
+./src/forgecore/lifecycle/manager.py:8:        self._state = LifecycleState.INITIALIZED
+./src/forgecore/lifecycle/manager.py:11:    def state(self) -> LifecycleState:
+./src/forgecore/lifecycle/manager.py:15:        self._state = LifecycleState.STARTING
+./src/forgecore/lifecycle/manager.py:18:        self._state = LifecycleState.RUNNING
+./src/forgecore/lifecycle/manager.py:21:        self._state = LifecycleState.STOPPING
+./src/forgecore/lifecycle/manager.py:24:        self._state = LifecycleState.STOPPED
+./src/forgecore/lifecycle/state.py:6:class LifecycleState(str, Enum):
+./src/forgecore/application/app.py:38:    def lifecycle(self):
+./src/forgecore/application/app.py:39:        return self.context.lifecycle
+./src/forgecore/application/app.py:42:        self.lifecycle.start()
+./src/forgecore/application/app.py:43:        self.lifecycle.run()
+./src/forgecore/application/app.py:46:        self.lifecycle.stop()
+./src/forgecore/application/app.py:47:        self.lifecycle.shutdown()
+./src/forgecore/context/context.py:4:from forgecore.lifecycle import LifecycleManager
+./src/forgecore/context/context.py:23:        self.lifecycle = LifecycleManager()
+./tests/test_lifecycle.py:1:from forgecore.lifecycle import LifecycleManager, LifecycleState
+./tests/test_lifecycle.py:4:def test_lifecycle():
+./tests/test_lifecycle.py:5:    manager = LifecycleManager()
+./tests/test_lifecycle.py:7:    assert manager.state is LifecycleState.INITIALIZED
+./tests/test_lifecycle.py:10:    assert manager.state is LifecycleState.STARTING
+./tests/test_lifecycle.py:13:    assert manager.state is LifecycleState.RUNNING
+./tests/test_lifecycle.py:16:    assert manager.state is LifecycleState.STOPPING
+./tests/test_lifecycle.py:19:    assert manager.state is LifecycleState.STOPPED
+./tests/test_application.py:2:from forgecore.lifecycle import LifecycleState
+./tests/test_application.py:8:    assert app.lifecycle.state is LifecycleState.INITIALIZED
+./tests/test_application.py:11:    assert app.lifecycle.state is LifecycleState.RUNNING
+./tests/test_application.py:14:    assert app.lifecycle.state is LifecycleState.STOPPED
+./tests/test_context.py:12:    assert app.lifecycle is app.context.lifecycle
+./tests/test_scope.py:1:from forgecore.services.scope import ServiceScope
+./tests/test_scope.py:4:def test_singleton_scope():
+./tests/test_scope.py:5:    assert ServiceScope.SINGLETON.value == "singleton"
+./tests/test_scope.py:8:def test_transient_scope():
+./tests/test_scope.py:9:    assert ServiceScope.TRANSIENT.value == "transient"
+./tests/test_descriptor.py:1:from forgecore.services import ServiceDescriptor, ServiceScope
+./tests/test_descriptor.py:16:    assert descriptor.scope is ServiceScope.SINGLETON
+./tests/test_descriptor.py:20:def test_descriptor_custom_scope():
+./tests/test_descriptor.py:24:        scope=ServiceScope.TRANSIENT,
+./tests/test_descriptor.py:27:    assert descriptor.scope is ServiceScope.TRANSIENT
+./tests/test_service_descriptor_container.py:1:from forgecore.services import ServiceContainer, ServiceScope
+./tests/test_service_descriptor_container.py:8:def test_register_scope():
+./tests/test_service_descriptor_container.py:13:        scope=ServiceScope.TRANSIENT,
+./tests/test_service_descriptor_container.py:18:    assert descriptor.scope is ServiceScope.TRANSIENT

forge_core_di-0.2.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "forge-core-di"
+version = "0.2.0"
+description = "Lightweight Dependency Injection and Application Runtime Core for Python."
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Akmal Maulana", email = "akmallmline@gmail.com" }
+]
+keywords = [
+    "dependency-injection",
+    "di-container",
+    "framework",
+    "application-kernel",
+    "autowiring",
+    "lifecycle",
+    "plugin",
+    "python",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+
+[project.urls]
+Homepage = "https://github.com/akmallmline/forgecore"
+Repository = "https://github.com/akmallmline/forgecore"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/forgecore"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+]