tks-essentials 0.1.1__tar.gz

tks-essentials-0.1.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

tks-essentials-0.1.1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: tks-essentials
+Version: 0.1.1
+Summary: Essentials for our TKS projects.
+Author-email: Brayan <brayan@sparkandhale.com>
+Project-URL: Homepage, https://github.com/The-Kara-System/tks-essentials
+Keywords: finance,trading,models
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis
+Requires-Dist: tomli; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# tks-essentials
+A library with essentials needed in every backend python app. e.g. logging, local db connection, filtering, formatting etc.
+
+## Sponsors
+Freya Alpha,
+The Kára System,
+Spark & Hale Robotic Industries
+
+## General
+Run and compiled for Python 3.9.13.
+Expected to run for Python 3+
+
+## Development
+
+### Testing
+run tests with `pytest -s -vv` to see all the details.
+
+### Installation as Consuming Developer
+
+Simply run: `pip install tks-essentials`
+
+Import in modules without the dash (e.g.): `from tksessentials.globallogger import GlobalLogger`
+
+### Setup as Contributor
+Create the virtul environment: 
+```
+py -m venv .venv
+```
+Start the Environment: 
+```
+./.venv/Scripts/activate
+```
+ (or allow VS Code to start it). Use `deactivate`to stop it.
+
+All the required libraries must be listed in requirements.txt and installed by  
+```
+python -m pip install -r .\requirements.txt
+```
+For Dev use 
+```
+python -m pip install -r .\requirements-dev.txt
+```
+
+To cleanup the environment run:
+```
+pip3 freeze > to-uninstall.txt
+```
+ and then
+```
+pip3 uninstall -y -r to-uninstall.txt
+```
+
+or 
+```
+pip3 install pip-autoremove
+```
+
+### Build Library
+Prerequisite: make sure that you give your Operating System user the right to modify files in the python directory. The directory where pyhton is installed.
+Use 
+```python setup.py bdist_wheel```
+ to create the dist, build and .eggs folder.
+
+## Reference from a different project
+In order to use your own version of the project - to maybe contribute to the library - simply clone the code from github into new directory. Then add the path of that new directory to the requirements.txt file of your project. Then change in tks-essentials whatever you recommend to improve. Don't forget the Open-Closed Principle: extend only (unless it requires a breaking change)
+
+
+## Releasing a new version
+
+This is entirely executed with Github Actions.

tks-essentials-0.1.1/README.md

@@ -0,0 +1,70 @@
+# tks-essentials
+A library with essentials needed in every backend python app. e.g. logging, local db connection, filtering, formatting etc.
+
+## Sponsors
+Freya Alpha,
+The Kára System,
+Spark & Hale Robotic Industries
+
+## General
+Run and compiled for Python 3.9.13.
+Expected to run for Python 3+
+
+## Development
+
+### Testing
+run tests with `pytest -s -vv` to see all the details.
+
+### Installation as Consuming Developer
+
+Simply run: `pip install tks-essentials`
+
+Import in modules without the dash (e.g.): `from tksessentials.globallogger import GlobalLogger`
+
+### Setup as Contributor
+Create the virtul environment: 
+```
+py -m venv .venv
+```
+Start the Environment: 
+```
+./.venv/Scripts/activate
+```
+ (or allow VS Code to start it). Use `deactivate`to stop it.
+
+All the required libraries must be listed in requirements.txt and installed by  
+```
+python -m pip install -r .\requirements.txt
+```
+For Dev use 
+```
+python -m pip install -r .\requirements-dev.txt
+```
+
+To cleanup the environment run:
+```
+pip3 freeze > to-uninstall.txt
+```
+ and then
+```
+pip3 uninstall -y -r to-uninstall.txt
+```
+
+or 
+```
+pip3 install pip-autoremove
+```
+
+### Build Library
+Prerequisite: make sure that you give your Operating System user the right to modify files in the python directory. The directory where pyhton is installed.
+Use 
+```python setup.py bdist_wheel```
+ to create the dist, build and .eggs folder.
+
+## Reference from a different project
+In order to use your own version of the project - to maybe contribute to the library - simply clone the code from github into new directory. Then add the path of that new directory to the requirements.txt file of your project. Then change in tks-essentials whatever you recommend to improve. Don't forget the Open-Closed Principle: extend only (unless it requires a breaking change)
+
+
+## Releasing a new version
+
+This is entirely executed with Github Actions.

tks-essentials-0.1.1/pyproject.toml

@@ -0,0 +1,51 @@
+# pyproject.toml
+
+[build-system]
+requires      = ["setuptools>=66.1.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tks-essentials"
+version = "0.1.1"
+description = "Essentials for our TKS projects."
+readme = "README.md"
+authors = [{ name = "Brayan", email = "brayan@sparkandhale.com" }]
+#license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python"
+]
+keywords = ["finance", "trading", "models"]
+dependencies = [
+    "redis",
+    'tomli; python_version < "3.11"',
+]
+requires-python = ">=3.9"
+
+[project.optional-dependencies]
+dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
+
+[project.urls]
+Homepage = "https://github.com/The-Kara-System/tks-essentials"
+
+[tool.bumpver]
+current_version = "0.1.1"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "bump version {old_version} -> {new_version}"
+commit = true
+tag = true
+push = true
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"',
+]
+#"setup.py" = [
+#    "version = '{version}'",
+#]
+#"README.md" = [
+#    "{version}",
+#    "{pep440_version}",
+#]
+

