pyaterochka-api 0.1.6__py3-none-any.whl

pyaterochka_api/__init__.py

@@ -0,0 +1,3 @@
+from .manager import Pyaterochka
+
+__all__ = ['Pyaterochka']

pyaterochka_api/api.py

@@ -0,0 +1,251 @@
+import aiohttp
+from fake_useragent import UserAgent
+from enum import Enum
+import re
+from tqdm.asyncio import tqdm
+from camoufox import AsyncCamoufox
+
+
+class PyaterochkaAPI:
+    """
+    Класс для загрузки JSON/image и парсинга JavaScript-конфигураций из удаленного источника.
+    """
+
+    class Patterns(Enum):
+        JS = r'\s*let\s+n\s*=\s*({.*});\s*'              # let n = {...};
+        STR = r'(\w+)\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"'  # key: "value"
+        DICT = r'(\w+)\s*:\s*{(.*?)}'                    # key: {...}
+        LIST = r'(\w+)\s*:\s*\[([^\[\]]*(?:\[.*?\])*)\]' # key: [value]
+        FIND = r'\{.*?\}|\[.*?\]'                        # {} or []
+
+    def __init__(self, debug: bool = False, proxy: str = None, autoclose_browser: bool = False):
+        self._debug = debug
+        self._proxy = proxy
+        self._session = None
+        self._autoclose_browser = autoclose_browser
+        self._browser = None
+        self._bcontext = None
+
+    @property
+    def proxy(self) -> str | None:
+        return self._proxy if hasattr(self, '_proxy') else None
+
+    @proxy.setter
+    def proxy(self, value: str | None) -> None:
+        self._proxy = value
+    
+    async def fetch(self, url: str) -> tuple[bool, dict | None | str, str]:
+        """
+        Выполняет HTTP-запрос к указанному URL и возвращает результат.
+
+        :return: Кортеж (успех, данные или None).
+        """
+        if self._debug:
+            print(f"Requesting \"{url}\"...", flush=True)
+
+        async with self._session.get(url=url) as response:
+            if self._debug:
+                print(f"Response status: {response.status}", flush=True)
+
+            if response.status == 200:
+                if response.headers['content-type'] == 'application/json':
+                    output_response = response.json()
+                elif response.headers['content-type'] == 'image/jpeg':
+                    output_response = response.read()
+                else:
+                    output_response = response.text()
+
+                return True, await output_response, response.headers['content-type']
+            elif response.status == 403:
+                if self._debug:
+                    print("Anti-bot protection. Use Russia IP address and try again.", flush=True)
+                return False, None, ''
+            else:
+                if self._debug:
+                    print(f"Unexpected error: {response.status}", flush=True)
+                raise Exception(f"Response status: {response.status} (unknown error/status code)")
+
+    async def _parse_js(self, js_code: str) -> dict | None:
+        """
+        Парсит JavaScript-код и извлекает данные из переменной "n".
+
+        :param js_code: JS-код в виде строки.
+        :return: Распарсенные данные в виде словаря или None.
+        """
+        matches = re.finditer(self.Patterns.JS.value, js_code)
+        match_list = list(matches)
+
+        if self._debug:
+            print(f"Found matches {len(match_list)}")
+            progress_bar = tqdm(total=33, desc="Parsing JS", position=0)
+
+        async def parse_match(match: str) -> dict:
+            result = {}
+
+            if self._debug:
+                progress_bar.set_description("Parsing strings")
+
+            # Парсинг строк
+            string_matches = re.finditer(self.Patterns.STR.value, match)
+            for m in string_matches:
+                key, value = m.group(1), m.group(2)
+                result[key] = value.replace('\"', '"').replace('\\', '\\')
+
+            if self._debug:
+                progress_bar.update(1)
+                progress_bar.set_description("Parsing dictionaries")
+
+            # Парсинг словарей
+            dict_matches = re.finditer(self.Patterns.DICT.value, match)
+            for m in dict_matches:
+                key, value = m.group(1), m.group(2)
+                if not re.search(self.Patterns.STR.value, value):
+                    result[key] = await parse_match(value)
+
+            if self._debug:
+                progress_bar.update(1)
+                progress_bar.set_description("Parsing lists")
+
+            # Парсинг списков
+            list_matches = re.finditer(self.Patterns.LIST.value, match)
+            for m in list_matches:
+                key, value = m.group(1), m.group(2)
+                if not re.search(self.Patterns.STR.value, value):
+                    result[key] = [await parse_match(item.group(0)) for item in re.finditer(self.Patterns.FIND.value, value)]
+
+            if self._debug:
+                progress_bar.update(1)
+
+            return result
+
+        if match_list and len(match_list) >= 1:
+            if self._debug:
+                print("Starting to parse match")
+            result = await parse_match(match_list[1].group(0))
+            if self._debug:
+                progress_bar.close()
+            return result
+        else:
+            if self._debug:
+                progress_bar.close()
+            raise Exception("N variable in JS code not found")
+
+    async def download_config(self, config_url: str) -> dict | None:
+        """
+        Загружает и парсит JavaScript-конфигурацию с указанного URL.
+
+        :param config_url: URL для загрузки конфигурации.
+        :return: Распарсенные данные в виде словаря или None.
+        """
+        is_success, js_code, _response_type = await self.fetch(url=config_url)
+
+        if not is_success:
+            if self._debug:
+                print("Failed to fetch JS code")
+            return None
+        elif self._debug:
+            print("JS code fetched successfully")
+
+        return await self._parse_js(js_code=js_code)
+
+
+    async def _browser_fetch(self, url: str, selector: str, state: str = 'attached') -> dict:
+        if self._browser is None or self._bcontext is None:
+            await self._new_session(include_aiohttp=False, include_browser=True)
+
+        page = await self._bcontext.new_page()
+        await page.goto(url, wait_until='commit')
+        # Wait until the selector script tag appears
+        await page.wait_for_selector(selector=selector, state=state)
+        content = await page.content()
+        await page.close()
+
+        if self._autoclose_browser:
+            await self.close(include_aiohttp=False, include_browser=True)
+        return content
+
+    def _parse_proxy(self, proxy_str: str | None) -> dict | None:
+        if not proxy_str:
+            return None
+
+        # Example: user:pass@host:port or just host:port
+        match = re.match(
+            r'^(?:(?P<scheme>https?:\/\/))?(?:(?P<username>[^:@]+):(?P<password>[^@]+)@)?(?P<host>[^:]+):(?P<port>\d+)$',
+            proxy_str,
+        )
+
+        proxy_dict = {}
+        if not match:
+            proxy_dict['server'] = proxy_str
+            
+            if not proxy_str.startswith('http://') and not proxy_str.startswith('https://'):
+                proxy_dict['server'] = f"http://{proxy_str}"
+            
+            return proxy_dict
+        else:
+            match_dict = match.groupdict()
+            proxy_dict['server'] = f"{match_dict['scheme'] or 'http://'}{match_dict['host']}:{match_dict['port']}"
+            
+            for key in ['username', 'password']:
+                if match_dict[key]:
+                    proxy_dict[key] = match_dict[key]
+            
+            return proxy_dict
+
+    async def _new_session(self, include_aiohttp: bool = True, include_browser: bool = False) -> None:
+        await self.close(include_aiohttp=include_aiohttp, include_browser=include_browser)
+
+        if include_aiohttp:
+            args = {"headers": {"User-Agent": UserAgent().random}}
+            if self._proxy: args["proxy"] = self._proxy
+            self._session = aiohttp.ClientSession(**args)
+        
+            if self._debug: print(f"A new connection aiohttp has been opened. Proxy used: {args.get('proxy')}")
+
+        if include_browser:
+            self._browser = await AsyncCamoufox(headless=not self._debug, proxy=self._parse_proxy(self.proxy), geoip=True).__aenter__()
+            self._bcontext = await self._browser.new_context()
+            
+            if self._debug: print(f"A new connection browser has been opened. Proxy used: {self.proxy}")
+
+    async def close(
+        self,
+        include_aiohttp: bool = True,
+        include_browser: bool = False
+    ) -> None:
+        """
+        Close the aiohttp session and/or Camoufox browser if they are open.
+        :param include_aiohttp: close aiohttp session if True
+        :param include_browser: close browser if True
+        """
+        to_close = []
+        if include_aiohttp:
+            to_close.append("session")
+        if include_browser:
+            to_close.append("bcontext")
+            to_close.append("browser")
+
+        if not to_close:
+            raise ValueError("No connections to close")
+
+        checks = {
+            "session": lambda a: a is not None and not a.closed,
+            "browser": lambda a: a is not None,
+            "bcontext": lambda a: a is not None
+        }
+
+        for name in to_close:
+            attr = getattr(self, f"_{name}", None)
+            if checks[name](attr):
+                if "browser" in name:
+                    await attr.__aexit__(None, None, None)
+                else:
+                    await attr.close()
+                setattr(self, f"_{name}", None)
+                if self._debug:
+                    print(f"The {name} connection was closed")
+            else:
+                if self._debug:
+                    print(f"The {name} connection was not open")
+
+

