rkt-config-lib 1.4.0__tar.gz → 2.0.0__tar.gz

rkt_config_lib-2.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: rkt_config_lib
+Version: 2.0.0
+Summary: RootKit custom PyYaml Lib
+Author-email: RootKit <rootkit@rootkit-lab.org>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Requires-Dist: PyYaml>=6.0.1
+Requires-Dist: rkt_tool_lib
+Requires-Dist: rkt_logger_lib

rkt_config_lib-2.0.0/README.md

@@ -0,0 +1,22 @@
+# rkt_config_lib
+
+Centralized Configuration Management wrapper around PyYaml.
+
+## Features
+- **Singleton Pattern**: Ensures a single configuration state across your application.
+- **Auto-Loading**: Automatically scans and loads all YAML files in a `config/` directory.
+- **Safe Loading**: Uses `yaml.safe_load` by default to prevent arbitrary code execution vulnerabilities.
+- **Integrated Logging**: Logs loading operations via `rkt_logger_lib`.
+
+## Usage
+
+```python
+from config import Config
+
+conf = Config()
+# Loads all .yml/.yaml files from ./config/ directory
+conf.get_data()
+
+# Access data (filename becomes the key)
+my_settings = conf.data.get("settings")
+```

rkt_config_lib-2.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rkt_config_lib"
+version = "2.0.0"
+description = "RootKit custom PyYaml Lib"
+authors = [
+  { name="RootKit", email="rootkit@rootkit-lab.org" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.7"
+dependencies = [
+    "PyYaml>=6.0.1",
+    "rkt_tool_lib",
+    "rkt_logger_lib",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

rkt_config_lib-2.0.0/src/config/__init__.py

@@ -0,0 +1 @@
+from .config import Config

rkt_config_lib-2.0.0/src/config/config.py

@@ -0,0 +1,59 @@
+import os
+from typing import Any
+
+import yaml
+
+from logger import Logger
+from tool import Singleton, Tool
+
+
+class Config(metaclass=Singleton):  # type: ignore[metaclass]
+    """
+    Configuration manager wrapping PyYaml.
+
+    This class handles the loading of YAML configuration files from a specific directory.
+    It implements the Singleton pattern to ensure centralized configuration management.
+    """
+
+    __slots__ = ["_me", "_logger", "_tool", "_skills_file", "data"]
+
+    def __init__(self) -> None:
+        self._me = self.__class__.__name__
+        self._logger = Logger(caller_class=self._me)
+        self._logger.set_logger(caller_class=self._me)
+        self._tool = Tool()
+        self.data: dict[str, Any] = {}
+
+    def get_data(self, needed_file: str = "", _config_dir: str = "config", create_if_not_exist: bool = False) -> None:
+        """
+        Load configuration files from the config directory.
+
+        It scans the directory for YAML files and loads them into `self.data`.
+
+        Args:
+            needed_file (str, optional): A specific file to load. If empty, loads all YAML files in the directory.
+                                         Defaults to "".
+            _config_dir (str, optional): Name of the configuration directory. Defaults to "config".
+            create_if_not_exist (bool, optional): Create the config directory if it doesn't exist. Defaults to False.
+        """
+        config_dir = self._tool.get_dir(_config_dir)
+
+        if (not config_dir or not os.path.exists(config_dir)) and create_if_not_exist:
+            os.makedirs(_config_dir, exist_ok=True)
+            config_dir = self._tool.formatted_from_os(os.path.abspath(_config_dir))
+
+        if needed_file:
+            filename = os.path.basename(needed_file).split(".")[0]
+            with open(f"{config_dir}{needed_file}", encoding="utf8") as nf:
+                self._logger.add(level="info", caller=self._me, message=f"Load '{filename}' file ...")
+                self.data[filename] = yaml.safe_load(nf)
+        else:
+            for file in os.listdir(config_dir):
+                try:
+                    (filename, ext) = os.path.basename(file).split(".")
+                except ValueError:
+                    continue
+                if ext in ["yml", "yaml"] and filename not in self.data.keys():
+                    with open(f"{config_dir}{file}", encoding="utf8") as f:
+                        self._logger.add(level="info", caller=self._me, message=f"Load '{filename}' file ...")
+                        self.data[filename] = yaml.safe_load(f)

rkt_config_lib-2.0.0/src/rkt_config_lib.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: rkt_config_lib
+Version: 2.0.0
+Summary: RootKit custom PyYaml Lib
+Author-email: RootKit <rootkit@rootkit-lab.org>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Requires-Dist: PyYaml>=6.0.1
+Requires-Dist: rkt_tool_lib
+Requires-Dist: rkt_logger_lib

rkt_config_lib-2.0.0/src/rkt_config_lib.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/config/__init__.py
+src/config/config.py
+src/rkt_config_lib.egg-info/PKG-INFO
+src/rkt_config_lib.egg-info/SOURCES.txt
+src/rkt_config_lib.egg-info/dependency_links.txt
+src/rkt_config_lib.egg-info/requires.txt
+src/rkt_config_lib.egg-info/top_level.txt
+tests/test_config.py

{rkt_config_lib-1.4.0/rkt_lib_toolkit → rkt_config_lib-2.0.0/src}/rkt_config_lib.egg-info/requires.txt

@@ -1,3 +1,3 @@
-PyYaml
+PyYaml>=6.0.1
 rkt_tool_lib
 rkt_logger_lib

rkt_config_lib-2.0.0/src/rkt_config_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+config

rkt_config_lib-2.0.0/tests/test_config.py

@@ -0,0 +1,66 @@
+import os
+import shutil
+from typing import Any, Optional
+from unittest import TestCase
+from unittest.mock import patch
+
+from yaml.scanner import ScannerError
+
+from config import Config
+from tool import Tool
+
+
+class TestConfig(TestCase):
+    def get_dir_side_effect(self, folder: str, root: "Optional[str]" = None) -> "Optional[str]":
+        if folder in ["valid_config", "dummy_config", "missing_folder"]:
+            return str(Tool.formatted_from_os(os.path.join(os.path.dirname(__file__), "resources", folder)))
+        # Use the original method from the class, passing a new instance or self if relevant
+        # Accessing the original method requires unpatching or saving it.
+        # Simpler: just return None or duplicate logic for now since we don't expect other calls.
+        return None
+
+    @patch("tool.Tool.get_dir")
+    def test_get_data(self, mock_get_dir: "Any") -> None:
+        mock_get_dir.side_effect = self.get_dir_side_effect
+        config = Config()
+        config.data.clear()
+        config.get_data(_config_dir="valid_config")
+
+        assert config.data == {
+            "valid_config": {
+                "key1": {"sub_key": "value", "sub_key2": "value", "sub_key3": "value", "sub_key4": "value"}
+            }
+        }
+
+    @patch("tool.Tool.get_dir")
+    def test_get_data_dummy_data(self, mock_get_dir: "Any") -> None:
+        mock_get_dir.side_effect = self.get_dir_side_effect
+        config = Config()
+        config.data.clear()
+        try:
+            config.get_data(_config_dir="dummy_config")
+            self.fail("ScannerError expected here!")
+        except ScannerError:
+            assert config.data == {}
+
+    @patch("tool.Tool.get_dir")
+    def test_get_data_dummy_folder(self, mock_get_dir: "Any") -> None:
+        mock_get_dir.side_effect = self.get_dir_side_effect
+        config = Config()
+        config.data.clear()
+        config.get_data(_config_dir="missing_folder", create_if_not_exist=True)
+        assert os.path.exists("missing_folder")
+        shutil.rmtree("missing_folder")
+
+    @patch("tool.Tool.get_dir")
+    def test_get_data_from_specific_file(self, mock_get_dir: "Any") -> None:
+        mock_get_dir.side_effect = self.get_dir_side_effect
+        config = Config()
+        config.data.clear()
+        config.get_data(_config_dir="valid_config", needed_file="valid_config.yml")
+
+        assert config.data == {
+            "valid_config": {
+                "key1": {"sub_key": "value", "sub_key2": "value", "sub_key3": "value", "sub_key4": "value"}
+            }
+        }

rkt_config_lib-1.4.0/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Dabo Ross
-
-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.

rkt_config_lib-1.4.0/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.2
-Name: rkt_config_lib
-Version: 1.4.0
-Summary: RootKit custom PyYaml Lib
-Author: RootKit
-Author-email: rootkit@rootkit-lab.org
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Natural Language :: French
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Topic :: Utilities
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYaml
-Requires-Dist: rkt_tool_lib
-Requires-Dist: rkt_logger_lib
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# rkt_config_lib - Python library
-
-![Package Version](https://badgen.net/badge/Package%20Version/latest%20-%201.3.0/green?scale=1.2)
-
-![quality](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=alert_status)
-![reliability_rating](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=reliability_rating)
-![security_rating](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=security_rating)
-![vulnerabilities](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=vulnerabilities)
-![coverage](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=coverage)
-![maintainability](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=sqale_rating)
-
-This Python library is based only on built-in Python libraries and one (1) non-build-in library : [PyYaml](https://pypi.org/project/PyYAML/)
-
-##### Python Version 3.7.2
-##### PyYaml Version 5.4.1 (Released Jan 20, 2021)
-
-----
-
-## What is Python?
-Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.
-
-[source](https://en.wikipedia.org/wiki/Python_(programming_language))
-## What is PyYaml?
-YAML is a data serialization format designed for human readability and interaction with scripting languages. PyYAML is a YAML parser and emitter for Python.
-
-PyYAML features a complete YAML 1.1 parser, Unicode support, pickle support, capable extension API, and sensible error messages. PyYAML supports standard YAML tags and provides Python-specific tags that allow to represent an arbitrary Python object.
-
-PyYAML is applicable for a broad range of tasks from complex configuration files to object serialization and persistence.
-
-[source](https://pypi.org/project/PyYAML/)
-## Libraries
-* Config: overlay of PyYaml library (read-only), use Tool and Logger library (rkt_tool_lib, rkt_logger_lib)
-
-## Use it
-### Install
-```bash
- (venv) my_project> pip install rkt_config_lib [--index-url https://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]
-```
-### Example
-```python
-from rkt_config_lib import Config
-
-c = Config()
-
-# by default search folder named "config" in root project folder
-# for load all yaml files
-c.get_data()
-
-print(f"{c.data}")
-```
-
-### Output (as file, sdtout or both)
-```log
-03/03/2022 16:44:09 :: [Logger] :: INFO :: Create logger for 'Config'
-03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'StreamHandler' in 'Config' logger
-03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'FileHandler' in 'Config' logger
-03/03/2022 16:44:09 :: [Config] :: INFO :: Load 'database' file ...
-```
-```
-{'database': {'connect_id': {'dbms': 'mariadb'}}}
-  ^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                       |
-   |                      data: file content
- file name without extension
-```
-
-## Contributing
-
-If you find this library useful here's how you can help:
-
-- Send a merge request with your kickass new features and bug fixes
-- Help new users with [issues](https://gitlab.tprc.ovh/python/rkt_lib_toolkit/-/issues) they may encounter
-- Support the development of this library and star this repo!

rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib/Config.py

@@ -1,53 +0,0 @@
-import os
-import yaml
-
-try:
-    from rkt_logger_lib.Logger import Logger
-except ImportError:
-    from rkt_lib_toolkit.rkt_logger_lib.Logger import Logger
-
-try:
-    from rkt_tool_lib.Tool import Tool, Singleton
-except ImportError:
-    from rkt_lib_toolkit.rkt_tool_lib.Tool import Tool, Singleton
-
-
-class Config(metaclass=Singleton):
-    """
-    Basic PyYaml wrapper
-    add custom logger, list of file need to be load
-
-    """
-    __slots__ = ["_me", "_logger", "_tool", "_skills_file", "data"]
-
-    def __init__(self) -> None:
-        self._me = self.__class__.__name__
-        self._logger = Logger(caller_class=self._me)
-        self._logger.set_logger(caller_class=self._me)
-        self._tool = Tool()
-        self.data = {}
-
-    def get_data(self, needed_file: str = "", _config_dir: str = "config", create_if_not_exist: bool = False) -> None:
-        """
-        Load all file in 'config_dir' and get data in dict formatted as : {"basename_1": <VALUE_1>, ...}
-        """
-        config_dir = self._tool.get_dir(_config_dir)
-
-        if (not config_dir or not os.path.exists(config_dir)) and create_if_not_exist:
-            os.makedirs(_config_dir, exist_ok=True)
-
-        if needed_file:
-            filename = os.path.basename(needed_file).split(".")[0]
-            with open(f"{config_dir}{needed_file}", "r", encoding='utf8') as nf:
-                self._logger.add(level="info", caller=self._me, message=f"Load '{filename}' file ...")
-                self.data[filename] = yaml.load(nf, Loader=yaml.FullLoader)
-        else:
-            for file in os.listdir(config_dir):
-                try:
-                    (filename, ext) = os.path.basename(file).split(".")
-                except ValueError:
-                    continue
-                if ext in ["yml", "yaml"] and filename not in self.data.keys():
-                    with open(f"{config_dir}{file}", "r", encoding='utf8') as f:
-                        self._logger.add(level="info", caller=self._me, message=f"Load '{filename}' file ...")
-                        self.data[filename] = yaml.load(f, Loader=yaml.FullLoader)

rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib/__init__.py

@@ -1 +0,0 @@
-from .Config import Config

rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib.egg-info/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.2
-Name: rkt_config_lib
-Version: 1.4.0
-Summary: RootKit custom PyYaml Lib
-Author: RootKit
-Author-email: rootkit@rootkit-lab.org
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Natural Language :: French
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Topic :: Utilities
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYaml
-Requires-Dist: rkt_tool_lib
-Requires-Dist: rkt_logger_lib
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# rkt_config_lib - Python library
-
-![Package Version](https://badgen.net/badge/Package%20Version/latest%20-%201.3.0/green?scale=1.2)
-
-![quality](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=alert_status)
-![reliability_rating](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=reliability_rating)
-![security_rating](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=security_rating)
-![vulnerabilities](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=vulnerabilities)
-![coverage](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=coverage)
-![maintainability](https://sonarqube.tprc.ovh/api/project_badges/measure?project=python_rkt_lib_toolkit_AXqQ32evGCA0VuRY8SuD&metric=sqale_rating)
-
-This Python library is based only on built-in Python libraries and one (1) non-build-in library : [PyYaml](https://pypi.org/project/PyYAML/)
-
-##### Python Version 3.7.2
-##### PyYaml Version 5.4.1 (Released Jan 20, 2021)
-
-----
-
-## What is Python?
-Python is an interpreted high-level general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.
-
-[source](https://en.wikipedia.org/wiki/Python_(programming_language))
-## What is PyYaml?
-YAML is a data serialization format designed for human readability and interaction with scripting languages. PyYAML is a YAML parser and emitter for Python.
-
-PyYAML features a complete YAML 1.1 parser, Unicode support, pickle support, capable extension API, and sensible error messages. PyYAML supports standard YAML tags and provides Python-specific tags that allow to represent an arbitrary Python object.
-
-PyYAML is applicable for a broad range of tasks from complex configuration files to object serialization and persistence.
-
-[source](https://pypi.org/project/PyYAML/)
-## Libraries
-* Config: overlay of PyYaml library (read-only), use Tool and Logger library (rkt_tool_lib, rkt_logger_lib)
-
-## Use it
-### Install
-```bash
- (venv) my_project> pip install rkt_config_lib [--index-url https://gitlab.tprc.ovh/api/v4/groups/python/-/packages/pypi]
-```
-### Example
-```python
-from rkt_config_lib import Config
-
-c = Config()
-
-# by default search folder named "config" in root project folder
-# for load all yaml files
-c.get_data()
-
-print(f"{c.data}")
-```
-
-### Output (as file, sdtout or both)
-```log
-03/03/2022 16:44:09 :: [Logger] :: INFO :: Create logger for 'Config'
-03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'StreamHandler' in 'Config' logger
-03/03/2022 16:44:09 :: [Logger] :: INFO :: add 'FileHandler' in 'Config' logger
-03/03/2022 16:44:09 :: [Config] :: INFO :: Load 'database' file ...
-```
-```
-{'database': {'connect_id': {'dbms': 'mariadb'}}}
-  ^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                       |
-   |                      data: file content
- file name without extension
-```
-
-## Contributing
-
-If you find this library useful here's how you can help:
-
-- Send a merge request with your kickass new features and bug fixes
-- Help new users with [issues](https://gitlab.tprc.ovh/python/rkt_lib_toolkit/-/issues) they may encounter
-- Support the development of this library and star this repo!

rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib.egg-info/SOURCES.txt

@@ -1,13 +0,0 @@
-LICENSE
-README
-rkt_lib_toolkit/rkt_config_lib/Config.py
-rkt_lib_toolkit/rkt_config_lib/__init__.py
-rkt_lib_toolkit/rkt_config_lib.egg-info/PKG-INFO
-rkt_lib_toolkit/rkt_config_lib.egg-info/SOURCES.txt
-rkt_lib_toolkit/rkt_config_lib.egg-info/dependency_links.txt
-rkt_lib_toolkit/rkt_config_lib.egg-info/requires.txt
-rkt_lib_toolkit/rkt_config_lib.egg-info/top_level.txt
-tests/test_AI.py
-tests/test_Config.py
-tests/test_Logger.py
-tests/test_Tool.py

rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib.egg-info/top_level.txt

@@ -1 +0,0 @@
-rkt_config_lib

rkt_config_lib-1.4.0/tests/test_AI.py

@@ -1,189 +0,0 @@
-import os.path
-import time
-from unittest import TestCase
-
-from pandas import DataFrame
-
-from rkt_lib_toolkit import Logger, Config
-from rkt_lib_toolkit.rkt_ai_lib import QLearning
-
-MODEL = "tests/resources/qlearning/load/load_coverage.gzip"
-
-
-class TestQLearning(TestCase):
-    def test_me_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.me = 'me'
-        assert ql.me == 'me'
-
-    def test_me_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert ql.me == 'QLearning'
-
-    def test_logger_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.logger = Logger(caller_class=ql.me)
-        assert isinstance(ql.logger, Logger)
-
-    def test_logger_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        logger = ql.logger
-        assert isinstance(logger, Logger)
-
-    def test_config_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.config = Config()
-        assert isinstance(ql.config, Config)
-
-    def test_config_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        config = ql.config
-        assert isinstance(config, Config)
-
-    def test_learning_rate_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        original_lr = ql.learning_rate
-        ql.learning_rate = 1.0
-        assert ql.learning_rate != original_lr
-
-    def test_learning_rate_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        original_lr = ql.learning_rate
-        assert ql.learning_rate == original_lr
-
-    def test_discount_factor_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        original_df = ql.discount_factor
-        ql.discount_factor = 1.0
-        assert ql.discount_factor != original_df
-
-    def test_discount_factor_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        original_df = ql.discount_factor
-        assert ql.discount_factor == original_df
-
-    def test_qtable_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert isinstance(ql.qtable, DataFrame)
-
-    def test_qtable_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        qtable = ql.qtable
-        assert isinstance(qtable, DataFrame)
-
-    def test_previous_state_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.previous_state = 's'
-        assert ql.previous_state == 's'
-
-    def test_previous_state_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert ql.previous_state == 'start'
-
-    def test_previous_action_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.previous_action = 'a'
-        assert ql.previous_action == 'a'
-
-    def test_previous_action_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert ql.previous_action == 'do-nothing'
-
-    def test_available_actions_setter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert ql.available_actions == ['a', 'b', 'c']
-
-    def test_available_actions_getter(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        actions_list = ql.available_actions
-        assert actions_list == ['a', 'b', 'c']
-
-    def test00_save(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.check_state_exist(state='s')
-        ql.previous_state = "new_action"
-        ql.check_state_exist(state='s1')
-        ql.save("tests/resources/qlearning/save/save_coverage.gzip")
-        ql.save(MODEL)
-        assert os.path.exists("tests/resources/qlearning/save/save_coverage.gzip")
-
-    def test01_load(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.load(do_load=True, file_to_load=MODEL)
-        assert isinstance(ql.qtable, DataFrame)
-
-    def test03_choose_action(self):
-        time.sleep(1.0)
-        ql = QLearning(actions=['a', 'b', 'c'], should_load=True,
-                       qtable_file_to_load=MODEL)
-
-        action = ql.choose_action(state='s')
-        assert action in ['a', 'b', 'c']
-
-    def test_learn(self):
-        ql = QLearning(actions=['a', 'b', 'c'], should_load=True,
-                       qtable_file_to_load=MODEL)
-        for i in range(2):
-            action = ql.choose_action(state=f's{i}')
-            ql.learn(state=f's{i}', action=action, reward=1.0)
-        assert ql.qtable.index.tolist() == ['start', 's1']
-
-    def test_check_state_exist(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        ql.check_state_exist(state='s')
-        qtable_len = len(ql.qtable.index)
-        ql.check_state_exist(state='s')
-        qtable2_len = len(ql.qtable.index)
-        ql.previous_state = "new_action"
-        ql.check_state_exist(state='s1')
-        qtable3_len = len(ql.qtable.index)
-        assert qtable_len == qtable2_len and qtable_len != qtable3_len
-
-    def test_representation(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        assert ql.__repr__() == f"QLearning(learning_rate={ql.learning_rate}, discount_factor={ql.discount_factor}, learning_method={ql._learning_method})"
-
-    def test_me_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.me = 1
-
-    def test_logger_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.logger = 1
-
-    def test_config_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.config = 1
-
-    def test_learning_rate_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.learning_rate = "0"
-
-    def test_discount_factor_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.discount_factor = "0"
-
-    def test_qtable_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.qtable = "0"
-
-    def test_previous_state_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.previous_state = 1
-
-    def test_previous_action_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.previous_action = 1
-
-    def test_available_actions_setter_error(self):
-        ql = QLearning(actions=['a', 'b', 'c'])
-        with self.assertRaises(TypeError):
-            ql.available_actions = 1

rkt_config_lib-1.4.0/tests/test_Config.py

@@ -1,52 +0,0 @@
-import os
-import shutil
-
-from unittest import TestCase
-
-from yaml.scanner import ScannerError
-from rkt_lib_toolkit.rkt_config_lib import Config
-
-
-class TestConfig(TestCase):
-    def test_get_data(self):
-        config = Config()
-        config.data.clear()
-        config.get_data(_config_dir="valid_config")
-
-        assert config.data == {
-            'valid_config': {'key1': {
-                'sub_key': 'value',
-                'sub_key2': 'value',
-                'sub_key3': 'value',
-                'sub_key4': 'value'
-                }
-            }
-        }
-
-    def test_get_data_dummy_data(self):
-        config = Config()
-        config.data.clear()
-        try:
-            config.get_data(_config_dir="dummy_config")
-            self.fail("ScannerError expected here!")
-        except ScannerError:
-            assert config.data == {}
-
-    def test_get_data_dummy_folder(self):
-        config = Config()
-        config.data.clear()
-        config.get_data(_config_dir="missing_folder", create_if_not_exist=True)
-        assert os.path.exists("missing_folder")
-        shutil.rmtree("missing_folder")
-
-    def test_get_data_from_specific_file(self):
-        config = Config()
-        config.data.clear()
-        config.get_data(_config_dir="valid_config", needed_file="valid_config.yml")
-
-        assert config.data == {
-            'valid_config': {'key1': {
-                'sub_key': 'value', 'sub_key2': 'value', 'sub_key3': 'value', 'sub_key4': 'value'
-                }
-            }
-        }

rkt_config_lib-1.4.0/tests/test_Logger.py

@@ -1,53 +0,0 @@
-import os
-import shutil
-from datetime import datetime
-from unittest import TestCase
-
-from rkt_lib_toolkit.rkt_logger_lib import Logger
-from rkt_lib_toolkit.rkt_exception_lib import InvalidLogLevelError, LogIsNotDirError
-from rkt_lib_toolkit.rkt_tool_lib import Singleton, Tool
-
-tool = Tool()
-
-
-class TestLogger(TestCase):
-
-    def test_logger_when_log_is_not_directory(self):
-        log = f"{tool.formatted_from_os(tool.get_cwd())}log_misstake"
-        if os.path.exists(log):
-            if os.path.isdir(log):
-                shutil.rmtree(log)
-            else:
-                os.remove(log)
-
-        open(log, "x").close()
-        Singleton._instances = {}
-        with self.assertRaises(LogIsNotDirError) as context:
-            logger = Logger("coverage", "log_misstake")
-
-        assert str(context.exception) == "\"log\" isn't a directory"
-        os.remove(log)
-
-    def test_add_without_exiting_log_level(self):
-        logger = Logger("coverage", "log")
-        logger.set_logger(caller_class="coverage", output="stream")
-        with self.assertRaises(InvalidLogLevelError):
-            logger.add("coverage", "tests coverage", 42)
-
-    def test_add_with_exiting_log_level(self):
-        logger = Logger("coverage", "log")
-        logger.set_logger(caller_class="coverage", output="stream")
-        assert logger.add("coverage", "tests coverage", 20) is None
-
-    def test_set_logger(self):
-        logger = Logger("coverage", "log")
-        logger.set_logger(caller_class="coverage", output="both", out_file="coverage", level=10)
-        logger.add("coverage", "test", 20)
-        excepted = f"{logger._tool.get_dir(folder='log')}coverage_{datetime.today().date()}.log"
-        obtained = logger.get_logger_file('coverage')
-        assert obtained == excepted, print(f"Expected: {excepted}\nObtained: {obtained}")
-
-    def test_no_logger_file(self):
-        logger = Logger("coverage", "log")
-        logger.set_logger(caller_class="coverage", output="both", out_file="coverage")
-        assert logger.get_logger_file('not_exist') is None

rkt_config_lib-1.4.0/tests/test_Tool.py

@@ -1,45 +0,0 @@
-import os
-
-from rkt_lib_toolkit.rkt_tool_lib import Tool, Singleton
-
-obj = Tool()
-
-
-class FakeClass(metaclass=Singleton):
-    def __init__(self):
-        self.name = "singleton"
-
-
-class TestTool:
-    def test_formatted_from_os(self):
-        if os.name == "nt":
-            excepted = obj.formatted_from_os(os.getcwd()).endswith("\\")
-        else:
-            excepted = obj.formatted_from_os(os.getcwd()).endswith("/")
-        assert excepted
-
-    def test_get_cwd(self):
-        assert obj.get_cwd() == f"{os.getcwd()}\\" if os.name == "nt" else f"{os.getcwd()}/"
-
-    def test_get_dir_flat(self):
-        if os.name == "nt":
-            excepted = f"{os.getcwd()}\\tests\\"
-        else:
-            excepted = f"{os.getcwd()}/tests/"
-        assert obj.get_dir("tests") == excepted
-
-    def test_get_dir_recursive(self):
-        if os.name == "nt":
-            excepted = f"{os.getcwd()}\\tests\\resources\\"
-        else:
-            excepted = f"{os.getcwd()}/tests/resources/"
-
-        assert obj.get_dir("resources") == excepted
-
-
-class TestSingleton:
-    def test_singleton(self):
-        obj_1 = FakeClass()
-        obj_2 = FakeClass()
-        assert obj_1 == obj_2
-