matrice-inference 0.1.33__tar.gz

matrice_inference-0.1.33/LICENSE.txt

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

matrice_inference-0.1.33/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: matrice_inference
+Version: 0.1.33
+Summary: Common server utilities for Matrice.ai services
+Author-email: "Matrice.ai" <dipendra@matrice.ai>
+License-Expression: MIT
+Keywords: matrice,common,utilities,pyarmor,obfuscated
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+Dynamic: requires-python
+
+
+# matrice\_inference

matrice_inference-0.1.33/README.md

@@ -0,0 +1,2 @@
+
+# matrice\_inference

matrice_inference-0.1.33/matrice_inference.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: matrice_inference
+Version: 0.1.33
+Summary: Common server utilities for Matrice.ai services
+Author-email: "Matrice.ai" <dipendra@matrice.ai>
+License-Expression: MIT
+Keywords: matrice,common,utilities,pyarmor,obfuscated
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+Dynamic: requires-python
+
+
+# matrice\_inference

matrice_inference-0.1.33/matrice_inference.egg-info/SOURCES.txt

@@ -0,0 +1,48 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.py
+matrice_inference.egg-info/PKG-INFO
+matrice_inference.egg-info/SOURCES.txt
+matrice_inference.egg-info/dependency_links.txt
+matrice_inference.egg-info/not-zip-safe
+matrice_inference.egg-info/top_level.txt
+src/matrice_inference/__init__.py
+src/matrice_inference/py.typed
+src/matrice_inference/server/__init__.py
+src/matrice_inference/server/inference_interface.py
+src/matrice_inference/server/proxy_interface.py
+src/matrice_inference/server/server.py
+src/matrice_inference/server/model/__init__.py
+src/matrice_inference/server/model/model_manager.py
+src/matrice_inference/server/model/model_manager_wrapper.py
+src/matrice_inference/server/model/triton_model_manager.py
+src/matrice_inference/server/model/triton_server.py
+src/matrice_inference/server/stream/__init__.py
+src/matrice_inference/server/stream/analytics_publisher.py
+src/matrice_inference/server/stream/app_deployment.py
+src/matrice_inference/server/stream/app_event_listener.py
+src/matrice_inference/server/stream/camera_config_monitor.py
+src/matrice_inference/server/stream/consumer_worker.py
+src/matrice_inference/server/stream/deployment_refresh_listener.py
+src/matrice_inference/server/stream/frame_cache.py
+src/matrice_inference/server/stream/inference_metric_logger.py
+src/matrice_inference/server/stream/inference_worker.py
+src/matrice_inference/server/stream/metric_publisher.py
+src/matrice_inference/server/stream/post_processing_worker.py
+src/matrice_inference/server/stream/producer_worker.py
+src/matrice_inference/server/stream/stream_pipeline.py
+src/matrice_inference/server/stream/utils.py
+src/matrice_inference/server/stream/worker_metrics.py
+src/matrice_inference/tmp/abstract_model_manager.py
+src/matrice_inference/tmp/batch_manager.py
+src/matrice_inference/tmp/overall_inference_testing.py
+src/matrice_inference/tmp/triton_utils.py
+src/matrice_inference/tmp/aggregator/__init__.py
+src/matrice_inference/tmp/aggregator/aggregator.py
+src/matrice_inference/tmp/aggregator/analytics.py
+src/matrice_inference/tmp/aggregator/ingestor.py
+src/matrice_inference/tmp/aggregator/latency.py
+src/matrice_inference/tmp/aggregator/pipeline.py
+src/matrice_inference/tmp/aggregator/publisher.py
+src/matrice_inference/tmp/aggregator/synchronizer.py

matrice_inference-0.1.33/matrice_inference.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

matrice_inference-0.1.33/matrice_inference.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

matrice_inference-0.1.33/matrice_inference.egg-info/top_level.txt

@@ -0,0 +1 @@
+matrice_inference

