update config and wildberries_client

config.py

@@ -15,12 +15,17 @@ class Config:
     
     def __init__(self):
         self.wildberries_api_token = os.getenv("WILDBERRIES_API_TOKEN")
+        
+        # Official Wildberries API URLs based on documentation
         self.wildberries_base_url = "https://statistics-api.wildberries.ru"
         self.wildberries_content_url = "https://content-api.wildberries.ru"
         self.wildberries_analytics_url = "https://seller-analytics-api.wildberries.ru"
         self.wildberries_common_url = "https://common-api.wildberries.ru"
+        self.wildberries_marketplace_url = "https://marketplace-api.wildberries.ru"
+        self.wildberries_supplies_url = "https://supplies-api.wildberries.ru"
         
-        # Rate limiting settings (matches official documentation)
+        # Rate limiting settings (based on official documentation)
+        # Statistics API: Maximum of 300 requests per minute
         self.rate_limit_requests = 300  # requests per minute
         self.rate_limit_window = 60     # seconds
         
@@ -58,7 +63,6 @@ class Config:
         return {
             "requests_per_minute": self.rate_limit_requests,
             "window_seconds": self.rate_limit_window,
-            "burst_allowance": self.rate_limit_burst,
             "backoff_factor": self.retry_backoff_factor
         }
     
@@ -67,37 +71,47 @@ class Config:
         return self.wildberries_api_token is not None and len(self.wildberries_api_token) > 0
     
     def get_endpoints(self) -> Dict[str, str]:
-        """Get API endpoint configurations"""
+        """Get API endpoint configurations based on official documentation"""
         return {
+            # Statistics API endpoints
             "sales": f"{self.wildberries_base_url}/api/v1/supplier/sales",
-            "orders": f"{self.wildberries_base_url}/api/v1/supplier/orders",
+            "orders": f"{self.wildberries_base_url}/api/v1/supplier/orders", 
             "stocks": f"{self.wildberries_base_url}/api/v1/supplier/stocks",
             "incomes": f"{self.wildberries_base_url}/api/v1/supplier/incomes",
             "reportDetailByPeriod": f"{self.wildberries_base_url}/api/v1/supplier/reportDetailByPeriod",
+            
+            # Analytics API endpoints
             "analytics": f"{self.wildberries_analytics_url}/api/v2/nm-report/detail",
+            
+            # Content API endpoints
             "content": f"{self.wildberries_content_url}/content/v1/cards/cursor/list",
+            
+            # Common API endpoints
+            "news": f"{self.wildberries_common_url}/api/communications/v2/news",
+            "seller_info": f"{self.wildberries_common_url}/api/v1/seller-info",
+            
+            # Connection check endpoints for each service
             "ping_statistics": f"{self.wildberries_base_url}/ping",
-            "ping_content": f"{self.wildberries_content_url}/ping",
+            "ping_content": f"{self.wildberries_content_url}/ping", 
             "ping_analytics": f"{self.wildberries_analytics_url}/ping",
             "ping_common": f"{self.wildberries_common_url}/ping",
-            "news": f"{self.wildberries_common_url}/api/communications/v2/news",
-            "seller_info": f"{self.wildberries_common_url}/api/v1/seller-info"
+            "ping_marketplace": f"{self.wildberries_marketplace_url}/ping",
+            "ping_supplies": f"{self.wildberries_supplies_url}/ping"
         }
     
     def validate_token(self, token: str) -> bool:
-        """Validate the format of a Wildberries API token"""
+        """Validate the format of a Wildberries API token (JWT format)"""
         if not token:
             return False
         
-        # Basic validation - Wildberries tokens are typically base64-encoded JWTs
-        # This is a simple check, not comprehensive
+        # Wildberries tokens are JWT format based on official documentation
         try:
             # Check if it looks like a JWT (three parts separated by dots)
             parts = token.split('.')
             if len(parts) != 3:
                 return False
             
-            # Check minimum length
+            # Check minimum length (JWT tokens are typically longer)
             if len(token) < 50:
                 return False
                 

wildberries_client.py

@@ -389,4 +389,123 @@ class WildberriesAPI:
                 "message": f"API connection failed: {str(e)}",
                 "records_count": 0,
                 "rate_limit_remaining": 0
+            }
+    
+    def ping(self, service: str = "statistics") -> Dict[str, Any]:
+        """
+        Test connection to specific WB API service
+        
+        Args:
+            service: API service to ping (statistics, content, analytics, common, marketplace, supplies)
+        
+        Returns:
+            Dict with ping result
+            
+        Note: Rate limit is 3 requests every 30 seconds per service
+        """
+        endpoint_key = f"ping_{service}"
+        if endpoint_key not in self.config.get_endpoints():
+            raise WildberriesAPIError(f"Unknown service: {service}")
+        
+        endpoint = self.config.get_endpoints()[endpoint_key]
+        
+        try:
+            # Simple request without using main rate limiter (ping has separate limits)
+            response = self.session.get(endpoint, timeout=10)
+            
+            if response.ok:
+                data = response.json()
+                return {
+                    "status": "success",
+                    "service": service,
+                    "timestamp": data.get("TS"),
+                    "api_status": data.get("Status"),
+                    "message": f"Connection to {service} API successful"
+                }
+            else:
+                return {
+                    "status": "error", 
+                    "service": service,
+                    "message": f"HTTP {response.status_code}: {response.text}"
+                }
+                
+        except Exception as e:
+            return {
+                "status": "error",
+                "service": service, 
+                "message": f"Connection failed: {str(e)}"
+            }
+    
+    def get_seller_info(self) -> Dict[str, Any]:
+        """
+        Get seller information including name and account ID
+        
+        Returns:
+            Dict with seller information
+            
+        Note: Maximum 1 request per minute per seller account
+        """
+        endpoint = self.config.get_endpoints()["seller_info"]
+        
+        try:
+            response = self._make_request("GET", endpoint)
+            
+            return {
+                "name": response.get("name"),
+                "seller_id": response.get("sid"), 
+                "trade_mark": response.get("tradeMark"),
+                "status": "success"
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching seller info: {str(e)}")
+            return {
+                "status": "error",
+                "message": f"Failed to fetch seller info: {str(e)}"
+            }
+    
+    def get_news(self, from_date: str = None, from_id: int = None, limit: int = 100) -> Dict[str, Any]:
+        """
+        Get seller portal news
+        
+        Args:
+            from_date: Date from which to get news (YYYY-MM-DD format)
+            from_id: News ID to start from (including it)
+            limit: Maximum number of news items (up to 100)
+        
+        Returns:
+            Dict with news data
+            
+        Note: Maximum 10 requests per 10 minutes per seller account
+        """
+        endpoint = self.config.get_endpoints()["news"]
+        
+        params = {}
+        if from_date:
+            params["from"] = from_date
+        if from_id:
+            params["fromID"] = from_id
+            
+        if not from_date and not from_id:
+            # Default to last 7 days if no parameters specified
+            from_date = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
+            params["from"] = from_date
+        
+        try:
+            response = self._make_request("GET", endpoint, params=params)
+            
+            news_items = response.get("data", [])
+            
+            return {
+                "status": "success",
+                "count": len(news_items),
+                "news": news_items[:limit] if len(news_items) > limit else news_items
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching news: {str(e)}")
+            return {
+                "status": "error", 
+                "message": f"Failed to fetch news: {str(e)}",
+                "news": []
             }