pyaterochka-api 0.1.7__tar.gz → 0.1.8__tar.gz

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyaterochka_api
-Version: 0.1.7
+Version: 0.1.8
 Summary: A Python API client for Pyaterochka store catalog
 Home-page: https://github.com/Open-Inflation/pyaterochka_api
 Author: Miskler
@@ -69,7 +69,7 @@ camoufox fetch
 
 ### Usage / Использование:
 ```py
-from pyaterochka_api import Pyaterochka
+from pyaterochka_api import Pyaterochka, PurchaseMode
 import asyncio
 
 

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/README.md

@@ -27,7 +27,7 @@ camoufox fetch
 
 ### Usage / Использование:
 ```py
-from pyaterochka_api import Pyaterochka
+from pyaterochka_api import Pyaterochka, PurchaseMode
 import asyncio
 
 

pyaterochka_api-0.1.8/pyaterochka_api/__init__.py

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

pyaterochka_api-0.1.8/pyaterochka_api/api.py

@@ -0,0 +1,180 @@
+import aiohttp
+from fake_useragent import UserAgent
+from camoufox import AsyncCamoufox
+import logging
+from .tools import parse_proxy, parse_js, get_env_proxy
+
+
+class PyaterochkaAPI:
+    """
+    Класс для загрузки JSON/image и парсинга JavaScript-конфигураций из удаленного источника.
+    """
+
+    def __init__(self,
+                 debug:             bool       = False,
+                 proxy:             str | None = None,
+                 autoclose_browser: bool       = False,
+                 trust_env:         bool       = False,
+                 timeout:           float      = 10.0
+        ):
+        self._debug = debug
+        self._proxy = proxy
+        self._session = None
+        self._autoclose_browser = autoclose_browser
+        self._browser = None
+        self._bcontext = None
+        self._trust_env = trust_env
+        self._timeout = timeout
+
+        self._logger = logging.getLogger(self.__class__.__name__)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('[%(asctime)s] %(levelname)s %(name)s: %(message)s')
+        handler.setFormatter(formatter)
+        if not self._logger.hasHandlers():
+            self._logger.addHandler(handler)
+
+    async def fetch(self, url: str) -> tuple[bool, dict | None | str, str]:
+        """
+        Выполняет HTTP-запрос к указанному URL и возвращает результат.
+
+        :return: Кортеж (успех, данные или None, тип данных или пустота).
+        """
+        args = {'url': url, 'timeout': aiohttp.ClientTimeout(total=self._timeout)}
+        if self._proxy: args["proxy"] = self._proxy
+
+        self._logger.info(f'Requesting "{url}" with proxy: "{args.get("proxy") or ("SYSTEM_PROXY" if get_env_proxy() else "WITHOUT")}", timeout: {self._timeout}...')
+        
+        async with self._session.get(**args) as response:
+            self._logger.info(f'Response status: {response.status}')
+
+            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:
+                self._logger.warning('Anti-bot protection. Use Russia IP address and try again.')
+                return False, None, ''
+            else:
+                self._logger.error(f'Unexpected error: {response.status}')
+                raise Exception(f"Response status: {response.status} (unknown error/status code)")
+
+    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:
+                self._logger.error('Failed to fetch JS code')
+            return None
+        elif self._debug:
+            self._logger.debug('JS code fetched successfully')
+
+        return await parse_js(js_code=js_code, debug=self._debug, logger=self._logger)
+
+
+    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', timeout=self._timeout * 1000)
+        # Wait until the selector script tag appears
+        await page.wait_for_selector(selector=selector, state=state, timeout=self._timeout * 1000)
+        content = await page.content()
+        await page.close()
+
+        if self._autoclose_browser:
+            await self.close(include_aiohttp=False, include_browser=True)
+        return content
+
+    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,
+                    "Accept": "application/json, text/plain, */*",
+                    "Accept-Language": "en-GB,en;q=0.5",
+                    "Accept-Encoding": "gzip, deflate, br, zstd",
+                    "X-PLATFORM": "webapp",
+                    "Origin": "https://5ka.ru",
+                    "Connection": "keep-alive",
+                    "Sec-Fetch-Dest": "empty",
+                    "Sec-Fetch-Mode": "cors",
+                    "Sec-Fetch-Site": "same-site",
+                    "Pragma": "no-cache",
+                    "Cache-Control": "no-cache",
+                    "TE": "trailers",
+                },
+                "trust_env": self._trust_env,
+            }
+            self._session = aiohttp.ClientSession(**args)
+            self._logger.info(f"A new aiohttp connection has been opened. trust_env: {args.get('trust_env')}")
+
+        if include_browser:
+            prox = parse_proxy(self._proxy, self._trust_env, self._logger)
+            self._logger.info(f"Opening new browser connection with proxy: {'SYSTEM_PROXY' if prox and not self._proxy else prox}")
+            self._browser = await AsyncCamoufox(headless=not self._debug, proxy=prox, geoip=True).__aenter__()
+            self._bcontext = await self._browser.new_context()
+            self._logger.info(f"A new browser context has been opened.")
+
+    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")
+
+        self._logger.info(f"Preparing to close: {to_close if to_close else 'nothing'}")
+
+        if not to_close:
+            self._logger.warning("No connections to close")
+            return
+
+        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):
+                self._logger.info(f"Closing {name} connection...")
+                try:
+                    if name == "browser":
+                        await attr.__aexit__(None, None, None)
+                    elif name in ["bcontext", "session"]:
+                        await attr.close()
+                    else:
+                        raise ValueError(f"Unknown connection type: {name}")
+                    
+                    setattr(self, f"_{name}", None)
+                    self._logger.info(f"The {name} connection was closed")
+                except Exception as e:
+                    self._logger.error(f"Error closing {name}: {e}")
+            else:
+                self._logger.warning(f"The {name} connection was not open")
+
+

