pycraftcore 0.1.0__py3-none-any.whl

pycraftcore/app_configuration/__init__.py

@@ -0,0 +1,5 @@
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+from pycraftcore.app_configuration.port.configuration import Configuration
+from pycraftcore.app_configuration.port.configuration_reader import ConfigurationReader
+
+__all__ = ["AppConfiguration", "Configuration", "ConfigurationReader"]

pycraftcore/app_configuration/adapter/load_configuration.py

@@ -0,0 +1,41 @@
+import threading
+from typing import ParamSpec
+
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+from pycraftcore.app_configuration.port.configuration_reader import (
+    ConfigurationReader,
+)
+from pycraftcore.logger.port.logger import Logger
+
+P = ParamSpec("P")
+
+
+class LoadConfiguration:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls, *args: P.args, **kwargs: P.kwargs):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = object.__new__(cls)
+        return cls._instance
+
+    def __init__(self, configuration_reader: ConfigurationReader, logger: Logger):
+        self._configuration_reader = configuration_reader
+        self._logger = logger
+        self._cached_config: AppConfiguration | None = None
+
+    def load(self) -> AppConfiguration | None:
+        if self._cached_config is None:
+            try:
+                self._cached_config = self._configuration_reader.read()
+            except Exception as exception:
+                self._logger.critical(exception.__str__())
+        return self._cached_config
+
+    def reload(self) -> AppConfiguration | None:
+        with self._lock:
+            configuration = self._configuration_reader.read()
+        self._cached_config = configuration
+        return self._cached_config

pycraftcore/app_configuration/adapter/omega_configuration_reader.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+from typing import cast, Any
+
+from omegaconf import OmegaConf, DictConfig
+
+from pycraftcore.app_configuration.adapter.schema import (
+    AppConfigurationSchema,
+    MapperDomainSchema,
+)
+from pycraftcore.app_configuration.enum.run_type_environment import (
+    RunTypeEnvironment,
+)
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+
+
+class OmegaConfigurationReader:
+    FILE_EXTENSION = "yml"
+    ROOT_CONFIG_FILE_NAME = "root"
+    CONNECTOR_CONFIG_FILE_NAME = "connector"
+    OPERATION_CONFIG_FILE_NAME = "operation"
+    CRONJOB_CONFIG_FILE_NAME = "cronjob"
+
+    def __init__(self, env: RunTypeEnvironment, config_directory: Path) -> None:
+        self._env = env
+        self._config_directory = config_directory
+
+    def read(self) -> AppConfiguration:
+        config_root: Path = (
+            self._config_directory / f"{self.ROOT_CONFIG_FILE_NAME}.{self.FILE_EXTENSION}"
+        )
+        config_dir_env = self._config_directory / f"{self._env.value}"
+
+        omega_config: DictConfig = self._omega_read(config_dir_env, config_root)
+        omega_container: Any = OmegaConf.to_container(
+            omega_config.app_configuration, resolve=True, throw_on_missing=True
+        )
+        app_config_schema = AppConfigurationSchema(**omega_container)
+        return MapperDomainSchema.map(app_config_schema)
+
+    def _omega_read(self, config_dir_env: Path, config_root: Path) -> DictConfig:
+        return cast(
+            DictConfig,
+            OmegaConf.merge(
+                *self._load_yml_dir(config_dir_env / self.CONNECTOR_CONFIG_FILE_NAME),
+                *self._load_yml_dir(config_dir_env / self.OPERATION_CONFIG_FILE_NAME),
+                *self._load_yml_dir(config_dir_env / self.CRONJOB_CONFIG_FILE_NAME),
+                OmegaConf.load(config_root),
+            ),
+        )
+
+    def _load_yml_dir(self, directory: Path) -> list:
+        return [OmegaConf.load(f) for f in sorted(directory.glob(f"*.{self.FILE_EXTENSION}"))]

