search1688api 1.0.0__py3-none-any.whl

search1688api/__init__.py

@@ -0,0 +1,9 @@
+from .models import Product
+from .async_session import Async1688Session
+from .sync_session import Sync1688Session
+
+__version__ = "1.0.0"
+__author__ = "netkaruma"
+__email__ = "suzumekaruma@gmail.com"
+
+__all__ = ["Sync1688Session", "Async1688Session"]

search1688api/async_session.py

@@ -0,0 +1,358 @@
+import asyncio
+from urllib import response
+import aiohttp
+import json
+import re
+import time
+from typing import List, Dict, Any
+from yarl import URL
+
+from .models import Product, DetailProduct, extract_products_from_html
+from .utils import prepare_image_request, generate_sign, read_and_encode_image
+
+
+class Async1688Session:
+    def __init__(self, default_timeout: float = 30):
+        self._session = None
+        self._token = None
+        self._token_part = None
+        self.app_key = "12574478"
+        self.base_url = "https://h5api.m.1688.com/h5/mtop.relationrecommend.wirelessrecommend.recommend/2.0/"
+        self._initialized = False
+        self.default_timeout = default_timeout
+        self.cookies_dict = {}
+    
+    async def __aenter__(self):
+        if not self._initialized:
+            await self.start()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+    
+    async def _initialize(self):
+        if self._initialized:
+            return
+        
+        await self.start()
+        self._initialized = True
+    
+    async def start(self):
+        if self._session and not self._session.closed:
+            await self.close()
+        
+        self._session = aiohttp.ClientSession()
+        
+        try:
+            test_params = {
+                "jsv": "2.7.2",
+                "appKey": self.app_key,
+                "t": str(int(time.time() * 1000)),
+                "api": "mtop.relationrecommend.WirelessRecommend.recommend",
+                "v": "2.0",
+                "type": "originaljson"
+            }
+            
+            async with self._session.get(
+                self.base_url,
+                params=test_params,
+                timeout=self.default_timeout
+            ) as response:
+                
+                url_obj = URL(self.base_url)
+                cookies = self._session.cookie_jar.filter_cookies(url_obj)
+                token_cookie = cookies.get('_m_h5_tk')
+                
+                if token_cookie:
+                    self._token = token_cookie.value
+                    self._token_part = self._token.split('_')[0]
+                    self._initialized = True
+                    return True
+                else:
+                    raise Exception("Не удалось получить токен")
+                
+        except Exception as e:
+            await self.close()
+            raise Exception(f"Ошибка запуска сессии: {e}")
+    
+    async def close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+            self._token = None
+            self._token_part = None
+            self._initialized = False
+            self.cookies_dict = {}
+    
+    async def _ensure_initialized(self):
+        if not self._initialized or not self.is_active:
+            await self._initialize()
+    
+    async def _get_image_id(self, image_path, timeout=None):
+        await self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        image_b64 = read_and_encode_image(image_path)
+        data_string = prepare_image_request(image_b64)
+        timestamp = str(int(time.time() * 1000))
+        sign = generate_sign(self._token_part, timestamp, self.app_key, data_string)
+        
+        params = {
+            "jsv": "2.7.2",
+            "appKey": self.app_key,
+            "t": timestamp,
+            "sign": sign,
+            "api": "mtop.relationrecommend.WirelessRecommend.recommend",
+            "ignoreLogin": "true",
+            "prefix": "h5api",
+            "v": "2.0",
+            "type": "originaljson",
+            "dataType": "jsonp", 
+            "jsonpIncPrefix": "search1688",
+            "timeout": "20000"
+        }
+        
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+            "origin": "https://s.1688.com",
+            "referer": "https://s.1688.com/",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        
+        try:
+            async with self._session.post(
+                self.base_url,
+                params=params,
+                data={"data": data_string},
+                headers=headers,
+                timeout=timeout
+            ) as response:
+                
+                if response.status == 200:
+                    result = await response.json()
+                    if result.get("data", {}).get("success"):
+                        image_id = result["data"].get("imageId")
+                        if image_id:
+                            return image_id
+                return None
+            
+        except Exception as e:
+            raise Exception(f"Ошибка при запросе: {e}")
+    
+    async def search_by_image(self, image_path: str, timeout: float = None) -> List[Product]:
+        await self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        image_id = await self._get_image_id(image_path, timeout=timeout)
+        
+        if not image_id:
+            return []
+        
+        products = await self._search_by_image_id(image_id, timeout=timeout)
+        return products
+    
+    async def _search_by_image_id(self, image_id: str, timeout=None) -> List[Product]:
+        await self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        search_url = f"https://s.1688.com/youyuan/index.htm"
+        params = {
+            "tab": "imageSearch",
+            "imageId": image_id
+        }
+        
+        headers = {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+            "referer": "https://s.1688.com/"
+        }
+        
+        try:
+            async with self._session.get(
+                search_url,
+                params=params,
+                headers=headers,
+                timeout=timeout
+            ) as response:
+                
+                if response.status == 200:
+                    html_content = await response.text()
+                    products = extract_products_from_html(html_content)
+                    return products
+                else:
+                    return []
+                    
+        except Exception:
+            return []
+    
+    async def _get_cookies_with_aiohttp(self):
+        """Получает куки через aiohttp запросы"""
+        temp_session = None
+        try:
+            # Используем временную сессию для получения кук
+            temp_session = aiohttp.ClientSession()
+            
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+                "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+                "Accept-Encoding": "gzip, deflate, br",
+                "DNT": "1",
+                "Connection": "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+                "Sec-Fetch-Dest": "document",
+                "Sec-Fetch-Mode": "navigate",
+                "Sec-Fetch-Site": "none",
+            }
+            
+            # Запрос к главной странице 1688
+            async with temp_session.get("https://www.1688.com/", headers=headers, allow_redirects=True) as response:
+                # Получаем куки из ответа
+                response_cookies = response.cookies
+                for cookie in response_cookies:
+                    self.cookies_dict[cookie.key] = cookie.value
+            
+            # Дополнительный запрос для симуляции поведения браузера
+            async with temp_session.get("https://login.1688.com/", headers=headers, allow_redirects=True) as response:
+                # Обновляем куки
+                response_cookies = response.cookies
+                for cookie in response_cookies:
+                    self.cookies_dict[cookie.key] = cookie.value
+            
+            # Запрос к API для получения дополнительных кук
+            api_headers = headers.copy()
+            api_headers.update({
+                "Accept": "application/json, text/plain, */*",
+                "Sec-Fetch-Dest": "empty",
+                "Sec-Fetch-Mode": "cors",
+                "Sec-Fetch-Site": "same-origin",
+            })
+            
+            async with temp_session.get("https://www.1688.com/api/token/init", headers=api_headers) as response:
+                # Обновляем куки
+                response_cookies = response.cookies
+                for cookie in response_cookies:
+                    self.cookies_dict[cookie.key] = cookie.value
+            
+        except Exception:
+            # Fallback на базовые куки
+            self.cookies_dict = {
+                "cna": "Ez7rHJABCwKCAXrD2Q==",
+                "_m_h5_tk": "random_token_12345", 
+                "_m_h5_tk_enc": "random_enc_token_12345",
+            }
+        finally:
+            # Всегда закрываем временную сессию
+            if temp_session and not temp_session.closed:
+                await temp_session.close()
+    
+    async def get_by_id(self, offer_id: str, timeout: float = None) -> DetailProduct:
+        """Парсит товар по ID"""
+        await self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        # Если куки еще не получены, получаем их
+        if not self.cookies_dict:
+            await self._get_cookies_with_aiohttp()
+        
+        url = f"https://detail.1688.com/offer/{offer_id}.html"
+        
+        cookies_str = '; '.join([f'{k}={v}' for k, v in self.cookies_dict.items()])
+        
+        headers = {
+            "cookie": cookies_str,
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+            "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+        }
+        
+        try:
+            async with self._session.get(
+                url,
+                headers=headers,
+                timeout=timeout
+            ) as response:
+
+                if response.status == 200:
+                    html_content = await response.text()
+                    
+                    # Ищем JSON данные
+                    json_str = self._extract_json_string(html_content)
+                    
+                    if json_str:
+                        # Исправляем JSON перед парсингом
+                        fixed_json_str = self._fix_json_issues(json_str)
+                        
+                        try:
+                            product_data = json.loads(fixed_json_str)
+                            product = DetailProduct(product_data)
+                            return product
+                        except json.JSONDecodeError as e:
+                            print(f"JSON decode error: {e}")
+                            return None
+                    else:
+                        print("No JSON data found in HTML")
+                        return None
+                else:
+                    print(f"HTTP error: {response.status}")
+                    return None
+                    
+        except asyncio.TimeoutError:
+            print("Request timeout")
+            return None
+        except Exception as e:
+            print(f"Request error: {e}")
+            return None
+
+    def _extract_json_string(self, html_content: str) -> str:
+        """Извлекает JSON строку из HTML"""
+        pattern = r'window\.contextPath\s*,\s*({.*?})\);'
+        match = re.search(pattern, html_content, re.DOTALL)
+        
+        if match:
+            json_str = match.group(1)
+            return json_str
+        
+        return ""
+
+    def _fix_json_issues(self, json_str: str) -> str:
+        """Исправляет проблемы в JSON"""
+        # Исправляем объект skuWeight
+        sku_weight_pattern = r'"skuWeight":\s*\{[^}]+\}'
+        def fix_sku_weight(match):
+            sku_weight_obj = match.group(0)
+            fixed = re.sub(r'(\s*)(\d+)(\s*):(\s*)', r'\1"\2"\3:\4', sku_weight_obj)
+            return fixed
+        
+        fixed_json = re.sub(sku_weight_pattern, fix_sku_weight, json_str)
+        
+        # Исправляем объект skuFeatures  
+        sku_features_pattern = r'"skuFeatures":\s*\{[^}]+\}'
+        def fix_sku_features(match):
+            sku_features_obj = match.group(0)
+            fixed = re.sub(r'(\s*)(\d+)(\s*):(\s*)', r'\1"\2"\3:\4', sku_features_obj)
+            return fixed
+        
+        fixed_json = re.sub(sku_features_pattern, fix_sku_features, fixed_json)
+        
+        return fixed_json
+
+    @property
+    def is_active(self):
+        return self._session is not None and not self._session.closed
+
+    def __await__(self):
+        return self._create_initialized().__await__()
+
+    async def _create_initialized(self):
+        await self._initialize()
+        return self

search1688api/models.py

@@ -0,0 +1,243 @@
+import json
+import re
+from typing import List, Dict, Any
+
+class Product:
+    def __init__(self, data: Dict[str, Any]):
+        self.raw_data = data
+        self.id = data.get("id")
+        self.name = data.get("information", {}).get("subject", "")
+        self.simple_name = data.get("information", {}).get("simpleSubject", "")
+        self.brief = data.get("information", {}).get("brief", "")
+        
+        company = data.get("company", {})
+        self.company = company.get("name", "")
+        self.company_location = f"{company.get('province', '')} {company.get('city', '')}".strip()
+        self.credit_level = company.get("creditLevelText", "")
+        self.is_factory = company.get("isFactory") == "Y"
+        
+        price_info = data.get("tradePrice", {}).get("offerPrice", {})
+        self.price = price_info.get("valueString", "")
+        self.quantity_prices = self._parse_quantity_prices(price_info.get("quantityPrices", []))
+        
+        image_info = data.get("image", {})
+        self.image_url = image_info.get("imgUrl", "")
+        self.image_url_220x220 = image_info.get("imgUrlOf220x220", "")
+        
+        trade_quantity = data.get("tradeQuantity", {})
+        self.booked_count = trade_quantity.get("bookedCount", 0)
+        self.sale_quantity = trade_quantity.get("saleQuantity", 0)
+        self.quantity_begin = trade_quantity.get("quantityBegin", 1)
+        
+        self.url = f"https://detail.1688.com/offer/{self.id}.html" if self.id else ""
+        self.category_id = data.get("information", {}).get("categoryId")
+        self.features = data.get("features", {}).get("list", [])
+        
+        self.tags = []
+        market_tags = data.get("marketOfferTag", {})
+        self.tags.extend(market_tags.get("offerTagIds", []))
+        self.tags.extend(market_tags.get("memberTagIds", []))
+        self.tags.extend(market_tags.get("holidayTagIds", []))
+        
+        self.service_labels = []
+        common_labels = data.get("commonPositionLabels", {}).get("offerMiddle", [])
+        for label in common_labels:
+            if label.get("enable"):
+                self.service_labels.append(label.get("text", ""))
+    
+    def _parse_quantity_prices(self, quantity_prices: List[Dict]) -> List[Dict]:
+        parsed_prices = []
+        for qp in quantity_prices:
+            quantity = qp.get("quantity", "")
+            price = qp.get("valueString", "")
+            if price:
+                parsed_prices.append({
+                    "quantity": quantity,
+                    "price": price
+                })
+        return parsed_prices
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "simple_name": self.simple_name,
+            "brief": self.brief,
+            "company": self.company,
+            "company_location": self.company_location,
+            "credit_level": self.credit_level,
+            "is_factory": self.is_factory,
+            "price": self.price,
+            "quantity_prices": self.quantity_prices,
+            "image_url": self.image_url,
+            "image_url_220x220": self.image_url_220x220,
+            "booked_count": self.booked_count,
+            "sale_quantity": self.sale_quantity,
+            "min_quantity": self.quantity_begin,
+            "url": self.url,
+            "category_id": self.category_id,
+            "tags": self.tags,
+            "service_labels": self.service_labels
+        }
+    
+    def __str__(self):
+        return f"Product(id={self.id}, name={self.simple_name[:50]}..., price={self.price}, company={self.company})"
+    
+    def __repr__(self):
+        return f"Product(id={self.id}, name={self.simple_name[:30]}...)"
+
+
+class DetailProduct:
+    def __init__(self, data: Dict[str, Any]):
+        self.raw_data = data
+        self._extract_data()
+    
+    def _extract_data(self):
+        """Извлекает все данные из JSON структуры"""
+        try:
+            # ID товара
+            self.id = self._get_nested_value(["result", "data", "shippingServices", "fields", "deliveryLimitTimeModel", "offerId"])
+            
+            # Название товара
+            self.name = self._get_nested_value(["result", "data", "gallery", "fields", "subject"])
+            
+            # Бренд и вес из featureAttributes
+            attributes = self._get_nested_value(["result", "global", "globalData", "model", "offerDetail", "featureAttributes"])
+            self.brand = None
+            self.weight = None
+            if attributes:
+                for attr in attributes:
+                    if attr.get("name") == "品牌":
+                        self.brand = attr.get("value")
+                    if attr.get("name") == "净含量":
+                        self.weight = attr.get("value")
+            
+            # Компания
+            self.company = self._get_nested_value(["result", "data", "Root", "fields", "dataJson", "tempModel", "companyName"])
+            
+            # Названия товаров (goods) с ценами и картинками
+            self.goods = []
+            
+            # ПРАВИЛЬНЫЙ путь к данным
+            sku_props = self._get_nested_value(["result", "data", "Root", "fields", "dataJson", "skuModel", "skuProps"])
+            sku_info_map = self._get_nested_value(["result", "data", "Root", "fields", "dataJson", "skuModel", "skuInfoMap"])
+            
+            if sku_props and len(sku_props) > 0 and 'value' in sku_props[0]:
+                goods_data = sku_props[0]['value']
+                
+                if goods_data and sku_info_map:
+                    for good in goods_data:
+                        good_name = good.get("name")
+                        image_url = good.get("imageUrl")
+                        
+                        # Получаем цену из skuInfoMap
+                        price = None
+                        if good_name in sku_info_map:
+                            price = sku_info_map[good_name].get("price")
+                        
+                        # Добавляем товар с названием, ценой и картинкой
+                        self.goods.append({
+                            "name": good_name,
+                            "price": price,
+                            "imageUrl": image_url
+                        })
+            
+            # Рейтинг
+            self.grade = self._get_nested_value(["result", "data", "productTitle", "fields", "rateInfo", "goodsGrade"])
+            
+            # Процент повторных заказов
+            self.repeat_orders = self._get_nested_value(["result", "data", "productTitle", "fields", "shopInfo", "byrRepeatRate3m"])
+            
+            # Количество продаж
+            self.saledCount = self._get_nested_value(["result", "data", "Root", "fields", "dataJson", "tempModel", "saledCount"])
+            
+        except Exception:
+            pass
+    
+    def _get_nested_value(self, keys: List[str]):
+        """Безопасно получает значение из вложенной структуры"""
+        current = self.raw_data
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return None
+        return current
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Возвращает данные в виде словаря"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "brand": self.brand,
+            "company": self.company,
+            "grade": self.grade,
+            "weight": self.weight,
+            "goods": self.goods,
+            "repeat_orders": self.repeat_orders,
+            "saledCount": self.saledCount
+        }
+
+
+def extract_products_from_html(html_content: str) -> List[Product]:
+    products = []
+    
+    try:
+        patterns = [
+            r'window\.data\.offerresultData\s*=\s*successDataCheck\(\s*({.*?})\s*\)',
+            r'window\.data\.offerresultData\s*=\s*({.*?});',
+            r'offerresultData\s*=\s*successDataCheck\(\s*({.*?})\s*\)'
+        ]
+        
+        json_data = None
+        for pattern in patterns:
+            match = re.search(pattern, html_content, re.DOTALL)
+            if match:
+                try:
+                    json_str = match.group(1)
+                    json_str = re.sub(r',\s*]', ']', json_str)
+                    json_str = re.sub(r',\s*}', '}', json_str)
+                    data = json.loads(json_str)
+                    json_data = data
+                    break
+                except json.JSONDecodeError:
+                    continue
+        
+        if not json_data:
+            return products
+        
+        offer_list = []
+        
+        if "data" in json_data and "offerList" in json_data["data"]:
+            offer_list = json_data["data"]["offerList"]
+        elif "offerList" in json_data:
+            offer_list = json_data["offerList"]
+        else:
+            def find_offer_list(obj):
+                if isinstance(obj, dict):
+                    for key, value in obj.items():
+                        if key == "offerList" and isinstance(value, list):
+                            return value
+                        result = find_offer_list(value)
+                        if result is not None:
+                            return result
+                elif isinstance(obj, list):
+                    for item in obj:
+                        result = find_offer_list(item)
+                        if result is not None:
+                            return result
+                return None
+            
+            offer_list = find_offer_list(json_data) or []
+        
+        for offer_data in offer_list:
+            try:
+                product = Product(offer_data)
+                products.append(product)
+            except Exception:
+                continue
+                
+    except Exception:
+        pass
+    
+    return products

