l4py 0.0.1__tar.gz

l4py-0.0.1/LICENSE

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

l4py-0.0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: l4py
+Version: 0.0.1
+Home-page: https://github.com/roymanigley/l4py
+Author: Roy Manigley
+Author-email: roy.manigley@gmail.com
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# l4py
+![Unit-Tests](https://github.com/roymanigley/l4py/actions/workflows/test.yml/badge.svg)  
+![Published Python Package](https://github.com/roymanigley/l4py/actions/workflows/publish.yml/badge.svg)
+
+## Installation
+```
+pip install l4py
+```
+or from Github:
+```
+git clone https://github.com/roymanigley/l4py.git
+cd l4py
+pip install -r requirements.txt
+python setup.py install
+```
+## Usage
+
+```python
+from l4py import Builder
+```

l4py-0.0.1/README.md

@@ -0,0 +1,20 @@
+# l4py
+![Unit-Tests](https://github.com/roymanigley/l4py/actions/workflows/test.yml/badge.svg)  
+![Published Python Package](https://github.com/roymanigley/l4py/actions/workflows/publish.yml/badge.svg)
+
+## Installation
+```
+pip install l4py
+```
+or from Github:
+```
+git clone https://github.com/roymanigley/l4py.git
+cd l4py
+pip install -r requirements.txt
+python setup.py install
+```
+## Usage
+
+```python
+from l4py import Builder
+```

l4py-0.0.1/l4py/__init__.py

@@ -0,0 +1,2 @@
+from .builder import LogBuilder as Builder
+from .builder import DjangoLogBuilder as DjangoBuilder

l4py-0.0.1/l4py/builder.py

@@ -0,0 +1,198 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+from l4py import utils
+from l4py.formatters import TextFormatter, JsonFormatter
+
+
+class LogBuilder:
+    __text_formatter = TextFormatter()
+    __json_formatter = JsonFormatter()
+
+    __console_format = None
+    __console_json = False
+    __console_level = None
+
+    __file = None
+    __file_format = None
+    __file_json = True
+    __file_level = None
+    __file_max_size = 10 * 1024 * 1024  # 10 MB (default)
+    __file_max_count = 5  # Default 5 backup files
+
+    def text_formatter(self, text_formatter: logging.Formatter) -> 'LogBuilder':
+        self.__text_formatter = text_formatter
+        return self
+
+    def json_formatter(self, json_formatter: logging.Formatter) -> 'LogBuilder':
+        self.__json_formatter = json_formatter
+        return self
+
+    def console_format(self, format_str: str) -> 'LogBuilder':
+        self.__console_format = format_str
+        return self
+
+    def console_json(self, value: bool) -> 'LogBuilder':
+        self.__console_json = value
+        return self
+
+    def console_level(self, level: int) -> 'LogBuilder':
+        self.__console_level = level
+        return self
+
+    def file(self, file_name: str) -> 'LogBuilder':
+        self.__file = file_name
+        return self
+
+    def file_format(self, format_str: str) -> 'LogBuilder':
+        self.__file_format = format_str
+        return self
+
+    def file_json(self, value: bool) -> 'LogBuilder':
+        self.__file_json = value
+        return self
+
+    def file_level(self, level: int) -> 'LogBuilder':
+        self.__file_level = level
+        return self
+
+    def file_max_size_mb(self, size_in_mb: int) -> 'LogBuilder':
+        self.__file_max_size = size_in_mb * 1024 * 1024
+        return self
+
+    def file_max_count(self, count: int) -> 'LogBuilder':
+        self.__file_max_count = count
+        return self
+
+    def build(self, logger_name: str = 'python-app') -> logging.Logger:
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(logging.DEBUG)
+
+        console_handler = self.__build_console_handler(logger_name)
+        logger.addHandler(console_handler)
+
+        if self.__file:
+            file_handler = self.__build_file_handler(logger_name)
+            logger.addHandler(file_handler)
+
+        return logger
+
+    def __build_console_handler(self, logger_name: str) -> logging.Handler:
+        console_handler = logging.StreamHandler()
+        log_level = self.__console_level
+        if log_level is None:
+            log_level = utils.get_log_level(logger_name)
+        console_handler.setLevel(log_level)
+        if self.__console_format:
+            console_formatter = logging.Formatter(self.__console_format)
+        elif self.__console_json:
+            console_formatter = self.__json_formatter
+        else:
+            console_formatter = self.__text_formatter
+        console_handler.setFormatter(console_formatter)
+        return console_handler
+
+    def __build_file_handler(self, logger_name: str) -> logging.Handler:
+        file_handler = RotatingFileHandler(
+            self.__file,
+            maxBytes=self.__file_max_size,
+            backupCount=self.__file_max_count
+        )
+        log_level = self.__file_level
+        if log_level is None:
+            log_level = utils.get_log_level(logger_name)
+        file_handler.setLevel(log_level)
+        if self.__file_format:
+            file_formatter = logging.Formatter(self.__file_format)
+        elif self.__file_json:
+            file_formatter = self.__json_formatter
+        else:
+            file_formatter = self.text_formatter
+        file_handler.setFormatter(file_formatter)
+        return file_handler
+
+
+class DjangoLogBuilder:
+    __text_formatter = TextFormatter()
+    __json_formatter = JsonFormatter()
+
+    __console_json = False
+
+    __file = None
+    __file_json = True
+    __file_max_size = 10 * 1024 * 1024  # 10 MB (default)
+    __file_max_count = 5  # Default 5 backup files
+
+    def console_json(self, value: bool) -> 'DjangoLogBuilder':
+        self.__console_json = value
+        return self
+
+    def file(self, file_name: str) -> 'DjangoLogBuilder':
+        self.__file = file_name
+        return self
+
+    def file_json(self, value: bool) -> 'DjangoLogBuilder':
+        self.__file_json = value
+        return self
+
+    def file_max_size_mb(self, size_in_mb: int) -> 'DjangoLogBuilder':
+        self.__file_max_size = size_in_mb * 1024 * 1024
+        return self
+
+    def file_max_count(self, count: int) -> 'DjangoLogBuilder':
+        self.__file_max_count = count
+        return self
+
+    def build_config_4_django(self, django_log_level=None, show_sql=False) -> dict:
+        django_log_level = django_log_level if django_log_level else utils.get_log_level_root()
+        django_config = {
+            'version': 1,
+            'disable_existing_loggers': False,
+            'filters': {
+                'trace_id': {
+                    '()': 'kydo.logging_helpers.TraceIDFilter',
+                },
+                'stack_trace': {
+                    '()': 'kydo.logging_helpers.StackTraceFilter',
+                },
+            },
+            'handlers': {
+                'console': {
+                    'class': 'logging.StreamHandler',
+                    'filters': ['trace_id', 'stack_trace'],
+                    'formatter': 'default',
+                },
+                'file': {
+                    'class': 'logging.handlers.RotatingFileHandler',
+                    'filename': self.__file,
+                    'maxBytes': self.__file_max_size,
+                    'backupCount': self.__file_max_count,
+                    'filters': ['trace_id', 'stack_trace'],
+                    'formatter': 'json',
+                },
+            },
+            'root': {
+                'level': utils.get_log_level_root(),
+            },
+            'loggers': {
+                'django': {
+                    'level': django_log_level,
+                    'propagate': False,
+                },
+                'django.db.backends': {
+                    'handlers': ['console', 'file'],
+                    'level': 'DEBUG' if show_sql else django_log_level,
+                    'propagate': False,
+                },
+            },
+            'formatters': {
+                'json': {
+                    '()': f'{JsonFormatter.__module__}.{JsonFormatter.__name__}',
+                },
+                'default': {
+                    '()': f'{TextFormatter.__module__}.{TextFormatter.__name__}',
+                },
+            },
+        }
+        return django_config

l4py-0.0.1/l4py/formatters.py

@@ -0,0 +1,55 @@
+import json
+import logging
+from datetime import datetime
+
+from l4py import utils
+
+
+class FormatTimeMixin():
+    def formatTime(self, record, datefmt=None):
+        ct = datetime.fromtimestamp(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)
+        else:
+            return ct.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(record.msecs):03d}"
+
+
+class JsonFormatter(FormatTimeMixin, logging.Formatter):
+
+    def __init__(self, app_name=utils.get_app_name()):
+        super().__init__()
+        self.app_name = app_name
+
+    def format(self, record):
+        log_record = {
+            "timestamp": self.formatTime(record),
+            "app_name": self.app_name,
+            "logger_name": record.name,
+            "level": record.levelname,
+            "file_name": record.filename,
+            "line_number": record.lineno,
+            "function_name": record.funcName,
+            "message": record.msg,
+        }
+        return json.dumps(log_record)
+
+
+class TextFormatter(FormatTimeMixin, logging.Formatter):
+
+    def __init__(self, app_name=utils.get_app_name()):
+        super().__init__()
+        self.app_name = app_name
+
+    def format(self, record):
+        log_record = {
+            "timestamp": self.formatTime(record),
+            "app_name": self.app_name,
+            "logger_name": record.name,
+            "level": record.levelname,
+            "file_name": record.filename,
+            "line_number": record.lineno,
+            "function_name": record.funcName,
+            "message": record.msg,
+        }
+        return '{timestamp} [{level:<8}] {app_name} {file_name}:{line_number} {function_name}: {message}'.format(
+            **log_record)

l4py-0.0.1/l4py/l4py.py

@@ -0,0 +1,17 @@
+from .builder import LogBuilder
+
+if __name__ == '__main__':
+    class TestLogger:
+
+        logger = LogBuilder()\
+            .file('test.log')\
+            .build(__name__)
+
+        def test(self):
+            self.logger.debug("This is a debug message")
+            self.logger.info("This is an info message")
+            self.logger.warning("This is a warning message")
+            self.logger.error("This is an error message")
+            self.logger.critical("This is a critical message")
+
+    TestLogger().test()

l4py-0.0.1/l4py/utils.py

@@ -0,0 +1,49 @@
+import logging
+import os
+
+_LOG_LEVEL_PREFIX = 'PYTHON_LOG_LEVEL_'
+_LOG_LEVEL_ROOT_KEY = f'{_LOG_LEVEL_PREFIX}ROOT'
+_LOG_LEVEL_LOGGER_KEY_FORMAT = f'{_LOG_LEVEL_PREFIX}{{}}'
+
+logging_env_vars = [
+    {'key': key, 'value': value}
+    for key, value in os.environ.items()
+    if key.startswith(_LOG_LEVEL_PREFIX)
+]
+logging_env_vars.sort(key=lambda item: item['key'])
+
+
+def get_app_name() -> str:
+    return os.environ.get('PYTHON_APP_NAME', 'python-app')
+
+
+def get_log_level_root() -> str:
+    return os.environ.get(_LOG_LEVEL_ROOT_KEY, logging.INFO)
+
+
+def get_log_level(logger_name: str) -> str:
+    log_level = get_log_level_root()
+    for key, value in [(v['key'], v['value']) for v in logging_env_vars]:
+        if key.startswith(_LOG_LEVEL_PREFIX):
+            logger_name_for_level = _LOG_LEVEL_LOGGER_KEY_FORMAT.format(logger_name)
+            if key == logger_name_for_level:
+                return value
+            elif (logger_name_for_level).startswith(key + '.'):
+                log_level = value
+    return log_level
+
+
+if __name__ == '__main__':
+    logger_name = 'logger.name'
+    os.environ.setdefault(f'{_LOG_LEVEL_PREFIX}logger', 'WARN')
+    os.environ.setdefault(f'{_LOG_LEVEL_PREFIX}logger.name', 'INFO')
+    os.environ.setdefault(f'{_LOG_LEVEL_PREFIX}logger.name_not', 'DEBUG')
+    os.environ.setdefault(f'{_LOG_LEVEL_PREFIX}logger.name_n', 'FATAL')
+
+    print(get_log_level('logger'))
+    print(get_log_level('logger.name'))
+    print(get_log_level('logger.name_not'))
+    print(get_log_level('logger.name_n'))
+    print(get_log_level('logger.name_naaaaa'))
+
+    print(logging.getLevelNamesMapping())

l4py-0.0.1/l4py.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: l4py
+Version: 0.0.1
+Home-page: https://github.com/roymanigley/l4py
+Author: Roy Manigley
+Author-email: roy.manigley@gmail.com
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# l4py
+![Unit-Tests](https://github.com/roymanigley/l4py/actions/workflows/test.yml/badge.svg)  
+![Published Python Package](https://github.com/roymanigley/l4py/actions/workflows/publish.yml/badge.svg)
+
+## Installation
+```
+pip install l4py
+```
+or from Github:
+```
+git clone https://github.com/roymanigley/l4py.git
+cd l4py
+pip install -r requirements.txt
+python setup.py install
+```
+## Usage
+
+```python
+from l4py import Builder
+```

l4py-0.0.1/l4py.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+l4py/__init__.py
+l4py/builder.py
+l4py/formatters.py
+l4py/l4py.py
+l4py/utils.py
+l4py.egg-info/PKG-INFO
+l4py.egg-info/SOURCES.txt
+l4py.egg-info/dependency_links.txt
+l4py.egg-info/top_level.txt

l4py-0.0.1/l4py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

l4py-0.0.1/l4py.egg-info/top_level.txt

@@ -0,0 +1 @@
+l4py

l4py-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

l4py-0.0.1/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup
+
+long_description = open('README.md', "rt").read()
+
+setup(
+    name='l4py',
+    version='0.0.1',
+    description='',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/roymanigley/l4py',
+    author='Roy Manigley',
+    author_email='roy.manigley@gmail.com',
+    license='MIT',
+    packages=['l4py'],
+    install_requires=[],
+
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 3.11',
+    ],
+)