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

{rkt_config_lib-1.3.0 → rkt_config_lib-1.4.0}/PKG-INFO

@@ -1,12 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: rkt_config_lib
-Version: 1.3.0
+Version: 1.4.0
 Summary: RootKit custom PyYaml Lib
-Home-page: UNKNOWN
 Author: RootKit
 Author-email: rootkit@rootkit-lab.org
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
@@ -20,6 +17,17 @@ 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
 
@@ -94,5 +102,3 @@ 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.3.0/rkt_lib_toolkit/config → rkt_config_lib-1.4.0/rkt_lib_toolkit/rkt_config_lib}/Config.py

@@ -1,9 +1,15 @@
 import os
 import yaml
 
-from rkt_lib_toolkit.tool.Tool import Tool, Singleton
+try:
+    from rkt_logger_lib.Logger import Logger
+except ImportError:
+    from rkt_lib_toolkit.rkt_logger_lib.Logger import Logger
 
-from rkt_lib_toolkit.logger.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):
@@ -21,14 +27,14 @@ class Config(metaclass=Singleton):
         self._tool = Tool()
         self.data = {}
 
-    def get_data(self, needed_file: str = "", config_dir: str = "config", create_if_not_exist: bool = False) -> None:
+    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)
+        config_dir = self._tool.get_dir(_config_dir)
 
-        if create_if_not_exist and not os.path.exists(config_dir):
-            os.makedirs(config_dir, exist_ok=True)
+        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]

{rkt_config_lib-1.3.0 → rkt_config_lib-1.4.0}/rkt_lib_toolkit/rkt_config_lib.egg-info/PKG-INFO

@@ -1,12 +1,9 @@
-Metadata-Version: 2.1
-Name: rkt-config-lib
-Version: 1.3.0
+Metadata-Version: 2.2
+Name: rkt_config_lib
+Version: 1.4.0
 Summary: RootKit custom PyYaml Lib
-Home-page: UNKNOWN
 Author: RootKit
 Author-email: rootkit@rootkit-lab.org
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
@@ -20,6 +17,17 @@ 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
 
@@ -94,5 +102,3 @@ 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.3.0 → rkt_config_lib-1.4.0}/rkt_lib_toolkit/rkt_config_lib.egg-info/SOURCES.txt

@@ -1,9 +1,13 @@
 LICENSE
 README
-rkt_lib_toolkit/config/Config.py
-rkt_lib_toolkit/config/__init__.py
+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
+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

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

rkt_config_lib-1.4.0/tests/test_AI.py

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,45 @@
+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
+

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

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