pyaterochka_api/manager.py

@@ -0,0 +1,232 @@
+from .api import PyaterochkaAPI
+from enum import Enum
+import re
+import json
+from io import BytesIO
+
+
+class Pyaterochka:
+    BASE_URL = "https://5ka.ru"
+    API_URL = "https://5d.5ka.ru/api"
+    HARDCODE_JS_CONFIG = "https://prod-cdn.5ka.ru/scripts/main.a0c039ea81eb8cf69492.js" # TODO сделать не хардкодным имя файла
+    DEFAULT_STORE_ID = "Y232"
+
+    class PurchaseMode(Enum):
+        STORE = "store"
+        DELIVERY = "delivery"
+
+    def __init__(self, debug: bool = False, proxy: str = None, autoclose_browser: bool = False):
+        self._debug = debug
+        self._proxy = proxy
+        self.api = PyaterochkaAPI(debug=self._debug, proxy=self._proxy, autoclose_browser=autoclose_browser)
+
+    def __enter__(self):
+        raise NotImplementedError("Use `async with Pyaterochka() as ...:`")
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def __aenter__(self):
+        await self.rebuild_connection(session=True)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def rebuild_connection(self, session: bool = True, browser: bool = False) -> None:
+        """
+        Rebuilds the connection to the Pyaterochka API.
+        Args:
+            session (bool, optional): Whether to create a new session (for all, except product_info). Defaults to True.
+            browser (bool, optional): Whether to create a new browser instance (for product_info). Defaults to False.
+        """
+        await self.api._new_session(session, browser)
+
+    async def close(self, session: bool = True, browser: bool = True) -> None:
+        """
+        Closes the connection to the Pyaterochka API.
+        Args:
+            session (bool, optional): Whether to close the session (for all, except product_info). Defaults to True.
+            browser (bool, optional): Whether to close the browser instance (for product_info). Defaults to True.
+        """
+        await self.api.close(include_aiohttp=session, include_browser=browser)
+
+    @property
+    def debug(self) -> bool:
+        """If True, it will print debug messages and disable headless in browser."""
+        return self._debug
+
+    @debug.setter
+    def debug(self, value: bool):
+        self._debug = value
+        self.api.debug = value
+
+    @property
+    def proxy(self) -> str:
+        """Proxy for requests. If None, it will be used without proxy."""
+        return self._proxy
+
+    @proxy.setter
+    def proxy(self, value: str):
+        self._proxy = value
+        self.api.proxy = value
+    
+    @property
+    def autoclose_browser(self) -> bool:
+        """If True, the browser closes after each request, clearing all cookies and caches.
+        If you have more than one request and this function is enabled, the processing speed will be greatly affected! (all caches are recreated every time)"""
+        return self.api._autoclose_browser
+
+    @proxy.setter
+    def autoclose_browser(self, value: bool):
+        self.api._autoclose_browser = value
+
+
+    async def categories_list(
+            self,
+            subcategories: bool = False,
+            include_restrict: bool = True,
+            mode: PurchaseMode = PurchaseMode.STORE,
+            sap_code_store_id: str = DEFAULT_STORE_ID
+    ) -> dict | None:
+        f"""
+        Asynchronously retrieves a list of categories from the Pyaterochka API.
+
+        Args:
+            subcategories (bool, optional): Whether to include subcategories in the response. Defaults to False.
+            include_restrict (bool, optional): I DO NOT KNOW WHAT IS IT
+            mode (PurchaseMode, optional): The purchase mode to use. Defaults to PurchaseMode.STORE.
+            sap_code_store_id (str, optional): The store ID (official name in API is "sap_code") to use. Defaults to "{self.DEFAULT_STORE_ID}". This lib not support search ID stores.
+
+        Returns:
+            dict | None: A dictionary representing the categories list if the request is successful, None otherwise.
+
+        Raises:
+            Exception: If the response status is not 200 (OK) or 403 (Forbidden / Anti-bot).
+        """
+
+        request_url = f"{self.API_URL}/catalog/v2/stores/{sap_code_store_id}/categories?mode={mode.value}&include_restrict={include_restrict}&include_subcategories={1 if subcategories else 0}"
+        _is_success, response, _response_type = await self.api.fetch(url=request_url)
+        return response
+
+    async def products_list(
+            self,
+            category_id: int,
+            mode: PurchaseMode = PurchaseMode.STORE,
+            sap_code_store_id: str = DEFAULT_STORE_ID,
+            limit: int = 30
+    ) -> dict | None:
+        f"""
+        Asynchronously retrieves a list of products from the Pyaterochka API for a given category.
+
+        Args:
+            category_id (int): The ID of the category.
+            mode (PurchaseMode, optional): The purchase mode to use. Defaults to PurchaseMode.STORE.
+            sap_code_store_id (str, optional): The store ID (official name in API is "sap_code") to use. Defaults to "{self.DEFAULT_STORE_ID}". This lib not support search ID stores.
+            limit (int, optional): The maximum number of products to retrieve. Defaults to 30. Must be between 1 and 499.
+
+        Returns:
+            dict | None: A dictionary representing the products list if the request is successful, None otherwise.
+
+        Raises:
+            ValueError: If the limit is not between 1 and 499.
+            Exception: If the response status is not 200 (OK) or 403 (Forbidden / Anti-bot).
+        """
+
+        if limit < 1 or limit >= 500:
+            raise ValueError("Limit must be between 1 and 499")
+
+        request_url = f"{self.API_URL}/catalog/v2/stores/{sap_code_store_id}/categories/{category_id}/products?mode={mode.value}&limit={limit}"
+        _is_success, response, _response_type = await self.api.fetch(url=request_url)
+        return response
+
+    async def product_info(self, plu_id: int) -> dict:
+        """
+        Asynchronously retrieves product information from the Pyaterochka API for a given PLU ID. Average time processing 2 seconds (first start 6 seconds).
+        Args:
+            plu_id (int): The PLU ID of the product.
+        Returns:
+            dict: A dictionary representing the product information.
+        Raises:
+            ValueError: If the response does not contain the expected JSON data.
+        """
+
+        url = f"{self.BASE_URL}/product/{plu_id}/"
+        response = await self.api._browser_fetch(url=url, selector='script#__NEXT_DATA__[type="application/json"]')
+
+        match = re.search(
+            r'<script\s+id="__NEXT_DATA__"\s+type="application/json">(.+?)</script>',
+            response,
+            flags=re.DOTALL
+        )
+        if not match:
+            raise ValueError("product_info: Failed to find JSON data in the response")
+        json_text = match.group(1)
+        data = json.loads(json_text)
+        data["props"]["pageProps"]["props"]["productStore"] = json.loads(data["props"]["pageProps"]["props"]["productStore"])
+        data["props"]["pageProps"]["props"]["catalogStore"] = json.loads(data["props"]["pageProps"]["props"]["catalogStore"])
+        data["props"]["pageProps"]["props"]["filtersPageStore"] = json.loads(data["props"]["pageProps"]["props"]["filtersPageStore"])
+
+        return data
+    
+    async def get_news(self, limit: int = None) -> dict | None:
+        """
+        Asynchronously retrieves news from the Pyaterochka API.
+
+        Args:
+            limit (int, optional): The maximum number of news items to retrieve. Defaults to None.
+        
+        Returns:
+            dict | None: A dictionary representing the news if the request is successful, None otherwise.
+        """
+        url = f"{self.BASE_URL}/api/public/v1/news/"
+        if limit and limit > 0:
+            url += f"?limit={limit}"
+
+        _is_success, response, _response_type = await self.api.fetch(url=url)
+        
+        return response
+
+    async def find_store(self, longitude: float, latitude: float) -> dict | None:
+        """
+        Asynchronously finds the store associated with the given coordinates.
+
+        Args:
+            longitude (float): The longitude of the location.
+            latitude (float): The latitude of the location.
+
+        Returns:
+            dict | None: A dictionary representing the store information if the request is successful, None otherwise.
+        """
+
+        request_url = f"{self.API_URL}/orders/v1/orders/stores/?lon={longitude}&lat={latitude}"
+        _is_success, response, _response_type = await self.api.fetch(url=request_url)
+        return response
+
+    async def download_image(self, url: str) -> BytesIO | None:
+        is_success, image_data, response_type = await self.api.fetch(url=url)
+
+        if not is_success:
+            if self.debug:
+                print("Failed to fetch image")
+            return None
+        elif self.debug:
+            print("Image fetched successfully")
+
+        image = BytesIO(image_data)
+        image.name = f'{url.split("/")[-1]}.{response_type.split("/")[-1]}'
+
+        return image
+
+    async def get_config(self) -> list | None:
+        """
+        Asynchronously retrieves the configuration from the hardcoded JavaScript file.
+
+        Args:
+            debug (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            list | None: A list representing the configuration if the request is successful, None otherwise.
+        """
+
+        return await self.api.download_config(config_url=self.HARDCODE_JS_CONFIG)

