droidoc 0.0.1__py3-none-any.whl

droidoc/__init__.py

@@ -0,0 +1,11 @@
+import os
+
+from ._version import __author__
+from ._version import __author_email__
+from ._version import __copyright__
+from ._version import __description__
+from ._version import __license__
+from ._version import __name_soft__
+from ._version import __title__
+from ._version import __url__
+from ._version import __version__

droidoc/__main__.py

@@ -0,0 +1,120 @@
+import argparse
+import signal
+import sys
+
+from loguru import logger
+
+from .droidoc import DroidocLib
+from droidoc import __author__
+from droidoc import __copyright__
+from droidoc import __description__
+from droidoc import __version__
+
+
+class SmartFormatter(argparse.HelpFormatter):
+    """Smart formatter for argparse - The lines are split for long text"""
+
+    def _split_lines(self, text, width):
+        if text.startswith("R|"):
+            return text[2:].splitlines()
+        # this is the RawTextHelpFormatter._split_lines
+        return argparse.HelpFormatter._split_lines(  # pylint: disable=protected-access
+            self, text, width
+        )
+
+
+class SigintHandler:  # pylint: disable=too-few-public-methods
+    """Handles the signal"""
+
+    def __init__(self):
+        self.SIGINT = False  # pylint: disable=invalid-name
+
+    def signal_handler(self, sig: int, frame):
+        """Trap the signal
+
+        Args:
+            sig (int): the signal number
+            frame: the current stack frame
+        """
+        # pylint: disable=unused-argument
+        logger.error("You pressed Ctrl+C")
+        self.SIGINT = True
+        sys.exit(2)
+
+
+def str2bool(string_to_test: str) -> bool:
+    """Checks if a given string is a boolean
+
+    Args:
+        string_to_test (str): string to test
+
+    Returns:
+        bool: True when the string is a boolean otherwise False
+    """
+    return string_to_test.lower() in ("yes", "true", "True", "t", "1")
+
+
+def parse_cli() -> argparse.Namespace:
+    """Parse command line inputs.
+
+    Returns
+    -------
+    argparse.Namespace
+        Command line options
+    """
+    parser = argparse.ArgumentParser(
+        description=__description__,
+        formatter_class=SmartFormatter,
+        epilog=__author__ + " - " + __copyright__,
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version="%(prog)s " + __version__
+    )
+
+    parser.add_argument(
+        "--conf_file",
+        default="conf/droidoc.conf",
+        help="The location of the configuration file (default: %(default)s)",
+    )
+
+    parser.add_argument(
+        "--directory",
+        default="/app",
+        help="The base directory where the data products are read and saved (default: %(default)s)",
+    )
+
+    parser.add_argument(
+        "--level",
+        choices=[
+            "INFO",
+            "DEBUG",
+            "WARNING",
+            "ERROR",
+            "CRITICAL",
+            "TRACE",
+        ],
+        default="INFO",
+        help="set Level log (default: %(default)s)",
+    )
+
+    return parser.parse_args()
+
+
+def run():
+    """Main function that instanciates the library."""
+    handler = SigintHandler()
+    signal.signal(signal.SIGINT, handler.signal_handler)
+    try:
+        options_cli = parse_cli()
+
+        droidoc = DroidocLib(**vars(options_cli))
+        droidoc.run()
+        sys.exit(0)
+    except Exception as error:  # pylint: disable=broad-except
+        logger.exception(error)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    # execute only if run as a script
+    run()

droidoc/_version.py

@@ -0,0 +1,13 @@
+from importlib.metadata import metadata
+
+pkg_metadata = metadata("droidoc")
+
+__name_soft__ = pkg_metadata.get("name", "unknown")
+__version__ = pkg_metadata.get("version", "0.0.0")
+__title__ = pkg_metadata.get("name", "unknown")
+__description__ = pkg_metadata.get("summary", "")
+__url__ = pkg_metadata.get("homepage", "")
+__author__ = pkg_metadata.get("authors", "unknown")
+__author_email__ = pkg_metadata.get("author-email", "unknown")
+__license__ = pkg_metadata.get("license", "")
+__copyright__ = "2026, (Dinil Bose Palakkatharappil )"

droidoc/droidoc.py

