fastapi-startkit 0.1.2__tar.gz → 0.1.3__tar.gz

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-startkit
-Version: 0.1.2
+Version: 0.1.3
 Summary: Fastapi_Startkit components
 Author: Bedram Tamang
 Author-email: tmgbedu@gmail.com

fastapi_startkit-0.1.3/fastapi_startkit/application.py

@@ -0,0 +1,132 @@
+import os
+from typing import Type, Callable, Any
+
+from fastapi import FastAPI, APIRouter
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from .container import Container
+from .environment.environment import LoadEnvironment
+from .configuration.providers import ConfigurationProvider
+
+def app() -> 'Container':
+    return Container.instance()
+
+class Application(Container):
+    DEFAULT_PROVIDERS = [
+        ConfigurationProvider,
+    ]
+
+    def __init__(self, base_path: str = None, providers=None):
+        super().__init__()
+
+        self.base_path: str = base_path
+        self.providers = self.DEFAULT_PROVIDERS + (providers or [])
+        self.published_resources = {}
+
+        # Set global singleton
+        Container.set_instance(self)
+
+        # Boot application
+        self.load_environment()
+        self.configure_paths()
+        self.register_providers()
+
+        self._fastapi = FastAPI()
+        self.load_providers()
+
+    def register_providers(self):
+        providers = []
+        for provider_data in self.providers:
+            config = {}
+            if isinstance(provider_data, tuple):
+                provider_class, config = provider_data
+            else:
+                provider_class = provider_data
+
+            provider = provider_class(self, config=config)
+            provider.register()
+            providers.append(provider)
+
+        self.providers = providers
+        return self
+
+    def load_providers(self):
+        for provider in self.providers:
+            self.resolve(provider.boot)
+        return self
+
+    def use_fastapi(self, fastapi: FastAPI):
+        self._fastapi = fastapi
+        return self
+
+    def get(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.get(path, **kwargs)
+
+    def post(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.post(path, **kwargs)
+
+    def put(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.put(path, **kwargs)
+
+    def delete(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.delete(path, **kwargs)
+
+    def patch(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.patch(path, **kwargs)
+
+    def options(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.options(path, **kwargs)
+
+    def head(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.head(path, **kwargs)
+
+    def trace(self, path: str, **kwargs) -> Callable:
+        return self._fastapi.trace(path, **kwargs)
+
+    # Include routers
+    def include_router(self, router: APIRouter, **kwargs):
+        self._fastapi.include_router(router, **kwargs)
+        return self
+
+    # Add middleware
+    def add_middleware(self, middleware_class: Type[BaseHTTPMiddleware], **options):
+        self._fastapi.add_middleware(middleware_class, **options)
+        return self
+
+    # Add event handlers (startup/shutdown)
+    def add_event_handler(self, event_type: str, func: Callable[..., Any]):
+        self._fastapi.add_event_handler(event_type, func)
+        return self
+
+    # Mount sub-apps
+    def mount(self, path: str, app_instance: FastAPI, **kwargs):
+        self._fastapi.mount(path, app_instance, **kwargs)
+        return self
+
+    # Add custom exception handlers
+    def add_exception_handler(self, exc_class_or_status_code: Any, handler: Callable[..., Any]):
+        self._fastapi.add_exception_handler(exc_class_or_status_code, handler)
+        return self
+
+    @property
+    def fastapi(self) -> FastAPI:
+        return self._fastapi
+
+    def __call__(self, *args, **kwargs):
+        return self._fastapi
+
+    def load_environment(self):
+        LoadEnvironment(base_path=self.base_path)
+
+    def configure_paths(self):
+        self.bind('config.location', os.path.join(self.base_path, "config"))
+
+    def use_config_path(self, path: str = None):
+        self.bind('config.location', path)
+
+        return self
+
+    def use_storage_path(self, path: str = None):
+        self.bind('storage.location', path)
+
+        return self

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/fastapi_startkit/configuration/Configuration.py

@@ -33,11 +33,6 @@ class Configuration:
             for name, value in params.items():
                 self._config[f"{module_name}.{name.lower()}"] = value
 
-        # check loaded configuration
-        if not self._config.get("application"):
-            raise InvalidConfigurationLocation(
-                f"Config directory {config_root} does not contain required configuration files."
-            )
 
     def merge_with(self, path, external_config):
         """Merge external config at key with project config at same key. It's especially
@@ -53,7 +48,7 @@ class Configuration:
             )
         if isinstance(external_config, str):
             # config is a path and should be loaded
-            params = Loader.get_parameters(external_config)
+            params = Loader().get_parameters(external_config)
         else:
             params = external_config
         base_config = {name.lower(): value for name, value in params.items()}

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/fastapi_startkit/container/container.py

@@ -15,19 +15,33 @@ class Container:
     Performs bindings and resolving of objects to and from the container.
     """
 
-    objects = {}
-    strict = False
-    override = True
-    resolve_parameters = {}
-    remember = False
-    _hooks = {
-        "make": {},
-        "bind": {},
-        "resolve": {},
-    }
-
-    swaps = {}
-    _remembered = {}
+    _instance = None
+
+    @classmethod
+    def set_instance(cls, instance):
+        cls._instance = instance
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            raise RuntimeError("Container not initialized")
+        return cls._instance
+
+
+    def __init__(self):
+        if not hasattr(self, 'objects'):
+            self.objects = {}
+            self.strict = False
+            self.override = True
+            self.resolve_parameters = {}
+            self.remember = False
+            self._hooks = {
+                "make": {},
+                "bind": {},
+                "resolve": {},
+            }
+            self.swaps = {}
+            self._remembered = {}
 
     def bind(self, name, class_obj):
         """Bind classes into the container with a key value pair.

fastapi_startkit-0.1.3/fastapi_startkit/facades/Facade.py

@@ -0,0 +1,4 @@
+class Facade(type):
+    def __getattr__(self, attribute, *args, **kwargs):
+        from ..application import app
+        return getattr(app().make(self.key), attribute)

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/fastapi_startkit/loader/Loader.py

@@ -25,7 +25,7 @@ class Loader:
         module_paths = list(map(as_filepath, files_or_directories))
         for module_loader, name, _ in pkgutil.iter_modules(module_paths):
             module = load(
-                f"{os.path.relpath(module_loader.path)}.{name}",
+                f"{module_loader.path}/{name}.py",
                 raise_exception=raise_exception,
             )
             _modules.update({name: module})

fastapi_startkit-0.1.3/fastapi_startkit/logging/configs/logging.py

@@ -0,0 +1,20 @@
+from fastapi_startkit.environment.environment import env
+
+DEFAULT = env('LOG_CHANNEL', 'single')
+
+CHANNELS = {
+    'timezone': env('LOG_TIMEZONE', 'UTC'),
+    'single': {
+        'driver': 'single',
+        'level': 'debug',
+        'path': 'storage/logs/single.log'
+    },
+    'stack': {
+        'driver': 'stack',
+        'channels': ['single', 'terminal']
+    },
+    'terminal': {
+        'driver': 'terminal',
+        'level': 'info'
+    }
+}

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/fastapi_startkit/logging/providers/LoggingProvider.py

@@ -1,3 +1,4 @@
+import os
 from fastapi_startkit.providers import Provider
 
 from ..ChannelFactory import ChannelFactory
@@ -9,12 +10,20 @@ from ..managers import LoggingManager
 
 class LoggingProvider(Provider):
     def register(self):
+        self.merge_config_from(self.config, 'logging')
+        source = os.path.abspath(os.path.join(os.path.dirname(__file__), "../configs/logging.py"))
+        self.merge_config_from(source, 'logging')
+
         self.application.bind('LogChannelFactory', ChannelFactory)
         self.application.bind('LogDriverFactory', DriverFactory)
         self.application.bind('LoggingManager', LoggingManager(ChannelFactory, DriverFactory))
         self.application.simple(LoggerExceptionListener)
 
     def boot(self):
+        source = os.path.abspath(os.path.join(os.path.dirname(__file__), "../configs/logging.py"))
+        self.publishes({
+            source: 'config/logging.py'
+        })
         config = self.application.make('config')
         if not config.get('logging.default'):
             return
@@ -23,3 +32,5 @@ class LoggingProvider(Provider):
 
         self.application.bind('logger', channel)
         self.application.swap(Logger, channel)
+
+        self.application.make('logger').info(self.config)

fastapi_startkit-0.1.3/fastapi_startkit/providers/Provider.py

@@ -0,0 +1,21 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..container import Container
+
+class Provider:
+    def __init__(self, application, config: dict = None) -> None:
+        self.application = application
+        self.config = config or {}
+
+    def register(self) -> None:
+        pass
+
+    def boot(self) -> None:
+        pass
+
+    def merge_config_from(self, source: str | dict, key: str) -> None:
+        self.application.make('config').merge_with(key, source)
+
+    def publishes(self, resources: dict, tag: str = None) -> None:
+        self.application.published_resources.update(resources)

fastapi_startkit-0.1.3/fastapi_startkit/tests/configurations/test_config_merge.py

@@ -0,0 +1,54 @@
+from unittest.mock import MagicMock, patch
+from fastapi_startkit.configuration import Configuration
+from fastapi_startkit.loader import Loader
+
+class TestConfiguration:
+    def test_merge_with_dict(self):
+        """Test merge_with accepts a dictionary and merges it as defaults."""
+        app = MagicMock()
+        config = Configuration(app)
+
+        # Set up the existing config
+        config.set('testkey', {'existing_key': 'existing_value'})
+
+        # Dictionary to merge (defaults)
+        defaults = {'new_key': 'new_value', 'existing_key': 'default_value'}
+
+        # Act
+        config.merge_with('testkey', defaults)
+
+        # Assert
+        merged = config.get('testkey')
+        # New keys should be added
+        assert merged['new_key'] == 'new_value'
+        # Existing keys should be PRESERVED (Low Priority behavior of merge_with)
+        # {**base_config, **self.get(path, {})} -> Existing overwrites base
+        assert merged['existing_key'] == 'existing_value'
+
+    def test_merge_with_file_path(self):
+        """Test merge_with accepts a file path, loads it, and merges as defaults."""
+        app = MagicMock()
+        config = Configuration(app)
+
+        # Setup
+        config.set('testkey', {'existing': 'orig'})
+
+        # Mock Loader to return params from file
+        with patch('fastapi_startkit.configuration.Configuration.Loader') as MockLoaderClass:
+            mock_loader = MockLoaderClass.return_value
+            mock_loader.get_parameters.return_value = {
+                'New': 'from_file',
+                'Existing': 'default_from_file'
+            }
+
+            # Act
+            config.merge_with('testkey', '/path/to/config.py')
+
+            # Assert
+            mock_loader.get_parameters.assert_called_once_with('/path/to/config.py')
+
+            merged = config.get('testkey')
+            # Keys are lowercased by merge_with logic: {name.lower(): value ...}
+            assert merged['new'] == 'from_file'
+            # Existing check
+            assert merged['existing'] == 'orig'

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/fastapi_startkit/utils/structures.py

@@ -20,17 +20,16 @@ def load(path, object_name=None, default=None, raise_exception=False):
     Returns:
         {object} -- The value (or default) read in the module or the module if no object name
     """
-    # modularize path if needed
-    module_path = modularize(path)
-    # module = pydoc.locate(dotted_path)
     try:
-        module = importlib.import_module(module_path)
+        name = path.split('/')[-1].replace('.py', '') if '/' in path else path.replace('.py', '')
+        spec = importlib.util.spec_from_file_location(name, path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
     except Exception as e:
         error_message = (
-            f"'{module_path}' not found OR error when importing this module: {str(e)}"
+            f"'{path}' error when loading from file: {str(e)}"
         )
         print("Warning: " + error_message)
-
         if raise_exception:
             raise LoaderNotFound(error_message)
         return None
@@ -42,12 +41,12 @@ def load(path, object_name=None, default=None, raise_exception=False):
             return getattr(module, object_name)
         except KeyError:
             if raise_exception:
-                raise LoaderNotFound(f"{object_name} not found in {module_path}")
+                raise LoaderNotFound(f"{object_name} not found in {path}")
             else:
                 return default
 
 
-def data(dictionary={}):
+def data(dictionary=None):
     """Transform the given dictionary to be read/written with dot notation.
 
     Arguments:
@@ -56,7 +55,7 @@ def data(dictionary={}):
     Returns:
         {dict} -- A dot dictionary
     """
-    return dotty(dictionary)
+    return dotty(dictionary or {})
 
 
 def data_get(dictionary, key, default=None):

{fastapi_startkit-0.1.2 → fastapi_startkit-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.1.2"
+version = "0.1.3"
 description = "Fastapi_Startkit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}

fastapi_startkit-0.1.2/fastapi_startkit/application.py

@@ -1,63 +0,0 @@
-import os
-
-from fastapi import FastAPI
-
-from .container import Container
-from .environment.environment import LoadEnvironment
-from .facades import Facade
-
-
-class Application(Container):
-    def __init__(self, base_path: str = None, providers=None):
-        self.base_path: str = base_path
-        self.providers = providers if providers else []
-        
-        Facade.application = self
-
-        self.load_environment()
-        self.configure_paths()
-        self.register_providers()
-
-        self.fastapi = FastAPI()
-        self.load_providers()
-
-    def register_providers(self):
-        providers = []
-        for provider_class in self.providers:
-            provider = provider_class(self)
-            provider.register()
-            providers.append(provider)
-        
-        self.providers = providers
-        return self
-
-    def load_providers(self):
-        for provider in self.providers:
-            self.resolve(provider.boot)
-        return self
-
-    def use_fastapi(self, fastapi: FastAPI):
-        self.fastapi = fastapi
-        return self
-
-    def get(self, path: str):
-        return self.fastapi.get(path)
-
-    def __call__(self):
-        return self.fastapi
-
-    def load_environment(self):
-        LoadEnvironment(base_path=self.base_path)
-
-    def configure_paths(self):
-        self.bind('config.location', os.path.join(self.base_path, "config"))
-
-    def use_config_path(self, path: str = None):
-        self.bind('config.location', path)
-
-        return self
-
-    def use_storage_path(self, path: str = None):
-        self.bind('storage.location', path)
-
-        return self

fastapi_startkit-0.1.2/fastapi_startkit/facades/Facade.py

@@ -1,11 +0,0 @@
-class Facade(type):
-    
-    application = None
-
-    def __getattr__(self, attribute, *args, **kwargs):
-        if self.application:
-            return getattr(self.application.make(self.key), attribute)
-            
-        from wsgi import application
-
-        return getattr(application.make(self.key), attribute)

fastapi_startkit-0.1.2/fastapi_startkit/logging/configs/logging.py

@@ -1,46 +0,0 @@
-""" Logging Settings """
-
-import os
-from fastapi_startkit.environment.environment import env
-
-"""Default Channel
-"""
-
-DEFAULT=env('LOG_CHANNEL', 'single')
-
-"""Channels
-"""
-CHANNELS = {
-    'timezone': env('LOG_TIMEZONE', 'UTC'),
-    'single': {
-        'driver': 'single',
-        'level': 'debug',
-        'path': 'storage/logs/single.log'
-    },
-    'stack': {
-        'driver': 'stack',
-        'channels': ['single', 'daily', 'slack', 'terminal']
-    },
-    'daily': {
-        'driver': 'daily',
-        'level': 'debug',
-        'path': 'storage/logs'
-    },
-    'terminal': {
-        'driver': 'terminal',
-        'level': 'info',
-    },
-    'slack': {
-        'driver': 'slack',
-        'channel': '#bot',
-        'emoji': ':warning:',
-        'username': 'Logging Bot',
-        'token': env('SLACK_TOKEN', None),
-        'level': 'debug'
-    },
-    'syslog': {
-        'driver': 'syslog',
-        'path': '/var/run/syslog',
-        'level': 'debug'
-    }
-}

fastapi_startkit-0.1.2/fastapi_startkit/providers/Provider.py

@@ -1,14 +0,0 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..container import Container
-
-class Provider:
-    def __init__(self, application) -> None:
-        self.application = application
-
-    def register(self) -> None:
-        pass
-
-    def boot(self) -> None:
-        pass