rkt-tool-lib 1.4.1__tar.gz → 1.5.0__tar.gz

{rkt_tool_lib-1.4.1 → rkt_tool_lib-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: rkt_tool_lib
-Version: 1.4.1
+Version: 1.5.0
 Summary: RootKit custom tool Lib
 Author: RootKit
 Author-email: rootkit@rootkit-lab.org
@@ -17,6 +17,13 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+Dynamic: summary
 
 # rkt_tool_lib - Python library
 

{rkt_tool_lib-1.4.1 → rkt_tool_lib-1.5.0}/rkt_lib_toolkit/rkt_tool_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: rkt-tool-lib
-Version: 1.4.1
+Metadata-Version: 2.2
+Name: rkt_tool_lib
+Version: 1.5.0
 Summary: RootKit custom tool Lib
 Author: RootKit
 Author-email: rootkit@rootkit-lab.org
@@ -17,6 +17,13 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+Dynamic: summary
 
 # rkt_tool_lib - Python library
 

{rkt_tool_lib-1.4.1 → rkt_tool_lib-1.5.0}/rkt_lib_toolkit/rkt_tool_lib.egg-info/SOURCES.txt

@@ -1,8 +1,12 @@
 LICENSE
 README
+rkt_lib_toolkit/rkt_tool_lib/Tool.py
+rkt_lib_toolkit/rkt_tool_lib/__init__.py
 rkt_lib_toolkit/rkt_tool_lib.egg-info/PKG-INFO
 rkt_lib_toolkit/rkt_tool_lib.egg-info/SOURCES.txt
 rkt_lib_toolkit/rkt_tool_lib.egg-info/dependency_links.txt
 rkt_lib_toolkit/rkt_tool_lib.egg-info/top_level.txt
-rkt_lib_toolkit/tool/Tool.py
-rkt_lib_toolkit/tool/__init__.py
+tests/test_AI.py
+tests/test_Config.py
+tests/test_Logger.py
+tests/test_Tool.py

rkt_tool_lib-1.5.0/rkt_lib_toolkit/rkt_tool_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+rkt_tool_lib

rkt_tool_lib-1.5.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_tool_lib-1.5.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_tool_lib-1.5.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_tool_lib-1.5.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_tool_lib-1.4.1/rkt_lib_toolkit/rkt_tool_lib.egg-info/top_level.txt

@@ -1 +0,0 @@
-tool