@@ -0,0 +1,99 @@
+import configparser
+import sys
+from typing import Any
+from typing import Dict
+
+from loguru import logger
+
+from ._version import __name_soft__
+
+
+class DroidocLib:
+    """The library"""
+
+    def __init__(self, **kwargs):
+        # pylint: disable=unused-argument
+        path_to_conf = kwargs.get("conf_file", "conf/droidoc.conf")
+        self.__config: configparser.ConfigParser = configparser.ConfigParser()
+        self.__config.optionxform = str  # type: ignore
+        self.__config.read(path_to_conf)
+
+        self.__directory: str = kwargs.get("directory", "/app")
+        self.__level: str = kwargs.get("level", "INFO")
+        DroidocLib._parse_level(self.__level)
+
+    @staticmethod
+    def _parse_level(level: str):
+        """Parse level name and set the rigt level for the logger.
+        If the level is not known, the INFO level is set
+
+        Args:
+            level (str): level name
+        """
+        if level == "INFO":
+            loguru_level = "INFO"
+        elif level == "DEBUG":
+            loguru_level = "DEBUG"
+        elif level == "WARNING":
+            loguru_level = "WARNING"
+        elif level == "ERROR":
+            loguru_level = "ERROR"
+        elif level == "CRITICAL":
+            loguru_level = "CRITICAL"
+        elif level == "TRACE":
+            loguru_level = "TRACE"
+        else:
+            loguru_level = "INFO"
+            logger.log(
+                loguru_level,
+                f"Unknown level name : {level} - setting level to INFO",
+            )
+
+        logger.remove()
+        logger.add(sys.stdout, level=loguru_level)
+
+    @property
+    def config(self) -> configparser.ConfigParser:
+        """The configuration file.
+
+        :getter: Returns the configuration file
+        :type: configparser.ConfigParser
+        """
+        return self.__config
+
+    @property
+    def directory(self) -> str:
+        """The Base directory.
+
+        :getter: Returns the base directory
+        :type: str
+        """
+        return self.__directory
+
+    @directory.setter
+    def directory(self, value: str):
+        self.__directory = value
+
+    def sample_function(input: str):
+        """
+        Decorator to log the inputs and/or outputs of a function, with a configurable log level.
+
+        Args:
+            input (bool, optional): Indicates whether to log the inputs of the function. Defaults to `True`.
+
+        Returns:
+            Callable: The decorated function that logs its inputs and/or outputs.
+
+        Usage:
+            This decorator allows you to log the inputs and/or outputs of a function with a configurable log level.
+            It can be used for debugging or monitoring function execution by tracking the values of arguments and results.
+
+        Example usage:
+            In this example, only the inputs will be logged at the `DEBUG` level, and the output will not be logged.
+
+        Notes:
+            - The `input` and `output` parameters allow fine-grained control over whether the function's arguments or results are logged.
+
+        """
+        output = "nothing"
+        return output

droidoc/monitoring.py

