pyquoks 2.4.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

pyquoks/__init__.py

@@ -1,9 +1,11 @@
 __all__ = [
-    "data",
+    "managers",
+    "providers",
+    "services",
     "utils",
-    "test",
 ]
 
-from . import data
+from . import managers
+from . import providers
+from . import services
 from . import utils
-from . import test

pyquoks/managers/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "config",
+    "data",
+    "database",
+]
+
+from . import config
+from . import data
+from . import database

pyquoks/managers/config.py

@@ -0,0 +1,154 @@
+import configparser
+import json
+import typing
+
+import pyquoks.utils
+
+
+class ConfigManager(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class for managing data in configuration file
+
+    **Required attributes**::
+
+        # Predefined
+
+        _PATH = pyquoks.utils.get_path("config.ini")
+
+    Attributes:
+        _PATH: Path to the configuration file
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_PATH",
+    }
+
+    _PATH: str = pyquoks.utils.get_path("config.ini")
+
+    def __init__(self) -> None:
+        self._check_attributes()
+
+        for attribute, object_type in self.__class__.__annotations__.items():
+            if issubclass(object_type, Config):
+                setattr(self, attribute, object_type(self))
+
+
+class Config(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class that represents a section in configuration file
+
+    **Required attributes**::
+
+        _SECTION = "Settings"
+
+        _VALUES = {"version": str, "beta": bool}
+
+    Attributes:
+        _SECTION: Name of the section in configuration file
+        _VALUES: Dictionary with settings and their types
+        _parent: Parent object
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_SECTION",
+        "_VALUES",
+    }
+
+    _SECTION: str
+
+    _VALUES: dict[str, type]
+
+    _incorrect_content_exception = configparser.ParsingError(
+        source="configuration file is filled incorrectly",
+    )
+
+    _parent: ConfigManager
+
+    def __init__(self, parent: ConfigManager) -> None:
+        self._check_attributes()
+
+        self._parent = parent
+
+        self._config = configparser.ConfigParser()
+        self._config.read(self._parent._PATH)
+
+        if not self._config.has_section(self._SECTION):
+            self._config.add_section(self._SECTION)
+
+        for attribute, object_type in self._VALUES.items():
+            try:
+                setattr(self, attribute, self._config.get(self._SECTION, attribute))
+            except Exception:
+                self._config.set(self._SECTION, attribute, object_type.__name__)
+                with open(self._parent._PATH, "w", encoding="utf-8") as file:
+                    self._config.write(file)
+
+        for attribute, object_type in self._VALUES.items():
+            try:
+                match object_type():
+                    case bool():
+                        if getattr(self, attribute) not in [str(True), str(False)]:
+                            setattr(self, attribute, None)
+                            raise self._incorrect_content_exception
+                        else:
+                            setattr(self, attribute, getattr(self, attribute) == str(True))
+                    case int():
+                        setattr(self, attribute, int(getattr(self, attribute)))
+                    case float():
+                        setattr(self, attribute, float(getattr(self, attribute)))
+                    case str():
+                        pass
+                    case dict() | list():
+                        setattr(self, attribute, json.loads(getattr(self, attribute)))
+                    case _:
+                        raise ValueError(f"{object_type.__name__} type is not supported!")
+            except Exception:
+                setattr(self, attribute, None)
+
+                raise self._incorrect_content_exception
+
+    @property
+    def _values(self) -> dict | None:
+        """
+        :return: Values stored in this section
+        """
+
+        try:
+            return {
+                attribute: getattr(self, attribute) for attribute in self._VALUES.keys()
+            }
+        except Exception:
+            return None
+
+    def update(self, **kwargs) -> None:
+        """
+        Updates provided attributes in object
+        """
+
+        for attribute, value in kwargs.items():
+
+            if attribute not in self._VALUES.keys():
+                raise AttributeError(f"{attribute} is not specified!")
+
+            object_type = self._VALUES.get(attribute)
+
+            if not isinstance(
+                    value,
+                    typing.get_origin(object_type) if typing.get_origin(object_type) else object_type,
+            ):
+                raise AttributeError(
+                    f"{attribute} has incorrect type! (must be {object_type.__name__})",
+                )
+
+            setattr(self, attribute, value)
+
+            match object_type():
+                case bool() | int() | float() | str():
+                    self._config.set(self._SECTION, attribute, str(value))
+                case dict() | list():
+                    self._config.set(self._SECTION, attribute, json.dumps(value))
+                case _:
+                    raise ValueError(f"{object_type.__name__} type is not supported!")
+
+            with open(self._parent._PATH, "w", encoding="utf-8") as file:
+                self._config.write(file)

