bosos-dev-tools 0.0.2__tar.gz

bosos_dev_tools-0.0.2/LICENSE

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

bosos_dev_tools-0.0.2/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: bosos-dev-tools
+Version: 0.0.2
+Summary: Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.
+Author-email: Björn Gunnarsson <bosos3@hotmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 bjorngun
+        
+        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.
+        
+Project-URL: Source, https://github.com/bjorngun/developer-tools
+Project-URL: Tracker, https://github.com/bjorngun/developer-tools/issues
+Keywords: development,tools,logging,decorators
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyodbc
+Requires-Dist: python-dotenv
+
+# Bosos Dev Tools
+
+Bosos Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.
+
+## Features
+
+- **Custom Logging Handlers**: Log messages to various destinations, including databases, with customizable formats.
+- **Timing Decorators**: Easily measure the execution time of your functions with minimal code changes.
+- **Progress Bar Utility**: Visualize the progress of long-running operations in the console.
+- **Debug Tools**: Check if debug or timing modes are enabled via environment variables.
+
+## Installation
+
+You can install the package via pip:
+
+```sh
+pip install bosos-dev-tools
+```
+
+## Usage
+
+### Custom Logging Handler
+
+The `LogDBHandler` allows you to log messages directly to a database.
+
+``` py
+import logging
+from dev_tools.custom_handlers import LogDBHandler
+
+logger = logging.getLogger('test_logger')
+db_handler = LogDBHandler(db_table='test_table')
+logger.addHandler(db_handler)
+logger.setLevel(logging.INFO)
+
+logger.info('This is a test log message.')
+```
+
+### Timing Decorator
+
+Use the `timing_decorator` to measure the execution time of functions.
+
+``` py
+from dev_tools.custom_decorators import timing_decorator
+
+@timing_decorator
+def example_function():
+    for i in range(1000000):
+        pass
+
+example_function()
+```
+
+### Progress Bar
+
+Use the `progress_bar` to measure the execution time of functions.
+
+``` py
+from dev_tools.progress_bar import progress_bar
+
+for item in progress_bar(range(10)):
+    pass
+```
+
+### Debug Tools
+
+Check if debug or timing modes are enabled via environment variables.
+Use the `logger_setup` to set up your logging settings at the beginning of the script.
+
+``` py
+from dev_tools.debug_tools import is_debug_on, is_timing_on
+
+print('Is debug on:', is_debug_on())
+print('Is timing on:', is_timing_on())
+```
+
+``` py
+from dev_tools.debug_tools import logger_setup
+
+def main():
+    logger_setup()
+
+if __name__ == '__main__':
+    main()
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/bjorngun/developer-tools/blob/main/LICENSE) file for more details.
+
+## Links
+
+- **Source Code**: [GitHub Repository](https://github.com/bjorngun/developer-tools)
+- **Issue Tracker**: [GitHub Issues](https://github.com/bjorngun/developer-tools/issues)

bosos_dev_tools-0.0.2/README.md

@@ -0,0 +1,93 @@
+# Bosos Dev Tools
+
+Bosos Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.
+
+## Features
+
+- **Custom Logging Handlers**: Log messages to various destinations, including databases, with customizable formats.
+- **Timing Decorators**: Easily measure the execution time of your functions with minimal code changes.
+- **Progress Bar Utility**: Visualize the progress of long-running operations in the console.
+- **Debug Tools**: Check if debug or timing modes are enabled via environment variables.
+
+## Installation
+
+You can install the package via pip:
+
+```sh
+pip install bosos-dev-tools
+```
+
+## Usage
+
+### Custom Logging Handler
+
+The `LogDBHandler` allows you to log messages directly to a database.
+
+``` py
+import logging
+from dev_tools.custom_handlers import LogDBHandler
+
+logger = logging.getLogger('test_logger')
+db_handler = LogDBHandler(db_table='test_table')
+logger.addHandler(db_handler)
+logger.setLevel(logging.INFO)
+
+logger.info('This is a test log message.')
+```
+
+### Timing Decorator
+
+Use the `timing_decorator` to measure the execution time of functions.
+
+``` py
+from dev_tools.custom_decorators import timing_decorator
+
+@timing_decorator
+def example_function():
+    for i in range(1000000):
+        pass
+
+example_function()
+```
+
+### Progress Bar
+
+Use the `progress_bar` to measure the execution time of functions.
+
+``` py
+from dev_tools.progress_bar import progress_bar
+
+for item in progress_bar(range(10)):
+    pass
+```
+
+### Debug Tools
+
+Check if debug or timing modes are enabled via environment variables.
+Use the `logger_setup` to set up your logging settings at the beginning of the script.
+
+``` py
+from dev_tools.debug_tools import is_debug_on, is_timing_on
+
+print('Is debug on:', is_debug_on())
+print('Is timing on:', is_timing_on())
+```
+
+``` py
+from dev_tools.debug_tools import logger_setup
+
+def main():
+    logger_setup()
+
+if __name__ == '__main__':
+    main()
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/bjorngun/developer-tools/blob/main/LICENSE) file for more details.
+
+## Links
+
+- **Source Code**: [GitHub Repository](https://github.com/bjorngun/developer-tools)
+- **Issue Tracker**: [GitHub Issues](https://github.com/bjorngun/developer-tools/issues)

bosos_dev_tools-0.0.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ['setuptools>=42', 'wheel']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'bosos-dev-tools'
+version = '0.0.2'
+description = 'Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.'#TODO
+authors = [{ name = 'Björn Gunnarsson', email = 'bosos3@hotmail.com' }]
+license = { file = 'LICENSE' }
+readme = 'README.md'
+keywords = ['development', 'tools', 'logging', 'decorators']
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.12',
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Build Tools',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: OS Independent',
+]
+requires-python = '>=3.12'
+dependencies = [
+    'pyodbc',
+    'python-dotenv',
+]
+
+[project.urls]
+Source = 'https://github.com/bjorngun/developer-tools'
+Tracker = 'https://github.com/bjorngun/developer-tools/issues'
+
+[tool.setuptools.packages.find]
+where = ['src']
+
+[tool.setuptools]
+package-dir = {'' = 'src'}

bosos_dev_tools-0.0.2/setup.cfg

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

bosos_dev_tools-0.0.2/src/bosos_dev_tools.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: bosos-dev-tools
+Version: 0.0.2
+Summary: Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.
+Author-email: Björn Gunnarsson <bosos3@hotmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 bjorngun
+        
+        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.
+        
+Project-URL: Source, https://github.com/bjorngun/developer-tools
+Project-URL: Tracker, https://github.com/bjorngun/developer-tools/issues
+Keywords: development,tools,logging,decorators
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyodbc
+Requires-Dist: python-dotenv
+
+# Bosos Dev Tools
+
+Bosos Dev Tools is a collection of utility tools for Python developers, designed to simplify debugging, logging, and monitoring tasks. This package includes custom logging handlers, decorators for measuring execution time, and a progress bar utility to enhance the development workflow.
+
+## Features
+
+- **Custom Logging Handlers**: Log messages to various destinations, including databases, with customizable formats.
+- **Timing Decorators**: Easily measure the execution time of your functions with minimal code changes.
+- **Progress Bar Utility**: Visualize the progress of long-running operations in the console.
+- **Debug Tools**: Check if debug or timing modes are enabled via environment variables.
+
+## Installation
+
+You can install the package via pip:
+
+```sh
+pip install bosos-dev-tools
+```
+
+## Usage
+
+### Custom Logging Handler
+
+The `LogDBHandler` allows you to log messages directly to a database.
+
+``` py
+import logging
+from dev_tools.custom_handlers import LogDBHandler
+
+logger = logging.getLogger('test_logger')
+db_handler = LogDBHandler(db_table='test_table')
+logger.addHandler(db_handler)
+logger.setLevel(logging.INFO)
+
+logger.info('This is a test log message.')
+```
+
+### Timing Decorator
+
+Use the `timing_decorator` to measure the execution time of functions.
+
+``` py
+from dev_tools.custom_decorators import timing_decorator
+
+@timing_decorator
+def example_function():
+    for i in range(1000000):
+        pass
+
+example_function()
+```
+
+### Progress Bar
+
+Use the `progress_bar` to measure the execution time of functions.
+
+``` py
+from dev_tools.progress_bar import progress_bar
+
+for item in progress_bar(range(10)):
+    pass
+```
+
+### Debug Tools
+
+Check if debug or timing modes are enabled via environment variables.
+Use the `logger_setup` to set up your logging settings at the beginning of the script.
+
+``` py
+from dev_tools.debug_tools import is_debug_on, is_timing_on
+
+print('Is debug on:', is_debug_on())
+print('Is timing on:', is_timing_on())
+```
+
+``` py
+from dev_tools.debug_tools import logger_setup
+
+def main():
+    logger_setup()
+
+if __name__ == '__main__':
+    main()
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/bjorngun/developer-tools/blob/main/LICENSE) file for more details.
+
+## Links
+
+- **Source Code**: [GitHub Repository](https://github.com/bjorngun/developer-tools)
+- **Issue Tracker**: [GitHub Issues](https://github.com/bjorngun/developer-tools/issues)

bosos_dev_tools-0.0.2/src/bosos_dev_tools.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/bosos_dev_tools.egg-info/PKG-INFO
+src/bosos_dev_tools.egg-info/SOURCES.txt
+src/bosos_dev_tools.egg-info/dependency_links.txt
+src/bosos_dev_tools.egg-info/requires.txt
+src/bosos_dev_tools.egg-info/top_level.txt
+src/dev_tools/__init__.py
+src/dev_tools/custom_decorators.py
+src/dev_tools/custom_handlers.py
+src/dev_tools/debug_tools.py
+src/dev_tools/progress_bar.py
+src/tests/__init__.py
+src/tests/test_custom_decorators.py
+src/tests/test_custom_handlers.py
+src/tests/test_debug_tools.py
+src/tests/test_progress_bar.py

bosos_dev_tools-0.0.2/src/bosos_dev_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bosos_dev_tools-0.0.2/src/bosos_dev_tools.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyodbc
+python-dotenv

bosos_dev_tools-0.0.2/src/bosos_dev_tools.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dev_tools
+tests

bosos_dev_tools-0.0.2/src/dev_tools/__init__.py

@@ -0,0 +1,12 @@
+from dev_tools.progress_bar import progress_bar
+from dev_tools.custom_decorators import timing_decorator
+from dev_tools.custom_handlers import LogDBHandler
+from dev_tools.debug_tools import is_debug_on, logger_setup
+
+__all__ = [
+    "logger_setup",
+    "is_debug_on",
+    "progress_bar",
+    "timing_decorator",
+    "LogDBHandler",
+]

bosos_dev_tools-0.0.2/src/dev_tools/custom_decorators.py

@@ -0,0 +1,25 @@
+import time
+from typing import Any, Callable
+from functools import wraps
+
+from dev_tools.debug_tools import is_timing_on
+
+
+def timing_decorator(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> Any:
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        elapsed_time = end_time - start_time
+
+        # Print elapsed time
+        print(f"Elapsed time for {func.__name__}: {elapsed_time:.2f} seconds")
+
+        # Check if timing is enabled and log if applicable
+        if is_timing_on() and args and hasattr(args[0], 'logger'):
+            logger = getattr(args[0], 'logger')
+            logger.info(f"Elapsed time for {func.__name__}: {elapsed_time:.2f} seconds")
+
+        return result
+    return wrapper

bosos_dev_tools-0.0.2/src/dev_tools/custom_handlers.py

@@ -0,0 +1,119 @@
+import logging
+import os
+from datetime import datetime
+import pyodbc
+import getpass
+from pathlib import Path
+
+
+class LogDBHandler(logging.Handler):
+    """Customized logging handler that puts logs to the database."""
+
+    class SQLLogConnection:
+        """Connection class for a SQL database."""
+
+        def __init__(self):
+            """Initializes connection to a database."""
+            try:
+                connection_string = (f'SERVER={os.getenv("LOGGER_DB_SERVER")};'
+                                    f'DATABASE={os.getenv("LOGGER_DB_NAME")};'
+                                    f'DRIVER={os.getenv("LOGGER_SQL_DRIVER")};'
+                                    'Trusted_Connection=yes;')
+
+                conn = pyodbc.connect(
+                    connection_string,
+                    autocommit=True,
+                    TrustServerCertificate='YES',
+                )
+                self.cursor = conn.cursor()
+            except pyodbc.Error as e:
+                logging.getLogger('sql_logger').error(f"Error connecting to database: {e}")
+                self.cursor = None
+
+        def insert(self, table: str, columns: list[str], values: list):
+            """Executes Insert statement in the connected database.
+
+            Args:
+                table (str): Name of the table being inserted into
+                columns (list[str]): List of names of the columns that are being inserted into
+                values (list): List of the values
+            """
+            if self.cursor is None:
+                logging.getLogger('sql_logger').error("No database connection available.")
+                return
+
+            table = f'[dbo].[{table}]'
+            header = ', '.join([f'[{x}]' for x in columns])
+            parameters = ', '.join(['?']*len(columns))
+
+            try:
+                self.cursor.execute(
+                    f'INSERT INTO {table} ({header}) VALUES({parameters})', values)
+            except pyodbc.Error as e:
+                logging.getLogger('sql_logger').error(f"Error executing insert statement: {e}")
+            except TypeError as e:
+                logging.getLogger('sql_logger').error(f"Type error with provided values: {e}")
+            except Exception as e:
+                logging.getLogger('sql_logger').error(f"Unexpected error: {e}")
+
+    # Maximum length for the log message to be stored in the database
+    MAX_LOG_LEN = 2048
+    # Message to append if the log message is truncated
+    MAX_LOG_MSG = '... too long, check the local logs to see the full msg'
+
+    def __init__(self, db_table: str):
+        """Initializes the handler and the SQL connection."""
+        logging.Handler.__init__(self)
+        self.sql_connection = self.SQLLogConnection()
+        self.db_table = db_table
+
+    def emit(self, record):
+        """Emits a record to the database."""
+
+        # Ensure message is a string and escape quotes if necessary
+        try:
+            log_message = str(record.msg).replace("'", "''")
+        except Exception as e:
+            logging.getLogger('sql_logger').error(f"Error processing log message: {e}")
+            return
+
+        # Truncate the log message if it exceeds the maximum length
+        if len(log_message) > self.MAX_LOG_LEN:
+            log_message = f'{log_message[:self.MAX_LOG_LEN - len(self.MAX_LOG_MSG)]}{self.MAX_LOG_MSG}'
+
+        # Set current time
+        current_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
+
+        # Database columns for the log entry
+        db_columns = [
+            'log_level',
+            'log_levelname',
+            'log_module',
+            'log_func',
+            'log',
+            'script',
+            'created_at',
+            'created_by',
+            'pathname',
+            'process_id',
+        ]
+
+        # Values for the log entry
+        row_values = [
+            record.levelno,
+            record.levelname,
+            record.name,
+            record.funcName,
+            log_message,
+            os.getenv("SCRIPT_NAME", Path.cwd().name),
+            current_time,
+            getpass.getuser(),
+            record.pathname,
+            os.getpid(),
+        ]
+
+        # Insert the log entry into the database
+        try:
+            self.sql_connection.insert(self.db_table, db_columns, row_values)
+        except Exception as e:
+            logging.getLogger('sql_logger').error(f"Error inserting log into database: {e}")

bosos_dev_tools-0.0.2/src/dev_tools/debug_tools.py

@@ -0,0 +1,103 @@
+import atexit
+from datetime import datetime
+import logging
+import logging.config
+import os
+import sys
+from pathlib import Path
+from dotenv import load_dotenv
+
+from .custom_handlers import LogDBHandler
+
+
+def is_debug_on() -> bool:
+    """Determine if debug mode is enabled."""
+    return os.getenv('DEBUG', 'False').lower() in ['true', '1', 't', 'yes']
+
+def is_timing_on() -> bool:
+    """Determine if timing mode is enabled."""
+    return os.getenv('TIMING', 'False').lower() in ['true', '1', 't', 'yes']
+
+def is_database_logging_on() -> bool:
+    """Determine if database logging mode is enabled."""
+    return os.getenv('LOGGER_DATABASE', 'False').lower() in ['true', '1', 't', 'yes']
+
+def log_exit_code():
+    """Log the exit code of the script."""
+    logger = logging.getLogger(__name__)
+    exit_code = 0 if sys.exc_info() == (None, None, None) else 1
+    logger.info(f'Exit code: {exit_code}')
+    
+def default_logging_config(logger_file_path: str):
+    """Default logging configuration."""
+    return {
+        'version': 1,
+        'disable_existing_loggers': False,
+        'formatters': {
+            'simple': {
+                'format': '%(levelname)s | %(name)s | %(message)s',
+                'datefmt': '%Y-%m-%dT%H:%M:%S',
+            },
+            'complex': {
+                'format': '%(levelname)s | %(asctime)s | %(name)s | %(funcName)s | %(message)s',
+                'datefmt': '%Y-%m-%dT%H:%M:%S',
+            },
+        },
+        'handlers': {
+            'screen': {
+                'class': 'logging.StreamHandler',
+                'formatter': 'simple',
+                'level': 'INFO' if is_debug_on() else 'WARNING',
+                'stream': 'ext://sys.stdout',
+            },
+            'file': {
+                'class': 'logging.FileHandler',
+                'formatter': 'complex',
+                'level': 'DEBUG' if is_debug_on() else 'INFO',
+                'filename': logger_file_path,
+            },
+        },
+        'root': {
+            'handlers': ['screen', 'file'],
+            'level': 'DEBUG' if is_debug_on() else 'INFO',
+        },
+    }
+
+def logger_setup():
+    """Set up logging configuration based on environment variables and debug mode."""
+    atexit.register(log_exit_code)
+
+    #Loads up all the environment variables
+    load_dotenv()
+    debug = is_debug_on()
+    today = datetime.now()
+
+    logger_conf_path = Path(os.getenv('LOGGER_CONF_PATH', 'logging.conf'))
+    if debug:
+        logger_conf_path = Path(os.getenv('LOGGER_CONF_DEV_PATH', 'logging_dev.conf'))
+    logger_folder_path = f'{os.getenv("LOGGER_PATH", "./logs")}/{today.strftime("%Y-%m-%d")}'
+
+    try:
+        Path(logger_folder_path).mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        print(f'Error creating log directory {Path(logger_folder_path)}: {e}', file=sys.stderr)
+        sys.exit(1)
+
+    logger_file_path = f'{logger_folder_path}/{today.strftime("%Y-%m-%dT%H%M%S")}.log'
+    logger_db_table = os.getenv('LOGGER_DB_TABLE', 'python_transfer_data_log')
+    if logger_conf_path.exists():
+        try:
+            logging.config.fileConfig(logger_conf_path, defaults={
+                'logfilename': logger_file_path,
+            })
+        except Exception as e:
+            print(f'Error setting up logging configuration from {logger_conf_path}: {e}', file=sys.stderr)
+            sys.exit(1)
+    else:
+        logging.config.dictConfig(default_logging_config(logger_file_path))
+        if (is_database_logging_on()):
+            log_db_handler = LogDBHandler(logger_db_table)
+            logging.getLogger('').addHandler(log_db_handler)
+
+    logger = logging.getLogger(__name__)
+    logger.info(f'Setting up logger for {os.getenv("SCRIPT_NAME", Path.cwd().name)}')

bosos_dev_tools-0.0.2/src/dev_tools/progress_bar.py

@@ -0,0 +1,86 @@
+import logging
+import time
+from collections.abc import Iterable
+from dev_tools.debug_tools import is_debug_on, is_timing_on
+
+
+def progress_bar(
+    iterable: Iterable,
+    prefix: str = "",
+    suffix: str = "",
+    decimals: int = 1,
+    length: int = 50,
+    fill: str = "█",
+    print_end: str = "\r",
+) -> Iterable:
+    """
+    Call in a loop to create terminal progress bar
+    @params:
+        iterable    - Required  : iterable object (Iterable)
+        prefix      - Optional  : prefix string (Str)
+        suffix      - Optional  : suffix string (Str)
+        decimals    - Optional  : positive number of decimals in percent complete (Int)
+        length      - Optional  : character length of bar (Int)
+        fill        - Optional  : bar fill character (Str)
+        print_end   - Optional  : end character (e.g. "\r", "\r\n") (Str)
+    """
+
+    debug = is_debug_on()
+    timing = is_timing_on()
+    total = len(iterable)
+    start_time = time.time()
+    logger = logging.getLogger(__name__)
+    errors = {}
+
+    def print_progress_bar(iteration: int) -> None:
+        if not debug or total == 0:
+            return
+
+        percent = f"{100 * (iteration / float(total)):.{decimals}f}"
+        filled_length = int(length * iteration // total)
+        bar = fill * filled_length + "-" * (length - filled_length)
+        time_str = get_timing_str(iteration)
+
+        try:
+            print(f"\r{prefix} |{bar}| {percent}% {suffix}{time_str}{'':<10}", end=print_end)
+        except UnicodeEncodeError:
+            if "UnicodeEncodeError" not in errors:
+                errors["UnicodeEncodeError"] = True
+                logger.exception("Progress bar is not able to print, DEBUG = %s", debug)
+                logging.exception("Progress bar is not able to print, DEBUG = %s", debug)   
+
+    def get_timing_str(iteration: int) -> str:
+        if not timing:
+            return ""
+
+        et = time.time() - start_time
+        et_str = f"Elapsed time: {format_time(et)}"
+        eta_str = "Time remaining: N/A"
+        if iteration > 0 and et > 0:
+            eta_seconds = et / (iteration / float(total)) - et
+            eta_str = f"Time remaining: {format_time(eta_seconds)}"
+
+        return f" |--{et_str} - {eta_str}--|"
+
+    def format_time(seconds) -> str:
+        minutes = int(seconds // 60)
+        seconds = seconds % 60
+
+        hours = int(minutes // 60)
+        minutes = minutes % 60
+
+        time_str = ""
+        if hours > 0:
+            time_str += f"{hours}h "
+        if minutes > 0:
+            time_str += f"{minutes}m "
+        time_str += f"{seconds:.2f}s"
+        return time_str
+
+    print_progress_bar(0)
+    for i, item in enumerate(iterable):
+        yield item
+        print_progress_bar(i + 1)
+    # Print New Line on Complete
+    if debug and total > 0:
+        print()

bosos_dev_tools-0.0.2/src/tests/test_custom_decorators.py

@@ -0,0 +1,14 @@
+import unittest
+from dev_tools.custom_decorators import timing_decorator
+
+class TestTimingDecorator(unittest.TestCase):
+    def test_timing_decorator(self):
+        @timing_decorator
+        def sample_function(x, y):
+            return x + y
+
+        result = sample_function(1, 2)
+        self.assertEqual(result, 3)
+
+if __name__ == '__main__':
+    unittest.main()

bosos_dev_tools-0.0.2/src/tests/test_custom_handlers.py

@@ -0,0 +1,22 @@
+import unittest
+from unittest.mock import patch
+import logging
+from dev_tools.custom_handlers import LogDBHandler
+
+class TestLogDBHandler(unittest.TestCase):
+    @patch('dev_tools.custom_handlers.pyodbc.connect')
+    def test_emit(self, mock_connect):
+        mock_connect.return_value.cursor.return_value.execute.return_value = None
+
+        logger = logging.getLogger('test_logger')
+        db_handler = LogDBHandler(db_table='test_table')
+        logger.addHandler(db_handler)
+        logger.setLevel(logging.INFO)
+
+        with self.assertLogs('test_logger', level='INFO') as log:
+            logger.info('This is a test log message')
+
+        self.assertIn('This is a test log message', log.output[0])
+
+if __name__ == '__main__':
+    unittest.main()

bosos_dev_tools-0.0.2/src/tests/test_debug_tools.py

@@ -0,0 +1,22 @@
+import unittest
+import os
+from unittest.mock import patch
+from dev_tools.debug_tools import is_debug_on, is_timing_on, logger_setup
+
+class TestDebugTools(unittest.TestCase):
+    @patch.dict(os.environ, {'DEBUG': 'true', 'TIMING': 'true'})
+    def test_is_debug_on(self):
+        self.assertTrue(is_debug_on())
+
+    @patch.dict(os.environ, {'DEBUG': 'false', 'TIMING': 'true'})
+    def test_is_timing_on(self):
+        self.assertTrue(is_timing_on())
+
+    @patch('dev_tools.debug_tools.logging.config.fileConfig')
+    @patch('dev_tools.debug_tools.logging.config.dictConfig')
+    def test_logger_setup(self, mock_dictConfig, mock_fileConfig):
+        logger_setup()
+        mock_dictConfig.assert_called()
+
+if __name__ == '__main__':
+    unittest.main()

bosos_dev_tools-0.0.2/src/tests/test_progress_bar.py

@@ -0,0 +1,18 @@
+import unittest
+import os
+from unittest.mock import patch
+from dev_tools.progress_bar import progress_bar
+
+class TestProgressBar(unittest.TestCase):
+    
+    @patch('builtins.print')
+    @patch.dict(os.environ, {'DEBUG': 'true', 'TIMING': 'true'})
+    def test_progress_bar(self, mock_print):
+        items = list(range(10))
+        result = list(progress_bar(items))
+
+        self.assertEqual(result, items)
+        self.assertTrue(mock_print.called)
+
+if __name__ == '__main__':
+    unittest.main()