pyquoks 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

pyquoks/data.py

@@ -1,211 +1,522 @@
 from __future__ import annotations
-import configparser, datetime, logging, json, sys, io, os
+import configparser, datetime, logging, sqlite3, json, sys, io, os
 import requests, PIL.Image, PIL.ImageDraw
 from . import utils
 
 
-# Providers
+# region Providers
+
 class IDataProvider:
-    _PATH: str
+    """
+    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 k, v in self._DATA_VALUES.items():
+        for filename, container 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())))
+                with open(self._PATH + self._FILENAME.format(filename), "rb") as file:
+                    setattr(self, filename, container(json.loads(file.read())))
             except:
-                setattr(self, k, None)
+                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("config.ini is filled incorrectly!")
+
+                self._incorrect_content_exception = configparser.ParsingError(
+                    "configuration file is filled incorrectly!"
+                )
                 self._config = configparser.ConfigParser()
-                self._config.read(utils.get_path("config.ini"))
+                self._config.read(parent._PATH)
+
                 if not self._config.has_section(self._SECTION):
                     self._config.add_section(self._SECTION)
-                for k, v in self._CONFIG_VALUES.items():
+
+                for setting, data_type in self._CONFIG_VALUES.items():
                     try:
-                        setattr(self, k, self._config.get(self._SECTION, k))
+                        setattr(self, setting, self._config.get(self._SECTION, setting))
                     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():
+                        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:
-                        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)))
+                        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, k, None)
+                        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 {i: getattr(self, i) for i in self._CONFIG_VALUES}
+                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 k, v in self._CONFIG_OBJECTS.items():
-            setattr(self, k, v(self))
+        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:
-            for i in self._NAMES:
-                setattr(self, i, parent.file_image(parent._PATH.format(self._PATH.format(i))))
+            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:
-            for k, v in self._URLS:
-                setattr(self, k, parent.network_image(v))
+            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
+    """
 
-    _PATH: str
     _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 k, v in self._ASSETS_OBJECTS.items():
-            setattr(self, k, v(self))
+        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)
-        alpha = PIL.Image.new("L", image.size, "white")
         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:
-        for k, v in self._STRINGS_OBJECTS.items():
-            setattr(self, k, v())
+        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()
 
 
-# Managers
 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 i in self._REGISTRY_VALUES.keys():
+
+                    for setting in self._REGISTRY_VALUES.keys():
                         try:
-                            setattr(self, i, winreg.QueryValueEx(self._path, i)[int()])
+                            setattr(self, setting, winreg.QueryValueEx(self._path, setting)[int()])
                         except:
-                            setattr(self, i, None)
+                            setattr(self, setting, None)
 
             @property
             def values(self) -> dict | None:
+                """
+                :return: Values stored in key in the Windows Registry
+                """
+
                 try:
-                    return {i: getattr(self, i) for i in self._REGISTRY_VALUES}
+                    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:
-                for k, v in kwargs.items():
-                    winreg.SetValueEx(self._path, k, None, self._REGISTRY_VALUES.get(k), v)
-                    setattr(self, k, v)
+                """
+                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 k, v in self._REGISTRY_OBJECTS.items():
-                setattr(self, k, v(self))
+
+            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
 
 
-# Services
+# 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,
-            folder_name: str = "logs",
+            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="$")
+            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)
+            os.makedirs(path, exist_ok=True)
+
             file_handler = logging.FileHandler(
-                utils.get_path(f"{folder_name}/{filename}-{name}.log", only_abspath=True),
+                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="$"),
+                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/localhost.py

@@ -1,17 +1,35 @@
 from __future__ import annotations
-import waitress, typing, flask
+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 k, v in self._RULES.items():
-            self.add_url_rule(rule=k, view_func=v)
+        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",

pyquoks/models.py

@@ -2,62 +2,137 @@ from __future__ import annotations
 
 
 class IContainer:
-    _ATTRIBUTES: set[str] = None
+    """
+    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
-    data: dict
+    """
+    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:
-        setattr(self, "data", json_data)
+        self._data = json_data
+
         if isinstance(self._ATTRIBUTES, set):
-            for i in self._ATTRIBUTES:
-                setattr(self, i, self.data.get(i, None))
+            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 k, v in self._DATA.items():
+            for name, data_class in self._DATA.items():
                 try:
-                    setattr(self, k, [v(i) for i in self.data])
+                    setattr(self, name, [data_class(data) for data in self._data])
                 except:
-                    setattr(self, k, None)
+                    setattr(self, name, None)
         elif isinstance(self._OBJECTS, dict):
-            for k, v in self._OBJECTS.items():
+            for name, data_class in self._OBJECTS.items():
                 try:
-                    setattr(self, k, [v(i) for i in self.data.get(k)])
+                    setattr(self, name, [data_class(data) for data in self._data.get(name)])
                 except:
-                    setattr(self, k, None)
+                    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
-    data: dict | list[dict]
+    """
+    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:
-        setattr(self, "data", json_data)
+        self._data = json_data
+
         if isinstance(self._ATTRIBUTES, set):