search1688api/sync_session.py

@@ -0,0 +1,388 @@
+import asyncio
+import requests
+import json
+import re
+import time
+import base64
+from typing import List, Dict, Any
+from urllib.parse import urlencode
+import aiohttp
+from yarl import URL
+
+from .models import Product, DetailProduct, extract_products_from_html
+from .utils import prepare_image_request, generate_sign, read_and_encode_image
+
+
+class Sync1688Session:
+    def __init__(self, default_timeout: float = 30):
+        self._async_session = None
+        self._token = None
+        self._token_part = None
+        self.app_key = "12574478"
+        self.base_url = "https://h5api.m.1688.com/h5/mtop.relationrecommend.wirelessrecommend.recommend/2.0/"
+        self._initialized = False
+        self.default_timeout = default_timeout
+        self.cookies_dict = {}
+        self._loop = None
+    
+    def __enter__(self):
+        if not self._initialized:
+            self.start()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+    
+    def _run_async(self, coro):
+        """Запускает асинхронную функцию в синхронном контексте"""
+        if self._loop is None:
+            try:
+                self._loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self._loop)
+        
+        if self._loop.is_running():
+            # Если loop уже запущен, создаем новую задачу
+            future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+            return future.result()
+        else:
+            # Если loop не запущен, запускаем его
+            return self._loop.run_until_complete(coro)
+    
+    def _initialize(self):
+        if self._initialized:
+            return
+        
+        self.start()
+        self._initialized = True
+    
+    def start(self):
+        if self._async_session and not self._async_session.closed:
+            self.close()
+        
+        async def _start_async():
+            self._async_session = aiohttp.ClientSession()
+            
+            try:
+                test_params = {
+                    "jsv": "2.7.2",
+                    "appKey": self.app_key,
+                    "t": str(int(time.time() * 1000)),
+                    "api": "mtop.relationrecommend.WirelessRecommend.recommend",
+                    "v": "2.0",
+                    "type": "originaljson"
+                }
+                
+                async with self._async_session.get(
+                    self.base_url,
+                    params=test_params,
+                    timeout=self.default_timeout
+                ) as response:
+                    
+                    url_obj = URL(self.base_url)
+                    cookies = self._async_session.cookie_jar.filter_cookies(url_obj)
+                    token_cookie = cookies.get('_m_h5_tk')
+                    
+                    if token_cookie:
+                        self._token = token_cookie.value
+                        self._token_part = self._token.split('_')[0]
+                        self._initialized = True
+                        return True
+                    else:
+                        raise Exception("Не удалось получить токен")
+                    
+            except Exception as e:
+                await self._async_session.close()
+                self._async_session = None
+                raise Exception(f"Ошибка запуска сессии: {e}")
+        
+        return self._run_async(_start_async())
+    
+    def close(self):
+        if self._async_session and not self._async_session.closed:
+            async def _close_async():
+                await self._async_session.close()
+            
+            self._run_async(_close_async())
+            self._async_session = None
+            self._token = None
+            self._token_part = None
+            self._initialized = False
+            self.cookies_dict = {}
+    
+    def _ensure_initialized(self):
+        if not self._initialized or not self.is_active:
+            self._initialize()
+    
+    def _get_image_id(self, image_path, timeout=None):
+        self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        async def _get_image_id_async():
+            image_b64 = read_and_encode_image(image_path)
+            data_string = prepare_image_request(image_b64)
+            timestamp = str(int(time.time() * 1000))
+            sign = generate_sign(self._token_part, timestamp, self.app_key, data_string)
+            
+            params = {
+                "jsv": "2.7.2",
+                "appKey": self.app_key,
+                "t": timestamp,
+                "sign": sign,
+                "api": "mtop.relationrecommend.WirelessRecommend.recommend",
+                "ignoreLogin": "true",
+                "prefix": "h5api",
+                "v": "2.0",
+                "type": "originaljson",
+                "dataType": "jsonp", 
+                "jsonpIncPrefix": "search1688",
+                "timeout": "20000"
+            }
+            
+            headers = {
+                "content-type": "application/x-www-form-urlencoded",
+                "origin": "https://s.1688.com",
+                "referer": "https://s.1688.com/",
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            }
+            
+            try:
+                async with self._async_session.post(
+                    self.base_url,
+                    params=params,
+                    data={"data": data_string},
+                    headers=headers,
+                    timeout=timeout
+                ) as response:
+                    
+                    if response.status == 200:
+                        result = await response.json()
+                        if result.get("data", {}).get("success"):
+                            image_id = result["data"].get("imageId")
+                            if image_id:
+                                return image_id
+                    return None
+                
+            except Exception as e:
+                raise Exception(f"Ошибка при запросе: {e}")
+        
+        return self._run_async(_get_image_id_async())
+    
+    def search_by_image(self, image_path: str, timeout: float = None) -> List[Product]:
+        self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        image_id = self._get_image_id(image_path, timeout=timeout)
+        
+        if not image_id:
+            return []
+        
+        products = self._search_by_image_id(image_id, timeout=timeout)
+        return products
+    
+    def _search_by_image_id(self, image_id: str, timeout=None) -> List[Product]:
+        self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        async def _search_by_image_id_async():
+            search_url = f"https://s.1688.com/youyuan/index.htm"
+            params = {
+                "tab": "imageSearch",
+                "imageId": image_id
+            }
+            
+            headers = {
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+                "referer": "https://s.1688.com/"
+            }
+            
+            try:
+                async with self._async_session.get(
+                    search_url,
+                    params=params,
+                    headers=headers,
+                    timeout=timeout
+                ) as response:
+                    
+                    if response.status == 200:
+                        html_content = await response.text()
+                        products = extract_products_from_html(html_content)
+                        return products
+                    else:
+                        return []
+                        
+            except Exception:
+                return []
+        
+        return self._run_async(_search_by_image_id_async())
+    
+    def _get_cookies_with_aiohttp(self):
+        """Получает куки через aiohttp запросы"""
+        async def _get_cookies_async():
+            temp_session = None
+            try:
+                temp_session = aiohttp.ClientSession()
+                
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+                    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+                    "Accept-Encoding": "gzip, deflate, br",
+                    "DNT": "1",
+                    "Connection": "keep-alive",
+                    "Upgrade-Insecure-Requests": "1",
+                    "Sec-Fetch-Dest": "document",
+                    "Sec-Fetch-Mode": "navigate",
+                    "Sec-Fetch-Site": "none",
+                }
+                
+                # Запрос к главной странице 1688
+                async with temp_session.get("https://www.1688.com/", headers=headers, allow_redirects=True) as response:
+                    # Получаем куки из ответа
+                    response_cookies = response.cookies
+                    for cookie in response_cookies:
+                        self.cookies_dict[cookie.key] = cookie.value
+                
+                # Дополнительный запрос для симуляции поведения браузера
+                async with temp_session.get("https://login.1688.com/", headers=headers, allow_redirects=True) as response:
+                    # Обновляем куки
+                    response_cookies = response.cookies
+                    for cookie in response_cookies:
+                        self.cookies_dict[cookie.key] = cookie.value
+                
+                # Запрос к API для получения дополнительных кук
+                api_headers = headers.copy()
+                api_headers.update({
+                    "Accept": "application/json, text/plain, */*",
+                    "Sec-Fetch-Dest": "empty",
+                    "Sec-Fetch-Mode": "cors",
+                    "Sec-Fetch-Site": "same-origin",
+                })
+                
+                async with temp_session.get("https://www.1688.com/api/token/init", headers=api_headers) as response:
+                    # Обновляем куки
+                    response_cookies = response.cookies
+                    for cookie in response_cookies:
+                        self.cookies_dict[cookie.key] = cookie.value
+                
+            except Exception:
+                # Fallback на базовые куки
+                self.cookies_dict = {
+                    "cna": "Ez7rHJABCwKCAXrD2Q==",
+                    "_m_h5_tk": "random_token_12345", 
+                    "_m_h5_tk_enc": "random_enc_token_12345",
+                }
+            finally:
+                if temp_session and not temp_session.closed:
+                    await temp_session.close()
+        
+        self._run_async(_get_cookies_async())
+    
+    def get_by_id(self, offer_id: str, timeout: float = None) -> DetailProduct:
+        """Парсит товар по ID"""
+        self._ensure_initialized()
+        
+        if timeout is None:
+            timeout = self.default_timeout
+        
+        # Если куки еще не получены, получаем их
+        if not self.cookies_dict:
+            self._get_cookies_with_aiohttp()
+        
+        async def _get_by_id_async():
+            url = f"https://detail.1688.com/offer/{offer_id}.html"
+            
+            cookies_str = '; '.join([f'{k}={v}' for k, v in self.cookies_dict.items()])
+            
+            headers = {
+                "cookie": cookies_str,
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+            }
+            
+            try:
+                async with self._async_session.get(
+                    url,
+                    headers=headers,
+                    timeout=timeout
+                ) as response:
+
+                    if response.status == 200:
+                        html_content = await response.text()
+                        
+                        # Ищем JSON данные
+                        json_str = self._extract_json_string(html_content)
+                        
+                        if json_str:
+                            # Исправляем JSON перед парсингом
+                            fixed_json_str = self._fix_json_issues(json_str)
+                            
+                            try:
+                                product_data = json.loads(fixed_json_str)
+                                product = DetailProduct(product_data)
+                                return product
+                            except json.JSONDecodeError as e:
+                                print(f"JSON decode error: {e}")
+                                return None
+                        else:
+                            print("No JSON data found in HTML")
+                            return None
+                    else:
+                        print(f"HTTP error: {response.status}")
+                        return None
+                        
+            except asyncio.TimeoutError:
+                print("Request timeout")
+                return None
+            except Exception as e:
+                print(f"Request error: {e}")
+                return None
+        
+        return self._run_async(_get_by_id_async())
+
+    def _extract_json_string(self, html_content: str) -> str:
+        """Извлекает JSON строку из HTML"""
+        pattern = r'window\.contextPath\s*,\s*({.*?})\);'
+        match = re.search(pattern, html_content, re.DOTALL)
+        
+        if match:
+            json_str = match.group(1)
+            return json_str
+        
+        return ""
+
+    def _fix_json_issues(self, json_str: str) -> str:
+        """Исправляет проблемы в JSON"""
+        # Исправляем объект skuWeight
+        sku_weight_pattern = r'"skuWeight":\s*\{[^}]+\}'
+        def fix_sku_weight(match):
+            sku_weight_obj = match.group(0)
+            fixed = re.sub(r'(\s*)(\d+)(\s*):(\s*)', r'\1"\2"\3:\4', sku_weight_obj)
+            return fixed
+        
+        fixed_json = re.sub(sku_weight_pattern, fix_sku_weight, json_str)
+        
+        # Исправляем объект skuFeatures  
+        sku_features_pattern = r'"skuFeatures":\s*\{[^}]+\}'
+        def fix_sku_features(match):
+            sku_features_obj = match.group(0)
+            fixed = re.sub(r'(\s*)(\d+)(\s*):(\s*)', r'\1"\2"\3:\4', sku_features_obj)
+            return fixed
+        
+        fixed_json = re.sub(sku_features_pattern, fix_sku_features, fixed_json)
+        
+        return fixed_json
+
+    @property
+    def is_active(self):
+        return self._async_session is not None and not self._async_session.closed