tks-essentials-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tks-essentials-0.1.1/setup.py

@@ -0,0 +1,26 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="tks-essentials",
+    packages=find_packages(
+        include=[
+            "tksessentials",
+            # 'tksessentials.models',
+        ],
+        exclude=["tests*"],
+    ),
+    # packages=['tksessentials'],
+    # package_dir={'tksessentials':'src'}
+    # packages=find_packages(),
+    # version='0.1.0',
+    # description='The library describes the most common models used in trading systems.',
+    # author='Brayan Svan',
+    # license='MIT',
+    # install_requires=['sqlmodel'],
+    # setup_requires=['pytest-runner'],
+    # tests_require=['pytest==4.4.1'],
+    # test_suite='tests',
+    # cmdclass={
+    #     'build': ProduceAvroSchemas,
+    # },
+)

tks-essentials-0.1.1/tests/test_asset_formatter.py

@@ -0,0 +1,60 @@
+import pytest
+from tksessentials.asset_formatter import AssetFormatter, BinanceFormatter, BybitFormatter 
+
+# Test unwrap_symbol
+def test_unwrap_symbol():
+    formatter = AssetFormatter()
+    assert formatter.unwrap_symbol('WETH') == 'ETH'
+    assert formatter.unwrap_symbol('BTC') == 'BTC'  # Non-existent in symbol_pairs
+
+# Test unwrap_market
+def test_unwrap_market():
+    formatter = AssetFormatter()
+    assert formatter.unwrap_market('WETH/USDT') == 'ETH/USDT'
+    assert formatter.unwrap_market('BTC-USDT') == 'BTC-USDT'
+
+@pytest.mark.parametrize("input_markets, expected_output", [
+    (["BTC/USDT", "ETH-USDT", "SOL/USDT"], ["BTC/USDT", "ETH-USDT", "SOL/USDT"]),  # valid markets
+    (["BTCUSDT", "ETH*USDT", "SOLUSDT"], []),  # invalid markets (missing '-' or '/')
+    (["BTC/USDT", "ETH*USDT", "SOL-USDT"], ["BTC/USDT", "SOL-USDT"]),  # mix of valid and invalid
+    (["BTC/USDTLONGG", "SHORT/ETH", "12CHARS-XY"], ["SHORT/ETH", "12CHARS-XY"]),  # check length and required characters
+    (["BTC-USDT", "ETH/USDT", "SOL"], ["BTC-USDT", "ETH/USDT"]),  # valid and without required characters
+    ([], [])  # empty list
+])
+def test_clean_markets(input_markets, expected_output):
+    assert AssetFormatter().clean_markets(input_markets) == expected_output
+
+# Test get_base and get_quote
+def test_get_base_and_quote():
+    formatter = AssetFormatter()
+    assert formatter.get_base('BTC/USDT') == 'BTC'
+    assert formatter.get_quote('BTC/USDT') == 'USDT'
+    # Add more tests for different formats and edge cases
+
+# Test format_pair_default
+def test_format_pair_default():
+    formatter = AssetFormatter()
+    assert formatter.format_pair_default('BTCUSDT') == 'BTC/USDT'
+    # Add tests for different formats and edge cases
+
+# Test format_to_dash and format_to_slash
+def test_format_to_dash_and_slash():
+    formatter = AssetFormatter()
+    assert formatter.format_to_dash('BTC/USDT') == 'BTC-USDT'
+    assert formatter.format_to_slash('BTC-USDT') == 'BTC/USDT'
+
+# Test format_set_to_dash and format_set_to_slash
+def test_format_set_to_dash_and_slash():
+    formatter = AssetFormatter()
+    markets = {'BTC/USDT', 'ETH/USDT'}
+    assert formatter.format_set_to_dash(markets) == {'BTC-USDT', 'ETH-USDT'}
+    assert formatter.format_set_to_slash(markets) == {'BTC/USDT', 'ETH/USDT'}
+
+# Tests for BinanceFormatter and BybitFormatter
+def test_binance_formatter():
+    formatter = BinanceFormatter()
+    assert formatter.format_pair('BTC/USDT') == 'BTC-USDT'
+
+def test_bybit_formatter():
+    formatter = BybitFormatter()
+    assert formatter.format_pair('BTC/USDT') == 'BTC_USDT'

tks-essentials-0.1.1/tests/test_security.py