-            for i in self._ATTRIBUTES:
-                setattr(self, i, self.data.get(i, None))
+            for name in self._ATTRIBUTES:
+                setattr(self, name, self._data.get(name, None))
         elif isinstance(self._ATTRIBUTES, dict):
-            for k, v in self._ATTRIBUTES.items():
-                if isinstance(v, set):
-                    for i in v:
+            for key, attributes in self._ATTRIBUTES.items():
+                if isinstance(attributes, set):
+                    for name in attributes:
                         try:
-                            setattr(self, i, self.data.get(k).get(i, None))
+                            setattr(self, name, self._data.get(key).get(name, None))
                         except:
-                            setattr(self, i, None)
+                            setattr(self, name, None)
+
         if isinstance(self._OBJECTS, dict):
-            for k, v in self._OBJECTS.items():
+            for name, data_class in self._OBJECTS.items():
                 try:
-                    setattr(self, k, v(self.data.get(k)))
+                    setattr(self, name, data_class(self._data.get(name)))
                 except:
-                    setattr(self, k, None)
+                    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 i in self._ATTRIBUTES:
-            setattr(self, i, kwargs.get(i, None))
+        for name in self._ATTRIBUTES:
+            setattr(self, name, kwargs.get(name, None))
 
     def update(self, **kwargs) -> None:
         self.__init__(**kwargs)

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.dist-info → pyquoks-1.3.0.dist-info}/METADATA

@@ -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.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyquoks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyquoks/data.py,sha256=5PkERLBiNmuEYy8mYTe2AWUUEPt3lAtH5tG9TlyBl4w,15399
+pyquoks/localhost.py,sha256=2sl1CovYrnIzBYW-eKDIYOfi5bUsSVTAdQobzAHpIys,828
+pyquoks/models.py,sha256=kdduuHgh8RLe8_S5Lmv3jS6hqsZG-oYQhPTgk2C11ug,4171
+pyquoks/utils.py,sha256=lcHZyIFIflGMqAhDkqm8GWOUFwb2f-IHgIPZxEiHBz0,484
+pyquoks-1.3.0.dist-info/licenses/LICENSE,sha256=eEd8UIYxvKUY7vqrV1XTFo70_FQdiW6o1fznseCXRJs,1095
+pyquoks-1.3.0.dist-info/METADATA,sha256=sCQPZSFYT7zfM4hFygVOeCWHXz1QEt7i9oOzhmKGNgw,1802
+pyquoks-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyquoks-1.3.0.dist-info/top_level.txt,sha256=4Eqn44TCCp-D8V6To92e8-KKr49ZGf0dCcsdRQmPkhc,8
+pyquoks-1.3.0.dist-info/RECORD,,

pyquoks-1.2.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-pyquoks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyquoks/data.py,sha256=S74VxkQtTQipfa1Z7LYiU5RTWSxhnGNhbtv0PB3glf4,8124
-pyquoks/localhost.py,sha256=mu55k4d1AZJ77IwavvOEEz9m3fNI6s_q97MSb90vy2Y,494
-pyquoks/models.py,sha256=_2mxn7nBZzm8jALJSKcFHal06RGh2whHYp7De-bBxqk,2187
-pyquoks/utils.py,sha256=5WswiChwsjJK3IWADizh_JnW0hmIP4PJQyXmhNlPExs,409
-pyquoks-1.2.2.dist-info/licenses/LICENSE,sha256=eEd8UIYxvKUY7vqrV1XTFo70_FQdiW6o1fznseCXRJs,1095
-pyquoks-1.2.2.dist-info/METADATA,sha256=Kx5JgLsBKQT4nAjuySiVNUiW2PObgh5H7isZZCwpykA,1801
-pyquoks-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyquoks-1.2.2.dist-info/top_level.txt,sha256=4Eqn44TCCp-D8V6To92e8-KKr49ZGf0dCcsdRQmPkhc,8
-pyquoks-1.2.2.dist-info/RECORD,,