search1688api/utils.py

@@ -0,0 +1,38 @@
+import base64
+import time
+import hashlib
+import json
+from typing import Dict, Any
+
+
+def prepare_image_request(image_b64: str) -> str:
+    params_data = {
+        "searchScene": "imageEx",
+        "interfaceName": "imageBase64ToImageId",
+        "serviceParam.extendParam[imageBase64]": image_b64,
+        "subChannel": "pc_image_search_image_id"
+    }
+    
+    request_data = {
+        "appId": 32517,
+        "params": json.dumps(params_data, separators=(',', ':'))
+    }
+    
+    return json.dumps(request_data, separators=(',', ':'))
+
+
+def generate_sign(token_part: str, timestamp: str, app_key: str, data_string: str) -> str:
+    if not token_part:
+        raise ValueError("Токен не установлен")
+    
+    sign_string = f"{token_part}&{timestamp}&{app_key}&{data_string}"
+    return hashlib.md5(sign_string.encode('utf-8')).hexdigest()
+
+
+def read_and_encode_image(image_path: str) -> str:
+    try:
+        with open(image_path, 'rb') as f:
+            image_b64 = base64.b64encode(f.read()).decode('utf-8')
+        return image_b64
+    except Exception as e:
+        raise ValueError(f"Ошибка чтения файла: {e}")

