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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: fastapi-startkit
-Version: 0.1.1
-Summary: Core Masonite components (Container, Config, Loader)
+Version: 0.1.3
+Summary: Fastapi_Startkit components
 Author: Bedram Tamang
 Author-email: tmgbedu@gmail.com
 Requires-Python: >=3.12,<4.0

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.1 → 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.1 → fastapi_startkit-0.1.3}/fastapi_startkit/configuration/providers/ConfigurationProvider.py

@@ -4,9 +4,6 @@ from ..Configuration import Configuration
 
 
 class ConfigurationProvider(Provider):
-    def __init__(self, application):
-        self.application = application
-
     def register(self):
         config = Configuration(self.application)
         config.load()

{fastapi_startkit-0.1.1 → 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.1 → 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/ChannelFactory.py

@@ -0,0 +1,20 @@
+from .channels import SingleChannel, DailyChannel, SlackChannel, StackChannel, SyslogChannel, TerminalChannel
+
+class ChannelFactory:
+
+    channels = {
+        'single': SingleChannel,
+        'daily': DailyChannel,
+        'slack': SlackChannel,
+        'stack': StackChannel,
+        'syslog': SyslogChannel,
+        'terminal': TerminalChannel
+    }
+
+    @classmethod
+    def make(cls, channel):
+        return cls.channels.get(channel)
+
+    @classmethod
+    def register(cls, channel_dictionary):
+        cls.channels.update(channel_dictionary)

fastapi_startkit-0.1.3/fastapi_startkit/logging/Logger.py

@@ -0,0 +1,2 @@
+class Logger:
+    pass

fastapi_startkit-0.1.3/fastapi_startkit/logging/__init__.py

@@ -0,0 +1 @@
+from .Logger import Logger

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/BaseChannel.py

@@ -0,0 +1,60 @@
+import pendulum
+from fastapi_startkit.facades import Config
+
+class BaseChannel:
+
+    def get_time(self):
+        
+        return pendulum.now().in_tz(Config.get('logging.channels.timezone', 'UTC'))
+
+    def emergency(self, message, *args, **kwargs):
+        if not self.driver.should_run('emergency', self.max_level):
+            return
+
+        return self.driver.emergency(message, *args, **kwargs)
+
+    def alert(self, message, *args, **kwargs):
+        if not self.driver.should_run('alert', self.max_level):
+            return
+
+        return self.driver.alert(message, *args, **kwargs)
+
+    def critical(self, message, *args, **kwargs):
+        if not self.driver.should_run('critical', self.max_level):
+            return
+
+        return self.driver.critical(message, *args, **kwargs)
+
+    def error(self, message, *args, **kwargs):
+        if not self.driver.should_run('error', self.max_level):
+            return
+
+        return self.driver.error(message, *args, **kwargs)
+
+    def warning(self, message, *args, **kwargs):
+        if not self.driver.should_run('warning', self.max_level):
+            return
+
+        return self.driver.warning(message, *args, **kwargs)
+
+    def notice(self, message, *args, **kwargs):
+        if not self.driver.should_run('notice', self.max_level):
+            return
+
+        return self.driver.notice(message, *args, **kwargs)
+
+    def info(self, message, *args, **kwargs):
+        if not self.driver.should_run('info', self.max_level):
+            return
+
+        return self.driver.info(message, *args, **kwargs)
+        
+    def debug(self, message, *args, **kwargs):
+        if not self.driver.should_run('debug', self.max_level):
+            return
+
+        return self.driver.debug(message, *args, **kwargs)
+
+    def channel(self, channel):
+        from ..ChannelFactory import ChannelFactory
+        return ChannelFactory().make(channel)()

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/DailyChannel.py

@@ -0,0 +1,17 @@
+from ..factory import DriverFactory
+from fastapi_startkit.facades import Config
+from fastapi_startkit.utils.filesystem import make_directory
+import os
+from .BaseChannel import BaseChannel
+
+class DailyChannel(BaseChannel):
+
+    def __init__(self, driver=None, path=None):
+        path = path or Config.get('logging.channels.daily.path')
+        path = os.path.join(path, self.get_time().to_date_string() + '.log')
+        self.max_level = Config.get('logging.channels.daily.level')
+        make_directory(path)
+        self.driver = DriverFactory.make(driver or Config.get('logging.channels.daily.driver'))(path=path, max_level=self.max_level)
+
+    def debug(self, message, *args, **kwargs):
+        return self.driver.debug(message, *args, **kwargs)

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/MultiBaseChannel.py

@@ -0,0 +1,64 @@
+import pendulum
+from fastapi_startkit.facades import Config
+
+class MultiBaseChannel:
+
+    def get_time(self):
+        return pendulum.now().in_tz(Config.get('logging.channels.timezone', 'UTC'))
+
+    def emergency(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('emergency', channel.max_level):
+                continue
+            
+            channel.driver.emergency(message, *args, **kwargs)
+
+    def alert(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('alert', channel.max_level):
+                continue
+            
+            channel.driver.alert(message, *args, **kwargs)
+            
+    def critical(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('critical', channel.max_level):
+                continue
+            
+            channel.driver.critical(message, *args, **kwargs)
+
+    def error(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('error', channel.max_level):
+                continue
+            
+            channel.driver.error(message, *args, **kwargs)
+
+    def warning(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('warning', channel.max_level):
+                continue
+            
+            channel.driver.warning(message, *args, **kwargs)
+
+    def notice(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('notice', channel.max_level):
+                continue
+            
+            channel.driver.notice(message, *args, **kwargs)
+
+    def info(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('info', channel.max_level):
+                continue
+            
+            channel.driver.info(message, *args, **kwargs)
+        
+    def debug(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('debug', channel.max_level):
+                continue
+            
+            channel.driver.debug(message, *args, **kwargs)
+

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/SingleChannel.py

@@ -0,0 +1,14 @@
+from ..factory import DriverFactory
+from fastapi_startkit.facades import Config
+from fastapi_startkit.utils.filesystem import make_directory
+import os
+import pendulum
+from .BaseChannel import BaseChannel
+
+
+class SingleChannel(BaseChannel):
+    def __init__(self, driver=None, path=None):
+        path = path or Config.get('logging.channels.single.path')
+        make_directory(path)
+        self.max_level = Config.get('logging.channels.single.level')
+        self.driver = DriverFactory.make(driver or Config.get('logging.channels.single.driver'))(path=path, max_level=self.max_level)

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/SlackChannel.py

@@ -0,0 +1,19 @@
+
+from ..factory import DriverFactory
+from fastapi_startkit.facades import Config
+import os
+import pendulum
+from .BaseChannel import BaseChannel
+
+class SlackChannel(BaseChannel):
+
+    def __init__(self, driver=None, path=None):
+        token = Config.get('logging.channels.slack.token')
+        channel = Config.get('logging.channels.slack.channel')
+        emoji = Config.get('logging.channels.slack.emoji')
+        username = Config.get('logging.channels.slack.username')
+        self.max_level = Config.get('logging.channels.slack.level')
+        self.driver = DriverFactory.make(driver or Config.get('logging.channels.slack.driver'))(emoji=emoji, username=username, token=token, channel=channel)
+
+    def debug(self, message, *args, **kwargs):
+        return self.driver.debug(message, *args, **kwargs)

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/StackChannel.py

@@ -0,0 +1,30 @@
+from ..factory import DriverFactory
+from fastapi_startkit.facades import Config
+import os
+import pendulum
+from .MultiBaseChannel import MultiBaseChannel
+
+class StackChannel(MultiBaseChannel):
+
+    def __init__(self, channels=[]):
+        channels = channels or Config.get('logging.channels.stack.channels')
+        from ..ChannelFactory import ChannelFactory
+        self.channels = []
+        for channel in channels:
+            channel = ChannelFactory.make(channel)()
+            self.channels.append(channel)
+    
+    def debug(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('debug', channel.max_level):
+                continue
+            
+            channel.driver.debug(message, *args, **kwargs)
+            
+    def notice(self, message, *args, **kwargs):
+        for channel in self.channels:
+            if not channel.driver.should_run('notice', channel.max_level):
+                continue
+            
+            channel.driver.notice(message, *args, **kwargs)
+

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/SyslogChannel.py

@@ -0,0 +1,14 @@
+from ..factory import DriverFactory
+from fastapi_startkit.facades import Config
+from fastapi_startkit.utils.filesystem import make_directory
+import os
+import pendulum
+from .BaseChannel import BaseChannel
+
+class SyslogChannel(BaseChannel):
+
+    def __init__(self, driver=None, path=None):
+        path = path or Config.get('logging.channels.syslog.path')
+        make_directory(path)
+        self.max_level = Config.get('logging.channels.syslog.level')
+        self.driver = DriverFactory.make(driver or Config.get('logging.channels.syslog.driver'))(path=path, max_level=self.max_level)

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/TerminalChannel.py

@@ -0,0 +1,14 @@
+import os
+
+import pendulum
+from fastapi_startkit.facades import Config
+
+from ..factory import DriverFactory
+from ..channels.BaseChannel import BaseChannel
+
+
+class TerminalChannel(BaseChannel):
+
+    def __init__(self, driver=None, path=None):
+        self.max_level = Config.get('logging.channels.terminal.level', 'debug')
+        self.driver = DriverFactory.make(driver or Config.get('logging.channels.terminal.driver'))(path=path, max_level=self.max_level)

fastapi_startkit-0.1.3/fastapi_startkit/logging/channels/__init__.py

@@ -0,0 +1,8 @@
+from .SingleChannel import SingleChannel
+from .TerminalChannel import TerminalChannel
+from .DailyChannel import DailyChannel
+from .SlackChannel import SlackChannel
+from .SyslogChannel import SyslogChannel
+from .StackChannel import StackChannel
+from .BaseChannel import BaseChannel
+from .MultiBaseChannel import MultiBaseChannel

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.3/fastapi_startkit/logging/drivers/BaseDriver.py

@@ -0,0 +1,25 @@
+import pendulum
+from fastapi_startkit.facades import Config
+
+class BaseDriver:
+
+    levels = [
+        'emergency',
+        'alert',
+        'critical',
+        'error',
+        'warning',
+        'notice',
+        'info',
+        'debug',
+    ]
+
+    def get_time(self):
+        return pendulum.now().in_tz(Config.get('logging.channels.timezone', 'UTC'))
+
+    def should_run(self, level, max_level):
+        if not max_level:
+            return True
+
+        return self.levels.index(level) <= self.levels.index(max_level)
+    

fastapi_startkit-0.1.3/fastapi_startkit/logging/drivers/LogSingleDriver.py

@@ -0,0 +1,84 @@
+import logging
+import os
+from .BaseDriver import BaseDriver
+
+class LogSingleDriver(BaseDriver):
+
+    def __init__(self, *args, **kwargs):
+        self.max_level = kwargs.get('max_level')
+        self.path = kwargs.get('path')
+        self.log = logging.getLogger('root')
+
+        handler = logging.FileHandler(self.path, 'a')
+        formatter = logging.Formatter('{} - %(levelname)s - %(message)s'.format(self.get_time().to_datetime_string()))
+        
+        handler.setFormatter(formatter)
+        self.log.addHandler(handler)
+
+    def change_format(self, changed_format):
+        for hdlr in self.log.handlers[:]:  # remove all old handlers
+            self.log.removeHandler(hdlr)
+
+        handler = logging.FileHandler(self.path, 'a')
+        formatter = logging.Formatter(changed_format)
+        
+        handler.setFormatter(formatter)
+
+        self.log.addHandler(handler)
+
+    def emergency(self, message, *args, **kwargs):
+        self.log.setLevel(logging.CRITICAL)
+        self.change_format('{} - {} - %(message)s'.format(
+                self.get_time().to_datetime_string(),
+                'EMERGENCY'))
+        return self.log.critical(message)
+
+    def alert(self, message, *args, **kwargs):
+        self.log.setLevel(logging.CRITICAL)
+        self.change_format('{} - {} - %(message)s'.format(
+                self.get_time().to_datetime_string(),
+                'ALERT'))
+        return self.log.critical(message)
+
+    def critical(self, message, *args, **kwargs):
+        self.log.setLevel(logging.CRITICAL)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'CRITICAL'))
+        return self.log.critical(message)
+
+    def error(self, message, *args, **kwargs):
+        self.log.setLevel(logging.ERROR)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'ERROR'))
+        return self.log.error(message)
+
+    def warning(self, message, *args, **kwargs):
+        self.log.setLevel(logging.WARNING)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'WARNING'))
+        return self.log.warning(message)
+
+    def notice(self, message, *args, **kwargs):
+        self.log.setLevel(logging.INFO)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'NOTICE'))
+        return self.log.info(message)
+
+    def info(self, message, *args, **kwargs):
+        self.log.setLevel(logging.INFO)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'INFO'))
+        return self.log.info(message)
+
+    def debug(self, message, *args, **kwargs):
+        self.log.setLevel(logging.DEBUG)
+        self.change_format('{} - {} - %(message)s'.format(
+            self.get_time().to_datetime_string(),
+            'DEBUG'))
+        return self.log.debug(message) 
+