🔧 feat: add config (for global sdk vars), Logger for factory log generation, update exception styling

Signed-off-by: saif <[email protected]>

Author: Rubix982

src/mapillary/models/__init__.py

@@ -15,3 +15,5 @@
 from . import exceptions  # noqa: F401
 from . import geojson  # noqa: F401
 from . import api  # noqa: F401
+from . import logger  # noqa: F401
+from . import config # noqa: F401

src/mapillary/models/config.py

@@ -0,0 +1,50 @@
+# Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
+# -*- coding: utf-8 -*-
+
+"""
+mapillary.models.config
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+This module contains the Config class which sets up some global variables fo the duration of
+the session that the SDK is in use for.
+
+For more information, please check out https://www.mapillary.com/developer/api-documentation/.
+
+- Copyright: (c) 2021 Facebook
+- License: MIT License
+"""
+
+from mapillary.models.logger import Logger
+
+Logger.setup_logger(name="mapillary.models.config")
+
+
+class Config:
+    """
+    Config setup for the SDK
+
+    Different parts of the SDK react differently depending on what is set
+
+    Usage::
+
+        >>> from mapillary.models.config import Config
+
+    :param use_strict: If set to True, the SDK will raise an exception if an invalid arguments
+    are sent to the functions in config.api calls. If set to False, the SDK will just log a warning.
+    :type use_strict: bool
+    :default use_strict: True
+    """
+
+    # Strict mode will raise exceptions when,
+    # 1. Invalid arguments are passed to a function, such as those
+    # files in the config.api directory. This can mean invalid date
+    # formats, invalid IDs, invalid data types, etc.
+
+    use_strict = True
+
+    def __init__(self, use_strict: bool = True) -> None:
+        """
+        Initialize the Config class
+        """
+
+        self.use_strict = use_strict

src/mapillary/models/exceptions.py

@@ -356,12 +356,19 @@ def enforce_literal(
                 param=param, value=option_selected, options=options
             )
 
+
 class InvalidNumberOfArguments(MapillaryException):
     """
     Raised when an inappropriate number of parameters are passed to a function
     """
 
-    def __init__(self, number_of_params_passed: int, actual_allowed_params: int, param: str,  *args: object) -> None:
+    def __init__(
+        self,
+        number_of_params_passed: int,
+        actual_allowed_params: int,
+        param: str,
+        *args: object,
+    ) -> None:
         super().__init__(*args)
 
         self.number_of_params_passed = number_of_params_passed
@@ -371,8 +378,12 @@ def __init__(self, number_of_params_passed: int, actual_allowed_params: int, par
     def __str__(self):
         return (
             f'InvalidNumberOfArguments: The parameter, "{self.param}" was '
-            f'passed "{self.number_of_params_passed}" items, when the max number of allowed items are "{self.actual_allowed_params}"'
+            f'passed "{self.number_of_params_passed}" items, when the max number of'
+            f'allowed items are "{self.actual_allowed_params}"'
         )
 
     def __repr__(self):
-        return f"InvalidNumberOfArguments(number_of_params_passed={self.number_of_params_passed}, actual_allowed_params={self.actual_allowed_params}, param={self.param})"
+        return (
+            f"InvalidNumberOfArguments(number_of_params_passed={self.number_of_params_passed},"
+            f"actual_allowed_params={self.actual_allowed_params}, param={self.param})"
+        )

src/mapillary/models/logger.py

@@ -0,0 +1,86 @@
+# Copyright (c) Facebook, Inc. and its affiliates. (https://www.facebook.com)
+# Copyright (c) 2022 Mapillary, Inc. (https://www.mapillary.com)
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+# -*- coding: utf-8 -*-
+
+"""
+mapillary.utils.logger
+~~~~~~~~~~~~~~~~~~~~~~
+
+This module implements the logger for mapillary, which is a wrapper of the logger package and
+the default configuration for each of the loggers per file.
+
+"""
+
+import logging
+import sys
+import os
+
+
+class Logger:
+
+    format_string: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    level: int = logging.INFO
+
+    @staticmethod
+    def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
+        """
+        Function setup as many loggers as you want. To be used at the top of the file.
+
+        Usage::
+
+            >>> Logger.setup_logger(name='mapillary.xxxx.yyyy', level=logging.INFO)
+            logger.Logger
+
+        :param name: The name of the logger
+        :type name: str
+
+        :param level: The level of the logger
+        :type level: int
+
+        :return: The logger object
+        :rtype: logging.Logger
+        """
+
+        # Basic logger setup
+        logger: Logger = logging.getLogger(name)
+
+        # stdout logger setup
+        stream_handler: logging.StreamHandler = logging.StreamHandler(sys.stdout)
+        logger.addHandler(stream_handler)
+
+        try:
+            logger.setLevel(level)
+        except ValueError:
+            logger.setLevel(logging.INFO)
+            logger.warning("LOG_LEVEL: Invalid variable - defaulting to: INFO")
+
+        # File logger setup
+        formatter: logging.Formatter = logging.Formatter(Logger.format_string)
+        handler: logging.FileHandler = logging.FileHandler(
+            Logger.get_os_log_path(name.split(".")[1] + ".log")
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        return logger
+
+    @staticmethod
+    def get_os_log_path(log_file: str) -> str:
+        """
+        Get the path of the log file based on the OS
+
+        :param log_file: The name of the log file
+        :type log_file: str
+
+        :return: The path where the logs will be stored
+        :rtype: str
+        """
+
+        log_path: str = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logs")
+
+        if not os.path.exists(log_path):
+            os.makedirs(log_path)
+
+        return os.path.join(log_path, log_file)