@@ -0,0 +1,35 @@
+import pytest
+from tksessentials.security import Crypto, IPSecurity
+from famodels.blocked_ip import BlockedIpReasonType
+
+AES_SECRET = "ZufDdKmoYgBv272G0DQWqz8Ng9ewM+IMGIMzkRQUoVNujiCHfdD4EULwXtn5fvwL"
+
+@pytest.mark.parametrize("message", ["test", "123908234ÖÄ$ASDFdd", "äjklöèü"])
+def test_encrypt_and_decrypt_text_message(monkeypatch, message):
+    monkeypatch.setenv("AES_SECRET", AES_SECRET)
+    crypto = Crypto()
+
+    encrypted_message = crypto.encrypt_as_text(message)
+    decrypted_message = crypto.decrypt_as_text(encrypted_message)
+
+    assert decrypted_message == message
+
+@pytest.mark.parametrize("message", ["firstname.name@domain.com"])
+def test_encrypt_and_decrypt_email_address(monkeypatch, message):
+    monkeypatch.setenv("AES_SECRET", AES_SECRET)
+    crypto = Crypto()
+
+    encrypted_message = crypto.encrypt_as_text(message)
+    decrypted_message = crypto.decrypt_as_text(encrypted_message)
+
+    assert decrypted_message == message
+
+# FAILY - NEEDS TO BE FIXED
+# @pytest.mark.parametrize("ip_address, blocking_reason", [("155.255.452.55", BlockedIpReasonType.EXCESSIVE_FAILED_LOGIN_ATTEMPTS)])
+# def test_block_ip_address(ip_address: str, blocking_reason: BlockedIpReasonType):
+#     ipSecurity = IPSecurity()
+
+#     assert ipSecurity.block_ip(ip_address, blocking_reason) is True
+#     assert ipSecurity.is_ip_blocked(ip_address) is True
+#     assert ipSecurity.unblock_ip(ip_address) is True
+#     assert ipSecurity.is_ip_blocked(ip_address) is False

tks-essentials-0.1.1/tests/test_utils.py

@@ -0,0 +1,120 @@
+import os
+import pathlib
+import pytest
+import yaml
+from tksessentials import utils
+
+@pytest.fixture
+def mock_project_root(monkeypatch, tmp_path):
+    # Directly set the PROJECT_ROOT in the utils module
+    utils.PROJECT_ROOT = tmp_path
+    return tmp_path
+
+def test_get_project_root(mock_project_root):
+    expected_path = str(mock_project_root)
+    assert utils.get_project_root() == expected_path
+
+
+def test_get_project_root_path(mock_project_root):
+    assert utils.get_project_root_path() == mock_project_root
+
+
+def test_get_app_config(monkeypatch, tmp_path):
+    # Create a temporary config directory
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    mock_config_file = config_dir / "app_config.yaml"
+
+    # Write the mock configuration
+    expected_config = {
+        "application": "TestApp",
+        "domain": "test.domain.com",
+        "env": "DEV",
+        "logging_level": "INFO"
+    }
+    with open(mock_config_file, "w") as file:
+        yaml.dump(expected_config, file)
+
+    # Override the `find_project_root` function to return the tmp_path
+    def mock_find_project_root(*args, **kwargs):
+        return tmp_path
+
+    monkeypatch.setattr(utils, "find_project_root", mock_find_project_root)
+
+    # Run the test
+    assert utils.get_app_config() == expected_config
+
+def test_find_project_root():
+    try:        
+        project_root = utils.find_project_root(pathlib.Path(__file__).resolve())
+        print(project_root)
+    except Exception as e:
+        # If any exception is caught, fail the test explicitly.
+        assert False, f"An exception was thrown: {e}"
+
+def test_get_application_name_success(monkeypatch):
+    def mock_get_app_config():
+        return {"application": "TestApp"}
+
+    monkeypatch.setattr(utils, "get_app_config", mock_get_app_config)
+    assert utils.get_application_name() == "TestApp"
+
+def test_get_application_name_failure(monkeypatch):
+    def mock_get_app_config():
+        return {}
+
+    monkeypatch.setattr(utils, "get_app_config", mock_get_app_config)
+    with pytest.raises(ValueError):
+        utils.get_application_name()
+
+def test_get_domain_name_success(monkeypatch):
+    def mock_get_app_config():
+        return {"domain": "test.domain.com"}
+
+    monkeypatch.setattr(utils, "get_app_config", mock_get_app_config)
+    assert utils.get_domain_name() == "test.domain.com"
+
+def test_get_domain_name_failure(monkeypatch):
+    def mock_get_app_config():
+        return {}
+
+    monkeypatch.setattr(utils, "get_app_config", mock_get_app_config)
+    with pytest.raises(ValueError):
+        utils.get_domain_name()
+
+def test_get_redis_cluster_service_name_with_env_in_dev(monkeypatch):
+    monkeypatch.setenv("REDIS_CLUSTER_NODES", "redis-node1:1234")
+    monkeypatch.setenv("ENV", "DEV")
+    expected_result = ["UNDEFINED - EMPLOYING LOCAL CLUSTER"]
+    assert utils.get_redis_cluster_service_name() == expected_result
+
+def test_get_redis_cluster_service_name_with_env_in_prod(monkeypatch):
+    monkeypatch.setenv("REDIS_CLUSTER_NODES", "redis-node1:1234")
+    monkeypatch.setenv("ENV", "PROD")
+    expected_result = ["redis-node1", "1234"]
+    assert utils.get_redis_cluster_service_name() == expected_result
+
+def test_get_redis_cluster_service_name_default(monkeypatch):
+    monkeypatch.delenv("REDIS_CLUSTER_NODES", raising=False)
+    expected_result = ["UNDEFINED - EMPLOYING LOCAL CLUSTER"]
+    assert utils.get_redis_cluster_service_name() == expected_result
+
+
+@pytest.mark.skipif(os.environ.get("GITHUB_ACTIONS") == "true", reason="Requires DEV environment with a local Redis cluster and should not run on GitHub Actions")
+def test_get_redis_cluster_client_add_method():
+    # Obtain the RedisCluster client
+    rc = utils.get_redis_cluster_client()
+
+    # Perform a test operation - add a key with a value
+    test_key = "test_key"
+    test_value = "test_value"
+    rc.set(test_key, test_value)
+
+    # Retrieve the value to verify the operation
+    value = rc.get(test_key)
+
+    # Clean up by deleting the test key
+    rc.delete(test_key)
+
+    # Assert that the retrieved value matches the test value
+    assert value == test_value