search1688api-1.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: search1688api
+Version: 1.0.0
+Summary: Python library for searching products on 1688.com by image
+Author: netkaruma
+Author-email: suzumekaruma@gmail.com
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.25.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: yarl>=1.6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

search1688api-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+search1688api/__init__.py,sha256=EiS7EmmOnbysLo64uEleBMtt0aEoRQw8krpNWJW_GHQ,249
+search1688api/async_session.py,sha256=2yKVcLSRY79UqTF3-s9GHNrV571QAIBrX3NUUePqCMo,13709
+search1688api/models.py,sha256=n25667nqJy7BXahwRNaTBNr3ElNHV_x28d1Kr_qLmz8,10104
+search1688api/sync_session.py,sha256=VLHNz2N0cRLklyRIdq99N27Gece2In0bATaV1zh6PLU,15653
+search1688api/utils.py,sha256=y471VoWWeGZlR4UsQMsdjFvCRE0__WzQg2u6tEk0-ew,1150
+search1688api-1.0.0.dist-info/METADATA,sha256=PtrH3Go4A6qBvRopcKyQh6XKelOAY-fLlwAVaVbuiSI,395
+search1688api-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+search1688api-1.0.0.dist-info/top_level.txt,sha256=45TXpEOgUUPrDbElDuwRjkWhu4CXwnO3e7p6w7RK2Kg,14
+search1688api-1.0.0.dist-info/RECORD,,

search1688api-1.0.0.dist-info/WHEEL

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

search1688api-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+search1688api