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

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

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

{fastapi_startkit-0.1.0 → fastapi_startkit-0.1.2}/fastapi_startkit/application.py

@@ -1,24 +1,34 @@
-from dotenv import load_dotenv
+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):
@@ -38,3 +48,16 @@ class Application(Container):
 
     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.0 → fastapi_startkit-0.1.2}/fastapi_startkit/configuration/Configuration.py

@@ -1,4 +1,4 @@
-from fastapi_startkit_foundation.loader import Loader
+from fastapi_startkit.loader import Loader
 from ..utils.structures import data
 from ..exceptions import InvalidConfigurationLocation, InvalidConfigurationSetup
 

{fastapi_startkit-0.1.0 → fastapi_startkit-0.1.2}/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.0 → fastapi_startkit-0.1.2}/fastapi_startkit/facades/Facade.py

@@ -1,5 +1,11 @@
 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/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.2/fastapi_startkit/logging/Logger.py

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

fastapi_startkit-0.1.2/fastapi_startkit/logging/__init__.py

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

fastapi_startkit-0.1.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/fastapi_startkit/logging/configs/logging.py

@@ -0,0 +1,46 @@
+""" 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/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.2/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) 
+    

fastapi_startkit-0.1.2/fastapi_startkit/logging/drivers/LogSlackDriver.py

@@ -0,0 +1,94 @@
+import os
+from .BaseDriver import BaseDriver
+import requests
+
+class LogSlackDriver(BaseDriver):
+
+    def __init__(self, *args, **kwargs):
+        self.slack_url = 'https://slack.com/api/chat.postMessage'
+        self.token = kwargs.get('token')
+        self.channel = kwargs.get('channel')
+        self.emoji = kwargs.get('emoji', ':warning:')
+        self.username = kwargs.get('username')
+
+    def emergency(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'EMERGENCY')
+        )
+
+    def alert(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'ALERT')
+        )
+
+    def critical(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'CRITICAL')
+        )
+
+    def error(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'ERROR')
+        )
+
+    def warning(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'WARNING')
+        )
+
+    def notice(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'NOTICE')
+        )
+
+    def info(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'INFO')
+        )
+
+    def debug(self, message, *args, **kwargs):
+        self.send(
+            self.get_format(message, 'DEBUG')
+        )
+
+    def get_format(self, message, level):
+        return "{time} - {level} - {message}".format(
+            time=self.get_time().to_datetime_string(),
+            message=message,
+            level=level
+        )
+
+    def send(self, message):
+        requests.post(self.slack_url, {
+            'token': self.token,
+            'channel': self.find_channel(self.channel),
+            'text': message,
+            'username': self.username,
+            'icon_emoji': self.emoji,
+            'as_user': False,
+            'reply_broadcast': True,
+            'unfurl_links': True,
+            'unfurl_media': True,
+        })
+
+    def find_channel(self, name):
+        """Calls the Slack API to find the channel name. 
+        This is so we do not have to specify the channel ID's. Slack requires channel ID's
+        to be used.
+        Arguments:
+            name {string} -- The channel name to find.
+        Raises:
+            SlackChannelNotFound -- Thrown if the channel name is not found.
+        Returns:
+            self
+        """
+        response = requests.post('https://slack.com/api/channels.list', {
+            'token': self.token
+        })
+
+        for channel in response.json()['channels']:
+            if channel['name'] == name.split('#')[1]:
+                return channel['id']
+
+        raise SlackChannelNotFound(
+            'Could not find the {} channel'.format(name))

fastapi_startkit-0.1.2/fastapi_startkit/logging/drivers/LogSyslogDriver.py

@@ -0,0 +1,48 @@
+from .BaseDriver import BaseDriver
+import logging
+import logging.handlers
+
+class LogSyslogDriver(BaseDriver):
+
+    def __init__(self, *args, **kwargs):
+        self.log = logging.getLogger('root')
+        path = kwargs.get('path')
+        
+        handler = logging.handlers.SysLogHandler(address = path)
+
+        formatter = logging.Formatter('{} - %(levelname)s - %(message)s'.format(self.get_time().to_datetime_string()))
+        handler.setFormatter(formatter)
+
+        self.log.addHandler(handler)
+
+    def emergency(self, message):
+        self.log.setLevel(logging.CRITICAL)
+        return self.log.critical(message)
+
+    def alert(self, message):
+        self.log.setLevel(logging.CRITICAL)
+        return self.log.critical(message)
+
+    def critical(self, message):
+        self.log.setLevel(logging.CRITICAL)
+        return self.log.critical(message)
+
+    def error(self, message):
+        self.log.setLevel(logging.ERROR)
+        return self.log.error(message)
+
+    def warning(self, message):
+        self.log.setLevel(logging.WARNING)
+        return self.log.warning(message)
+
+    def notice(self, message):
+        self.log.setLevel(logging.NOTICE)
+        return self.log.info(message)
+
+    def info(self, message):
+        self.log.setLevel(logging.INFO)
+        return self.log.info(message)
+
+    def debug(self, message):
+        self.log.setLevel(logging.DEBUG)
+        return self.log.debug(message)

fastapi_startkit-0.1.2/fastapi_startkit/logging/drivers/LogTerminalDriver.py

@@ -0,0 +1,60 @@
+# from logging import Logger
+import os
+
+from fastapi_startkit.facades import Config
+from fastapi_startkit.utils.console import HasColoredOutput
+
+from .BaseDriver import BaseDriver
+
+
+class LogTerminalDriver(BaseDriver, HasColoredOutput):
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def emergency(self, message):
+        super().warning(
+            self.get_format(message, 'EMERGENCY')
+        )
+
+    def alert(self, message):
+        super().warning(
+            self.get_format(message, 'ALERT')
+        )
+
+    def critical(self, message):
+        super().warning(
+            self.get_format(message, 'CRITICAL')
+        )
+
+    def error(self, message):
+        super().warning(
+            self.get_format(message, 'ERROR')
+        )
+
+    def warning(self, message):
+        super().warning(
+            self.get_format(message, 'WARNING')
+        )
+
+    def notice(self, message):
+        super().warning(
+            self.get_format(message, 'NOTICE')
+        )
+
+    def info(self, message):
+        super().warning(
+            self.get_format(message, 'INFO')
+        )
+
+    def debug(self, message):
+        super().warning(
+            self.get_format(message, 'DEBUG')
+        )
+
+    def get_format(self, message, level):
+        return '{time} - {level} - {message}'.format(
+                time=self.get_time().to_datetime_string(),
+                level=level,
+                message=message
+            )

fastapi_startkit-0.1.2/fastapi_startkit/logging/drivers/__init__.py

@@ -0,0 +1,5 @@
+from .LogSingleDriver import LogSingleDriver
+from .LogTerminalDriver import LogTerminalDriver
+from .LogSlackDriver import LogSlackDriver
+from .LogSyslogDriver import LogSyslogDriver
+from .BaseDriver import BaseDriver

fastapi_startkit-0.1.2/fastapi_startkit/logging/factory.py

@@ -0,0 +1,15 @@
+from .drivers import LogSingleDriver, LogTerminalDriver, LogSlackDriver, LogSyslogDriver
+class DriverFactory:
+
+    drivers = {
+        'single': LogSingleDriver,
+        'daily': LogSingleDriver,
+        'slack': LogSlackDriver,
+        'syslog': LogSyslogDriver,
+        'terminal': LogTerminalDriver
+    }
+
+    @classmethod
+    def make(cls, driver):
+        return cls.drivers.get(driver)
+

fastapi_startkit-0.1.2/fastapi_startkit/logging/listeners.py

@@ -0,0 +1,15 @@
+from .Logger import Logger
+
+class LoggerExceptionListener:
+
+    listens = ['*']
+
+    def __init__(self, logger: Logger):
+        self.logger = logger
+
+    def handle(self, exception, file, line):
+        self.logger.error("{} in {} on line {}".format(
+            exception.__class__.__name__, 
+            file,
+            line
+        ))

fastapi_startkit-0.1.2/fastapi_startkit/logging/managers/LoggingManager.py

@@ -0,0 +1,11 @@
+class LoggingManager:
+
+    # config = 'LoggingConfig'
+    # driver_prefix = 'Logging'
+
+    def __init__(self, channel_factory=None, driver_factory=None):
+        self.channel_factory = channel_factory
+        self.driver_factory = driver_factory
+
+    def channel(self, channel):
+        return self.channel_factory.make(channel)()

fastapi_startkit-0.1.2/fastapi_startkit/logging/managers/__init__.py

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

fastapi_startkit-0.1.2/fastapi_startkit/logging/providers/LoggingProvider.py

@@ -0,0 +1,25 @@
+from fastapi_startkit.providers import Provider
+
+from ..ChannelFactory import ChannelFactory
+from ..Logger import Logger
+from ..factory import DriverFactory
+from ..listeners import LoggerExceptionListener
+from ..managers import LoggingManager
+
+
+class LoggingProvider(Provider):
+    def register(self):
+        self.application.bind('LogChannelFactory', ChannelFactory)
+        self.application.bind('LogDriverFactory', DriverFactory)
+        self.application.bind('LoggingManager', LoggingManager(ChannelFactory, DriverFactory))
+        self.application.simple(LoggerExceptionListener)
+
+    def boot(self):
+        config = self.application.make('config')
+        if not config.get('logging.default'):
+            return
+        logger = self.application.make('LoggingManager')
+        channel = logger.channel(config.get('logging.default'))
+
+        self.application.bind('logger', channel)
+        self.application.swap(Logger, channel)

fastapi_startkit-0.1.2/fastapi_startkit/logging/providers/__init__.py

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

fastapi_startkit-0.1.2/fastapi_startkit/providers/__init__.py

@@ -0,0 +1,3 @@
+from .Provider import Provider
+
+__all__ = ["Provider"]

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

@@ -1,7 +1,7 @@
 [project]
 name = "fastapi-startkit"
-version = "0.1.0"
-description = "Core Masonite components (Container, Config, Loader)"
+version = "0.1.2"
+description = "Fastapi_Startkit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}
 ]

fastapi_startkit-0.1.0/fastapi_startkit/providers/ConfigurationProvider.py

@@ -1,13 +0,0 @@
-from .Provider import Provider
-from ..configuration import Configuration
-import os
-
-class ConfigurationProvider(Provider):
-    def register(self):
-        self.application.bind('config.location', os.path.join(self.application.base_path, "config"))
-        configuration = Configuration(self.application)
-        configuration.load()
-        self.application.bind("config", configuration)
-
-    def boot(self):
-        pass

fastapi_startkit-0.1.0/fastapi_startkit/providers/__init__.py

@@ -1,4 +0,0 @@
-from .Provider import Provider
-from .ConfigurationProvider import ConfigurationProvider
-
-__all__ = ["Provider", "ConfigurationProvider"]