pyaterochka-api 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

pyaterochka_api/__init__.py

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

pyaterochka_api/api.py

@@ -1,9 +1,8 @@
 import aiohttp
 from fake_useragent import UserAgent
-from enum import Enum
-import re
-from tqdm.asyncio import tqdm
 from camoufox import AsyncCamoufox
+import logging
+from .tools import parse_proxy, parse_js, get_env_proxy
 
 
 class PyaterochkaAPI:
@@ -11,41 +10,42 @@ 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):
+    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
 
-    @property
-    def proxy(self) -> str | None:
-        return self._proxy if hasattr(self, '_proxy') else None
+        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)
 
-    @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).
+        :return: Кортеж (успех, данные или None, тип данных или пустота).
         """
-        if self._debug:
-            print(f"Requesting \"{url}\"...", flush=True)
+        args = {'url': url, 'timeout': aiohttp.ClientTimeout(total=self._timeout)}
+        if self._proxy: args["proxy"] = self._proxy
 
-        async with self._session.get(url=url) as response:
-            if self._debug:
-                print(f"Response status: {response.status}", flush=True)
+        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':
@@ -57,79 +57,12 @@ class PyaterochkaAPI:
 
                 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)
+                self._logger.warning('Anti-bot protection. Use Russia IP address and try again.')
                 return False, None, ''
             else:
-                if self._debug:
-                    print(f"Unexpected error: {response.status}", flush=True)
+                self._logger.error(f'Unexpected error: {response.status}')
                 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.
@@ -141,22 +74,22 @@ class PyaterochkaAPI:
 
         if not is_success:
             if self._debug:
-                print("Failed to fetch JS code")
+                self._logger.error('Failed to fetch JS code')
             return None
         elif self._debug:
-            print("JS code fetched successfully")
+            self._logger.debug('JS code fetched successfully')
 
-        return await self._parse_js(js_code=js_code)
+        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:
+    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)
+            await self.new_session(include_aiohttp=False, include_browser=True)
 
         page = await self._bcontext.new_page()
-        await page.goto(url, wait_until='commit')
+        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)
+        await page.wait_for_selector(selector=selector, state=state, timeout=self._timeout * 1000)
         content = await page.content()
         await page.close()
 
@@ -164,49 +97,37 @@ class PyaterochkaAPI:
             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:
+    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
+            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. Proxy used: {args.get('proxy')}")
+            self._logger.info(f"A new aiohttp connection has been opened. trust_env: {args.get('trust_env')}")
 
         if include_browser:
-            self._browser = await AsyncCamoufox(headless=not self._debug, proxy=self._parse_proxy(self.proxy), geoip=True).__aenter__()
+            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()
-            
-            if self._debug: print(f"A new connection browser has been opened. Proxy used: {self.proxy}")
+            self._logger.info(f"A new browser context has been opened.")
 
     async def close(
         self,
@@ -225,8 +146,11 @@ class PyaterochkaAPI:
             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:
-            raise ValueError("No connections to close")
+            self._logger.warning("No connections to close")
+            return
 
         checks = {
             "session": lambda a: a is not None and not a.closed,
@@ -237,15 +161,20 @@ class PyaterochkaAPI:
         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")
+                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:
-                if self._debug:
-                    print(f"The {name} connection was not open")
+                self._logger.warning(f"The {name} connection was not open")
 
 

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/manager.py

@@ -3,36 +3,44 @@ from enum import Enum
 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"
+    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)
+    @beartype
+    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):
         raise NotImplementedError("Use `async with Pyaterochka() as ...:`")
 
+    @beartype
     def __exit__(self, exc_type, exc_val, exc_tb):
         pass
 
+    @beartype
     async def __aenter__(self):
-        await self.rebuild_connection(session=True)
+        await self.rebuild_connection(session=True, browser=False)
         return self
 
+    @beartype
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close()
 
+    @beartype
     async def rebuild_connection(self, session: bool = True, browser: bool = False) -> None:
         """
         Rebuilds the connection to the Pyaterochka API.