pyquoks/managers/data.py

@@ -0,0 +1,94 @@
+import json
+import os
+import typing
+
+import pydantic
+
+import pyquoks.utils
+
+
+class DataManager(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class for managing data from JSON-like files
+
+    **Required attributes**::
+
+        # Predefined:
+
+        _PATH = pyquoks.utils.get_path("data/")
+
+        _FILENAME = "{0}.json"
+
+    Attributes:
+        _PATH: Path to the directory with JSON-like files
+        _FILENAME: Filename of JSON-like files
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_PATH",
+        "_FILENAME",
+    }
+
+    _PATH: str = pyquoks.utils.get_path("data/")
+
+    _FILENAME: str = "{0}.json"
+
+    def __init__(self) -> None:
+        self._check_attributes()
+
+        for attribute, object_type in self.__class__.__annotations__.items():
+            if issubclass(
+                    typing.get_args(object_type)[0],
+                    pydantic.BaseModel,
+            ) if typing.get_origin(object_type) else issubclass(
+                object_type,
+                pydantic.BaseModel,
+            ):
+                try:
+                    with open(self._PATH + self._FILENAME.format(attribute), "rb") as file:
+                        data = json.loads(file.read())
+
+                        if typing.get_origin(object_type) == list:
+                            setattr(self, attribute, [typing.get_args(object_type)[0](**model) for model in data])
+                        else:
+                            setattr(self, attribute, object_type(**data))
+                except Exception:
+                    setattr(self, attribute, None)
+
+    def update(self, **kwargs) -> None:
+        """
+        Updates provided attributes in object
+        """
+
+        for attribute, value in kwargs.items():
+            value: pydantic.BaseModel | list[pydantic.BaseModel]
+
+            if attribute not in self.__class__.__annotations__.keys():
+                raise AttributeError(f"{attribute} is not specified!")
+
+            object_type = self.__class__.__annotations__.get(attribute)
+
+            if not isinstance(
+                    value,
+                    typing.get_origin(object_type) if typing.get_origin(object_type) else object_type,
+            ):
+                raise AttributeError(
+                    f"{attribute} has incorrect type! (must be {object_type.__name__})",
+                )
+
+            setattr(self, attribute, value)
+
+            os.makedirs(
+                name=self._PATH,
+                exist_ok=True,
+            )
+
+            with open(self._PATH + self._FILENAME.format(attribute), "w", encoding="utf-8") as file:
+                json.dump(
+                    [model.model_dump() for model in value] if typing.get_origin(
+                        object_type,
+                    ) == list else value.model_dump(),
+                    fp=file,
+                    ensure_ascii=False,
+                    indent=2,
+                )

pyquoks/managers/database.py