@@ -0,0 +1,146 @@
+"""Some Utilities."""
+
+import os
+import time
+import tracemalloc
+from functools import partial
+from functools import wraps
+
+from loguru import logger
+
+
+class UtilsMonitoring:  # noqa: R0205
+    """Some Utilities."""
+
+    # pylint: disable:invalid_name
+    @staticmethod
+    def io_display(
+        func=None, input=True, output=True, level="TRACE"
+    ):  # pylint: disable=W0622
+        """
+        Decorator to log the inputs and/or outputs of a function, with a configurable log level.
+
+        Args:
+            func (Callable, optional): Function to decorate. Defaults to `None`, which allows the decorator to be used with parameters.
+            input (bool, optional): Indicates whether to log the inputs of the function. Defaults to `True`.
+            output (bool, optional): Indicates whether to log the outputs of the function. Defaults to `True`.
+            level (str, optional): The log level used for logging messages. Defaults to "TRACE". Can be any of the log levels supported by `loguru` ("TRACE", "DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL").
+
+        Returns:
+            Callable: The decorated function that logs its inputs and/or outputs.
+
+        Usage:
+            This decorator allows you to log the inputs and/or outputs of a function with a configurable log level.
+            It can be used for debugging or monitoring function execution by tracking the values of arguments and results.
+
+        Example usage:
+
+            @UtilsMonitoring.io_display(input=True, output=False, level="DEBUG")
+            def add(a, b):
+                return a + b
+
+            add(3, 4)
+
+        In this example, only the inputs will be logged at the `DEBUG` level, and the output will not be logged.
+
+        Notes:
+            - If `func` is `None`, the decorator is configured with the given parameters.
+            - The `input` and `output` parameters allow fine-grained control over whether the function's arguments or results are logged.
+            - The `level` parameter must be a valid log level in `loguru` and is converted to uppercase before use.
+
+        """
+
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                # Obtenir le logger avec le niveau configuré
+                log_level = level.upper()
+
+                # Logger les entrées si configuré
+                if input:
+                    logger.log(
+                        log_level,
+                        f"Input in the function '{func.__name__}' with args={args}, kwargs={kwargs}",
+                    )
+
+                # Execute the function
+                result = func(*args, **kwargs)
+
+                # Log the outputs if configured
+                if output:
+                    logger.log(
+                        log_level,
+                        f"Output in the function '{func.__name__}' with result={result}",
+                    )
+
+                return result
+
+            return wrapper
+
+        return decorator
+
+    @staticmethod
+    def time_spend(func=None, level="DEBUG", threshold_in_ms=1000):
+        """Monitor the performances of a function.
+
+        Parameters
+        ----------
+        func: func
+            Function to monitor (default: {None})
+        level: int
+            Level from which the monitoring starts (default: {logging.DEBUG})
+        threshold_in_ms: int
+            an alert is sent at any level when the function duration >
+            threshold_in_ms (default: {1000})
+
+        Returns
+        -------
+        object : the result of the function
+        """
+        if func is None:
+            return partial(UtilsMonitoring.time_spend, level=level)
+
+        @wraps(func)
+        def newfunc(*args, **kwargs):
+            start_time = time.time()
+            result = func(*args, **kwargs)
+            elapsed_time = time.time() - start_time
+            logger.log(
+                level,
+                "function [{}] finished in {:.2f} ms".format(
+                    func.__qualname__, elapsed_time * 1000
+                ),
+            )
+            return result
+
+        return newfunc
+
+    @staticmethod
+    def measure_memory(func=None, level="DEBUG"):
+        """Measure the memory of the function
+
+        Args:
+            func (func, optional): Function to measure. Defaults to None.
+            level (int, optional): Level of the log. Defaults to DEBUG.
+
+        Returns:
+            object : the result of the function
+        """
+        if func is None:
+            return partial(UtilsMonitoring.measure_memory, level=level)
+
+        @wraps(func)
+        def newfunc(*args, **kwargs):
+            tracemalloc.start()
+            result = func(*args, **kwargs)
+            current, peak = tracemalloc.get_traced_memory()
+            msg = f"""
+            \033[37mFunction Name       :\033[35;1m {func.__name__}\033[0m
+            \033[37mCurrent memory usage:\033[36m {current / 10 ** 6}MB\033[0m
+            \033[37mPeak                :\033[36m {peak / 10 ** 6}MB\033[0m
+            """
+            logger.log(level, msg)
+            tracemalloc.stop()
+            return result
+
+        return newfunc