tks-essentials-0.1.1/tests/test_validators.py

@@ -0,0 +1,32 @@
+from email_validator import EmailSyntaxError
+import pytest
+from tksessentials import validators
+
+@pytest.mark.parametrize("email", ["john.doe@gmail.com"])
+def test_email_address(email):
+    try:
+        validators.validate_email(email)
+    except EmailSyntaxError:
+        pytest.fail("validate_email() raised exception unexpectedly!")    
+
+@pytest.mark.parametrize("email", ["name@com", "@domain.com", "name@domain", "firstname.name@DOMAIN-THAT-PROBABLY-WILL-NEVER-EXIST-TEST-0123.com"])
+def test_wrong_email_addresses(email):
+    with pytest.raises(Exception): 
+        validators.validate_email(email)
+
+
+@pytest.mark.parametrize("ip_address", ["100.128.0.0"])
+def test_ip_addresses(ip_address: str):
+    try:
+        validators.validate_ip_address(ip_address)
+    except ValueError:
+        pytest.fail("validate_ip_address() raised exception unexpectedly!")      
+
+@pytest.mark.parametrize("ip_address", [
+    None,
+    "127 .0.0.1",
+    "999.255.255.255",
+    "100.128.0.0/222"])
+def test_wrong_ip_addresses(ip_address: str):
+    with pytest.raises(Exception): 
+        validators.validate_ip_address(ip_address)

tks-essentials-0.1.1/tks_essentials.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: tks-essentials
+Version: 0.1.1
+Summary: Essentials for our TKS projects.
+Author-email: Brayan <brayan@sparkandhale.com>
+Project-URL: Homepage, https://github.com/The-Kara-System/tks-essentials
+Keywords: finance,trading,models
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis
+Requires-Dist: tomli; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# tks-essentials
+A library with essentials needed in every backend python app. e.g. logging, local db connection, filtering, formatting etc.
+
+## Sponsors
+Freya Alpha,
+The Kára System,
+Spark & Hale Robotic Industries
+
+## General
+Run and compiled for Python 3.9.13.
+Expected to run for Python 3+
+
+## Development
+
+### Testing
+run tests with `pytest -s -vv` to see all the details.
+
+### Installation as Consuming Developer
+
+Simply run: `pip install tks-essentials`
+
+Import in modules without the dash (e.g.): `from tksessentials.globallogger import GlobalLogger`
+
+### Setup as Contributor
+Create the virtul environment: 
+```
+py -m venv .venv
+```
+Start the Environment: 
+```
+./.venv/Scripts/activate
+```
+ (or allow VS Code to start it). Use `deactivate`to stop it.
+
+All the required libraries must be listed in requirements.txt and installed by  
+```
+python -m pip install -r .\requirements.txt
+```
+For Dev use 
+```
+python -m pip install -r .\requirements-dev.txt
+```
+
+To cleanup the environment run:
+```
+pip3 freeze > to-uninstall.txt
+```
+ and then
+```
+pip3 uninstall -y -r to-uninstall.txt
+```
+
+or 
+```
+pip3 install pip-autoremove
+```
+
+### Build Library
+Prerequisite: make sure that you give your Operating System user the right to modify files in the python directory. The directory where pyhton is installed.
+Use 
+```python setup.py bdist_wheel```
+ to create the dist, build and .eggs folder.
+
+## Reference from a different project
+In order to use your own version of the project - to maybe contribute to the library - simply clone the code from github into new directory. Then add the path of that new directory to the requirements.txt file of your project. Then change in tks-essentials whatever you recommend to improve. Don't forget the Open-Closed Principle: extend only (unless it requires a breaking change)
+
+
+## Releasing a new version
+
+This is entirely executed with Github Actions.

tks-essentials-0.1.1/tks_essentials.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+tests/test_asset_formatter.py
+tests/test_security.py
+tests/test_utils.py
+tests/test_validators.py
+tks_essentials.egg-info/PKG-INFO
+tks_essentials.egg-info/SOURCES.txt
+tks_essentials.egg-info/dependency_links.txt
+tks_essentials.egg-info/requires.txt
+tks_essentials.egg-info/top_level.txt
+tksessentials/__init__.py
+tksessentials/asset_formatter.py
+tksessentials/constants.py
+tksessentials/global_logger.py
+tksessentials/security.py
+tksessentials/utils.py
+tksessentials/validators.py