matrice_inference-0.1.33/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=65.0.0", "wheel", "pyarmor>=8.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "matrice_inference"
+dynamic = ["version"]
+description = "Common server utilities for Matrice.ai services"
+readme = "README.md"
+authors = [{ name = "Matrice.ai", email = "dipendra@matrice.ai" }]
+license = "MIT"
+requires-python = ">=3.8, <4"
+keywords = ["matrice", "common", "utilities", "pyarmor", "obfuscated"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+
+
+# PyArmor configuration is handled via pyarmor.yml file
+# The [tool.pyarmor] section is not used in PyArmor 8.x

matrice_inference-0.1.33/setup.cfg

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

matrice_inference-0.1.33/setup.py

@@ -0,0 +1,322 @@
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from setuptools import setup, find_packages
+from setuptools.command.build_py import build_py as _build_py
+from setuptools.command.sdist import sdist as _sdist
+
+# Configuration of package name and source directory
+PACKAGE_NAME = "matrice_inference"
+SOURCE_DIR = f"src/{PACKAGE_NAME}"
+OBFUSCATED_DIR = f"{PACKAGE_NAME}_obfuscated"
+BUILD_DIR = "build"
+
+# Read version from appropriate version file based on environment
+def get_version():
+    """Get version based on environment or git branch.
+    If environment is dev, append 'dev' suffix automatically."""
+    # Check environment variable first (set by CI/CD)
+    env_type = os.environ.get('BUILD_ENV', '').lower()
+    append_dev_suffix = False
+    
+    if env_type == 'dev':
+        version_file = "version-dev.txt"
+        append_dev_suffix = True
+    elif env_type == 'staging':
+        version_file = "version-staging.txt"
+    elif env_type == 'prod':
+        version_file = "version-prod.txt"
+    else:
+        # Try to detect from git branch
+        try:
+            result = subprocess.run(
+                ['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
+                capture_output=True, text=True, check=True
+            )
+            branch = result.stdout.strip()
+            
+            if branch == 'dev':
+                version_file = "version-dev.txt"
+                append_dev_suffix = True
+            elif branch == 'staging':
+                version_file = "version-staging.txt"
+            elif branch in ['main', 'master', 'prod']:
+                version_file = "version-prod.txt"
+            else:
+                # Default to dev for unknown branches
+                version_file = "version-dev.txt"
+                append_dev_suffix = True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            # Default to dev if git detection fails
+            version_file = "version-dev.txt"
+            append_dev_suffix = True
+    
+    # Read the determined version file
+    try:
+        with open(version_file, "r", encoding="utf-8") as f:
+            version = f.read().strip()
+            if append_dev_suffix and not version.endswith("dev"):
+                version = f"{version}dev"
+            print(f"Using version {version} from {version_file}")
+            return version
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Version file not found: {version_file}")
+
+VERSION = get_version()
+
+class PyArmorBuild(_build_py):
+    """Custom build_py to obfuscate Python files using PyArmor."""
+    
+    def run(self):
+        try:
+            # Clean up previous obfuscated files
+            if os.path.exists(OBFUSCATED_DIR):
+                shutil.rmtree(OBFUSCATED_DIR)
+            
+            # Run PyArmor obfuscation
+            self._obfuscate_package()
+            
+            # Copy obfuscated files to build directory
+            self._copy_obfuscated_files()
+            
+        except Exception as e:
+            print(f"Error in PyArmorBuild: {e}")
+            raise
+    
+    def _obfuscate_package(self):
+        """Obfuscate the package using PyArmor."""
+        print(f"Obfuscating package {PACKAGE_NAME}...")
+        
+        # Check if we should skip obfuscation
+        skip_obfuscation = os.environ.get('SKIP_PYARMOR_OBFUSCATION', '').lower() == 'true'
+        if skip_obfuscation:
+            print("⚠ Skipping PyArmor obfuscation (SKIP_PYARMOR_OBFUSCATION=true)")
+            self._copy_source_files()
+            return
+        
+        # Create output directory
+        os.makedirs(OBFUSCATED_DIR, exist_ok=True)
+        
+        # Try obfuscating core files first (most important)
+        core_files = self._get_core_files()
+        if core_files:
+            print(f"Attempting to obfuscate {len(core_files)} core files first...")
+            success = self._obfuscate_selective(core_files)
+            if not success:
+                print("⚠ Core file obfuscation failed, falling back to copying source files")
+                self._copy_source_files()
+                return
+        
+        # Try full obfuscation
+        cmd = [
+            "pyarmor",
+            "gen",
+            "--output", OBFUSCATED_DIR,
+            SOURCE_DIR
+        ]
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            print("✓ PyArmor obfuscation completed successfully")
+            if result.stdout:
+                print(f"PyArmor output: {result.stdout}")
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr or str(e)
+            print(f"⚠ PyArmor obfuscation failed: {e}")
+            if e.stderr:
+                print(f"Error details: {e.stderr}")
+            
+            # Handle specific license limitation error
+            if "out of license" in error_msg or "license" in error_msg.lower():
+                print("\n" + "="*60)
+                print("PyArmor Trial License Limitation Detected")
+                print("="*60)
+                print("The free trial version of PyArmor has a file limit.")
+                print("Your package has too many files to obfuscate with the trial version.")
+                print("\nOptions to resolve this:")
+                print("1. Purchase a PyArmor license: https://pyarmor.readthedocs.io/en/stable/licenses.html")
+                print("2. Reduce the number of files (exclude test files, examples, etc.)")
+                print("3. Set environment variable: SKIP_PYARMOR_OBFUSCATION=true")
+                print("4. Use selective obfuscation of core files only")
+                print("="*60)
+                
+                # Fall back to copying source files without obfuscation
+                print("Falling back to building package without obfuscation...")
+                self._copy_source_files()
+                return
+            else:
+                raise
+        except FileNotFoundError:
+            print("PyArmor not found. Please install PyArmor: pip install pyarmor")
+            raise
+    
+    def _get_core_files(self):
+        """Get list of core files to obfuscate (excluding tests, examples)."""
+        core_files = []
+        if not os.path.exists(SOURCE_DIR):
+            return core_files
+            
+        for root, dirs, files in os.walk(SOURCE_DIR):
+            # Skip test directories and other non-essential directories
+            dirs[:] = [d for d in dirs if not d.startswith(('test', '__pycache__', 'example', 'demo'))]
+            
+            for file in files:
+                if file.endswith('.py') and not file.startswith('test_'):
+                    core_files.append(os.path.join(root, file))
+        
+        return core_files
+    
+    def _obfuscate_selective(self, file_list):
+        """Obfuscate only selected files."""
+        print(f"Attempting selective obfuscation of {len(file_list)} files...")
+        
+        # Create a temporary directory with only core files
+        temp_source = f"{SOURCE_DIR}_temp"
+        try:
+            if os.path.exists(temp_source):
+                shutil.rmtree(temp_source)
+            
+            # Copy only core files maintaining structure
+            for file_path in file_list:
+                rel_path = os.path.relpath(file_path, SOURCE_DIR)
+                dest_path = os.path.join(temp_source, rel_path)
+                os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+                shutil.copy2(file_path, dest_path)
+            
+            # Try to obfuscate the reduced set
+            cmd = ["pyarmor", "gen", "--output", OBFUSCATED_DIR, temp_source]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            print("✓ Selective obfuscation completed successfully")
+            return True
+            
+        except subprocess.CalledProcessError as e:
+            print(f"✗ Selective obfuscation also failed: {e}")
+            return False
+        finally:
+            if os.path.exists(temp_source):
+                shutil.rmtree(temp_source)
+    
+    def _copy_source_files(self):
+        """Copy source files without obfuscation as fallback."""
+        print("Copying source files without obfuscation...")
+        
+        if os.path.exists(SOURCE_DIR):
+            dest_package_dir = os.path.join(OBFUSCATED_DIR, PACKAGE_NAME)
+            if os.path.exists(dest_package_dir):
+                shutil.rmtree(dest_package_dir)
+            shutil.copytree(SOURCE_DIR, dest_package_dir)
+            print(f"✓ Source files copied to {dest_package_dir}")
+        else:
+            print(f"✗ Source directory not found: {SOURCE_DIR}")
+    
+    def _copy_obfuscated_files(self):
+        """Copy obfuscated files to build directory."""
+        build_package_dir = os.path.join(self.build_lib, PACKAGE_NAME)
+        os.makedirs(build_package_dir, exist_ok=True)
+        
+        # Find the obfuscated package directory
+        obfuscated_package_dir = None
+        for root, dirs, files in os.walk(OBFUSCATED_DIR):
+            if PACKAGE_NAME in dirs:
+                obfuscated_package_dir = os.path.join(root, PACKAGE_NAME)
+                break
+        
+        if not obfuscated_package_dir:
+            # Try direct path if PyArmor created it differently
+            obfuscated_package_dir = os.path.join(OBFUSCATED_DIR, PACKAGE_NAME)
+        
+        if os.path.exists(obfuscated_package_dir):
+            # Copy all obfuscated files
+            for root, dirs, files in os.walk(obfuscated_package_dir):
+                for file in files:
+                    src_path = os.path.join(root, file)
+                    rel_path = os.path.relpath(src_path, obfuscated_package_dir)
+                    dest_path = os.path.join(build_package_dir, rel_path)
+                    os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+                    shutil.copy2(src_path, dest_path)
+            
+            print(f"Copied obfuscated files to {build_package_dir}")
+        else:
+            print(f"Warning: Obfuscated package directory not found at {obfuscated_package_dir}")
+            print(f"Available directories in {OBFUSCATED_DIR}:")
+            if os.path.exists(OBFUSCATED_DIR):
+                for item in os.listdir(OBFUSCATED_DIR):
+                    print(f"  - {item}")
+
+class PyArmorSdist(_sdist):
+    """Custom sdist to include obfuscated files."""
+    
+    def run(self):
+        try:
+            # Run the build command first to generate obfuscated files
+            self.run_command("build_py")
+            super().run()
+        except Exception as e:
+            print(f"Error in PyArmorSdist: {e}")
+            raise
+
+def find_original_packages():
+    """Find packages in the original source directory."""
+    packages = []
+    source_path = Path(SOURCE_DIR)
+    if source_path.exists():
+        for py_file in source_path.rglob("__init__.py"):
+            package_dir = py_file.parent
+            rel_path = package_dir.relative_to(SOURCE_DIR)
+            if rel_path == Path("."):
+                packages.append(PACKAGE_NAME)
+            else:
+                packages.append(f"{PACKAGE_NAME}.{str(rel_path).replace(os.sep, '.')}")
+    return packages
+
+def get_package_data():
+    """Get package data for obfuscated files."""
+    return {
+        PACKAGE_NAME: [
+            "*.py",
+            "*.pyi", 
+            "*.pyx",
+            "*.so",
+            "*.pyd",
+            "py.typed",
+            "**/*.py",
+            "**/*.pyi",
+            "**/*.pyx", 
+            "**/*.so",
+            "**/*.pyd",
+            "**/py.typed",
+            "pytransform/*",
+            "**/*",
+        ],
+    }
+
+# Ensure py.typed exists for type hints
+def ensure_py_typed():
+    """Create py.typed file if it doesn't exist."""
+    src_py_typed = os.path.join(SOURCE_DIR, "py.typed")
+    if not os.path.exists(src_py_typed):
+        with open(src_py_typed, "w") as f:
+            f.write("")
+        print("Created py.typed file")
+
+# Create py.typed file
+ensure_py_typed()
+
+setup(
+    name=PACKAGE_NAME,
+    version=VERSION,
+    packages=find_original_packages(),
+    package_dir={PACKAGE_NAME: SOURCE_DIR},
+    include_package_data=True,
+    package_data=get_package_data(),
+    cmdclass={
+        'build_py': PyArmorBuild,
+        'sdist': PyArmorSdist,
+    },
+    zip_safe=False,
+    python_requires=">=3.8",
+    setup_requires=[
+        "pyarmor>=8.0.0",
+    ],
+)

matrice_inference-0.1.33/src/matrice_inference/__init__.py

@@ -0,0 +1,91 @@
+"""Module providing __init__ functionality."""
+
+import os
+import sys
+import platform
+import subprocess
+
+from matrice_common.utils import dependencies_check
+
+base = [
+    "httpx",
+    "fastapi",
+    "uvicorn",
+    "pillow",
+    "confluent_kafka[snappy]",
+    "aiokafka",
+    "aiohttp",
+    "filterpy",
+    "scipy",
+    "scikit-learn",
+    "matplotlib",
+    "scikit-image",
+    "python-snappy",
+    "pyyaml",
+    "imagehash",
+    "Pillow",
+    "transformers"
+]
+
+# Helper to attempt installation and verify importability
+def _install_and_verify(pkg: str, import_name: str):
+    """Install a package expression and return True if the import succeeds."""
+    try:
+        if pkg=='onnxruntime-gpu':
+            pkg = 'onnxruntime'
+        __import__(pkg)
+        return True
+    except:
+        if dependencies_check([pkg]):
+            try:
+                __import__(import_name)
+                return True
+            except ImportError:
+                return False
+        return False
+
+# Runtime gating for optional OCR bootstrap (default OFF), and never on Jetson
+_ENABLE_OCR_BOOTSTRAP = os.getenv("MATRICE_ENABLE_OCR_BOOTSTRAP", "0")
+_IS_JETSON = (platform.machine().lower() in ("aarch64", "arm64"))
+
+print("*******************************Deployment ENV Info**********************************")
+print(f"ENABLE_JETSON_PIP_SETTINGS: {_ENABLE_OCR_BOOTSTRAP}") #0 if OFF, 1 if ON, this will be set to 1 in jetson byom codebase.
+print(f"IS_JETSON_ARCH?: {_IS_JETSON}") #True if Jetson, False otherwise
+print("*************************************************************************************")
+
+if not int(_ENABLE_OCR_BOOTSTRAP) and not _IS_JETSON:
+    # Install base dependencies first
+    dependencies_check(base)
+
+    if not dependencies_check(["opencv-python"]):
+        dependencies_check(["opencv-python-headless"])
+
+    # Attempt GPU-specific dependencies first
+    _gpu_ok = _install_and_verify("onnxruntime-gpu", "onnxruntime") and _install_and_verify(
+        "fast-plate-ocr[onnx-gpu]", "fast_plate_ocr"
+    )
+
+    if not _gpu_ok:
+        # Fallback to CPU variants
+        _cpu_ok = _install_and_verify("onnxruntime", "onnxruntime") and _install_and_verify(
+            "fast-plate-ocr[onnx]", "fast_plate_ocr"
+        )
+        if not _cpu_ok:
+            # Last-chance fallback without extras tag (PyPI sometimes lacks them)
+            _install_and_verify("fast-plate-ocr", "fast_plate_ocr")
+
+# matrice_deps = ["matrice_common", "matrice_analytics", "matrice"]
+
+# dependencies_check(matrice_deps)
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from server.server import MatriceDeployServer  # noqa: E402
+from server.server import MatriceDeployServer as MatriceDeploy  # noqa: E402 # Keep this for backwards compatibility
+from server.inference_interface import InferenceInterface  # noqa: E402
+from server.proxy_interface import MatriceProxyInterface  # noqa: E402
+
+__all__ = [
+    "MatriceDeploy",
+    "MatriceDeployServer",
+    "InferenceInterface",
+    "MatriceProxyInterface",
+]

matrice_inference-0.1.33/src/matrice_inference/server/__init__.py

@@ -0,0 +1,29 @@
+import os
+import logging
+
+# Define paths
+log_path = os.path.join(os.getcwd(), "deploy_server.log")
+
+# Create handlers explicitly
+console_handler = logging.StreamHandler()
+file_handler = logging.FileHandler(log_path)
+
+# Set levels
+console_handler.setLevel(logging.INFO)
+file_handler.setLevel(logging.DEBUG)
+
+# Define a formatter
+formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+console_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
+
+# Get the root logger
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)  # Root level must be the lowest (DEBUG)
+
+# Optional: remove any default handlers if basicConfig was called earlier
+if logger.hasHandlers():
+    logger.handlers.clear()
+
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)