@@ -40,8 +48,9 @@ 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:
         """
         Closes the connection to the Pyaterochka API.
@@ -52,43 +61,72 @@ class Pyaterochka:
         await self.api.close(include_aiohttp=session, include_browser=browser)
 
     @property
+    @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
-    def proxy(self) -> str:
+    @beartype
+    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
-    def proxy(self, value: str):
-        self._proxy = value
-        self.api.proxy = value
+    @beartype
+    def proxy(self, value: str | None):
+        self.api._proxy = value
     
     @property
+    @beartype
     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
+    @autoclose_browser.setter
+    @beartype
     def autoclose_browser(self, value: bool):
         self.api._autoclose_browser = value
+    
+    @property
+    @beartype
+    def trust_env(self) -> bool:
+        """Passed directly to aiohttp. Also, if no proxy is specified, the system proxy (variable HTTPS_PROXY) will be used for the browser."""
+        return self.api._trust_env
+
+    @trust_env.setter
+    @beartype
+    def trust_env(self, value: bool):
+        self.api._trust_env = value
+    
+    @property
+    @beartype
+    def timeout(self) -> float:
+        """Timeout value for the API requests."""
+        return self.api._timeout
+
+    @timeout.setter
+    @beartype
+    def timeout(self, value: float):
+        if value <= 0:
+            raise ValueError("Timeout must be greater than 0")
 
+        self.api._timeout = value
 
+    @beartype
     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:
+    ) -> list[dict]:
         f"""
         Asynchronously retrieves a list of categories from the Pyaterochka API.
 
@@ -99,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).
@@ -109,24 +147,25 @@ class Pyaterochka:
         _is_success, response, _response_type = await self.api.fetch(url=request_url)
         return response
 
+    @beartype
     async def products_list(
             self,
-            category_id: int,
+            category_id: str,
             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.
 
         Args:
-            category_id (int): The ID of the category.
+            category_id (str): The ID of the (sub)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.
+            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.
@@ -140,9 +179,11 @@ class Pyaterochka:
         _is_success, response, _response_type = await self.api.fetch(url=request_url)
         return response
 
+    @beartype
     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:
@@ -152,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>',
@@ -169,7 +210,8 @@ class Pyaterochka:
 
         return data
     
-    async def get_news(self, limit: int = None) -> dict | None:
+    @beartype
+    async def get_news(self, limit: int | None = None) -> dict:
         """
         Asynchronously retrieves news from the Pyaterochka API.
 
@@ -177,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:
@@ -187,7 +229,8 @@ class Pyaterochka:
         
         return response
 
-    async def find_store(self, longitude: float, latitude: float) -> dict | None:
+    @beartype
+    async def find_store(self, longitude: float, latitude: float) -> dict:
         """
         Asynchronously finds the store associated with the given coordinates.
 
@@ -196,29 +239,33 @@ 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}"
         _is_success, response, _response_type = await self.api.fetch(url=request_url)
         return response
 
-    async def download_image(self, url: str) -> BytesIO | None:
+    @beartype
+    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]}'
 
         return image
 