droidoc-0.0.1.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: droidoc
+Version: 0.0.1
+Summary: Droids Documentation fo Humanoids
+License-Expression: MIT
+License-File: AUTHORS.rst
+License-File: LICENSE
+Author: Dinil Bose Palakkatharappil
+Author-email: dinilbose@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Description-Content-Type: text/x-rst
+
+===============================
+droidoc
+===============================
+
+.. image:: https://img.shields.io/badge/Maintained%3F-yes-green.svg
+   :target: https://gitlab.com/dinilbose/droidoc/-/network/main
+.. image:: https://img.shields.io/badge/MIT-green
+
+Droids Documentation fo Humanoids
+
+
+Stable release
+--------------
+
+To install droidoc, run this command in your terminal:
+
+.. code-block:: console
+
+    $ pip install git+https://gitlab.com/dinilbose/droidoc.git
+
+This is the preferred method to install droidoc, as it will always install the most recent stable release.
+
+If you don't have `pip`_ installed, this `Python installation guide`_ can guide
+you through the process.
+
+.. _pip: https://pip.pypa.io
+.. _Python installation guide: http://docs.python-guide.org/en/latest/starting/installation/
+
+
+From sources
+------------
+
+The sources for droidoc can be downloaded from the `Gitlab repo`_.
+
+You can either clone the public repository:
+
+.. code-block:: console
+
+    $ git clone https://gitlab.com/dinilbose/droidoc.git
+
+Or download the `tarball`_:
+
+.. code-block:: console
+
+    $ curl -OJL https://gitlab.com/dinilbose/droidoc/tarball/main
+
+Once you have a copy of the source, you can install it with:
+
+.. code-block:: console
+
+    $ make  # install in the system root
+    $ make user # or Install for non-root usage
+
+
+.. _Gitlab repo: https://gitlab.com/dinilbose/droidoc
+.. _tarball: https://gitlab.com/dinilbose/droidoc/tarball/main
+
+
+
+Development
+-----------
+
+.. code-block:: console
+
+        $ git clone droidoc.git
+        $ cd droidoc
+        $ make prepare-dev
+        $ source .droidoc
+        $ make install-dev
+
+
+To get more information about the preconfigured tasks:
+
+.. code-block:: console
+
+        $ make help
+
+Usage
+-----
+
+To use droidoc in a project::
+
+    import droidoc
+
+
+With the docker:
+
+.. code-block:: console
+
+        $ docker run -u $(id -u):$(id -g) -v $(pwd):/app --rm droidoc_image droidoc
+
+
+
+
+Run tests
+---------
+
+.. code-block:: console
+
+        $make tests
+
+
+Documentation
+-------------
+The documentation is automatically deployed on https://gitlab.com/dinilbose/droidoc based on main branch
+
+Container
+---------
+A container is automatically created on https://gitlab.com/dinilbose/droidoc/container_registry
+
+
+Author
+------
+👤 **Dinil Bose Palakkatharappil**
+
+
+
+🤝 Contributing
+---------------
+Contributions, issues and feature requests are welcome!
+
+Feel free to check `issues page <https://gitlab.com/dinilbose/droidoc/issues>`_. You can also take a look at the `contributing guide <https://gitlab.com/dinilbose/droidoc/blob/main/CONTRIBUTING.rst>`_
+
+
+📝 License
+----------
+This project is `MIT <https://gitlab.com/dinilbose/droidoc/blob/main/LICENSE>`_ licensed.
+

droidoc-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+droidoc/__init__.py,sha256=8HSSvwahpvEqgQUukcKd75s3fAcvALSz2sA-NblNkGg,323
+droidoc/__main__.py,sha256=aruWo6XMqXrmixmr_GjfmmgslIsdlx1Yut_EhUve4Xo,3052
+droidoc/_version.py,sha256=Vz1prWfBLSoexX2EV3EcTeKcUj_YCADCzYi-LlvcoFU,537
+droidoc/conf/droidoc.conf,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+droidoc/droidoc.py,sha256=T5as23hbS5E1roHz5SOhFvtRfak8NZElQBGi8a4LHTE,3073
+droidoc/monitoring.py,sha256=BmT6VtBVYay_B-sWP3qh61wET6wxLTHmfsbv0Rf6mPM,5148
+droidoc-0.0.1.dist-info/METADATA,sha256=0JLzrUpO7j4iep6o_IGRWLE9s-ZNUoR72gYIfmwWxgM,3342
+droidoc-0.0.1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+droidoc-0.0.1.dist-info/entry_points.txt,sha256=18LF0rOYXsgxbalXzOGLmx_PQA7evhrXc5j1PoakYSA,48
+droidoc-0.0.1.dist-info/licenses/AUTHORS.rst,sha256=bmXXV1kKC0oIeS2qrV3ipV8DLeywqk9YYn2xUOaZU64,150
+droidoc-0.0.1.dist-info/licenses/LICENSE,sha256=NxurTJqckso6NgPqJb1N6RI4DrZRPyT-rryPF77LhU8,1062
+droidoc-0.0.1.dist-info/RECORD,,

droidoc-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.5.0
+Root-Is-Purelib: true
+Tag: py3-none-any

droidoc-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+droidoc=droidoc.__main__:run
+

droidoc-0.0.1.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,13 @@
+=======
+Credits
+=======
+
+Development Lead
+----------------
+
+* Dinil Bose Palakkatharappil <dinilbose@gmail.com>
+
+Contributors
+------------
+
+None yet.

droidoc-0.0.1.dist-info/licenses/LICENSE

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