pyquoks 1.2.2__tar.gz → 1.3.0__tar.gz

{pyquoks-1.2.2 → pyquoks-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyquoks
-Version: 1.2.2
+Version: 1.3.0
 Summary: Пакет PyPI для часто используемых модулей в проектах diquoks
 Home-page: https://diquoks.ru
 Author: Denis Titovets
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: blinker==1.9.0
-Requires-Dist: certifi==2025.8.3
+Requires-Dist: certifi==2025.10.5
 Requires-Dist: charset-normalizer==3.4.3
 Requires-Dist: click==8.3.0
 Requires-Dist: colorama==0.4.6
@@ -20,7 +20,7 @@ Requires-Dist: Flask==3.1.2
 Requires-Dist: idna==3.10
 Requires-Dist: itsdangerous==2.2.0
 Requires-Dist: Jinja2==3.1.6
-Requires-Dist: MarkupSafe==3.0.2
+Requires-Dist: MarkupSafe==3.0.3
 Requires-Dist: pillow==11.3.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: urllib3==2.5.0

{pyquoks-1.2.2 → pyquoks-1.3.0}/requirements.txt

@@ -1,5 +1,5 @@
 blinker==1.9.0
-certifi==2025.8.3
+certifi==2025.10.5
 charset-normalizer==3.4.3
 click==8.3.0
 colorama==0.4.6
@@ -7,7 +7,7 @@ Flask==3.1.2
 idna==3.10
 itsdangerous==2.2.0
 Jinja2==3.1.6
-MarkupSafe==3.0.2
+MarkupSafe==3.0.3
 pillow==11.3.0
 requests==2.32.5
 urllib3==2.5.0

{pyquoks-1.2.2 → pyquoks-1.3.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pyquoks
-version = 1.2.2
+version = 1.3.0
 author = Denis Titovets
 author_email = den232titovets@yandex.ru
 description = Пакет PyPI для часто используемых модулей в проектах diquoks

pyquoks-1.3.0/src/pyquoks/data.py

@@ -0,0 +1,522 @@
+from __future__ import annotations
+import configparser, datetime, logging, sqlite3, json, sys, io, os
+import requests, PIL.Image, PIL.ImageDraw
+from . import utils
+
+
+# region Providers
+
+class IDataProvider:
+    """
+    Class for providing data from JSON-like files
+    """
+
+    _PATH: str = utils.get_path("data/")
+    """
+    Path to the directory with JSON-like files
+    """
+
+    _FILENAME: str = "{0}.json"
+    """
+    Filename of JSON-like files
+    """
+
+    _DATA_VALUES: dict[str, type]
+    """
+    Dictionary with filenames and containers
+
+    Example:
+        _DATA_VALUES = {"users": UsersContainer}
+    """
+
+    def __init__(self) -> None:
+        for filename, container in self._DATA_VALUES.items():
+            try:
+                with open(self._PATH + self._FILENAME.format(filename), "rb") as file:
+                    setattr(self, filename, container(json.loads(file.read())))
+            except:
+                setattr(self, filename, None)
+
+
+class IConfigProvider:
+    """
+    Class for providing data from configuration file
+    """
+
+    class IConfig:
+        """
+        Class that represents a section in configuration file
+        """
+
+        _SECTION: str = None
+        """
+        Name of the section in configuration file
+
+        Example:
+            _SECTION = "Settings"
+        """
+
+        _CONFIG_VALUES: dict[str, type]
+        """
+        Dictionary with settings and their types
+        """
+
+        def __init__(self, parent: IConfigProvider = None) -> None:
+            if isinstance(parent, IConfigProvider):
+                self._CONFIG_VALUES = parent._CONFIG_VALUES.get(self._SECTION)
+
+                self._incorrect_content_exception = configparser.ParsingError(
+                    "configuration file is filled incorrectly!"
+                )
+                self._config = configparser.ConfigParser()
+                self._config.read(parent._PATH)
+
+                if not self._config.has_section(self._SECTION):
+                    self._config.add_section(self._SECTION)
+
+                for setting, data_type in self._CONFIG_VALUES.items():
+                    try:
+                        setattr(self, setting, self._config.get(self._SECTION, setting))
+                    except:
+                        self._config.set(self._SECTION, setting, data_type.__name__)
+                        with open(parent._PATH, "w", encoding="utf-8") as file:
+                            self._config.write(file)
+
+                for setting, data_type in self._CONFIG_VALUES.items():
+                    try:
+                        match data_type.__name__:
+                            case "int":
+                                setattr(self, setting, int(getattr(self, setting)))
+                            case "bool":
+                                if getattr(self, setting) not in (str(True), str(False)):
+                                    setattr(self, setting, None)
+                                    raise self._incorrect_content_exception
+                                else:
+                                    setattr(self, setting, getattr(self, setting) == str(True))
+                            case "dict" | "list":
+                                setattr(self, setting, json.loads(getattr(self, setting)))
+                    except:
+                        setattr(self, setting, None)
+                        raise self._incorrect_content_exception
+
+                if not self.values:
+                    raise self._incorrect_content_exception
+
+        @property
+        def values(self) -> dict | None:
+            """
+            :return: Values stored in section
+            """
+
+            try:
+                return {setting: getattr(self, setting) for setting in self._CONFIG_VALUES.keys()}
+            except:
+                return None
+
+    _PATH: str = utils.get_path("config.ini")
+    """
+    Path to the configuration file
+    """
+
+    _CONFIG_VALUES: dict[str, dict[str, type]]
+    """
+    Dictionary with sections, their settings and their types
+
+    Example:
+        _CONFIG_VALUES = {"Settings": {"version": str}}
+    """
+
+    _CONFIG_OBJECTS: dict[str, type]
+    """
+    Dictionary with names of attributes and child objects
+
+    Example:
+        _CONFIG_OBJECTS = {"settings": SettingsConfig}
+    """
+
+    def __init__(self) -> None:
+        for name, data_class in self._CONFIG_OBJECTS.items():
+            setattr(self, name, data_class(self))
+
+
+class IAssetsProvider:
+    """
+    Class for providing various assets data
+    """
+
+    class IDirectory:
+        """
+        Class that represents a directory with various assets
+        """
+
+        _PATH: str = None
+        """
+        Path to the directory with assets files
+
+        Example:
+            _PATH = "images/"
+        """
+
+        _FILENAME: str = None
+        """
+        Filename of assets files
+
+        Example:
+            _FILENAME = "{0}.png"
+        """
+
+        _NAMES: set[str]
+        """
+        Names of files in the directory
+
+        Example:
+            _NAMES = {"picture1", "picture2"}
+        """
+
+        def __init__(self, parent: IAssetsProvider) -> None:
+            self._PATH = parent._PATH + self._PATH
+
+            if isinstance(parent, IAssetsProvider):
+                for filename in self._NAMES:
+                    setattr(self, filename, parent.file_image(self._PATH + self._FILENAME.format(filename)))
+
+    class INetwork:
+        """
+        Class that represents a set of images obtained from a network
+        """
+
+        _URLS: dict[str, str]
+        """
+        Dictionary with names of attributes and URLs
+
+        Example:
+            _URLS = {"example": "https://example.com/image.png"}
+        """
+
+        def __init__(self, parent: IAssetsProvider) -> None:
+            if isinstance(parent, IAssetsProvider):
+                for name, url in self._URLS.items():
+                    setattr(self, name, parent.network_image(url))
+
+    _PATH: str = utils.get_path("assets/")
+    """
+    Path to the directory with assets folders
+    """
+
+    _ASSETS_OBJECTS: dict[str, type]
+    """
+    Dictionary with names of attributes and child objects
+
+    Example:
+        _ASSETS_OBJECTS = {"images": ImagesAssets, "example": ExampleNetwork}
+    """
+
+    def __init__(self) -> None:
+        for name, data_class in self._ASSETS_OBJECTS.items():
+            setattr(self, name, data_class(self))
+
+    @staticmethod
+    def file_image(path: str) -> PIL.Image.Image:
+        """
+        :return: Image object from a file
+        """
+
+        with open(path, "rb") as file:
+            return PIL.Image.open(io.BytesIO(file.read()))
+
+    @staticmethod
+    def network_image(url: str) -> PIL.Image.Image:
+        """
+        :return: Image object from a URL
+        """
+
+        return PIL.Image.open(io.BytesIO(requests.get(url).content))
+
+    @staticmethod
+    def round_corners(image: PIL.Image.Image, radius: int) -> PIL.Image.Image:
+        """
+        :return: Image with rounded edges of the specified radius
+        """
+
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        width, height = image.size
+
+        shape = PIL.Image.new("L", (radius * 2, radius * 2), 0)
+        PIL.ImageDraw.Draw(shape).ellipse((0, 0, radius * 2, radius * 2), fill=255)
+
+        alpha = PIL.Image.new("L", image.size, "white")
+        alpha.paste(shape.crop((0, 0, radius, radius)), (0, 0))
+        alpha.paste(shape.crop((0, radius, radius, radius * 2)), (0, height - radius))
+        alpha.paste(shape.crop((radius, 0, radius * 2, radius)), (width - radius, 0))
+        alpha.paste(shape.crop((radius, radius, radius * 2, radius * 2)), (width - radius, height - radius))
+        image.putalpha(alpha)
+
+        return image
+
+
+class IStringsProvider:
+    """
+    Class for providing various strings data
+    """
+
+    class IStrings:
+        """
+        Class that represents a container for strings
+        """
+
+        pass
+
+    _STRINGS_OBJECTS: dict[str, type]
+    """
+    Dictionary with names of attributes and child objects
+
+    Example:
+        _STRINGS_OBJECTS = {"localizable": LocalizableStrings}
+    """
+
+    def __init__(self) -> None:
+        for name, data_class in self._STRINGS_OBJECTS.items():
+            setattr(self, name, data_class())
+
+
+# endregion
+
+# region Managers
+
+class IDatabaseManager:
+    """
+    Class for managing database connections
+    """
+
+    class IDatabase(sqlite3.Connection):
+        """
+        Class that represents a database connection
+        """
+
+        _NAME: str = None
+        """
+        Name of the database
+
+        Example:
+            _NAME = "users"
+        """
+
+        _SQL: str = None
+        """
+        SQL expression for creating a database
+
+        Example:
+            _SQL = f\"\"\"CREATE TABLE IF NOT EXISTS {_NAME} (user_id INTEGER PRIMARY KEY NOT NULL)\"\"\"
+        """
+
+        _FILENAME: str = "{0}.db"
+        """
+        File extension of database
+        """
+
+        def __init__(self, parent: IDatabaseManager) -> None:
+            if isinstance(parent, IDatabaseManager):
+                self._FILENAME = self._FILENAME.format(self._NAME)
+
+                super().__init__(
+                    database=parent._PATH + self._FILENAME,
+                    check_same_thread=False,
+                )
+
+                self._cursor = self.cursor()
+                self._db_cursor.execute(self._SQL)
+                self.commit()
+
+        @property
+        def _db_cursor(self) -> sqlite3.Cursor:
+            return self._cursor
+
+    _PATH: str = utils.get_path("db/")
+    """
+    Path to the directory with databases
+    """
+
+    _DATABASE_OBJECTS: dict[str, type]
+    """
+    Dictionary with names of attributes and child objects
+
+    Example:
+        _DATABASE_OBJECTS = {"users": UsersDatabase}
+    """
+
+    def __init__(self) -> None:
+        os.makedirs(self._PATH, exist_ok=True)
+
+        for name, data_class in self._DATABASE_OBJECTS.items():
+            setattr(self, name, data_class(self))
+
+    def close_all(self) -> None:
+        """
+        Closes all database connections
+        """
+        for database in self._DATABASE_OBJECTS.keys():
+            getattr(self, database).close()
+
+
+if sys.platform == "win32":
+    import winreg
+
+
+    class IRegistryManager:
+        """
+        Class for managing data in the Windows Registry
+        """
+
+        class IRegistry:
+            """
+            Class that represents a key with parameters in the Windows Registry
+            """
+
+            _NAME: str = None
+            """
+            Name of key in the Windows Registry
+
+            Example:
+                _NAME = "OAuth"
+            """
+
+            _REGISTRY_VALUES: dict[str, int]
+            """
+            Dictionary with settings and their types
+            """
+
+            _path: winreg.HKEYType
+
+            def __init__(self, parent: IRegistryManager = None) -> None:
+                if isinstance(parent, IRegistryManager):
+                    self._REGISTRY_VALUES = parent._REGISTRY_VALUES.get(self._NAME)
+                    self._path = winreg.CreateKey(parent._path, self._NAME)
+
+                    for setting in self._REGISTRY_VALUES.keys():
+                        try:
+                            setattr(self, setting, winreg.QueryValueEx(self._path, setting)[int()])
+                        except:
+                            setattr(self, setting, None)
+
+            @property
+            def values(self) -> dict | None:
+                """
+                :return: Values stored in key in the Windows Registry
+                """
+
+                try:
+                    return {setting: getattr(self, setting) for setting in self._REGISTRY_VALUES.keys()}
+                except:
+                    return None
+
+            def refresh(self) -> IRegistryManager.IRegistry:
+                """
+                :return: Instance with refreshed values
+                """
+
+                self.__init__()
+                return self
+
+            def update(self, **kwargs) -> None:
+                """
+                Updates provided settings in the Windows Registry
+                """
+
+                for setting, value in kwargs.items():
+                    winreg.SetValueEx(self._path, setting, None, self._REGISTRY_VALUES.get(setting), value)
+                    setattr(self, setting, value)
+
+        _KEY: str
+        """
+        Path to key in the Windows Registry
+
+        Example:
+            _KEY = "Software\\\\\\\\diquoks Software\\\\\\\\pyquoks"
+        """
+
+        _REGISTRY_VALUES: dict[str, dict[str, int]]
+        """
+        Dictionary with keys, their settings and their types
+
+        Example:
+            _REGISTRY_VALUES = {"OAuth": {"access_token": winreg.REG_SZ}}
+        """
+
+        _REGISTRY_OBJECTS: dict[str, type]
+        """
+        Dictionary with names of attributes and child objects
+
+        Example:
+            _REGISTRY_OBJECTS = {"oauth": OAuthRegistry}
+        """
+
+        _path: winreg.HKEYType
+
+        def __init__(self) -> None:
+            self._path = winreg.CreateKey(winreg.HKEY_CURRENT_USER, self._KEY)
+
+            for name, data_class in self._REGISTRY_OBJECTS.items():
+                setattr(self, name, data_class(self))
+
+        def refresh(self) -> IRegistryManager:
+            """
+            :return: Instance with refreshed values
+            """
+
+            self.__init__()
+            return self
+
+
+# endregion
+
+# region Services
+
+class LoggerService(logging.Logger):
+    """
+    Class that provides methods for parallel logging
+    """
+
+    def __init__(
+            self,
+            name: str, file_handling: bool = True,
+            filename: str = datetime.datetime.now().strftime("%d-%m-%y-%H-%M-%S"),
+            level: int = logging.NOTSET,
+            path: str = utils.get_path("logs/", only_abspath=True),
+    ) -> None:
+        super().__init__(name, level)
+
+        stream_handler = logging.StreamHandler(sys.stdout)
+        stream_handler.setFormatter(
+            logging.Formatter(
+                fmt="$levelname $asctime $name - $message",
+                datefmt="%d-%m-%y %H:%M:%S",
+                style="$",
+            )
+        )
+        self.addHandler(stream_handler)
+
+        if file_handling:
+            os.makedirs(path, exist_ok=True)
+
+            file_handler = logging.FileHandler(
+                path + f"{filename}-{name}.log",
+                encoding="utf-8",
+            )
+            file_handler.setFormatter(
+                logging.Formatter(
+                    fmt="$levelname $asctime - $message",
+                    datefmt="%d-%m-%y %H:%M:%S",
+                    style="$",
+                ),
+            )
+            self.addHandler(file_handler)
+
+    def log_exception(self, e: Exception) -> None:
+        """
+        Logs an exception with detailed traceback
+        """
+
+        self.error(msg=e, exc_info=True)
+
+# endregion

pyquoks-1.3.0/src/pyquoks/localhost.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import typing
+import waitress, flask
+
+
+class ILocalhostFlask(flask.Flask):
+    """
+    Class for creating a simple localhost server
+    """
+
+    _RULES: dict[str, typing.Callable]
+    """
+    Dictionary with rules and functions
+    
+    Example:
+        _RULES = {"/": base_redirect}
+    """
+
+    def __init__(self, import_name: str) -> None:
+        super().__init__(import_name)
+
+        for rule, view_func in self._RULES.items():
+            self.add_url_rule(
+                rule=rule,
+                view_func=view_func,
+            )
+
+    def serve(self, port: int) -> None:
+        """
+        Starts this Flask application
+        """
+
+        waitress.serve(
+            app=self,
+            host="127.0.0.1",
+            port=port,
+        )

pyquoks-1.3.0/src/pyquoks/models.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+
+class IContainer:
+    """
+    Class for storing lists of models and another parameters
+    """
+
+    _ATTRIBUTES: set[str] | dict[str, set[str]] = None
+    """
+    Set of parameters that also can be stored one key deep
+
+    Example:
+        _ATTRIBUTES = {"beatmap_id", "score_id"}
+
+        _ATTRIBUTES = {"attributes": {"max_combo", "star_rating"}}
+    """
+
+    _DATA: dict[str, type] = None
+    """
+    Dictionary with name and type of models stored in list inside ``json_data``
+
+    Example:
+        _DATA = {"scores": ScoreModel}
+    """
+
+    _OBJECTS: dict[str, type] = None
+    """
+    Dictionary with keys of ``json_data`` and types of models stored in a list inside
+
+    Example:
+        _OBJECTS = {"beatmaps": BeatmapModel, "scores": ScoreModel}
+    """
+
+    _data: dict
+    """
+    Initial data that was passed into object
+    """
+
+    def __init__(self, json_data: dict) -> None:
+        self._data = json_data
+
+        if isinstance(self._ATTRIBUTES, set):
+            for name in self._ATTRIBUTES:
+                setattr(self, name, self._data.get(name, None))
+        elif isinstance(self._ATTRIBUTES, dict):
+            for key, attributes in self._ATTRIBUTES.items():
+                if isinstance(attributes, set):
+                    for name in attributes:
+                        try:
+                            setattr(self, name, self._data.get(key).get(name, None))
+                        except:
+                            setattr(self, name, None)
+
+        if isinstance(self._DATA, dict):
+            for name, data_class in self._DATA.items():
+                try:
+                    setattr(self, name, [data_class(data) for data in self._data])
+                except:
+                    setattr(self, name, None)
+        elif isinstance(self._OBJECTS, dict):
+            for name, data_class in self._OBJECTS.items():
+                try:
+                    setattr(self, name, [data_class(data) for data in self._data.get(name)])
+                except:
+                    setattr(self, name, None)
+
+
+class IModel:
+    """
+    Class for storing parameters and models
+    """
+
+    _ATTRIBUTES: set[str] | dict[str, set[str]] = None
+    """
+    Set of parameters that also can be stored one key deep
+
+    Example:
+        _ATTRIBUTES = {"beatmap_id", "score_id"}
+
+        _ATTRIBUTES = {"attributes": {"max_combo", "star_rating"}}
+    """
+
+    _OBJECTS: dict[str, type] = None
+    """
+    Dictionary with attributes and their models
+    
+    Example:
+        _OBJECTS = {"score": ScoreModel}
+    """
+
+    _data: dict | list[dict]
+    """
+    Initial data that was passed into object
+    """
+
+    def __init__(self, json_data: dict | list[dict]) -> None:
+        self._data = json_data
+
+        if isinstance(self._ATTRIBUTES, set):
+            for name in self._ATTRIBUTES:
+                setattr(self, name, self._data.get(name, None))
+        elif isinstance(self._ATTRIBUTES, dict):
+            for key, attributes in self._ATTRIBUTES.items():
+                if isinstance(attributes, set):
+                    for name in attributes:
+                        try:
+                            setattr(self, name, self._data.get(key).get(name, None))
+                        except:
+                            setattr(self, name, None)
+
+        if isinstance(self._OBJECTS, dict):
+            for name, data_class in self._OBJECTS.items():
+                try:
+                    setattr(self, name, data_class(self._data.get(name)))
+                except:
+                    setattr(self, name, None)
+
+
+class IValues:
+    """
+    Class for storing various parameters and values
+    """
+
+    _ATTRIBUTES: set[str] = None
+    """
+    Attributes that can be stored in this class
+
+    Example:
+        _ATTRIBUTES = {"settings", "path"}
+    """
+
+    def __init__(self, **kwargs) -> None:
+        for name in self._ATTRIBUTES:
+            setattr(self, name, kwargs.get(name, None))
+
+    def update(self, **kwargs) -> None:
+        self.__init__(**kwargs)

{pyquoks-1.2.2 → pyquoks-1.3.0}/src/pyquoks/utils.py

@@ -3,6 +3,10 @@ import sys, os
 
 
 def get_path(relative_path: str, only_abspath: bool = False) -> str:
+    """
+    :return: Absolute path for provided relative path
+    """
+
     try:
         # noinspection PyUnresolvedReferences
         base_path = sys._MEIPASS

{pyquoks-1.2.2 → pyquoks-1.3.0}/src/pyquoks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyquoks
-Version: 1.2.2
+Version: 1.3.0
 Summary: Пакет PyPI для часто используемых модулей в проектах diquoks
 Home-page: https://diquoks.ru
 Author: Denis Titovets
@@ -12,7 +12,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: blinker==1.9.0
-Requires-Dist: certifi==2025.8.3
+Requires-Dist: certifi==2025.10.5
 Requires-Dist: charset-normalizer==3.4.3
 Requires-Dist: click==8.3.0
 Requires-Dist: colorama==0.4.6
@@ -20,7 +20,7 @@ Requires-Dist: Flask==3.1.2
 Requires-Dist: idna==3.10
 Requires-Dist: itsdangerous==2.2.0
 Requires-Dist: Jinja2==3.1.6
-Requires-Dist: MarkupSafe==3.0.2
+Requires-Dist: MarkupSafe==3.0.3
 Requires-Dist: pillow==11.3.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: urllib3==2.5.0

{pyquoks-1.2.2 → pyquoks-1.3.0}/src/pyquoks.egg-info/requires.txt

@@ -1,5 +1,5 @@
 blinker==1.9.0
-certifi==2025.8.3
+certifi==2025.10.5
 charset-normalizer==3.4.3
 click==8.3.0
 colorama==0.4.6
@@ -7,7 +7,7 @@ Flask==3.1.2
 idna==3.10
 itsdangerous==2.2.0
 Jinja2==3.1.6
-MarkupSafe==3.0.2
+MarkupSafe==3.0.3
 pillow==11.3.0
 requests==2.32.5
 urllib3==2.5.0

pyquoks-1.2.2/src/pyquoks/data.py

@@ -1,211 +0,0 @@
-from __future__ import annotations
-import configparser, datetime, logging, json, sys, io, os
-import requests, PIL.Image, PIL.ImageDraw
-from . import utils
-
-
-# Providers
-class IDataProvider:
-    _PATH: str
-    _DATA_VALUES: dict[str, type]
-
-    def __init__(self) -> None:
-        for k, v in self._DATA_VALUES.items():
-            try:
-                with open(self._PATH.format(k), "rb") as file:
-                    setattr(self, k, v(json_data=json.loads(file.read())))
-            except:
-                setattr(self, k, None)
-
-
-class IConfigProvider:
-    class IConfig:
-        _SECTION: str = None
-        _CONFIG_VALUES: dict[str, type]
-
-        def __init__(self, parent: IConfigProvider = None) -> None:
-            if isinstance(parent, IConfigProvider):
-                self._CONFIG_VALUES = parent._CONFIG_VALUES.get(self._SECTION)
-                self._incorrect_content_exception = configparser.ParsingError("config.ini is filled incorrectly!")
-                self._config = configparser.ConfigParser()
-                self._config.read(utils.get_path("config.ini"))
-                if not self._config.has_section(self._SECTION):
-                    self._config.add_section(self._SECTION)
-                for k, v in self._CONFIG_VALUES.items():
-                    try:
-                        setattr(self, k, self._config.get(self._SECTION, k))
-                    except:
-                        self._config.set(self._SECTION, k, v.__name__)
-                        with open(utils.get_path("config.ini"), "w", encoding="utf-8") as file:
-                            self._config.write(fp=file)
-                for k, v in self._CONFIG_VALUES.items():
-                    try:
-                        if v == int:
-                            setattr(self, k, int(getattr(self, k)))
-                        elif v == bool:
-                            if getattr(self, k) not in (str(True), str(False)):
-                                setattr(self, k, None)
-                                raise self._incorrect_content_exception
-                            else:
-                                setattr(self, k, getattr(self, k) == str(True))
-                        elif v in (dict, list):
-                            setattr(self, k, json.loads(getattr(self, k)))
-                    except:
-                        setattr(self, k, None)
-                        raise self._incorrect_content_exception
-                if not self.values:
-                    raise self._incorrect_content_exception
-
-        @property
-        def values(self) -> dict | None:
-            try:
-                return {i: getattr(self, i) for i in self._CONFIG_VALUES}
-            except:
-                return None
-
-    _CONFIG_VALUES: dict[str, dict[str, type]]
-    _CONFIG_OBJECTS: dict[str, type]
-
-    def __init__(self) -> None:
-        for k, v in self._CONFIG_OBJECTS.items():
-            setattr(self, k, v(self))
-
-
-class IAssetsProvider:
-    class IDirectory:
-        _PATH: str = None
-        _NAMES: set[str]
-
-        def __init__(self, parent: IAssetsProvider) -> None:
-            for i in self._NAMES:
-                setattr(self, i, parent.file_image(parent._PATH.format(self._PATH.format(i))))
-
-    class INetwork:
-        _URLS: dict[str, str]
-
-        def __init__(self, parent: IAssetsProvider) -> None:
-            for k, v in self._URLS:
-                setattr(self, k, parent.network_image(v))
-
-    _PATH: str
-    _ASSETS_OBJECTS: dict[str, type]
-
-    def __init__(self) -> None:
-        for k, v in self._ASSETS_OBJECTS.items():
-            setattr(self, k, v(self))
-
-    @staticmethod
-    def file_image(path: str) -> PIL.Image.Image:
-        with open(path, "rb") as file:
-            return PIL.Image.open(io.BytesIO(file.read()))
-
-    @staticmethod
-    def network_image(url: str) -> PIL.Image.Image:
-        return PIL.Image.open(io.BytesIO(requests.get(url).content))
-
-    @staticmethod
-    def round_corners(image: PIL.Image.Image, radius: int) -> PIL.Image.Image:
-        if image.mode != "RGB":
-            image = image.convert("RGB")
-        width, height = image.size
-        shape = PIL.Image.new("L", (radius * 2, radius * 2), 0)
-        alpha = PIL.Image.new("L", image.size, "white")
-        PIL.ImageDraw.Draw(shape).ellipse((0, 0, radius * 2, radius * 2), fill=255)
-        alpha.paste(shape.crop((0, 0, radius, radius)), (0, 0))
-        alpha.paste(shape.crop((0, radius, radius, radius * 2)), (0, height - radius))
-        alpha.paste(shape.crop((radius, 0, radius * 2, radius)), (width - radius, 0))
-        alpha.paste(shape.crop((radius, radius, radius * 2, radius * 2)), (width - radius, height - radius))
-        image.putalpha(alpha)
-        return image
-
-
-class IStringsProvider:
-    class IStrings:
-        pass
-
-    _STRINGS_OBJECTS: dict[str, type]
-
-    def __init__(self) -> None:
-        for k, v in self._STRINGS_OBJECTS.items():
-            setattr(self, k, v())
-
-
-# Managers
-if sys.platform == "win32":
-    import winreg
-
-
-    class IRegistryManager:
-        class IRegistry:
-            _NAME: str = None
-            _REGISTRY_VALUES: dict[str, int]
-
-            def __init__(self, parent: IRegistryManager = None) -> None:
-                if isinstance(parent, IRegistryManager):
-                    self._REGISTRY_VALUES = parent._REGISTRY_VALUES.get(self._NAME)
-                    self._path = winreg.CreateKey(parent._path, self._NAME)
-                    for i in self._REGISTRY_VALUES.keys():
-                        try:
-                            setattr(self, i, winreg.QueryValueEx(self._path, i)[int()])
-                        except:
-                            setattr(self, i, None)
-
-            @property
-            def values(self) -> dict | None:
-                try:
-                    return {i: getattr(self, i) for i in self._REGISTRY_VALUES}
-                except:
-                    return None
-
-            def refresh(self) -> IRegistryManager.IRegistry:
-                self.__init__()
-                return self
-
-            def update(self, **kwargs) -> None:
-                for k, v in kwargs.items():
-                    winreg.SetValueEx(self._path, k, None, self._REGISTRY_VALUES.get(k), v)
-                    setattr(self, k, v)
-
-        _KEY: str
-        _REGISTRY_VALUES: dict[str, dict[str, int]]
-        _REGISTRY_OBJECTS: dict[str, type]
-        _path: winreg.HKEYType
-
-        def __init__(self) -> None:
-            self._path = winreg.CreateKey(winreg.HKEY_CURRENT_USER, self._KEY)
-            for k, v in self._REGISTRY_OBJECTS.items():
-                setattr(self, k, v(self))
-
-        def refresh(self) -> IRegistryManager:
-            self.__init__()
-            return self
-
-
-# Services
-class LoggerService(logging.Logger):
-    def __init__(
-            self,
-            name: str, file_handling: bool = True,
-            filename: str = datetime.datetime.now().strftime("%d-%m-%y-%H-%M-%S"),
-            level: int = logging.NOTSET,
-            folder_name: str = "logs",
-    ) -> None:
-        super().__init__(name, level)
-        stream_handler = logging.StreamHandler(sys.stdout)
-        stream_handler.setFormatter(
-            logging.Formatter(fmt="$levelname $asctime $name - $message", datefmt="%d-%m-%y %H:%M:%S", style="$")
-        )
-        self.addHandler(stream_handler)
-        if file_handling:
-            os.makedirs(utils.get_path(folder_name, only_abspath=True), exist_ok=True)
-            file_handler = logging.FileHandler(
-                utils.get_path(f"{folder_name}/{filename}-{name}.log", only_abspath=True),
-                encoding="utf-8",
-            )
-            file_handler.setFormatter(
-                logging.Formatter(fmt="$levelname $asctime - $message", datefmt="%d-%m-%y %H:%M:%S", style="$"),
-            )
-            self.addHandler(file_handler)
-
-    def log_exception(self, e: Exception) -> None:
-        self.error(msg=e, exc_info=True)

pyquoks-1.2.2/src/pyquoks/localhost.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-import waitress, typing, flask
-
-
-class ILocalhostFlask(flask.Flask):
-    _RULES: dict[str, typing.Callable]
-
-    def __init__(self, import_name: str) -> None:
-        super().__init__(import_name)
-
-        for k, v in self._RULES.items():
-            self.add_url_rule(rule=k, view_func=v)
-
-    def serve(self, port: int) -> None:
-        waitress.serve(
-            app=self,
-            host="127.0.0.1",
-            port=port,
-        )

pyquoks-1.2.2/src/pyquoks/models.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-
-class IContainer:
-    _ATTRIBUTES: set[str] = None
-    _DATA: dict[str, type] = None
-    _OBJECTS: dict[str, type] = None
-    data: dict
-
-    def __init__(self, json_data: dict) -> None:
-        setattr(self, "data", json_data)
-        if isinstance(self._ATTRIBUTES, set):
-            for i in self._ATTRIBUTES:
-                setattr(self, i, self.data.get(i, None))
-        if isinstance(self._DATA, dict):
-            for k, v in self._DATA.items():
-                try:
-                    setattr(self, k, [v(i) for i in self.data])
-                except:
-                    setattr(self, k, None)
-        elif isinstance(self._OBJECTS, dict):
-            for k, v in self._OBJECTS.items():
-                try:
-                    setattr(self, k, [v(i) for i in self.data.get(k)])
-                except:
-                    setattr(self, k, None)
-
-
-class IModel:
-    _ATTRIBUTES: set[str] | dict[str, set[str]] = None
-    _OBJECTS: dict[str, type] = None
-    data: dict | list[dict]
-
-    def __init__(self, json_data: dict | list[dict]) -> None:
-        setattr(self, "data", json_data)
-        if isinstance(self._ATTRIBUTES, set):
-            for i in self._ATTRIBUTES:
-                setattr(self, i, self.data.get(i, None))
-        elif isinstance(self._ATTRIBUTES, dict):
-            for k, v in self._ATTRIBUTES.items():
-                if isinstance(v, set):
-                    for i in v:
-                        try:
-                            setattr(self, i, self.data.get(k).get(i, None))
-                        except:
-                            setattr(self, i, None)
-        if isinstance(self._OBJECTS, dict):
-            for k, v in self._OBJECTS.items():
-                try:
-                    setattr(self, k, v(self.data.get(k)))
-                except:
-                    setattr(self, k, None)
-
-
-class IValues:
-    _ATTRIBUTES: set[str] = None
-
-    def __init__(self, **kwargs) -> None:
-        for i in self._ATTRIBUTES:
-            setattr(self, i, kwargs.get(i, None))
-
-    def update(self, **kwargs) -> None:
-        self.__init__(**kwargs)