pycraftcore/app_configuration/adapter/schema.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+from typing import Sequence
+
+from pycraftcore.app_configuration.enum.connector_type import ConnectorType
+from pycraftcore.app_configuration.enum.run_type_application import (
+    RunTypeApplication,
+)
+from pycraftcore.app_configuration.enum.run_type_environment import (
+    RunTypeEnvironment,
+)
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+from pycraftcore.app_configuration.model.connector import ConnectorTyping
+
+from pycraftcore.app_configuration.model.cronjob import CronJob
+from pycraftcore.app_configuration.model.operation import OperationTyping
+
+
+class AppConfigurationSchema(BaseModel):
+    env: RunTypeEnvironment
+    run: RunTypeApplication
+    connector: dict[ConnectorType, dict[str, ConnectorTyping]]
+    operation: dict[str, OperationTyping]
+    cronjob: Sequence[CronJob]
+
+
+class MapperDomainSchema:
+    @staticmethod
+    def map(app_configuration_schema: AppConfigurationSchema) -> AppConfiguration:
+        return AppConfiguration(**vars(app_configuration_schema))

pycraftcore/app_configuration/enum/connector_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ConnectorType(Enum):
+    api = "api"
+    database = "database"
+    cache = "cache"
+    file = "file"
+    telemetry = "telemetry"

pycraftcore/app_configuration/enum/file_operation_action.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class FileOperationAction(Enum):
+    read = "read"
+    write = "write"
+    delete = "delete"

pycraftcore/app_configuration/enum/run_type_application.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class RunTypeApplication(Enum):
+    asynchronous = "async"
+    synchronous = "sync"

pycraftcore/app_configuration/enum/run_type_environment.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class RunTypeEnvironment(Enum):
+    debug = "debug"
+    production = "prod"
+    staging = "stg"
+    develop = "dev"

pycraftcore/app_configuration/model/configuration.py

@@ -0,0 +1,22 @@
+from typing import Sequence
+from dataclasses import dataclass
+
+from pycraftcore.app_configuration.enum.connector_type import ConnectorType
+from pycraftcore.app_configuration.enum.run_type_application import (
+    RunTypeApplication,
+)
+from pycraftcore.app_configuration.enum.run_type_environment import (
+    RunTypeEnvironment,
+)
+from pycraftcore.app_configuration.model.connector import ConnectorTyping
+from pycraftcore.app_configuration.model.cronjob import CronJob
+from pycraftcore.app_configuration.model.operation import OperationTyping
+
+
+@dataclass(frozen=True, slots=True)
+class AppConfiguration:
+    env: RunTypeEnvironment
+    run: RunTypeApplication
+    connector: dict[ConnectorType, dict[str, ConnectorTyping]]
+    operation: dict[str, OperationTyping]
+    cronjob: Sequence[CronJob]

pycraftcore/app_configuration/model/connector.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from typing import Union
+
+from pycraftcore.app_configuration.enum.connector_type import ConnectorType
+from pycraftcore.authentication import AuthTyping
+
+
+@dataclass(slots=True)
+class BaseConnector:
+    name: str
+    type: ConnectorType
+    auth: AuthTyping
+
+
+@dataclass(slots=True)
+class ApiConnector(BaseConnector):
+    base_url: str
+    timeout: int
+    retry: int
+    certificate: str | None = field(default=None)
+
+
+@dataclass(slots=True)
+class DatabaseConnector(BaseConnector):
+    engine: str
+    host: str
+    port: int
+    default_name: str
+    pool: dict[str, int]
+
+
+@dataclass(slots=True)
+class FileConnector(BaseConnector):
+    base_path: str
+
+
+@dataclass(slots=True)
+class TelemetryConnector(BaseConnector):
+    host: str
+    port: int
+
+
+ConnectorTyping = Union[ApiConnector, FileConnector, DatabaseConnector, TelemetryConnector]

pycraftcore/app_configuration/model/cronjob.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from pycraftcore.app_configuration.model.operation import OperationTyping
+
+
+@dataclass(slots=True)
+class CronJob:
+    name: str
+    cron: str
+    operation: OperationTyping