-    async def get_config(self) -> list | None:
+    @beartype
+    async def get_config(self) -> dict:
         """
         Asynchronously retrieves the configuration from the hardcoded JavaScript file.
 
@@ -226,7 +273,7 @@ class Pyaterochka:
             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.
+            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/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.6.dist-info → pyaterochka_api-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyaterochka_api
-Version: 0.1.6
+Version: 0.1.8
 Summary: A Python API client for Pyaterochka store catalog
 Home-page: https://github.com/Open-Inflation/pyaterochka_api
 Author: Miskler
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: camoufox[geoip]
+Requires-Dist: beartype
 Requires-Dist: fake-useragent
 Requires-Dist: tqdm
 Provides-Extra: tests
@@ -43,6 +44,7 @@ Dynamic: summary
 
 Pyaterochka (Пятёрочка) - https://5ka.ru/
 
+[![GitHub Actions](https://github.com/Open-Inflation/pyaterochka_api/workflows/API%20Tests%20Daily/badge.svg)](https://github.com/Open-Inflation/pyaterochka_api/actions?query=workflow%3A"API+Tests+Daily?query=branch%3Amain")
 ![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/)
@@ -67,12 +69,12 @@ camoufox fetch
 
 ### Usage / Использование:
 ```py
-from pyaterochka_api import Pyaterochka
+from pyaterochka_api import Pyaterochka, PurchaseMode
 import asyncio
 
 
 async def main():
-    async with Pyaterochka(proxy="user:password@host:port", debug=False, autoclose_browser=False) as API:
+    async with Pyaterochka(proxy="user:password@host:port", debug=False, autoclose_browser=False, trust_env=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)
@@ -102,6 +104,12 @@ async def main():
         # 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: Напрямую передается в aiohttp, так же учитывается в браузере. В первую очередь нужен для использования системного `HTTPS_PROXY`.
+        # Но системный прокси применяется, только если не указали иное напрямую в `API.proxy`.
+        # ENG: Directly passed to aiohttp, also taken into account in the browser. Primarily needed for using the system `HTTPS_PROXY`.
+        # But the system proxy is applied only if you did not specify otherwise directly in `API.proxy`.
+        API.trust_env = 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)
@@ -121,13 +129,17 @@ async def main():
         with open(image.name, 'wb') as f:
             f.write(image.getbuffer())
 
+        # RUS: Можно указать свой таймаут (браузер может его интерпретировать как x2 т.к. там 2 итерации скачивания)
+        # ENG: You can specify your own timeout (the browser may interpret it as x2 since there are 2 iterations of downloading)
+        API.timeout = 7
+
         # 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()
+        # RUS: Изменения происходят сразу же, кроме product_info, т.к. за него отвечает браузер
+        # ENG: Changes take effect immediately, except for product_info, as it is handled by the browser
+        await API.rebuild_connection(session=False, browser=True)
+        await API.product_info(43347)
 
 
 if __name__ == '__main__':

pyaterochka_api-0.1.8.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyaterochka_api/__init__.py,sha256=6XnalFPUumYqDJFyXw2puejJ612o-D1tYjZ_IjQ7Hx0,108
+pyaterochka_api/api.py,sha256=KEr28n1aH69cVo0ztHCgB4ANVVZ-CezLWYTiPpfAmoc,7793
+pyaterochka_api/enums.py,sha256=JnX4JiHzXyRo4se8sCFx0LyqcKlXXED0VcA0xI7r_ZI,621
+pyaterochka_api/manager.py,sha256=yQw0njGCsropysT-_siuyNxXNpX-VJKOcVD8b-aV48I,10765
+pyaterochka_api/tools.py,sha256=xFOThNRClX4u0cMfmQ5fVQKLM2Fn-rBAekzo_yBvRnQ,4447
+pyaterochka_api-0.1.8.dist-info/licenses/LICENSE,sha256=Ee_P5XQUYoJuffzRL24j4GWpqgoWphUOKswpB2f9HcQ,1071
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/api_tests.py,sha256=XgOFu8yUKYqeRZ6QuQE-ZjMuPreQUb9y8iR7bDw-DOE,2763
+tests/tools_tests.py,sha256=UKWVHu-QkEzc7iLsm5wIhA17FLq3E7SxwkLHc5GEI2M,1040
+tests/snapshots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/snapshots/snap_base_tests.py,sha256=ryxaXZI10UonxclonGuLatjS3ZNMzkUeyz8uB0U5PdQ,27356
+pyaterochka_api-0.1.8.dist-info/METADATA,sha256=3rFmk1lprX-iELCmBvC4-wFZE-EIOLx7UlZJECjgr_8,9305
+pyaterochka_api-0.1.8.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+pyaterochka_api-0.1.8.dist-info/top_level.txt,sha256=PXTSi8y2C5_Mz20pJJFqOUBnjAIAXP_cc38mthvJ2x4,22
+pyaterochka_api-0.1.8.dist-info/RECORD,,

tests/{base_tests.py → api_tests.py}

@@ -14,7 +14,7 @@ def gen_schema(data):
 
 @pytest.mark.asyncio
 async def test_list(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(debug=True, trust_env=True) as API:
         categories = await API.categories_list(subcategories=True)
         snapshot.assert_match(gen_schema(categories), "categories_list")
         
@@ -23,25 +23,25 @@ async def test_list(snapshot: SnapshotTest):
 
 @pytest.mark.asyncio
 async def test_product_info(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(trust_env=True) as API:
         result = await API.product_info(43347)
         snapshot.assert_match(gen_schema(result), "product_info")
 
 @pytest.mark.asyncio
 async def test_get_news(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(debug=True, trust_env=True) as API:
         result = await API.get_news(limit=5)
         snapshot.assert_match(gen_schema(result), "get_news")
 
 @pytest.mark.asyncio
 async def test_find_store(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(debug=True, trust_env=True) as API:
         categories = await API.find_store(longitude=37.63156, latitude=55.73768)
         snapshot.assert_match(gen_schema(categories), "store_info")
 
 @pytest.mark.asyncio
 async def test_download_image(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(debug=True, trust_env=True) as API:
         result = await API.download_image("https://photos.okolo.app/product/1392827-main/800x800.jpeg")
         assert isinstance(result, BytesIO)
         assert result.getvalue()
@@ -55,12 +55,12 @@ async def test_set_debug(snapshot: SnapshotTest):
 
 @pytest.mark.asyncio
 async def test_rebuild_connection(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
+    async with Pyaterochka(debug=True, trust_env=True) as API:
         await API.rebuild_connection()
         snapshot.assert_match("connection has been rebuilt", "rebuild_connection")
 
-@pytest.mark.asyncio
-async def test_get_config(snapshot: SnapshotTest):
-    async with Pyaterochka() as API:
-        result = await API.get_config()
-        snapshot.assert_match(gen_schema(result), "get_config")
+#@pytest.mark.asyncio
+#async def test_get_config(snapshot: SnapshotTest):
+#    async with Pyaterochka(debug=True, trust_env=True, timeout=30) as API:
+#        result = await API.get_config()
+#        snapshot.assert_match(gen_schema(result), "get_config")

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': [
                             {

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

@@ -1,12 +0,0 @@
-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,,