tks-essentials-0.1.1/tks_essentials.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tks-essentials-0.1.1/tks_essentials.egg-info/requires.txt

@@ -0,0 +1,11 @@
+redis
+
+[:python_version < "3.11"]
+tomli
+
+[dev]
+black
+bumpver
+isort
+pip-tools
+pytest

tks-essentials-0.1.1/tks_essentials.egg-info/top_level.txt

@@ -0,0 +1 @@
+tksessentials

tks-essentials-0.1.1/tksessentials/asset_formatter.py

@@ -0,0 +1,134 @@
+import re
+from typing import Set
+from . import global_logger
+
+class AssetFormatter:
+    def __init__(self, default_quote_asset: str = "USDT") -> None:
+        self.default_quote_asset = default_quote_asset
+        self.logger = global_logger.setup_custom_logger("app")
+        self.symbol_pairs = {"WETH": "ETH"}
+
+    def unwrap_symbol(self, wrapped_symbol):
+        # Convert the input to uppercase to make the function case-insensitive
+        wrapped_symbol_upper = wrapped_symbol.upper()
+        # Return the unwrapped symbol, or the original symbol if not found
+        return self.symbol_pairs.get(wrapped_symbol_upper, wrapped_symbol)
+
+    def get_wrapped_symbol(self, original_symbol) -> str:
+        """Returns the wrapped symbol for an asset. Or None"""
+        for key, val in self.symbol_pairs.items():
+            if val == original_symbol:
+                return key
+        return None
+
+    def unwrap_market(self, market):
+        # Extract the base and quote assets from the market string
+        base_asset = self.get_base(market)
+        quote_asset = self.get_quote(market)
+        unwrapped_base = self.unwrap_symbol(base_asset)
+        delimiter = "/"
+        if "-" in market:
+            delimiter = "-"
+
+        # Combine the unwrapped base asset with the quote asset
+        return f"{unwrapped_base}{delimiter}{quote_asset}"
+
+    def clean_markets(self, markets: dict) -> dict:
+        """
+        Removes all non-compliant markets, those exceeding 12 characters in length,
+        and those not containing a '-' or '/'.
+        """
+        allowed_chars_pattern = re.compile(r"^[a-zA-Z0-9/-]{1,12}$")
+        must_have_chars = {"-", "/"}
+
+        cleaned_markets = []
+
+        for market in markets:
+            if allowed_chars_pattern.match(market) and any(
+                char in market for char in must_have_chars
+            ):
+                cleaned_markets.append(market)
+            else:
+                self.logger.info(
+                    f"Invalid market format, length, or missing required characters found and removed: {market}"
+                )
+        self.logger.debug(f"Cleaned markets: {cleaned_markets}")
+        return cleaned_markets
+
+    def get_base(self, pair_string: str) -> str:
+        """Returns the base asset. From SOL/USDT that is SOL."""
+        match = re.match(r"([A-Za-z]+)[/-]", pair_string)
+        if match:
+            base_asset = match.group(1)
+            return base_asset
+        else:
+            raise ValueError("Invalid pair string format")
+
+    def get_quote(self, pair_string: str) -> str:
+        """Returns the quote asset. From SOL/USDT that is USDT."""
+        match = re.match(r"[A-Za-z]+[/-]([A-Za-z]+)", pair_string)
+        if match:
+            quote_asset = match.group(1)
+            return quote_asset
+        else:
+            # Fall back to default quote asset if not found
+            return self.default_quote_asset
+
+    def format_pair(self, pair_string: str) -> str:
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+    def format_set_of_pairs(self, pairs: Set[str]) -> Set[str]:
+        return {self.format_pair(pair) for pair in pairs}
+
+    def format_pair_default(self, pair_string: str) -> str:
+        """Will format the pair string to a slash-format. Mainly used for the ccxt LIB."""
+        # Regex pattern to match 'BTCUSDT', 'BTC/USDT', and 'BTC-USDT'
+        pattern = r"([A-Za-z]+)[/-]?(USDT)$"
+        match = re.match(pattern, pair_string)
+
+        if match:
+            base_asset, quote_asset = match.groups()
+            formatted_pair = f"{base_asset}/{quote_asset}"
+            return formatted_pair
+        else:
+            self.logger.error(f"Invalid pair format: {pair_string}")
+            raise ValueError(f"Invalid pair format: {pair_string}")
+
+    def format_to_dash(self, pair_string: str) -> str:
+        """Takes any combination of a market pair and replaces the divider by a dash (-)."""
+        match = re.match(r"([A-Za-z0-9]+)[/-]?([A-Za-z0-9]+)", pair_string)        
+        if match is None:
+            raise ValueError(f"Invalid market pair format: '{pair_string}'")
+        base_asset, _ = match.groups()
+        return f"{base_asset}-{self.default_quote_asset}"
+
+    def format_to_slash(self, pair_string: str) -> str:
+        """Takes any combinatin of a market pair and replaces the divider by a front slash (/)."""
+        match = re.match(r"([A-Za-z0-9]+)[/-]?([A-Za-z0-9]+)", pair_string)        
+        if match is None:
+            raise ValueError(f"Invalid market pair format: '{pair_string}'")
+        base_asset, _ = match.groups()
+        return f"{base_asset}/{self.default_quote_asset}"
+
+    def format_set_to_dash(self, markets: Set[str]) -> Set[str]:
+        """Takes a set of market pairs and formats each to dash notation."""
+        return {self.format_to_dash(pair) for pair in markets}
+
+    def format_set_to_slash(self, markets: Set[str]) -> Set[str]:
+        """Takes a set of market pairs and formats each to front slash notation."""
+        return {self.format_to_slash(pair) for pair in markets}
+
+
+class BinanceFormatter(AssetFormatter):
+    def format_pair(self, pair_string: str) -> str:
+        match = re.match(r"([A-Za-z]+)[/-]?([A-Za-z]+)", pair_string)
+        base_asset, _ = match.groups()
+        return f"{base_asset}-{self.default_quote_asset}"
+
+
+class BybitFormatter(AssetFormatter):
+    def format_pair(self, pair_string: str) -> str:
+        match = re.match(r"([A-Za-z]+)[/-]?([A-Za-z]+)", pair_string)
+        base_asset, _ = match.groups()
+        # Assuming Bybit format is slightly different, for example
+        return f"{base_asset}_{self.default_quote_asset}"