pycraftcore/app_configuration/model/operation.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Union, List
+
+from pycraftcore.app_configuration.enum.file_operation_action import (
+    FileOperationAction,
+)
+from pycraftcore.app_configuration.model.connector import ConnectorTyping
+from pycraftcore.http.enum.http_method import HttpMethod
+
+ParamType = Union[str, List[str]]
+
+
+@dataclass(slots=True)
+class BaseOperation:
+    name: str
+    connector: ConnectorTyping
+
+
+@dataclass(slots=True)
+class ApiOperation(BaseOperation):
+    endpoint: str
+    method: HttpMethod
+    parameters: dict[str, ParamType]
+
+
+@dataclass(slots=True)
+class FileOperation(BaseOperation):
+    action: FileOperationAction
+    parameters: dict[str, ParamType]
+
+
+OperationTyping = Union[FileOperation, ApiOperation]

pycraftcore/app_configuration/port/configuration.py

@@ -0,0 +1,9 @@
+from typing import Protocol
+
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+
+
+class Configuration(Protocol):
+    def load(self) -> AppConfiguration | None: ...
+
+    def reload(self) -> AppConfiguration | None: ...

pycraftcore/app_configuration/port/configuration_reader.py

@@ -0,0 +1,7 @@
+from typing import Protocol
+
+from pycraftcore.app_configuration.model.configuration import AppConfiguration
+
+
+class ConfigurationReader(Protocol):
+    def read(self) -> AppConfiguration: ...

pycraftcore/authentication/__init__.py

@@ -0,0 +1,5 @@
+from pycraftcore.authentication.model.basic_auth import BasicAuth
+from pycraftcore.authentication.model.no_auth import NoAuth
+from pycraftcore.authentication.model.token_auth import TokenAuth
+
+AuthTyping = NoAuth | TokenAuth | BasicAuth

pycraftcore/authentication/model/auth_type.py

@@ -0,0 +1,7 @@
+import enum
+
+
+class AuthType(enum.Enum):
+    token = "token"
+    basic = "basic"
+    none = "none"

pycraftcore/authentication/model/basic_auth.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from .auth_type import AuthType
+
+
+@dataclass(frozen=True, slots=True)
+class BasicAuth:
+    username: str
+    password: str
+    type: AuthType = field(default=AuthType.basic)

pycraftcore/authentication/model/no_auth.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass, field
+
+from .auth_type import AuthType
+
+
+@dataclass(frozen=True, slots=True)
+class NoAuth:
+    type: AuthType = field(default=AuthType.none)

pycraftcore/authentication/model/token_auth.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from .auth_type import AuthType
+
+
+@dataclass(frozen=True, slots=True)
+class TokenAuth:
+    key_name: str
+    key_value: str
+    type: AuthType = field(default=AuthType.token)

pycraftcore/computation_engine/adapter/compute_engine.py

@@ -0,0 +1,20 @@
+from pycraftcore.computation_engine.port.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from pycraftcore.computation_engine.port.calculus_operation import (
+    CalculusOperation,
+)
+
+
+class ComputeEngine:
+    def __init__(self, arithmetic: ArithmeticOperation, calculus: CalculusOperation):
+        self._arithmetic = arithmetic
+        self._calculus = calculus
+
+    @property
+    def arithmetic(self) -> ArithmeticOperation:
+        return self._arithmetic
+
+    @property
+    def calculus(self) -> CalculusOperation:
+        return self._calculus

pycraftcore/computation_engine/adapter/numpy_arithmetic_operation.py

