search1688api 1.0.0__tar.gz

search1688api-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,165 @@
+# 1688 Search API by Image 
+
+Python библиотека для поиска товаров на 1688.com по изображению.
+А также парсинга данных товаров по ID/Артикулу
+
+## Установка
+
+```bash
+pip install search1688api
+```
+
+## Использование
+
+### Синхронная версия
+
+```python
+from search1688api import Sync1688Session
+
+with Sync1688Session() as session:
+    # Поиск по изображению
+    products = session.search_by_image("path/to/image.jpg")
+    for product in products:
+        print(product.name)
+        print(product.url)
+        print(product.company)
+        print(product.price)
+    
+    # Получение детальной информации о товаре по ID
+    detailed_product = session.get_by_id("741375431874")
+    if detailed_product:
+        print(detailed_product.to_dict())
+```
+
+### Асинхронная версия
+
+```python
+import asyncio
+from search1688api import Async1688Session
+
+async def main():
+    async with Async1688Session() as session:
+        # Поиск по изображению
+        products = await session.search_by_image("path/to/image.jpg")
+        for product in products:
+            print(product.name)
+            print(product.url)
+            print(product.company)
+            print(product.price)
+        
+        # Получение детальной информации о товаре по ID
+        detailed_product = await session.get_by_id("741375431874")
+        if detailed_product:
+            print(detailed_product.to_dict())
+
+asyncio.run(main())
+```
+## Настройка таймаута
+### При создании сессии
+
+```python
+# Таймаут по умолчанию 30 секунд
+session = Sync1688Session()
+
+# Установить кастомный таймаут
+session = Sync1688Session(default_timeout=60)  # 60 секунд
+```
+
+### Для отдельных запросов
+```python
+# Использовать таймаут по умолчанию
+products = session.search_by_image("image.jpg")
+detailed = session.get_by_id("123456")
+
+# Установить таймаут для конкретного запроса
+products = session.search_by_image("image.jpg", timeout=10)  # 10 секунд
+detailed = session.get_by_id("123456", timeout=15)           # 15 секунд
+```
+### Изменение таймаута после создания
+```python
+session = Sync1688Session()
+session.default_timeout = 45  # Теперь все запросы будут с таймаутом 45 секунд
+```
+## Модель Product
+
+## Класс Product содержит следующие атрибуты:
+| Атрибут             | Тип          | Описание                                                                            |
+| ------------------- | ------------ | ----------------------------------------------------------------------------------- |
+| `id`                | `str`        | Уникальный идентификатор товара на 1688                                             |
+| `name`              | `str`        | Полное название товара                                                              |
+| `simple_name`       | `str`        | Упрощённое/сокращённое название товара                                              |
+| `brief`             | `str`        | Краткое описание товара                                                             |
+| `company`           | `str`        | Название компании-продавца                                                          |
+| `company_location`  | `str`        | Регион продавца (провинция и город)                                                 |
+| `credit_level`      | `str`        | Уровень доверия продавца (рейтинг)                                                  |
+| `is_factory`        | `bool`       | Является ли продавец фабрикой (`True`/`False`)                                      |
+| `price`             | `str`        | Основная цена товара                                                                |
+| `quantity_prices`   | `List[Dict]` | Список цен в зависимости от количества. Пример: `[{"quantity": 2, "price": "¥10"}]` |
+| `image_url`         | `str`        | Ссылка на основное изображение товара                                               |
+| `image_url_220x220` | `str`        | Ссылка на изображение размером 220x220                                              |
+| `booked_count`      | `int`        | Количество забронированных единиц                                                   |
+| `sale_quantity`     | `int`        | Количество проданных единиц                                                         |
+| `quantity_begin`    | `int`        | Минимальное количество заказа                                                       |
+| `url`               | `str`        | Прямая ссылка на страницу товара (`https://detail.1688.com/offer/{id}.html`)        |
+| `category_id`       | `int`        | Идентификатор категории товара                                                      |
+| `tags`              | `List[str]`  | Список идентификаторов тегов (рыночные, членские, праздничные и т. д.)              |
+| `service_labels`    | `List[str]`  | Список активных сервисных меток (например, «Быстрая доставка»)                      |
+| `raw_data`          | `Dict`       | Исходные данные товара из JSON ответа                                               |
+## Класс DetailProduct (парсинг по ID)
+| Атрибут | Тип | Описание |
+|---------|-----|-----------|
+| `id` | `str` | ID товара |
+| `name` | `str` | Название товара |
+| `brand` | `str` | Бренд товара |
+| `company` | `str` | Название компании |
+| `grade` | `str` | Рейтинг товара |
+| `weight` | `str` | Вес/объем товара |
+| `goods` | `List[Dict]` | Список вариантов товара с ценами и изображениями |
+| `repeat_orders` | `str` | Процент повторных заказов |
+| `saledCount` | `int` | Количество продаж |
+| `raw_data` | `Dict` | Исходные данные товара из JSON ответа |
+
+## Методы
+```python
+search_by_image(image_path: str, timeout: float = None) -> List[Product]
+```
+
+### Параметры:
+1. **image_path** - путь к файлу изображения
+2. **timeout** - таймаут запроса в секундах (по умолчанию используется default_timeout сессии)
+### Возвращает: список объектов Product
+
+```python
+get_by_id(offer_id: str, timeout: float = None) -> DetailProduct
+```
+### Получение детальной информации о товаре по его ID.
+### Параметры:
+1. **offer_id** - ID товара на 1688.com
+2. **timeout** - таймаут запроса в секундах (по умолчанию используется default_timeout сессии)
+### Возвращает: объект DetailProduct или None если товар не найден
+
+## Конвертация в словарь
+```python
+product_dict = product.to_dict()
+detailed_product_dict = detailed_product.to_dict()
+```
+
+## Пример конвертации в словарь
+```python
+product_dict = product.to_dict()
+print(product_dict)
+```
+
+## Работа с вариантами товара
+```python
+detailed_product = session.get_by_id("741375431874", timeout=30)
+if detailed_product:
+    for variant in detailed_product.goods:
+        print(f"Вариант: {variant['name']}")
+        print(f"Цена: {variant['price']}")
+        print(f"Изображение: {variant['imageUrl']}")
+```
+
+## Лицензия
+
+MIT

search1688api-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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/search1688api.egg-info/PKG-INFO

@@ -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/search1688api.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+search1688api/__init__.py
+search1688api/async_session.py
+search1688api/models.py
+search1688api/sync_session.py
+search1688api/utils.py
+search1688api.egg-info/PKG-INFO
+search1688api.egg-info/SOURCES.txt
+search1688api.egg-info/dependency_links.txt
+search1688api.egg-info/requires.txt
+search1688api.egg-info/top_level.txt

search1688api-1.0.0/search1688api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

search1688api-1.0.0/search1688api.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.25.0
+aiohttp>=3.8.0
+yarl>=1.6.0

search1688api-1.0.0/search1688api.egg-info/top_level.txt

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

search1688api-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

search1688api-1.0.0/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="search1688api",
+    version="1.0.0",
+    author="netkaruma",
+    author_email="suzumekaruma@gmail.com",
+    description="Python library for searching products on 1688.com by image",
+    packages=find_packages(),
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.0",
+        "aiohttp>=3.8.0",
+        "yarl>=1.6.0",
+    ],
+)