tks-essentials-0.1.1/tksessentials/constants.py

@@ -0,0 +1 @@
+DEFAULT_ENCODING = "utf-8"

tks-essentials-0.1.1/tksessentials/global_logger.py

@@ -0,0 +1,61 @@
+import inspect
+import logging
+import queue
+import logging.handlers
+from . import utils
+
+loggers = {}
+
+def setup_custom_logger(name):
+    global loggers
+
+    if loggers.get(name):
+        return loggers.get(name)
+    else:
+        formatter = logging.Formatter(
+            "%(asctime)s [%(module)s:%(lineno)d] %(levelname)s %(message)s"
+        )
+
+        logger = logging.getLogger(name)
+        # clean the handlers, otherwise you get duplicated records when logging
+        if logger.hasHandlers():
+            return logger
+            # logger.handlers.clear()
+        logger.propagate = False
+        level = logging.getLevelName(utils.get_logging_level())
+        logger.setLevel(level)
+        log_queue = queue.Queue()
+        queue_handler = logging.handlers.QueueHandler(log_queue)
+        # set the non-blocking handler first
+        logger.addHandler(queue_handler)
+
+        # Stream is important for looking at the k8s pod logs.
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(logging.DEBUG)
+        stream_handler.setFormatter(formatter)
+
+        # the local logging is fine, but there sould be a Fluent Bit integration, which sends logs to the central LMM instance
+        timerotating_handler = logging.handlers.TimedRotatingFileHandler(
+            utils.get_log_path().joinpath("app_rolling.log"), when="D", backupCount=30
+        )
+        timerotating_handler.setLevel(utils.get_logging_level())
+        timerotating_handler.setFormatter(formatter)
+        listener = logging.handlers.QueueListener(
+            log_queue, stream_handler, timerotating_handler, respect_handler_level=True
+        )
+
+        # Only print the following when instantiated by the main.py file - and not other files.
+        # This will ensure that the important project variables are printet on startup.
+        current_stack = inspect.stack()
+        if any("main.py" in frame.filename for frame in current_stack):
+            # Print settings:
+            logger.info(f"Starting {utils.get_application_name()} in {utils.get_environment()}.")
+            logger.info(f"Domain {utils.get_domain_name()}")
+            logger.info(f"Root {utils.get_project_root()}")
+            logger.info(f"Log Path {utils.get_log_path()}")
+            logger.info(f"Logging Level {utils.get_logging_level()}")
+            logger.info(f"Redis Cluster Service Name {utils.get_redis_cluster_service_name()}")
+
+        listener.start()
+
+    return logger

tks-essentials-0.1.1/tksessentials/security.py