@@ -0,0 +1,49 @@
+from typing import Sequence, Any
+
+import numpy as np
+
+from pycraftcore.computation_engine.const_typing import Numeric
+
+
+class NumPyArithmeticOperation:
+    def to_array(self, sequence: Sequence[Any]) -> np.ndarray:
+        return self._as_array(sequence)
+
+    def log_returns(self, sequence: Sequence[Numeric]) -> np.ndarray:
+
+        if len(sequence) < 2:
+            return self._empty_array()
+
+        array = self._as_array(sequence)
+
+        ratio = array[1:] / array[:-1]
+        ratio = np.where(ratio <= 0, np.nan, ratio)
+        return np.log(ratio)
+
+    def rolling_average(self, sequence: Sequence[Numeric], window: int = 5) -> np.ndarray:
+        if len(sequence) < window:
+            return self._empty_array()
+
+        array = self._as_array(sequence)
+        kernel = self._as_array((np.ones(window) / window).astype(np.float64))
+        return np.convolve(array, kernel)
+
+    def rolling_standard_deviation(
+        self, sequence: Sequence[Numeric], window: int = 5
+    ) -> np.ndarray:
+        if len(sequence) < window:
+            return self._empty_array()
+
+        array = self._as_array(sequence)
+
+        return np.array([np.std(array[i : i + window]) for i in range(len(array) - window + 1)])
+
+    @staticmethod
+    def _empty_array() -> np.ndarray:
+        return np.array([], dtype=np.float64)
+
+    @staticmethod
+    def _as_array(sequence: Sequence[Any]) -> np.ndarray:
+        if isinstance(sequence, np.ndarray):
+            return sequence
+        return np.asarray(sequence, dtype=np.float64)

pycraftcore/computation_engine/adapter/scipy_calculus_operation.py

@@ -0,0 +1,21 @@
+from typing import Sequence, Any
+
+import numpy as np
+from scipy import interpolate, integrate
+
+from pycraftcore.computation_engine.const_typing import Numeric, Kind
+
+
+class ScipyCalculusOperation:
+    def _to_array(self, sequence: Sequence[Any]) -> np.ndarray:
+        return np.asarray(sequence, dtype=np.float64)
+
+    def integrate(self, sequence: Sequence[Numeric], dx: float) -> float:
+        arr = self._to_array(sequence)
+        return float(integrate.trapezoid(arr, dx=dx))
+
+    def interpolate(self, sequence: Sequence[Numeric], kind: Kind = "linear") -> Sequence[Numeric]:
+        arr = self._to_array(sequence)
+        x = np.arange(len(arr))
+        f = interpolate.interp1d(x, arr, kind=kind)
+        return f(x)

pycraftcore/computation_engine/const_typing.py

@@ -0,0 +1,15 @@
+from typing import Literal
+
+Numeric = int | float
+
+Kind = Literal[
+    "linear",
+    "nearest",
+    "nearest-up",
+    "zero",
+    "slinear",
+    "quadratic",
+    "cubic",
+    "previous",
+    "next",
+]

pycraftcore/computation_engine/port/arithmetic_operation.py

@@ -0,0 +1,15 @@
+from typing import Sequence, Any, Protocol
+
+from pycraftcore.computation_engine.const_typing import Numeric
+
+
+class ArithmeticOperation(Protocol):
+    def to_array(self, sequence: Sequence[Any]) -> Sequence[Any]: ...
+
+    def log_returns(self, sequence: Sequence[Numeric]) -> Sequence[Numeric]: ...
+
+    def rolling_average(self, sequence: Sequence[Numeric], window: int) -> Sequence[Numeric]: ...
+
+    def rolling_standard_deviation(
+        self, sequence: Sequence[Numeric], window: int
+    ) -> Sequence[Numeric]: ...

pycraftcore/computation_engine/port/calculus_operation.py

@@ -0,0 +1,11 @@
+from typing import Sequence, Protocol
+
+from pycraftcore.computation_engine.const_typing import Numeric, Kind
+
+
+class CalculusOperation(Protocol):
+    def integrate(self, sequence: Sequence[Numeric], dx: float) -> float: ...
+
+    def interpolate(
+        self, sequence: Sequence[Numeric], kind: Kind = "linear"
+    ) -> Sequence[Numeric]: ...

pycraftcore/computation_engine/port/engine.py

@@ -0,0 +1,16 @@
+from typing import Protocol
+
+from pycraftcore.computation_engine.port.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from pycraftcore.computation_engine.port.calculus_operation import (
+    CalculusOperation,
+)
+
+
+class Engine(Protocol):
+    @property
+    def arithmetic(self) -> ArithmeticOperation: ...
+
+    @property
+    def calculus(self) -> CalculusOperation: ...

pycraftcore/file_handler/adapter/extension/yml_reader.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+import yaml
+
+from pycraftcore.file_handler.port.reader import Reader
+
+
+class YmlFileReader(Reader):
+    @staticmethod
+    def read(file_path: str) -> dict[str, Any]:
+        with open(file_path, "r") as file:
+            return yaml.safe_load(file)