pyaterochka_api-0.1.8/pyaterochka_api/enums.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+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 []
+    # http(s)://user:pass@host:port
+    PROXY = r'^(?:(?P<scheme>https?:\/\/))?(?:(?P<username>[^:@]+):(?P<password>[^@]+)@)?(?P<host>[^:\/]+)(?::(?P<port>\d+))?$'
+
+class PurchaseMode(Enum):
+    STORE    = "store"
+    DELIVERY = "delivery"

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/pyaterochka_api/manager.py

@@ -4,23 +4,24 @@ import re
 import json
 from io import BytesIO
 from beartype import beartype
+from .enums import PurchaseMode
 
 
 class Pyaterochka:
-    BASE_URL = "https://5ka.ru"
-    API_URL = "https://5d.5ka.ru/api"
+    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"
+    DEFAULT_STORE_ID   = "Y232"
 
     @beartype
-    def __init__(self, debug: bool = False, proxy: str = None, autoclose_browser: bool = False, trust_env: bool = False, timeout: int = 10):
-        self._debug = debug
-        self._proxy = proxy
-        self.api = PyaterochkaAPI(debug=self._debug, proxy=self._proxy, autoclose_browser=autoclose_browser, trust_env=trust_env, timeout=timeout)
+    def __init__(self, debug: bool = False, proxy: str | None = None, autoclose_browser: bool = False, trust_env: bool = False, timeout: float = 10.0):
+        self.api = PyaterochkaAPI()
+        
+        self.debug = debug
+        self.proxy = proxy
+        self.autoclose_browser = autoclose_browser
+        self.trust_env = trust_env
+        self.timeout = timeout
 
     @beartype
     def __enter__(self):
@@ -47,7 +48,7 @@ class Pyaterochka:
             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)
+        await self.api.new_session(session, browser)
 
     @beartype
     async def close(self, session: bool = True, browser: bool = True) -> None:
@@ -63,25 +64,23 @@ class Pyaterochka:
     @beartype
     def debug(self) -> bool:
         """If True, it will print debug messages and disable headless in browser."""
-        return self._debug
+        return self.api._debug
 
     @debug.setter
     @beartype
     def debug(self, value: bool):