@@ -0,0 +1,104 @@
+import base64
+import json
+import os
+from tksessentials.constants import DEFAULT_ENCODING
+from builtins import bytes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.backends import default_backend
+from famodels.blocked_ip import BlockedIp, BlockedIpReasonType
+from redis_om.model.model import NotFoundError
+from tksessentials import global_logger, utils
+
+def get_secret_key() -> str:
+    """Returns the general encryption key to encrypt data."""
+    key = os.getenv("ENCRYPTION_KEY")
+    if not key:
+        raise ValueError("ENCRYPTION_KEY environment variable is not set or empty.")
+    return key
+
+def get_JWT_secret() -> str:
+    """Returns JWT secret."""
+    jwt_secret = os.getenv("JWT_SECRET")
+    if not jwt_secret:
+        raise ValueError("JWT_SECRET environment variable is not set or empty.")
+    return jwt_secret
+
+def get_AES_secret() -> bytes:
+    """Returns AES secret."""
+    aes_secret = bytes(os.getenv("AES_SECRET"), DEFAULT_ENCODING)
+    if not aes_secret:
+        raise ValueError("AES_SECRET environment variable is not set or empty.")
+    return aes_secret
+
+
+class Crypto:
+    def __init__(self):
+        self.backend = default_backend()
+        self.key = base64.urlsafe_b64encode(get_AES_secret())[:32]
+        self.encryptor = Cipher(algorithms.AES(self.key), modes.ECB(), self.backend).encryptor()
+        self.decryptor = Cipher(algorithms.AES(self.key), modes.ECB(), self.backend).decryptor()
+
+    def encrypt(self, value: str) -> bytes:
+        byte_value = bytes(value, DEFAULT_ENCODING)
+        padder = padding.PKCS7(algorithms.AES(self.key).block_size).padder()
+        padded_data = padder.update(byte_value) + padder.finalize()
+        encrypted_text = self.encryptor.update(padded_data) + self.encryptor.finalize()
+        return base64.urlsafe_b64encode(encrypted_text)
+
+    def encrypt_as_text(self, value) -> str:
+        return str(self.encrypt(value), encoding=DEFAULT_ENCODING)
+
+    def decrypt(self, value: str) -> bytes:
+        byte_value = base64.urlsafe_b64decode(bytes(value, DEFAULT_ENCODING))
+        padder = padding.PKCS7(algorithms.AES(self.key).block_size).unpadder()
+        decrypted_data = self.decryptor.update(byte_value)
+        unpadded = padder.update(decrypted_data) + padder.finalize()
+        return unpadded
+
+    def decrypt_as_text(self, value) -> str:
+        return str(self.decrypt(value), encoding=DEFAULT_ENCODING)
+
+class IPSecurity():
+    def __init__(self):
+        self.rc = utils.get_redis_cluster_client()
+        self.db_path = f"{utils.get_domain_name()}:blocked-ip"
+        self.logger = global_logger.setup_custom_logger("app")
+
+    def __get_blocked_ip_from_database(self, ip_address: str) -> str:
+        blockedIP_json: str = None
+        try:
+            blockedIP_json = self.rc.execute_command("JSON.GET", f"{self.db_path}:{ip_address}")
+        except NotFoundError:
+            self.logger.info(f"There is no blocked ip with address {ip_address} in the database.")
+
+        return blockedIP_json
+
+    def get_blocked_ip(self, ip_address: str) -> BlockedIp:
+        """Will try to fetch a blocked ip record in the database by the provided ip address """
+        blockedIp: BlockedIp = None
+        blockedIP_json = self.__get_blocked_ip_from_database(ip_address)
+        if (blockedIP_json):
+            blockedIp_dict = json.loads(blockedIP_json)
+            blockedIp = BlockedIp(**blockedIp_dict)
+
+        return blockedIp
+
+    def is_ip_blocked(self, ip_address: str) -> bool:
+        """Will try to determine if provided ip address is in the blocked ip list"""
+        blockedIP_json = self.__get_blocked_ip_from_database(ip_address)
+        if (blockedIP_json):
+            return True
+
+        return False
+
+    def block_ip(self, ip_address: str, blocking_reason: BlockedIpReasonType) -> bool:
+        blockedIp = BlockedIp(ip_address=ip_address, blocking_reason=blocking_reason)
+        blockedIpJsonModel = blockedIp.model_dump_json()
+
+        self.logger.debug(f"About to block ip address '{ip_address}' due to {blocking_reason}")
+        return self.rc.execute_command("JSON.SET", f"{self.db_path}:blocked-ip:{ip_address}", ".", blockedIpJsonModel)
+
+    def unblock_ip(self, ip_address) -> bool:
+        self.logger.debug(f"About to unblock ip address '{ip_address}'")
+        return self.rc.execute_command("JSON.DEL", f"{self.db_path}:blocked-ip:{ip_address}", ".")

tks-essentials-0.1.1/tksessentials/utils.py

