pyaterochka-api 0.1.7__py3-none-any.whl → 0.1.9__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,10 +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 os
+import logging
+from .tools import parse_proxy, parse_js, get_env_proxy
 
 
 class PyaterochkaAPI:
@@ -12,14 +10,13 @@ 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):
+    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
@@ -29,14 +26,13 @@ class PyaterochkaAPI:
         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 и возвращает результат.
@@ -46,12 +42,10 @@ class PyaterochkaAPI:
         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)
+        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:
-            if self._debug:
-                print(f"Response status: {response.status}", flush=True)
+            self._logger.info(f'Response status: {response.status}')
 
             if response.status == 200:
                 if response.headers['content-type'] == 'application/json':
@@ -63,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.
@@ -147,17 +74,17 @@ 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', timeout=self._timeout * 1000)
@@ -170,39 +97,7 @@ 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:
-            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:
+    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:
@@ -225,16 +120,14 @@ class PyaterochkaAPI:
                 "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')}")
+            self._logger.info(f"A new aiohttp connection has been opened. trust_env: {args.get('trust_env')}")
 
         if include_browser:
-            prox = self._parse_proxy(self.proxy)
+            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()
-            
-            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}")
+            self._logger.info(f"A new browser context has been opened.")
 
     async def close(
         self,
@@ -253,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,
@@ -265,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

@@ -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/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")