-        self._debug = value
-        self.api.debug = value
+        self.api._debug = value
 
     @property
     @beartype
-    def proxy(self) -> str:
+    def proxy(self) -> str | None:
         """Proxy for requests. If None, it will be used without proxy."""
-        return self._proxy
+        return self.api._proxy
 
     @proxy.setter
     @beartype
-    def proxy(self, value: str):
-        self._proxy = value
-        self.api.proxy = value
+    def proxy(self, value: str | None):
+        self.api._proxy = value
     
     @property
     @beartype
@@ -108,13 +107,13 @@ class Pyaterochka:
     
     @property
     @beartype
-    def timeout(self) -> int:
+    def timeout(self) -> float:
         """Timeout value for the API requests."""
         return self.api._timeout
 
-    @trust_env.setter
+    @timeout.setter
     @beartype
-    def timeout(self, value: int):
+    def timeout(self, value: float):
         if value <= 0:
             raise ValueError("Timeout must be greater than 0")
 
@@ -127,7 +126,7 @@ class Pyaterochka:
             include_restrict: bool = True,
             mode: PurchaseMode = PurchaseMode.STORE,
             sap_code_store_id: str = DEFAULT_STORE_ID
-    ) -> list[dict] | None:
+    ) -> list[dict]:
         f"""
         Asynchronously retrieves a list of categories from the Pyaterochka API.
 
@@ -138,7 +137,7 @@ class Pyaterochka:
             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.
+            list[dict]: A dictionary representing the categories list if the request is successful, error otherwise.
 
         Raises:
             Exception: If the response status is not 200 (OK) or 403 (Forbidden / Anti-bot).
@@ -155,7 +154,7 @@ class Pyaterochka:
             mode: PurchaseMode = PurchaseMode.STORE,
             sap_code_store_id: str = DEFAULT_STORE_ID,
             limit: int = 30
-    ) -> dict | None:
+    ) -> dict:
         f"""
         Asynchronously retrieves a list of products from the Pyaterochka API for a given category.
 
@@ -166,7 +165,7 @@ class Pyaterochka:
             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.
+            dict: A dictionary representing the products list if the request is successful, error otherwise.
 
         Raises:
             ValueError: If the limit is not between 1 and 499.
@@ -184,6 +183,7 @@ class Pyaterochka:
     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:
@@ -193,7 +193,7 @@ class Pyaterochka:
         """
 
         url = f"{self.BASE_URL}/product/{plu_id}/"
-        response = await self.api._browser_fetch(url=url, selector='script#__NEXT_DATA__[type="application/json"]')
+        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>',
@@ -211,7 +211,7 @@ class Pyaterochka:
         return data
     
     @beartype
-    async def get_news(self, limit: int = None) -> dict | None:
+    async def get_news(self, limit: int | None = None) -> dict:
         """
         Asynchronously retrieves news from the Pyaterochka API.
 
@@ -219,7 +219,7 @@ class Pyaterochka:
             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.
+            dict: A dictionary representing the news if the request is successful, error otherwise.
         """
         url = f"{self.BASE_URL}/api/public/v1/news/"
         if limit and limit > 0:
@@ -230,7 +230,7 @@ class Pyaterochka:
         return response
 
     @beartype
-    async def find_store(self, longitude: float, latitude: float) -> dict | None:
+    async def find_store(self, longitude: float, latitude: float) -> dict:
         """
         Asynchronously finds the store associated with the given coordinates.
 
@@ -239,7 +239,7 @@ class Pyaterochka:
             latitude (float): The latitude of the location.
 
         Returns:
-            dict | None: A dictionary representing the store information if the request is successful, None otherwise.
+            dict: A dictionary representing the store information if the request is successful, error otherwise.
         """
 
         request_url = f"{self.API_URL}/orders/v1/orders/stores/?lon={longitude}&lat={latitude}"
@@ -247,15 +247,17 @@ class Pyaterochka:
         return response
 
     @beartype
-    async def download_image(self, url: str) -> BytesIO | None:
+    async def download_image(self, url: str) -> BytesIO:
         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")
+            self.api._logger.error("Failed to fetch image")
+            return
+        elif not isinstance(image_data, (bytes, bytearray)):
+            self.api._logger.error("Image data is not bytes")
+            return
+        
+        self.api._logger.debug("Image fetched successfully")
 
         image = BytesIO(image_data)
         image.name = f'{url.split("/")[-1]}.{response_type.split("/")[-1]}'
@@ -263,7 +265,7 @@ class Pyaterochka:
         return image
 
     @beartype
-    async def get_config(self) -> dict | None:
+    async def get_config(self) -> dict:
         """
         Asynchronously retrieves the configuration from the hardcoded JavaScript file.
 
@@ -271,7 +273,7 @@ class Pyaterochka:
             debug (bool, optional): Whether to print debug information. Defaults to False.
 
         Returns:
-            dict | None: A dictionary representing the configuration if the request is successful, None otherwise.
+            dict: A dictionary representing the configuration if the request is successful, error otherwise.
         """
 
         return await self.api.download_config(config_url=self.HARDCODE_JS_CONFIG)

pyaterochka_api-0.1.8/pyaterochka_api/tools.py

@@ -0,0 +1,121 @@
+from .enums import Patterns
+import os
+import re
+from tqdm import tqdm
+
+def get_env_proxy() -> str | None:
+    """
+    Получает прокси из переменных окружения.
+    :return: Прокси-строка или None.
+    """
+    proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy") or os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+    return proxy if proxy else None
+
+def parse_proxy(proxy_str: str | None, trust_env: bool, logger) -> dict | None:
+    logger.debug(f"Parsing proxy string: {proxy_str}")
+
+    if not proxy_str:
+        if trust_env:
+            logger.debug("Proxy string not provided, checking environment variables for HTTP(S)_PROXY")
+            proxy_str = get_env_proxy()
+        
+        if not proxy_str:
+            logger.info("No proxy string found, returning None")
+            return None
+        else:
+            logger.info(f"Proxy string found in environment variables")
+
+    # Example: user:pass@host:port or just host:port
+    match = re.match(Patterns.PROXY.value, proxy_str)
+    
+    proxy_dict = {}
+    if not match:
+        logger.warning(f"Proxy string did not match expected pattern, using basic formating")
+        proxy_dict['server'] = proxy_str
+        
+        if not proxy_str.startswith('http://') and not proxy_str.startswith('https://'):
+            logger.warning("Proxy string missing protocol, prepending 'http://'")
+            proxy_dict['server'] = f"http://{proxy_str}"
+        
+        logger.info(f"Proxy parsed as basic")
+        return proxy_dict
+    else:
+        match_dict = match.groupdict()
+        proxy_dict['server'] = f"{match_dict['scheme'] or 'http://'}{match_dict['host']}"
+        if match_dict['port']:
+            proxy_dict['server'] += f":{match_dict['port']}"
+        
+        for key in ['username', 'password']:
+            if match_dict[key]:
+                proxy_dict[key] = match_dict[key]
+        
+        logger.info(f"Proxy WITH{'OUT' if 'username' not in proxy_dict else ''} credentials")
+        
+        logger.info(f"Proxy parsed as regex")
+        return proxy_dict
+
+async def _parse_match(match: str, progress_bar: tqdm | None = None) -> dict:
+    result = {}
+
+    if progress_bar:
+        progress_bar.set_description("Parsing strings")
+
+    # Парсинг строк
+    string_matches = re.finditer(Patterns.STR.value, match)
+    for m in string_matches:
+        key, value = m.group(1), m.group(2)
+        result[key] = value.replace('\"', '"').replace('\\', '\\')
+
+    if progress_bar:
+        progress_bar.update(1)
+        progress_bar.set_description("Parsing dictionaries")
+
+    # Парсинг словарей
+    dict_matches = re.finditer(Patterns.DICT.value, match)
+    for m in dict_matches:
+        key, value = m.group(1), m.group(2)
+        if not re.search(Patterns.STR.value, value):
+            result[key] = await _parse_match(value, progress_bar)
+
+    if progress_bar:
+        progress_bar.update(1)
+        progress_bar.set_description("Parsing lists")
+
+    # Парсинг списков
+    list_matches = re.finditer(Patterns.LIST.value, match)
+    for m in list_matches:
+        key, value = m.group(1), m.group(2)
+        if not re.search(Patterns.STR.value, value):
+            result[key] = [await _parse_match(item.group(0), progress_bar) for item in re.finditer(Patterns.FIND.value, value)]
+
+    if progress_bar:
+        progress_bar.update(1)
+
+    return result
+
+async def parse_js(js_code: str, debug: bool, logger) -> dict | None:
+    """
+    Парсит JavaScript-код и извлекает данные из переменной "n".
+
+    :param js_code: JS-код в виде строки.
+    :return: Распарсенные данные в виде словаря или None.
+    """
+    matches = re.finditer(Patterns.JS.value, js_code)
+    match_list = list(matches)
+
+    logger.debug(f'Found matches {len(match_list)}')
+    
+    progress_bar = tqdm(total=33, desc="Parsing JS", position=0) if debug else None
+
+    if match_list and len(match_list) >= 1:
+        logger.info('Starting to parse match')
+        result = await _parse_match(match_list[1].group(0), progress_bar)
+        
+        if progress_bar:
+            progress_bar.close()
+        logger.info('Complited parsing match')
+        return result
+    else:
+        if progress_bar:
+            progress_bar.close()
+        raise Exception("N variable in JS code not found")

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/pyaterochka_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyaterochka_api
-Version: 0.1.7
+Version: 0.1.8
 Summary: A Python API client for Pyaterochka store catalog
 Home-page: https://github.com/Open-Inflation/pyaterochka_api
 Author: Miskler
@@ -69,7 +69,7 @@ camoufox fetch
 
 ### Usage / Использование:
 ```py
-from pyaterochka_api import Pyaterochka
+from pyaterochka_api import Pyaterochka, PurchaseMode
 import asyncio
 
 

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/pyaterochka_api.egg-info/SOURCES.txt

@@ -4,13 +4,16 @@ pyproject.toml
 setup.py
 pyaterochka_api/__init__.py
 pyaterochka_api/api.py
+pyaterochka_api/enums.py
 pyaterochka_api/manager.py
+pyaterochka_api/tools.py
 pyaterochka_api.egg-info/PKG-INFO
 pyaterochka_api.egg-info/SOURCES.txt
 pyaterochka_api.egg-info/dependency_links.txt
 pyaterochka_api.egg-info/requires.txt
 pyaterochka_api.egg-info/top_level.txt
 tests/__init__.py
-tests/base_tests.py
+tests/api_tests.py
+tests/tools_tests.py
 tests/snapshots/__init__.py
 tests/snapshots/snap_base_tests.py

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='pyaterochka_api',
-    version='0.1.7',
+    version='0.1.8',
     packages=find_packages(),
     install_requires=[
         'aiohttp',

{pyaterochka_api-0.1.7 → pyaterochka_api-0.1.8}/tests/snapshots/snap_base_tests.py

@@ -667,6 +667,7 @@ snapshots['test_list products_list'] = {
                     'str'
                 ]
             },
+            'initial_weight_step': 'str',
             'labels': [
                 {
                     'bg_color': 'str',
@@ -674,6 +675,7 @@ snapshots['test_list products_list'] = {
                     'text_color': 'str'
                 }
             ],
+            'min_weight': 'str',
             'name': 'str',
             'plu': 'int',
             'prices': {
@@ -763,6 +765,7 @@ snapshots['test_product_info product_info'] = {
                         },
                         'ingredients': 'str',
                         'ingredients_html': 'NoneType',
+                        'initial_weight_step': 'str',
                         'is_available': 'bool',
                         'is_various_manufacturers': 'bool',
                         'labels': [
@@ -772,6 +775,7 @@ snapshots['test_product_info product_info'] = {
                                 'text_color': 'str'
                             }
                         ],
+                        'min_weight': 'str',
                         'name': 'str',
                         'nutrients': [
                             {

pyaterochka_api-0.1.8/tests/tools_tests.py

@@ -0,0 +1,30 @@
+import pytest
+from pyaterochka_api.tools import parse_proxy
+import itertools
+import logging
+
+@pytest.mark.asyncio
+async def test_parse_proxy():
+    # Варианты параметров
+    schemes = ['http://', 'https://', '']
+    auths = [('', ''), ('user', 'pass')]
+    hosts = ['127.0.0.1', 'example.com']
+    ports = ['', '8080']
+
+    logger = logging.getLogger("test_parse_proxy")
+
+    for scheme, (username, password), host, port in itertools.product(schemes, auths, hosts, ports):
+        # Формируем строку прокси
+        auth_part = f"{username}:{password}@" if username else ""
+        port_part = f":{port}" if port else ""
+        proxy_str = f"{scheme}{auth_part}{host}{port_part}"
+
+        expected = {'server': f"{scheme}{host}{port_part}"}
+        if not scheme:
+            expected['server'] = "http://"+expected['server']
+        if username:
+            expected['username'] = username
+            expected['password'] = password
+
+        assert parse_proxy(proxy_str, True, logger) == expected
+

pyaterochka_api-0.1.7/pyaterochka_api/__init__.py

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

pyaterochka_api-0.1.7/pyaterochka_api/api.py

@@ -1,279 +0,0 @@
-import aiohttp
-from fake_useragent import UserAgent
-from enum import Enum
-import re
-from tqdm.asyncio import tqdm
-from camoufox import AsyncCamoufox
-import os
-
-
-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, trust_env: bool = False, timeout: int = 10):
-        self._debug = debug
-        self._proxy = proxy
-        self._session = None
-        self._autoclose_browser = autoclose_browser
-        self._browser = None
-        self._bcontext = None
-        self._trust_env = trust_env
-        self._timeout = timeout
-
-    @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, тип данных или пустота).
-        """
-        args = {'url': url, 'timeout': aiohttp.ClientTimeout(total=self._timeout)}
-        if self._proxy: args["proxy"] = self._proxy
-
-        if self._debug:
-            print(f"Requesting \"{url}\" with proxy \"{args.get('proxy')}\", timeout {self._timeout}...", flush=True)
-        
-        async with self._session.get(**args) 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', timeout=self._timeout * 1000)
-        # Wait until the selector script tag appears
-        await page.wait_for_selector(selector=selector, state=state, timeout=self._timeout * 1000)
-        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:
-            if self._trust_env:
-                proxy_str = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
-            
-            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,
-                    "Accept": "application/json, text/plain, */*",
-                    "Accept-Language": "en-GB,en;q=0.5",
-                    "Accept-Encoding": "gzip, deflate, br, zstd",
-                    "X-PLATFORM": "webapp",
-                    "Origin": "https://5ka.ru",
-                    "Connection": "keep-alive",
-                    "Sec-Fetch-Dest": "empty",
-                    "Sec-Fetch-Mode": "cors",
-                    "Sec-Fetch-Site": "same-site",
-                    "Pragma": "no-cache",
-                    "Cache-Control": "no-cache",
-                    "TE": "trailers",
-                },
-                "trust_env": self._trust_env,
-            }
-            self._session = aiohttp.ClientSession(**args)
-        
-            if self._debug: print(f"A new connection aiohttp has been opened. trust_env: {args.get('trust_env')}")
-
-        if include_browser:
-            prox = self._parse_proxy(self.proxy)
-            self._browser = await AsyncCamoufox(headless=not self._debug, proxy=prox, geoip=True).__aenter__()
-            self._bcontext = await self._browser.new_context()
-            
-            toprint = "SYSTEM_PROXY" if prox and not self.proxy else prox
-            if self._debug: print(f"A new connection browser has been opened. Proxy used: {toprint}")
-
-    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")
-
-