@@ -0,0 +1,160 @@
+import os
+import pathlib
+from pathlib import Path
+import yaml
+from redis.cluster import RedisCluster, ClusterNode
+
+PROJECT_ROOT = None
+
+# Determine the project root path when the module is loaded
+def find_project_root(current_path: pathlib.Path, max_depth: int = 10) -> pathlib.Path:
+    """
+    Recursively search for a marker (like the 'config' or 'logs' directory) to find the project root.
+    """
+
+    # Check if PROJECT_ROOT environment variable is set
+    project_root_env = os.getenv('PROJECT_ROOT')
+    if project_root_env:
+        return pathlib.Path(project_root_env)
+
+    for _ in range(max_depth):
+        if (current_path.cwd() / "config").exists() or (current_path.cwd() / "logs").exists():
+            return current_path.cwd()
+        current_path = current_path.parent
+    raise FileNotFoundError(f"Could not find the project root within the provided path {current_path} \
+                            with the max depth of {max_depth}. \
+                            The current path is {current_path.cwd()}. \
+                            Ensure the 'config' or 'logs' folder exists in {str(current_path)}. \
+                            The PROJECT_ROOT environement variable is: {project_root_env}")
+
+
+# Initialize PROJECT_ROOT when the module is loaded
+def initialize_project_root():
+    global PROJECT_ROOT
+    PROJECT_ROOT = find_project_root(pathlib.Path(__file__).resolve())
+
+initialize_project_root()
+
+def get_project_root_path() -> Path:
+    """
+    Return the project root path.
+    """
+    return PROJECT_ROOT
+
+def get_project_root() -> str:
+    str_path = str(PROJECT_ROOT)
+    # print(f"utils.py: {str_path}")
+    return str_path
+
+def get_log_path() -> Path:
+    abs_path = get_project_root_path().joinpath("logs")
+    return abs_path
+
+def get_secrets_path() -> Path:
+    abs_path = get_project_root_path().joinpath("secrets")
+    return abs_path
+
+def get_app_config() -> dict:
+    app_cfg = None
+    try:
+        project_root = find_project_root(pathlib.Path(__file__).resolve())
+        config_path = project_root.joinpath("config/app_config.yaml")
+        with open(config_path, "r") as ymlfile:
+            app_cfg = yaml.safe_load(ymlfile)
+    except yaml.YAMLError as ex:
+        raise FileNotFoundError(
+            f"Failed to load the config/app_config.yaml file. Aborting the application. Error: {ex}"
+        )
+    return app_cfg
+
+def get_application_name() -> str:
+    app_name = get_app_config().get("application")
+    if app_name is None:
+        raise ValueError("Application name not found in app_config.")
+    return app_name
+
+def get_domain_name() -> str:
+    domain_name = get_app_config().get("domain")
+    if domain_name is None:
+        raise ValueError("Domain name not found in app_config.")
+    return domain_name
+
+def get_environment() -> str:
+    """Will fetch the environment variable ENV. If not present it will fall back to DEV """
+    return os.environ.get("ENV", "DEV")
+
+def get_service_url() -> str:
+    """This own service url value. This global environment variable is usually used by consumers apps of this API."""
+    return os.getenv("OPENAPI_SERVICE_URL", "http://localhost:8080")
+
+def get_service_doc_url() -> str:
+    """Return the OpenAPI url"""
+    return f"{get_service_url}/docs"
+
+def get_logging_level() -> str:
+    return get_app_config().get("logging_level", os.getenv("LOGGING_LEVEL", "DEBUG")).upper()
+
+def get_redis_cluster_service_name():
+    """Reads one service name and one port from the environemnt variable.
+    For all environements BUT the DEV environment.
+    For PROD/UAT the Kubernetes Service will route the requests to any of the leaders,
+    summarized by redis-cluster-leader
+    """
+    if get_environment().upper() == "DEV" or get_environment().upper() is None:
+        nodes_env = "UNDEFINED - EMPLOYING LOCAL CLUSTER"
+    else:
+        nodes_env = os.getenv("REDIS_CLUSTER_NODES", "NODES_NOT_DEFINED")
+    return nodes_env.split(":")
+
+def get_redis_cluster_pw():
+    return os.getenv("REDIS_CLUSTER_PW")
+
+def get_redis_cluster_client() -> RedisCluster:
+    """Creates a redis client to access the redis cluster in the current environment.
+    That could be PROD, UAT or DEV."""
+    rc: RedisCluster = None
+    if get_environment().upper() == "DEV":
+        REDIS_SERVICE = os.environ.get("REDIS_SERVICE", "127.0.0.1")
+        REDIS_PORTS = os.environ.get("REDIS_PORTS", "7000,7001,7002").split(",")
+        nodes = [ClusterNode(REDIS_SERVICE, int(port)) for port in REDIS_PORTS]
+        address_remap_dict = {
+            "172.30.0.11:6379": ("127.0.0.1", 7000),
+            "172.30.0.12:6379": ("127.0.0.1", 7001),
+            "172.30.0.13:6379": ("127.0.0.1", 7002),
+        }
+
+        def address_remap(address):
+            host, port = address
+            return address_remap_dict.get(f"{host}:{port}", address)
+
+        # rc = RedisCluster(startup_nodes=nodes, decode_responses=True, skip_full_coverage_check=True)
+        rc = RedisCluster(
+            username='default',
+            password='my-password',
+            startup_nodes=nodes,
+            decode_responses=True,
+            skip_full_coverage_check=True,
+            address_remap=address_remap,
+        )
+    else:
+        # PROD/UAT (any non-DEV environment)
+        host_name, port = get_redis_cluster_service_name()
+        if not host_name:
+            raise Exception("No Redis cluster nodes in app_config file.")
+            # TODO add the error log as soon this common code is in the library.
+
+        PW = get_redis_cluster_pw()
+        if isinstance(PW, str):
+            rc = RedisCluster(
+                host=host_name,
+                port=int(port),
+                username='default',
+                password=PW,
+                decode_responses=True,
+                require_full_coverage=False,
+                read_from_replicas=True
+            )
+        else:
+            raise ValueError("There is NO password for the Redis Cluster available with this deployment. Please see to it.")
+
+    return rc

tks-essentials-0.1.1/tksessentials/validators.py

@@ -0,0 +1,9 @@
+import ipaddress
+import email_validator
+
+def validate_email(email: str):
+    email_validator.validate_email(email, check_deliverability=True)
+
+def validate_ip_address(ip_string: str):
+    ipaddress.ip_address(ip_string)
+