@@ -0,0 +1,103 @@
+import os
+import sqlite3
+
+import pyquoks.utils
+
+
+class DatabaseManager(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class for managing database connections
+
+    **Required attributes**::
+
+        # Predefined
+
+        _PATH = pyquoks.utils.get_path("db/")
+
+    Attributes:
+        _PATH: Path to the directory with databases
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_PATH",
+    }
+
+    _PATH: str = pyquoks.utils.get_path("db/")
+
+    def __init__(self) -> None:
+        self._check_attributes()
+
+        os.makedirs(
+            name=self._PATH,
+            exist_ok=True,
+        )
+
+        for attribute, object_type in self.__class__.__annotations__.items():
+            if issubclass(object_type, Database):
+                setattr(self, attribute, object_type(self))
+
+    def close_all(self) -> None:
+        """
+        Closes all database connections
+        """
+
+        for attribute, object_type in self.__class__.__annotations__.items():
+            if issubclass(object_type, Database):
+                getattr(self, attribute).close()
+
+
+class Database(sqlite3.Connection, pyquoks.utils._HasRequiredAttributes):
+    """
+    Class that represents a database connection
+
+    **Required attributes**::
+
+        _NAME = "users"
+
+        _SQL = f\"""CREATE TABLE IF NOT EXISTS {_NAME} (user_id INTEGER PRIMARY KEY NOT NULL)\"""
+
+        # Predefined
+
+        _FILENAME = "{0}.db"
+
+    Attributes:
+        _NAME: Name of the database
+        _SQL: SQL expression for creating a table
+        _FILENAME: Filename of the database
+        _parent: Parent object
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_NAME",
+        "_SQL",
+        "_FILENAME",
+    }
+
+    _NAME: str
+
+    _SQL: str
+
+    _FILENAME: str = "{0}.db"
+
+    _parent: DatabaseManager
+
+    def __init__(self, parent: DatabaseManager) -> None:
+        self._check_attributes()
+
+        self._parent = parent
+
+        self._FILENAME = self._FILENAME.format(self._NAME)
+
+        super().__init__(
+            database=self._parent._PATH + self._FILENAME,
+            check_same_thread=False,
+        )
+        self.row_factory = sqlite3.Row
+
+        cursor = self.cursor()
+
+        cursor.execute(
+            self._SQL,
+        )
+
+        self.commit()

pyquoks/providers/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "assets",
+    "environment",
+    "strings",
+]
+
+from . import assets
+from . import environment
+from . import strings

pyquoks/providers/assets.py

@@ -0,0 +1,141 @@
+import io
+
+import PIL.Image
+import requests
+
+import pyquoks.utils
+
+
+class AssetsProvider(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class for providing various assets data
+
+    **Required attributes**::
+
+        # Predefined:
+
+        _PATH = pyquoks.utils.get_path("assets/")
+
+    Attributes:
+        _PATH: Path to the directory with assets folders
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_PATH",
+    }
+
+    _PATH: str = pyquoks.utils.get_path("assets/")
+
+    def __init__(self) -> None:
+        self._check_attributes()
+
+        for attribute, object_type in self.__class__.__annotations__.items():
+            if issubclass(object_type, Directory | Network):
+                setattr(self, attribute, object_type(self))
+
+
+class Directory(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class that represents a directory with various assets
+
+    **Required attributes**::
+
+        _ATTRIBUTES = {"picture1", "picture2"}
+
+        _PATH = "images/"
+
+        _FILENAME = "{0}.png"
+
+    Attributes:
+        _ATTRIBUTES: Names of files in the directory
+        _PATH: Path to the directory with assets files
+        _FILENAME: Filename of assets files
+        _parent: Parent object
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_ATTRIBUTES",
+        "_PATH",
+        "_FILENAME",
+    }
+
+    _ATTRIBUTES: set[str]
+
+    _PATH: str
+
+    _FILENAME: str
+
+    _parent: AssetsProvider
+
+    def __init__(self, parent: AssetsProvider) -> None:
+        self._check_attributes()
+
+        self._parent = parent
+
+        self._PATH = self._parent._PATH + self._PATH
+
+        for attribute in self._ATTRIBUTES:
+            try:
+                setattr(self, attribute, self.file_image(
+                    path=self._PATH + self._FILENAME.format(attribute),
+                ))
+            except Exception:
+                setattr(self, attribute, None)
+
+    @staticmethod
+    def file_image(path: str) -> PIL.Image.Image:
+        """
+        :param path: Absolute path of the image file
+        :return: Image object from a file
+        """
+
+        with open(path, "rb") as file:
+            return PIL.Image.open(
+                fp=io.BytesIO(file.read()),
+            )
+
+
+class Network(pyquoks.utils._HasRequiredAttributes):
+    """
+    Class that represents a set of images obtained from a network
+
+    **Required attributes**::
+
+        _URLS = {"example": "https://example.com/image.png"}
+
+    Attributes:
+        _URLS: Dictionary with names of attributes and URLs
+        _parent: Parent object
+    """
+
+    _REQUIRED_ATTRIBUTES = {
+        "_URLS",
+    }
+
+    _URLS: dict[str, str]
+
+    _parent: AssetsProvider
+
+    def __init__(self, parent: AssetsProvider) -> None:
+        self._check_attributes()
+
+        self._parent = parent
+
+        for attribute, url in self._URLS.items():
+            try:
+                setattr(self, attribute, self.network_image(
+                    url=url,
+                ))
+            except Exception:
+                setattr(self, attribute, None)
+
+    @staticmethod
+    def network_image(url: str) -> PIL.Image.Image:
+        """
+        :param url: URL of the image file
+        :return: Image object from a URL
+        """
+
+        return PIL.Image.open(
+            fp=io.BytesIO(requests.get(url).content),
+        )

pyquoks/providers/environment.py

@@ -0,0 +1,18 @@
+import os
+
+
+class EnvironmentProvider:
+    """
+    Class for providing environment variables
+    """
+
+    def __init__(self) -> None:
+        self.load_variables()
+
+    def load_variables(self) -> None:
+        """
+        Loads specified environment variables
+        """
+
+        for attribute in self.__class__.__annotations__.keys():
+            setattr(self, attribute, os.getenv(attribute, None))

pyquoks/providers/strings.py

@@ -0,0 +1,23 @@
+class StringsProvider:
+    """
+    Class for providing various strings data
+    """
+
+    def __init__(self) -> None:
+        for attribute, child_class in self.__class__.__annotations__.items():
+            if issubclass(child_class, Strings):
+                setattr(self, attribute, child_class(self))
+            else:
+                raise AttributeError(
+                    f"{attribute} has incorrect type! (must be subclass of {Strings.__name__})",
+                )
+
+
+class Strings:
+    """
+    Class that represents a container for strings
+    """
+
+    # noinspection PyUnusedLocal
+    def __init__(self, parent: StringsProvider) -> None:
+        ...  # TODO

pyquoks/services/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    "logger",
+]
+
+from . import logger

pyquoks/services/logger.py

@@ -0,0 +1,86 @@
+import datetime
+import logging
+import os
+import sys
+import typing
+
+import pyquoks.utils
+
+
+class LoggerService(logging.Logger):
+    """
+    Class that provides methods for parallel logging
+
+    Attributes:
+        _LOG_PATH: Path to the logs file
+    """
+
+    _LOG_PATH: str | None
+
+    def __init__(
+            self,
+            filename: str,
+            level: int = logging.NOTSET,
+            file_handling: bool = True,
+            path: str = pyquoks.utils.get_path("logs/"),
+    ) -> None:
+        super().__init__(filename, level)
+
+        self.stream_handler = logging.StreamHandler(sys.stdout)
+        self.stream_handler.setFormatter(
+            logging.Formatter(
+                fmt="$levelname $asctime $name - $message",
+                datefmt="%d-%m-%y %H:%M:%S",
+                style="$",
+            )
+        )
+        self.addHandler(self.stream_handler)
+
+        if file_handling:
+            os.makedirs(
+                name=path,
+                exist_ok=True
+            )
+            self._LOG_PATH = path + f"{int(datetime.datetime.now().timestamp())}.{filename}.log"
+
+            self.file_handler = logging.FileHandler(
+                filename=self._LOG_PATH,
+                encoding="utf-8",
+            )
+            self.file_handler.setFormatter(
+                logging.Formatter(
+                    fmt="$levelname $asctime - $message",
+                    datefmt="%d-%m-%y %H:%M:%S",
+                    style="$",
+                ),
+            )
+            self.addHandler(self.file_handler)
+        else:
+            self._LOG_PATH = None
+
+    @property
+    def file(self) -> typing.IO | None:
+        """
+        :return: Opened file-like object of current logs
+        """
+
+        if self._LOG_PATH:
+            return open(self._LOG_PATH, "rb")
+        else:
+            return None
+
+    def log_error(self, exception: Exception, raise_again: bool = False) -> None:
+        """
+        Logs an exception with detailed traceback
+
+        :param exception: Exception to be logged
+        :param raise_again: Whether or not exception should be raised again
+        """
+
+        self.error(
+            msg=exception,
+            exc_info=True,
+        )
+
+        if raise_again:
+            raise exception

pyquoks/utils.py

@@ -38,12 +38,15 @@ def get_path(relative_path: str, use_meipass: bool = False) -> str:
     return os.path.join(base_path, relative_path)
 
 
-def get_process_created_datetime(pid: int = os.getpid()) -> datetime.datetime:
+def get_process_created_datetime(pid: int = None) -> datetime.datetime:
     """
     :param pid: ID of the process
     :return: Datetime when the process was created
     """
 
+    if pid is None:
+        pid = os.getpid()
+
     process = psutil.Process(pid)
 
     return datetime.datetime.fromtimestamp(

{pyquoks-2.4.0.dist-info → pyquoks-2.5.0.dist-info}/METADATA

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: pyquoks
-Version: 2.4.0
+Version: 2.5.0
 Summary: Пакет PyPI для часто используемых модулей в проектах diquoks
 License: MIT
 License-File: LICENSE
 Author: Denis Titovets
 Author-email: den232titovets@yandex.ru
-Requires-Python: >=3.14
+Requires-Python: >=3.14,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: pillow (>=12.1.0)
-Requires-Dist: psutil (>=7.2.1)
+Requires-Dist: psutil (>=7.2.2)
 Requires-Dist: pydantic (>=2.12.5)
 Requires-Dist: requests (>=2.32.5)
 Description-Content-Type: text/markdown