pycraftcore/file_handler/adapter/extension/yml_writer.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+import yaml
+
+from pycraftcore.file_handler.port.writer import Writer
+
+
+class YmlFileWriter(Writer):
+    @staticmethod
+    def write(file_path: str, data: dict[str, Any]) -> None:
+        with open(file_path, "w") as file:
+            yaml.dump(data, file)

pycraftcore/file_handler/adapter/factory.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from typing import Any
+
+from pycraftcore.file_handler.adapter.strategy import FileHandlerStrategy
+
+
+class FileHandlerFactory:
+    def __init__(self, file_path: str, strategy: FileHandlerStrategy) -> None:
+        self._file_path = Path(file_path)
+        self._strategy = strategy
+
+    def _file_extension(self) -> str:
+        return self._file_path.suffix.lstrip(".")
+
+    def _validate_file_for_read(self) -> None:
+        if not self._file_path.exists():
+            raise FileNotFoundError(f"File not found at {self._file_path}")
+
+        if not self._strategy.supports(self._file_extension()):
+            raise NotImplementedError(f"File extension not supported: {self._file_extension()}")
+
+    def _validate_file_for_write(self) -> None:
+        if not self._file_path.parent.exists():
+            raise FileNotFoundError(f"File location not found at {self._file_path}")
+
+        if not self._strategy.supports(self._file_extension()):
+            raise NotImplementedError(f"File extension not supported: {self._file_extension()}")
+
+    def read(self) -> dict[str, Any]:
+        self._validate_file_for_read()
+        reader = self._strategy.get_reader(self._file_extension())
+        return reader.read(str(self._file_path))
+
+    def write(self, data: Any) -> None:
+        self._validate_file_for_write()
+        writer = self._strategy.get_writer(self._file_extension())
+        writer.write(str(self._file_path), data)

pycraftcore/file_handler/adapter/handler.py

@@ -0,0 +1,12 @@
+from pycraftcore.file_handler.adapter.provider import FileHandlerProvider
+from pycraftcore.file_handler.adapter.strategy import FileHandlerStrategy
+from pycraftcore.file_handler.adapter.extension.yml_reader import YmlFileReader
+from pycraftcore.file_handler.adapter.extension.yml_writer import YmlFileWriter
+
+strategy = FileHandlerStrategy(
+    {
+        "yml": {"reader": YmlFileReader(), "writer": YmlFileWriter()},
+    }
+)
+
+Handler = FileHandlerProvider(strategy)

pycraftcore/file_handler/adapter/provider.py

@@ -0,0 +1,10 @@
+from pycraftcore.file_handler.adapter.factory import FileHandlerFactory
+from pycraftcore.file_handler.adapter.strategy import FileHandlerStrategy
+
+
+class FileHandlerProvider:
+    def __init__(self, strategy: FileHandlerStrategy) -> None:
+        self._strategy = strategy
+
+    def __call__(self, file_path: str) -> FileHandlerFactory:
+        return FileHandlerFactory(file_path, self._strategy)

pycraftcore/file_handler/adapter/strategy.py

@@ -0,0 +1,23 @@
+from typing import TypedDict
+
+from pycraftcore.file_handler.port.reader import Reader
+from pycraftcore.file_handler.port.writer import Writer
+
+
+class FileHandlerDict(TypedDict):
+    reader: Reader
+    writer: Writer
+
+
+class FileHandlerStrategy:
+    def __init__(self, handlers: dict[str, FileHandlerDict]) -> None:
+        self._handlers = handlers
+
+    def get_reader(self, extension: str) -> Reader:
+        return self._handlers[extension]["reader"]
+
+    def get_writer(self, extension: str) -> Writer:
+        return self._handlers[extension]["writer"]
+
+    def supports(self, extension: str) -> bool:
+        return extension in self._handlers

pycraftcore/file_handler/port/reader.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Reader(ABC):
+    @staticmethod
+    @abstractmethod
+    def read(file_path: str) -> Any: ...