pyaterochka_api-0.1.6.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: pyaterochka_api
+Version: 0.1.6
+Summary: A Python API client for Pyaterochka store catalog
+Home-page: https://github.com/Open-Inflation/pyaterochka_api
+Author: Miskler
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: camoufox[geoip]
+Requires-Dist: fake-useragent
+Requires-Dist: tqdm
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-asyncio; extra == "tests"
+Requires-Dist: snapshottest~=1.0.0a1; extra == "tests"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Pyaterochka API *(not official / не официальный)*
+
+Pyaterochka (Пятёрочка) - https://5ka.ru/
+
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyaterochka_api)
+![PyPI - Package Version](https://img.shields.io/pypi/v/pyaterochka_api?color=blue)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/pyaterochka_api?label=PyPi%20downloads)](https://pypi.org/project/pyaterochka-api/)
+[![Discord](https://img.shields.io/discord/792572437292253224?label=Discord&labelColor=%232c2f33&color=%237289da)](https://discord.gg/UnJnGHNbBp)
+[![Telegram](https://img.shields.io/badge/Telegram-24A1DE)](https://t.me/miskler_dev)
+
+
+
+## Installation / Установка:
+1. Install package / Установка пакета:
+```bash
+pip install pyaterochka_api
+```
+2. ***Debian/Ubuntu Linux***: Install dependencies / Установка зависимостей:
+```bash
+sudo apt update && sudo apt install -y libgtk-3-0 libx11-xcb1
+```
+3. Install browser / Установка браузера:
+```bash
+camoufox fetch
+```
+
+### Usage / Использование:
+```py
+from pyaterochka_api import Pyaterochka
+import asyncio
+
+
+async def main():
+    async with Pyaterochka(proxy="user:password@host:port", debug=False, autoclose_browser=False) as API:
+        # RUS: Вводим геоточку (самого магазина или рядом с ним) и получаем инфу о магазине
+        # ENG: Enter a geolocation (of the store or near it) and get info about the store
+        find_store = await API.find_store(longitude=37.63156, latitude=55.73768)
+        print(f"Store info output: {find_store!s:.100s}...\n")
+
+        # RUS: Выводит список всех категорий на сайте
+        # ENG: Outputs a list of all categories on the site
+        catalog = await API.categories_list(subcategories=True, mode=API.PurchaseMode.DELIVERY)
+        print(f"Categories list output: {catalog!s:.100s}...\n")
+
+        # RUS: Выводит список всех товаров выбранной категории (ограничение 100 элементов, если превышает - запрашивайте через дополнительные страницы)
+        # ENG: Outputs a list of all items in the selected category (limiting to 100 elements, if exceeds - request through additional pages)
+        # Страниц не сущетвует, использовать желаемый лимит (до 499) / Pages do not exist, use the desired limit (up to 499)
+        items = await API.products_list(catalog[0]['id'], limit=5)
+        print(f"Items list output: {items!s:.100s}...\n")
+
+        # RUS: Выводит информацию о товаре (по его plu - id товара).
+        # Функция в первый раз достаточно долгая, порядка 5-9 секунды, последующие запросы около 2 секунд (если браузер не был закрыт)
+        # ENG: Outputs information about the product (by its plu - product id).
+        # The function is quite long the first time, about 5-9 seconds, subsequent requests take about 2 seconds (if the browser was not closed)
+        info = await API.product_info(43347)
+        print(f"Product output: {info["props"]["pageProps"]["props"]['productStore']!s:.100s}...\n")
+
+        # RUS: Влияет исключительно на функцию выше (product_info), если включено, то после отработки запроса браузер закроется и кеши очищаются.
+        # Не рекомендую включать, если вам все же нужно освободить память, лучше использовать API.close(session=False, browser=True)
+        # ENG: Affects only the function above (product_info), if enabled, the browser will close after the request is processed and caches are cleared.
+        # I do not recommend enabling it, if you still need to free up memory, it is better to use API.close(session=False, browser=True)
+        API.autoclose_browser = True
+
+        # RUS: Выводит список последних промо-акций/новостей (можно поставить ограничитель по количеству, опционально)
+        # ENG: Outputs a list of the latest promotions/news (you can set a limit on the number, optionally)
+        news = await API.get_news(limit=5)
+        print(f"News output: {news!s:.100s}...\n")
+
+        # RUS: Выводит основной конфиг сайта (очень долгая функция, рекомендую сохранять в файл и переиспользовать)
+        # ENG: Outputs the main config of the site (large function, recommend to save in a file and re-use it)
+        print(f"Main config: {await API.get_config()!s:.100s}...\n")
+
+        # RUS: Если требуется, можно настроить вывод логов в консоль
+        # ENG: If required, you can configure the output of logs in the console
+        API.debug = True
+
+        # RUS: Скачивает картинку товара (возвращает BytesIO или None)
+        # ENG: Downloads the product image (returns BytesIO or None)
+        image = await API.download_image(url=items['products'][0]['image_links']['normal'][0])
+        with open(image.name, 'wb') as f:
+            f.write(image.getbuffer())
+
+        # RUS: Так же как и debug, в рантайме можно переназначить прокси
+        # ENG: As with debug, you can reassign the proxy in runtime
+        API.proxy = "user:password@host:port"
+        # RUS: Чтобы применить изменения, нужно пересоздать подключение (session - aiohttp отвечающее за все, кроме product_info, за него browser)
+        # ENG: To apply changes, you need rebuild connection (session - aiohttp responsible for everything except product_info, for it browser)
+        await API.rebuild_connection()
+        await API.categories_list()
+
+
+if __name__ == '__main__':
+    asyncio.run(main())
+```
+
+### Report / Обратная связь
+
+If you have any problems using it /suggestions, do not hesitate to write to the [project's GitHub](https://github.com/Open-Inflation/pyaterochka_api/issues)!
+
+Если у вас возникнут проблемы в использовании / пожелания, не стесняйтесь писать на [GitHub проекта](https://github.com/Open-Inflation/pyaterochka_api/issues)!

pyaterochka_api-0.1.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyaterochka_api/__init__.py,sha256=s91K-ZPzFZkk93AY_BtXwhpSxZpO1IHi1a3RThd1jtM,60
+pyaterochka_api/api.py,sha256=DHEbtxniZaFnlYUAit3fGBr9dn7wreawjBa1G6huCXU,9829
+pyaterochka_api/manager.py,sha256=7jiGFMT344iklGSifbjNWeBCkeG9HNqQ3V-D0Gc__pA,9603
+pyaterochka_api-0.1.6.dist-info/licenses/LICENSE,sha256=Ee_P5XQUYoJuffzRL24j4GWpqgoWphUOKswpB2f9HcQ,1071
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/base_tests.py,sha256=l_qweYyxL507nRv-SteZdrU-yHONDZQxJfyOSi8pmzw,2576
+tests/snapshots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/snapshots/snap_base_tests.py,sha256=0Vc6Vjm8rLyPVbSRUu2xX8XVOEtU_pns2-oJE-EETyQ,27182
+pyaterochka_api-0.1.6.dist-info/METADATA,sha256=ksmYPe29fLKlxRIjVXkXZgcV5a4RbK4pkSV0G_T-3nk,8098
+pyaterochka_api-0.1.6.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+pyaterochka_api-0.1.6.dist-info/top_level.txt,sha256=PXTSi8y2C5_Mz20pJJFqOUBnjAIAXP_cc38mthvJ2x4,22
+pyaterochka_api-0.1.6.dist-info/RECORD,,

pyaterochka_api-0.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyaterochka_api-0.1.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Open Inflation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyaterochka_api-0.1.6.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pyaterochka_api
+tests