tgshops-integrations 2.3__tar.gz → 3.0__tar.gz

{tgshops_integrations-2.3 → tgshops_integrations-3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tgshops_integrations
-Version: 2.3
+Version: 3.0
 Summary: Library is intended to provide the integration of the external service or CRM system with the TelegramShops/It allows to configure the relationship between NocoDB list of the products used further to display in the shop/As a resultss the products can be synchronized and updated uppon the request.
 Home-page: https://git.the-devs.com/virtual-shops/shop-system/shop-backend-integrations/integration-library/integration-library
 Author: Dimi Latoff

{tgshops_integrations-2.3 → tgshops_integrations-3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup,find_packages
 
 setup(
     name='tgshops_integrations',
-    version='2.3',
+    version='3.0',
     packages=find_packages(),
     install_requires=[
         # List your library's dependencies here

tgshops_integrations-3.0/tgshops_integrations/middlewares/gateway.py

@@ -0,0 +1,143 @@
+from typing import List, Optional
+from pathlib import Path
+import importlib.util
+
+from aiocache import cached
+from models.products import ProductModel
+
+# TODO: For test purposes, remove in production
+import sys
+sys.path.append('/home/latoff/Desktop/MarketBots')
+
+from tgshops_integrations.nocodb_connector.client import NocodbClient
+from tgshops_integrations.nocodb_connector.model_mapping import (
+    dump_product_data,
+    dump_product_data_with_check,
+    get_pagination_info,
+    ID_FIELD,
+    parse_product_data,
+    PRODUCT_CATEGORY_ID_LOOKUP_FIELD,
+    PRODUCT_NAME_FIELD,
+    PRODUCT_PRICE_FIELD,
+    PRODUCT_STOCK_FIELD,
+    PRODUCT_IMAGES_LOOKUP_FIELD,
+    PRODUCT_EXTERNAL_ID,
+)
+from services.nocodb_connector.categories import CategoryManager
+from services.nocodb_connector.products import ProductManager
+from loguru import logger
+
+
+def custom_key_builder(func, *args, **kwargs):
+    """
+    Key builder function for caching.
+    Excludes 'self' by processing args from args[1:].
+    """
+    args_key_part = "-".join(str(arg) for arg in args[1:])
+    kwargs_key_part = "-".join(f"{key}-{value}" for key, value in sorted(kwargs.items()))
+    return f"{func.__name__}-{args_key_part}-{kwargs_key_part}"
+
+
+class Gateway(NocodbClient):
+
+    def __init__(
+        self,
+        logging: bool = False,
+        NOCODB_HOST: Optional[str] = None,
+        NOCODB_API_KEY: Optional[str] = None,
+        SOURCE: Optional[str] = None,
+        filter_buttons: Optional[List[str]] = [],
+        config_path: Optional[Path] = None,
+        special_attributes: bool = False,
+    ):
+        super().__init__(NOCODB_HOST=NOCODB_HOST, NOCODB_API_KEY=NOCODB_API_KEY, SOURCE=SOURCE)
+
+        self.logging = logging
+        self.required_fields = []
+        self.projection = []
+        self.special_attributes = special_attributes
+        self.filter_buttons = filter_buttons
+
+        if config_path:
+            self.load_config_from_path(config_path)
+
+    def load_config_from_path(self, config_path: Path):
+        """Loads configuration from the specified path."""
+        if config_path.exists():
+            spec = importlib.util.spec_from_file_location("config", config_path)
+            self.config = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(self.config)
+        else:
+            raise FileNotFoundError(f"Configuration file not found at {config_path}")
+
+    async def load_data(self, SOURCE: Optional[str] = None):
+        """Loads necessary data including tables, categories, and products."""
+        self.SOURCE = SOURCE
+        self.tables_list = await self.get_all_tables()
+        self.products_table = self.tables_list[self.config.NOCODB_PRODUCTS]
+        self.category_manager = CategoryManager(
+            table_id=self.tables_list[self.config.NOCODB_CATEGORIES],
+            NOCODB_HOST=self.NOCODB_HOST,
+            NOCODB_API_KEY=self.NOCODB_API_KEY,
+            logging=True,
+            filter_buttons=self.filter_buttons,
+        )
+        self.product_manager = ProductManager(
+            table_id=self.tables_list[self.config.NOCODB_PRODUCTS],
+            NOCODB_HOST=self.NOCODB_HOST,
+            NOCODB_API_KEY=self.NOCODB_API_KEY,
+            logging=True,
+        )
+
+    @cached(ttl=60, key_builder=custom_key_builder)
+    async def update_attributes(self, products: List[ProductModel]):
+        """Updates attributes for the product table."""
+        system_attributes = [PRODUCT_EXTERNAL_ID, PRODUCT_IMAGES_LOOKUP_FIELD]
+        attributes = await self.get_table_meta(table_name=self.products_table)
+        self.columns = [item['title'].lower() for item in attributes.get('columns', [])]
+
+        # Ensure system attributes exist
+        for attribute_name in system_attributes:
+            if attribute_name.lower() not in self.columns:
+                await self.create_table_column(table_name=self.products_table, name=attribute_name)
+                logger.info(f"Created attribute: {attribute_name}")
+
+        # Validate and add extra attributes
+        for item in products:
+            attributes = await self.get_table_meta(table_name=self.products_table)
+            self.columns = [col['title'].lower() for col in attributes.get('columns', [])]
+
+            for attribute in item.extra_attributes:
+                if attribute.name.rstrip().lower() not in self.columns:
+                    await self.create_table_column(table_name=self.products_table, name=attribute.name.lower())
+                    logger.info(f"Created attribute: {attribute.name.lower()}")
+
+    async def update_products(self, external_products: List[ProductModel]):
+        """Updates product data by comparing with existing records."""
+        await self.update_attributes(products=external_products)
+        self.actual_products = await self.product_manager.get_all_products()
+        self.ids_mapping = {product.external_id: product.id for product in self.actual_products}
+        self.products_meta = {product.external_id: product for product in self.actual_products}
+
+        for product in external_products:
+            if product.external_id in self.ids_mapping:
+                product.id = self.ids_mapping[product.external_id]
+                current_hash = self.product_manager.hash_product(product, special_attributes=self.special_attributes)
+                existing_hash = self.product_manager.hash_product(
+                    self.products_meta[product.external_id],
+                    special_attributes=self.special_attributes,
+                )
+                if current_hash != existing_hash:
+                    await self.product_manager.update_product(product=product)
+            else:
+                checked_data = dump_product_data_with_check(
+                    data=product,
+                    data_check=self.category_manager.categories,
+                )
+                await self.product_manager.create_product(product=product, checked_data=checked_data)
+
+    async def delete_all_products(self):
+        """Deletes all products in the table."""
+        items = await self.product_manager.get_products_v2(offset=0, limit=200)
+        for item in items:
+            await self.product_manager.delete_table_record(self.products_table, item.id)

{tgshops_integrations-2.3 → tgshops_integrations-3.0}/tgshops_integrations/models/products.py

@@ -4,7 +4,6 @@ from datetime import datetime
 
 from pydantic import BaseModel, Field, schema, validator
 
-
 class ExtraAttribute(BaseModel):
     name: str
     description: Optional[str]
@@ -29,12 +28,12 @@ class ExternalProductModel(BaseModel):
 class ProductModel(BaseModel):
     id: Optional[str]
     external_id: Optional[str]
-    category: Optional[List[str]]
+    category: Optional[List[int]]
     category_name: Optional[List[str]]
     name: str
     description: Optional[str]
     price: Optional[float]
-    final_price: Optional[float]
+    final_price: Optional[int]
     currency: Optional[str]
     stock_qty: int
     orders_qty: int = Field(0, hidden_field=True)

tgshops_integrations-3.0/tgshops_integrations/nocodb_connector/categories_management.py

@@ -0,0 +1,149 @@
+from typing import List
+from loguru import logger
+from aiocache import cached
+from models.categories import CategoryModel, CategoryResponseModel, CategoryListResponseModel
+from models.products import ProductModel
+from tgshops_integrations.nocodb_connector.client import custom_key_builder, NocodbClient
+from tgshops_integrations.nocodb_connector.model_mapping import (
+    CATEGORY_IMAGE_FIELD,
+    CATEGORY_NAME_FIELD,
+    CATEGORY_PARENT_FIELD,
+    CATEGORY_PARENT_ID_FIELD,
+    PRODUCT_NAME_FIELD,
+    CATEGORY_ID_OF_CATEGORY_FIELD,
+    dump_category_data,
+    get_pagination_info,
+    parse_category_data,
+)
+
+class CategoryManager(NocodbClient):
+    def __init__(
+        self,
+        table_id=None,
+        logging=False,
+        config_type=None,
+        NOCODB_HOST=None,
+        NOCODB_API_KEY=None,
+        SOURCE=None,
+        filter_buttons=None,
+    ):
+        super().__init__(NOCODB_HOST=NOCODB_HOST, NOCODB_API_KEY=NOCODB_API_KEY, SOURCE=SOURCE)
+        self.NOCODB_HOST = NOCODB_HOST
+        self.NOCODB_API_KEY = NOCODB_API_KEY
+        self.SOURCE = SOURCE
+        self.CONFIG_TYPE = config_type
+        self.categories_table = table_id
+        self.external_categories = {}
+        self.logging = logging
+        self.filter_categories = []
+        self.filter_buttons = filter_buttons or []
+        self.required_fields = [CATEGORY_NAME_FIELD]
+        self.projection = ["Id", CATEGORY_NAME_FIELD, CATEGORY_PARENT_ID_FIELD, CATEGORY_ID_OF_CATEGORY_FIELD]
+
+    @cached(ttl=30, key_builder=custom_key_builder)
+    async def get_categories(self, table_id: str) -> List[CategoryModel]:
+        records = await self.get_table_records(table_id, self.required_fields, self.projection)
+        return [parse_category_data(record) for record in records]
+
+    @cached(ttl=30, key_builder=custom_key_builder)
+    async def get_categories_v2(self, table_id: str, offset: int = None, limit: int = None) -> CategoryListResponseModel:
+        response = await self.get_table_records_v2(
+            table_name=self.categories_table,
+            required_fields=self.required_fields,
+            projection=self.projection,
+            offset=offset,
+            limit=limit,
+        )
+        page_info = get_pagination_info(page_info=response['pageInfo'])
+        categories = [parse_category_data(record) for record in response['list']]
+        return CategoryListResponseModel(categories=categories, page_info=page_info)
+
+    @cached(ttl=30, key_builder=custom_key_builder)
+    async def get_category(self, table_id: str, category_id: str) -> CategoryModel:
+        record = await self.get_table_record(self.categories_table, category_id, self.required_fields, self.projection)
+        return parse_category_data(record)
+
+    async def create_category(self, table_id: str, category: CategoryModel) -> CategoryModel:
+        category_json = dump_category_data(category)
+        record = await self.create_table_record(self.categories_table, category_json)
+        return parse_category_data(record)
+
+    @cached(ttl=30, key_builder=custom_key_builder)
+    async def get_categories_in_category(self, table_id: str, category_id: str) -> List[CategoryModel]:
+        extra_where = (
+            f"({CATEGORY_PARENT_ID_FIELD},eq,{category_id})"
+            if category_id
+            else f"({CATEGORY_PARENT_FIELD},eq,0)"
+        )
+        records = await self.get_table_records(
+            table_name=self.categories_table,
+            required_fields=self.required_fields,
+            projection=self.projection,
+            extra_where=extra_where,
+        )
+        return [parse_category_data(record) for record in records]
+
+    async def update_categories(self, external_products: List[ProductModel]) -> None:
+        self.categories = await self.get_product_categories(table_id=self.categories_table, table_name=PRODUCT_NAME_FIELD)
+        categories_list = list(self.categories.keys())
+        properties_to_create = []
+
+        for product in external_products:
+            for num, product_property in enumerate(product.product_properties):
+                if product_property not in categories_list:
+                    parent_id = (
+                        self.categories[self.filter_buttons[num]]
+                        if self.filter_buttons
+                        else self.categories[product.category_I_name[0]]
+                    )
+                    properties_to_create.append([product_property, parent_id])
+                    categories_list.append(product_property)
+
+        if properties_to_create:
+            properties_to_create.sort(key=lambda x: x[0])
+            new_id = max(self.categories.values(), default=0) + 1
+
+            for product_property, parent_id in properties_to_create:
+                new_property = await self.create_product_category(
+                    table_id=self.categories_table,
+                    property_name=product_property,
+                    category_id=new_id,
+                    table_name=PRODUCT_NAME_FIELD,
+                )
+                if self.logging:
+                    logger.info(f"New Category: {new_property}")
+                new_id += 1
+
+    async def link_categories(self, parent_id: int, child_id: int):
+        metadata = await self.get_table_meta(self.categories_table)
+        linked_column = next((col for col in metadata['columns'] if col["title"] == "Set parent category" and col["uidt"] == "Links"), None)
+
+        if linked_column:
+            await self.link_table_record(
+                linked_column["base_id"],
+                linked_column["fk_model_id"],
+                child_id,
+                linked_column["id"],
+                parent_id,
+            )
+
+    async def unlink_categories(self, parent_id: int, child_id: int):
+        metadata = await self.get_table_meta(self.categories_table)
+        linked_column = next((col for col in metadata['columns'] if col["uidt"] == "Links"), None)
+
+        if linked_column:
+            await self.unlink_table_record(
+                linked_column["base_id"],
+                linked_column["fk_model_id"],
+                parent_id,
+                linked_column["id"],
+                child_id,
+            )
+
+    async def map_categories(self, external_products: List[ProductModel]) -> List[ProductModel]:
+        for num, product in enumerate(external_products):
+            if not product.category and product.product_properties:
+                external_products[num].category = [
+                    str(self.categories[property_name]) for property_name in product.product_properties
+                ]
+        return external_products

tgshops_integrations-3.0/tgshops_integrations/nocodb_connector/client.py

@@ -0,0 +1,288 @@
+from typing import List, Optional, Dict, Union
+import httpx
+import requests
+import io
+from loguru import logger
+from tgshops_integrations.nocodb_connector.model_mapping import ID_FIELD
+
+
+def custom_key_builder(func, *args, **kwargs) -> str:
+    """
+    Custom key builder for caching.
+    Excludes 'self' by starting args processing from args[1:].
+    """
+    args_key_part = "-".join(str(arg) for arg in args[1:])
+    kwargs_key_part = "-".join(f"{key}-{value}" for key, value in sorted(kwargs.items()))
+    return f"{func.__name__}-{args_key_part}-{kwargs_key_part}"
+
+
+class NocodbClient:
+    def __init__(self, NOCODB_HOST: Optional[str] = None, NOCODB_API_KEY: Optional[str] = None, SOURCE: Optional[str] = None):
+        self.NOCODB_HOST = NOCODB_HOST
+        self.NOCODB_API_KEY = NOCODB_API_KEY
+        self.SOURCE = SOURCE
+        self.httpx_client = httpx.AsyncClient(timeout=60.0)
+        self.httpx_client.headers = {"xc-token": self.NOCODB_API_KEY}
+
+    def construct_get_params(
+        self,
+        required_fields: Optional[List[str]] = None,
+        projection: Optional[List[str]] = None,
+        extra_where: Optional[str] = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None
+    ) -> Dict[str, Union[str, int]]:
+        """
+        Constructs GET parameters for API requests.
+        """
+        params = {}
+        if projection:
+            params["fields"] = ','.join(projection)
+        if required_fields:
+            params["where"] = "~and".join(f"({field},isnot,null)" for field in required_fields)
+        if extra_where:
+            params["where"] = f"{params.get('where', '')}~and{extra_where}" if params.get("where") else extra_where
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        return params
+
+    async def get_table_records(
+        self,
+        table_name: str,
+        required_fields: Optional[List[str]] = None,
+        projection: Optional[List[str]] = None,
+        extra_where: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> List[dict]:
+        """
+        Fetches records from a specified table.
+        """
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        params = self.construct_get_params(required_fields, projection, extra_where, limit=limit)
+        response = await self.httpx_client.get(url, params=params)
+        if response.status_code == 200:
+            return response.json().get("list", [])
+        logger.error(f"Error fetching records: {response.text}")
+        raise Exception(response.text)
+    
+    async def get_table_records_v2(self,
+                                   table_name: str,
+                                   required_fields: list = None,
+                                   projection: list = None,
+                                   extra_where: str = None,
+                                   offset: int = None,
+                                   limit: int = 25) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        extra_params = self.construct_get_params(required_fields, projection, extra_where, offset=offset, limit=limit)
+        response = await self.httpx_client.get(url, params=extra_params)
+        if response.status_code == 200:
+            return response.json()
+        raise Exception(response.text)
+
+    async def get_table_record(self,
+                               table_name: str,
+                               record_id: str,
+                               required_fields: list = None,
+                               projection: list = None) -> dict:
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records/{record_id}"
+        extra_params = self.construct_get_params(required_fields, projection)
+        response = await self.httpx_client.get(url, params=extra_params)
+        if response.status_code == 200:
+            return response.json()
+        raise Exception(response.text)
+
+    async def create_table_record(self, table_name: str, record: dict) -> dict:
+        """
+        Creates a new record in a table.
+        """
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        response = await self.httpx_client.post(url, json=record)
+        if response.status_code == 200:
+            record["id"] = response.json().get("id") or response.json().get("Id")
+            return record
+        logger.error(f"Error creating record: {response.text}")
+        raise Exception(response.text)
+
+    async def delete_table_record(self, table_name: str, record_id: str) -> dict:
+        """
+        Deletes a record from a specified table.
+        """
+        url = f"{self.NOCODB_HOST}/tables/{table_name}/records"
+        response = requests.delete(url, json={"Id": record_id}, headers=self.httpx_client.headers)
+        if response.status_code == 200:
+            logger.info(f"Deleted record {record_id}")
+            return response.json()
+        logger.error(f"Error deleting record: {response.text}")
+        raise Exception(response.text)
+
+    async def get_product_categories(self, table_id: str, table_name: str) -> Dict[str, str]:
+        """
+        Fetches product categories from a specified table.
+        """
+        url = f"{self.NOCODB_HOST}/tables/{table_id}/records"
+        params = self.construct_get_params(limit=75)
+        response = await self.httpx_client.get(url, params=params)
+        if response.status_code == 200:
+            return {category[table_name]: category["Id"] for category in response.json().get("list", [])}
+        logger.error(f"Error fetching categories: {response.text}")
+        raise Exception(response.text)
+
+    async def create_product_category(
+        self, table_id: str, category_name: str, table_name: str, category_id: int = 0
+    ) -> dict:
+        """
+        Creates a new product category in a specified table.
+        """
+        url = f"{self.NOCODB_HOST}/tables/{table_id}/records"
+        record = {table_name: category_name, "Id": category_id}
+        response = await self.httpx_client.post(url, json=record)
+        if response.status_code == 200:
+            return record
+        logger.error(f"Error creating product category: {response.text}")
+        raise Exception(response.text)
+
+    async def get_table_meta(self, table_name: str) -> dict:
+        """
+        Fetches metadata of a table.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_name}"
+        response = await self.httpx_client.get(url)
+        if response.status_code == 200:
+            return response.json()
+        logger.error(f"Error fetching table metadata: {response.text}")
+        raise Exception(response.text)
+
+    async def get_all_tables(self, source: Optional[str] = None) -> Dict[str, str]:
+        """
+        Fetches all tables from the specified project source.
+        """
+        source = source or self.SOURCE
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/projects/{source}/tables?includeM2M=false"
+        response = await self.httpx_client.get(url)
+        if response.status_code == 200:
+            tables_info = response.json().get('list', [])
+            self.tables_list = {table["title"]: table["id"] for table in tables_info}
+            return self.tables_list
+        logger.error(f"Failed to fetch tables: {response.text}")
+        raise Exception(response.text)
+
+    async def get_sources(self) -> list:
+        """
+        Fetches all project sources.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/projects/"
+        response = await self.httpx_client.get(url)
+        if response.status_code == 200:
+            return response.json().get('list', [])
+        logger.error(f"Failed to fetch sources: {response.text}")
+        raise Exception(response.text)
+
+    async def get_table_meta(self, table_name: str) -> dict:
+        """
+        Fetches metadata of a specified table.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_name}"
+        response = await self.httpx_client.get(url)
+        if response.status_code == 200:
+            return response.json()
+        logger.error(f"Failed to fetch table metadata: {response.text}")
+        raise Exception(response.text)
+
+    async def create_table_column(self, table_name: str, name: str) -> dict:
+        """
+        Creates a new column in the specified table.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/meta/tables/{table_name}/columns"
+        payload = {
+            "column_name": name,
+            "dt": "character varying",
+            "dtx": "specificType",
+            "ct": "varchar(45)",
+            "clen": 45,
+            "dtxp": "45",
+            "dtxs": "",
+            "altered": 1,
+            "uidt": "SingleLineText",
+            "uip": "",
+            "uicn": "",
+            "title": name
+        }
+        response = await self.httpx_client.post(url, json=payload)
+        if response.status_code == 200:
+            return response.json()
+        logger.error(f"Failed to create table column: {response.text}")
+        raise Exception(response.text)
+
+    async def link_table_record(
+        self,
+        base_id: str,
+        fk_model_id: str,
+        record_id: str,
+        source_column_id: str,
+        linked_record_id: str
+    ) -> dict:
+        """
+        Links a record to another record in a many-to-many relationship.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/data/noco/{base_id}/{fk_model_id}/{record_id}/mm/{source_column_id}/{linked_record_id}"
+        response = await self.httpx_client.post(url, headers=self.httpx_client.headers)
+        if response.status_code == 200:
+            return response.json()
+        logger.error(f"Failed to link table record: {response.text}")
+        raise Exception(response.text)
+
+    async def unlink_table_record(
+        self,
+        base_id: str,
+        fk_model_id: str,
+        record_id: str,
+        source_column_id: str,
+        linked_record_id: str
+    ) -> dict:
+        """
+        Unlinks a record from another record in a many-to-many relationship.
+        """
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/data/noco/{base_id}/{fk_model_id}/{record_id}/mm/{source_column_id}/{linked_record_id}"
+        response = await self.httpx_client.delete(url)
+        if response.status_code == 200:
+            return response.json()
+        logger.error(f"Failed to unlink table record: {response.text}")
+        raise Exception(response.text)
+
+    async def save_image_to_nocodb(
+        self,
+        image_url: str,
+        image_name: str,
+        source_column_id: str,
+        product_table_name: str,
+        images_column_id: str
+    ) -> Optional[str]:
+        """
+        Saves an image to NocoDB's storage.
+        """
+        try:
+            response = requests.get(image_url)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Error loading image from URL {image_url}: {e}")
+            return None
+
+        file = io.BytesIO(response.content)
+        file_size = file.getbuffer().nbytes
+
+        if not file_size:
+            logger.error(f"Image file from {image_url} is empty.")
+            return None
+
+        files = {'file': (image_name, file, 'image/jpeg')}
+        url = f"{self.NOCODB_HOST.replace('/api/v2', '/api/v1')}/db/storage/upload?path=noco/{source_column_id}/{product_table_name}/{images_column_id}"
+        try:
+            response = await self.httpx_client.post(url, files=files, timeout=httpx.Timeout(200.0))
+            if response.status_code == 200:
+                return response.json()[0].get('url', None)
+            logger.error(f"Error saving image {image_name}: {response.text}")
+        except Exception as e:
+            logger.error(f"Unexpected error saving image {image_name}: {e}")
+        return None