amochka 0.1.3__py3-none-any.whl → 0.1.6__py3-none-any.whl

amochka/__init__.py

@@ -2,4 +2,5 @@
 amochka: Библиотека для работы с API amoCRM.
 """
 
-from .client import AmoCRMClient
+from .client import AmoCRMClient, CacheConfig
+__all__ = ['AmoCRMClient', 'CacheConfig']

amochka/client.py

@@ -19,35 +19,46 @@ RATE_LIMIT = 7  # Максимум 7 запросов в секунду
 class Deal(dict):
     """
     Объект сделки расширяет стандартный словарь данными из custom_fields_values.
-    (Описание класса без изменений)
+
+    Обеспечивает два способа доступа к кастомным полям:
+      1. get(key): при обращении по названию (строкой) или по ID поля (integer)
+         возвращает текстовое значение поля (например, «Дурина Юлия»).
+      2. get_id(key): возвращает идентификатор выбранного варианта (enum_id) для полей типа select.
+         Если в данных enum_id отсутствует, производится поиск в переданной конфигурации полей,
+         сравнение выполняется без учёта регистра и лишних пробелов.
+
+    Параметр custom_fields_config – словарь, где ключи – ID полей, а значения – модели полей.
     """
-    def __init__(self, data, custom_fields_config=None):
+    def __init__(self, data, custom_fields_config=None, logger=None):
         super().__init__(data)
         self._custom = {}
         self._custom_config = custom_fields_config  # сохраняем конфигурацию кастомных полей
+        self._logger = logger or logging.getLogger(__name__)
         custom = data.get("custom_fields_values") or []
-        logger.debug(f"Processing custom_fields_values: {custom}")
+        self._logger.debug(f"Processing custom_fields_values: {custom}")
         for field in custom:
             if isinstance(field, dict):
                 field_name = field.get("field_name")
                 values = field.get("values")
                 if field_name and values and isinstance(values, list) and len(values) > 0:
                     key_name = field_name.lower().strip()
-                    # Сохраняем текстовое значение для доступа по названию
-                    self._custom[key_name] = values[0].get("value")
-                    logger.debug(f"Set custom field '{key_name}' = {self._custom[key_name]}")
+                    stored_value = values[0].get("value")
+                    stored_enum_id = values[0].get("enum_id")  # может быть None для некоторых полей
+                    # Сохраняем полную информацию (и для get() и для get_id())
+                    self._custom[key_name] = {"value": stored_value, "enum_id": stored_enum_id}
+                    self._logger.debug(f"Set custom field '{key_name}' = {{'value': {stored_value}, 'enum_id': {stored_enum_id}}}")
                 field_id = field.get("field_id")
                 if field_id is not None and values and isinstance(values, list) and len(values) > 0:
                     stored_value = values[0].get("value")
                     stored_enum_id = values[0].get("enum_id")  # может быть None для некоторых полей
                     self._custom[int(field_id)] = {"value": stored_value, "enum_id": stored_enum_id}
-                    logger.debug(f"Set custom field id {field_id} = {{'value': {stored_value}, 'enum_id': {stored_enum_id}}}")
+                    self._logger.debug(f"Set custom field id {field_id} = {{'value': {stored_value}, 'enum_id': {stored_enum_id}}}")
         if custom_fields_config:
             for cid, field_obj in custom_fields_config.items():
                 key = field_obj.get("name", "").lower().strip() if isinstance(field_obj, dict) else str(field_obj).lower().strip()
                 if key not in self._custom:
                     self._custom[key] = None
-                    logger.debug(f"Field '{key}' not found in deal data; set to None")
+                    self._logger.debug(f"Field '{key}' not found in deal data; set to None")
 
     def __getitem__(self, key):
         if key in super().keys():
@@ -69,11 +80,65 @@ class Deal(dict):
         except KeyError:
             return default
 
+    def get_field_type(self, key):
+        """
+        Определяет тип кастомного поля.
+        
+        :param key: Название поля (строка) или ID поля (integer).
+        :return: Строка с типом поля ('text', 'select', 'numeric', 'checkbox', и т.д.) 
+                 или None, если поле не найдено или тип не определён.
+        """
+        field_def = None
+        
+        # Получаем определение поля из конфигурации
+        if self._custom_config:
+            if isinstance(key, int):
+                field_def = self._custom_config.get(key)
+            else:
+                for fid, fdef in self._custom_config.items():
+                    if isinstance(fdef, dict) and fdef.get("name", "").lower().strip() == key.lower().strip():
+                        field_def = fdef
+                        break
+        
+        # Если нашли определение, возвращаем его тип
+        if field_def and isinstance(field_def, dict):
+            return field_def.get("type")
+        
+        # Если конфигурации нет или поле не найдено, пробуем определить тип по данным
+        stored = None
+        if isinstance(key, str):
+            lower_key = key.lower().strip()
+            if lower_key in self._custom:
+                stored = self._custom[lower_key]
+        elif isinstance(key, int):
+            if key in self._custom:
+                stored = self._custom[key]
+                
+        if isinstance(stored, dict) and "enum_id" in stored:
+            return "select"
+        
+        return None
+
     def get_id(self, key, default=None):
         """
-        Возвращает идентификатор выбранного варианта (enum_id) для кастомного поля.
-        (Описание метода без изменений)
+        Возвращает идентификатор выбранного варианта (enum_id) для кастомного поля типа select.
+        Для полей других типов возвращает их значение, как метод get().
+        
+        Если значение enum_id отсутствует в данных, производится поиск в конфигурации кастомных полей,
+        сравнение значения выполняется без учёта регистра и пробелов.
+
+        :param key: Название поля (строка) или ID поля (integer).
+        :param default: Значение по умолчанию, если enum_id не найден.
+        :return: Для полей типа select - идентификатор варианта (целое число).
+                 Для других типов полей - значение поля. 
+                 Если поле не найдено - default.
         """
+        field_type = self.get_field_type(key)
+        
+        # Если это не поле списка, возвращаем значение как get()
+        if field_type is not None and field_type != "select":
+            return self.get(key, default)
+            
         stored = None
         if isinstance(key, str):
             lower_key = key.lower().strip()
@@ -100,48 +165,125 @@ class Deal(dict):
                     for enum in enums:
                         if enum.get("value", "").lower().strip() == stored.get("value", "").lower().strip():
                             return enum.get("id", default)
-        return default
+        
+        # Если это не поле типа select или не удалось найти enum_id, 
+        # возвращаем значение поля
+        return self.get(key, default)
+
+class CacheConfig:
+    """
+    Конфигурация кэширования для AmoCRMClient.
+    
+    Параметры:
+        enabled (bool): Включено ли кэширование
+        storage (str): Тип хранилища ('file' или 'memory')
+        file (str): Путь к файлу кэша (используется только при storage='file')
+        lifetime_hours (int|None): Время жизни кэша в часах (None для бесконечного)
+    """
+    def __init__(self, enabled=True, storage='file', file=None, lifetime_hours=24):
+        self.enabled = enabled
+        self.storage = storage.lower()
+        self.file = file
+        self.lifetime_hours = lifetime_hours
+    
+    @classmethod
+    def disabled(cls):
+        """Создает конфигурацию с отключенным кэшированием"""
+        return cls(enabled=False)
+    
+    @classmethod
+    def memory_only(cls, lifetime_hours=24):
+        """Создает конфигурацию с кэшированием только в памяти"""
+        return cls(enabled=True, storage='memory', lifetime_hours=lifetime_hours)
+    
+    @classmethod
+    def file_cache(cls, file=None, lifetime_hours=24):
+        """Создает конфигурацию с файловым кэшированием"""
+        return cls(enabled=True, storage='file', file=file, lifetime_hours=lifetime_hours)
 
 class AmoCRMClient:
     """
     Клиент для работы с API amoCRM.
-    (Описание класса без изменений, за исключением добавления параметра use_file_cache)
+
+    Основные функции:
+      - load_token: Загружает и проверяет токен авторизации.
+      - _make_request: Выполняет HTTP-запрос с учетом ограничения по скорости.
+      - get_deal_by_id: Получает данные сделки по ID и возвращает объект Deal.
+      - get_custom_fields_mapping: Загружает и кэширует список кастомных полей.
+      - find_custom_field_id: Ищет кастомное поле по его названию.
+      - update_lead: Обновляет сделку, включая стандартные и кастомные поля.
+
+    Дополнительно можно задать уровень логирования через параметр log_level,
+    либо полностью отключить логирование, установив disable_logging=True.
     """
-    def __init__(self, base_url, token_file=None, cache_file=None, log_level=logging.INFO, disable_logging=False, use_file_cache=True):
+    def __init__(
+        self, 
+        base_url, 
+        token_file=None, 
+        cache_config=None, 
+        log_level=logging.INFO, 
+        disable_logging=False
+    ):
         """
-        Инициализирует клиента, задавая базовый URL, токен авторизации и файл кэша для кастомных полей.
+        Инициализирует клиента, задавая базовый URL, токен авторизации и настройки кэша для кастомных полей.
         
-        :param use_file_cache: Если True, кэш будет сохраняться в файл; иначе — только в оперативной памяти.
+        :param base_url: Базовый URL API amoCRM.
+        :param token_file: Файл, содержащий токен авторизации.
+        :param cache_config: Конфигурация кэширования (объект CacheConfig или None для значений по умолчанию)
+        :param log_level: Уровень логирования (например, logging.DEBUG, logging.INFO).
+        :param disable_logging: Если True, логирование будет отключено.
         """
         self.base_url = base_url.rstrip('/')
         domain = self.base_url.split("//")[-1].split(".")[0]
         self.domain = domain
         self.token_file = token_file or os.path.join(os.path.expanduser('~'), '.amocrm_token.json')
-        if not cache_file:
-            cache_file = f"custom_fields_cache_{self.domain}.json"
-        self.cache_file = cache_file
-        self.use_file_cache = use_file_cache
-        self.token = self.load_token()
-        self._custom_fields_mapping = None
-
+        
+        # Создаем логгер для конкретного экземпляра клиента
+        self.logger = logging.getLogger(f"{__name__}.{self.domain}")
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+            self.logger.propagate = False  # Отключаем передачу логов в родительский логгер
+        
         if disable_logging:
-            logging.disable(logging.CRITICAL)
+            self.logger.setLevel(logging.CRITICAL + 1)  # Выше, чем любой стандартный уровень
+        else:
+            self.logger.setLevel(log_level)
+        
+        # Настройка кэширования
+        if cache_config is None:
+            self.cache_config = CacheConfig()
         else:
-            logger.setLevel(log_level)
+            self.cache_config = cache_config
+            
+        # Установка файла кэша, если используется файловое хранилище
+        if self.cache_config.enabled and self.cache_config.storage == 'file':
+            if not self.cache_config.file:
+                self.cache_config.file = f"custom_fields_cache_{self.domain}.json"
         
-        logger.debug(f"AmoCRMClient initialized for domain {self.domain}")
+        self.logger.debug(f"AmoCRMClient initialized for domain {self.domain}")
+        
+        self.token = self.load_token()
+        self._custom_fields_mapping = None
 
     def load_token(self):
-        # Метод без изменений
+        """
+        Загружает токен авторизации из файла или строки, проверяет его срок действия.
+
+        :return: Действительный access_token.
+        :raises Exception: Если токен не найден или истёк.
+        """
         data = None
         if os.path.exists(self.token_file):
             with open(self.token_file, 'r') as f:
                 data = json.load(f)
-            logger.debug(f"Token loaded from file: {self.token_file}")
+            self.logger.debug(f"Token loaded from file: {self.token_file}")
         else:
             try:
                 data = json.loads(self.token_file)
-                logger.debug("Token parsed from provided string.")
+                self.logger.debug("Token parsed from provided string.")
             except Exception as e:
                 raise Exception("Токен не найден и не удалось распарсить переданное содержимое.") from e
 
@@ -152,7 +294,7 @@ class AmoCRMClient:
             expires_at = float(expires_at_str)
         
         if expires_at and time.time() < expires_at:
-            logger.debug("Token is valid.")
+            self.logger.debug("Token is valid.")
             return data.get('access_token')
         else:
             raise Exception("Токен найден, но он истёк. Обновите токен.")
@@ -160,77 +302,112 @@ class AmoCRMClient:
     @sleep_and_retry
     @limits(calls=RATE_LIMIT, period=1)
     def _make_request(self, method, endpoint, params=None, data=None):
-        # Метод без изменений
+        """
+        Выполняет HTTP-запрос к API amoCRM с учетом ограничения по скорости (rate limit).
+
+        :param method: HTTP-метод (GET, PATCH, POST, DELETE и т.д.).
+        :param endpoint: Конечная точка API (начинается с /api/v4/).
+        :param params: GET-параметры запроса.
+        :param data: Данные, отправляемые в JSON-формате.
+        :return: Ответ в формате JSON или None (если статус 204).
+        :raises Exception: При получении кода ошибки, отличного от 200/204.
+        """
         url = f"{self.base_url}{endpoint}"
         headers = {
             "Authorization": f"Bearer {self.token}",
             "Content-Type": "application/json"
         }
-        logger.debug(f"Making {method} request to {url} with params {params} and data {data}")
+        self.logger.debug(f"Making {method} request to {url} with params {params} and data {data}")
         response = requests.request(method, url, headers=headers, params=params, json=data)
         if response.status_code not in (200, 204):
-            logger.error(f"Request error {response.status_code}: {response.text}")
+            self.logger.error(f"Request error {response.status_code}: {response.text}")
             raise Exception(f"Ошибка запроса: {response.status_code}, {response.text}")
         if response.status_code == 204:
             return None
         return response.json()
 
-    def get_deal_by_id(self, deal_id):
-        # Метод без изменений
+    def get_deal_by_id(self, deal_id, skip_fields_mapping=False):
+        """
+        Получает данные сделки по её ID и возвращает объект Deal.
+        Если данные отсутствуют или имеют неверную структуру, выбрасывается исключение.
+        
+        :param deal_id: ID сделки для получения
+        :param skip_fields_mapping: Если True, не загружает справочник кастомных полей
+                                   (используйте для работы только с ID полей)
+        :return: Объект Deal с данными сделки
+        """
         endpoint = f"/api/v4/leads/{deal_id}"
         params = {'with': 'contacts,companies,catalog_elements,loss_reason,tags'}
         data = self._make_request("GET", endpoint, params=params)
-        custom_config = self.get_custom_fields_mapping()
-        logger.debug(f"Deal {deal_id} data received (содержимое полей не выводится полностью).")
-        return Deal(data, custom_fields_config=custom_config)
+        
+        # Проверяем, что получили данные и что они содержат ключ "id"
+        if not data or not isinstance(data, dict) or "id" not in data:
+            self.logger.error(f"Deal {deal_id} not found or invalid response: {data}")
+            raise Exception(f"Deal {deal_id} not found or invalid response.")
+
+        custom_config = None if skip_fields_mapping else self.get_custom_fields_mapping()
+        self.logger.debug(f"Deal {deal_id} data received (содержимое полей не выводится полностью).")
+        return Deal(data, custom_fields_config=custom_config, logger=self.logger)
 
     def _save_custom_fields_cache(self, mapping):
         """
         Сохраняет кэш кастомных полей в файл, если используется файловый кэш.
-        Если файловый кэш не используется, операция пропускается.
+        Если кэширование отключено или выбран кэш в памяти, операция пропускается.
         """
-        if not self.use_file_cache:
-            logger.debug("File caching disabled; cache stored in memory only.")
+        if not self.cache_config.enabled:
+            self.logger.debug("Caching disabled; cache not saved.")
+            return
+        if self.cache_config.storage != 'file':
+            self.logger.debug("Using memory caching; no file cache saved.")
             return
         cache_data = {"last_updated": time.time(), "mapping": mapping}
-        with open(self.cache_file, "w") as f:
+        with open(self.cache_config.file, "w") as f:
             json.dump(cache_data, f)
-        logger.debug(f"Custom fields cache saved to {self.cache_file}")
+        self.logger.debug(f"Custom fields cache saved to {self.cache_config.file}")
 
     def _load_custom_fields_cache(self):
         """
         Загружает кэш кастомных полей из файла, если используется файловый кэш.
-        Если файловый кэш не используется, возвращает None.
+        Если кэширование отключено или выбран кэш в памяти, возвращает None.
         """
-        if not self.use_file_cache:
-            logger.debug("File caching disabled; no cache loaded from file.")
+        if not self.cache_config.enabled:
+            self.logger.debug("Caching disabled; no cache loaded.")
+            return None
+        if self.cache_config.storage != 'file':
+            self.logger.debug("Using memory caching; cache will be kept in memory only.")
             return None
-        if os.path.exists(self.cache_file):
-            with open(self.cache_file, "r") as f:
+        if os.path.exists(self.cache_config.file):
+            with open(self.cache_config.file, "r") as f:
                 try:
                     cache_data = json.load(f)
-                    logger.debug("Custom fields cache loaded successfully.")
+                    self.logger.debug("Custom fields cache loaded successfully.")
                     return cache_data
                 except Exception as e:
-                    logger.error(f"Error loading cache: {e}")
+                    self.logger.error(f"Error loading cache: {e}")
                     return None
         return None
 
-    def get_custom_fields_mapping(self, force_update=False, cache_duration_hours=24):
+    def get_custom_fields_mapping(self, force_update=False):
         """
         Возвращает словарь отображения кастомных полей для сделок.
         Если данные кэшированы и не устарели, возвращает кэш; иначе выполняет запросы для получения данных.
         """
-        if not force_update:
-            if self._custom_fields_mapping:
-                return self._custom_fields_mapping
-            cache_data = self._load_custom_fields_cache()
-            if cache_data:
-                last_updated = cache_data.get("last_updated", 0)
-                if time.time() - last_updated < cache_duration_hours * 3600:
+        if not force_update and self._custom_fields_mapping is not None:
+            return self._custom_fields_mapping
+
+        cache_data = self._load_custom_fields_cache() if self.cache_config.enabled else None
+        if cache_data:
+            last_updated = cache_data.get("last_updated", 0)
+            if self.cache_config.lifetime_hours is not None:
+                if time.time() - last_updated < self.cache_config.lifetime_hours * 3600:
                     self._custom_fields_mapping = cache_data.get("mapping")
-                    logger.debug("Using cached custom fields mapping.")
+                    self.logger.debug("Using cached custom fields mapping.")
                     return self._custom_fields_mapping
+            else:
+                # Бесконечный кэш – не проверяем срок
+                self._custom_fields_mapping = cache_data.get("mapping")
+                self.logger.debug("Using cached custom fields mapping (infinite cache).")
+                return self._custom_fields_mapping
 
         mapping = {}
         page = 1
@@ -242,19 +419,23 @@ class AmoCRMClient:
                 for field in response["_embedded"]["custom_fields"]:
                     mapping[field["id"]] = field
                 total_pages = response.get("_page_count", page)
-                logger.debug(f"Fetched page {page} of {total_pages}")
+                self.logger.debug(f"Fetched page {page} of {total_pages}")
                 page += 1
             else:
                 break
 
-        logger.debug("Custom fields mapping fetched (содержимое маппинга не выводится полностью).")
+        self.logger.debug("Custom fields mapping fetched (содержимое маппинга не выводится полностью).")
         self._custom_fields_mapping = mapping
-        self._save_custom_fields_cache(mapping)
+        if self.cache_config.enabled:
+            self._save_custom_fields_cache(mapping)
         return mapping
 
     def find_custom_field_id(self, search_term):
         """
         Ищет кастомное поле по заданному названию (или части названия).
+
+        :param search_term: Строка для поиска по имени поля.
+        :return: Кортеж (field_id, field_obj) если найдено, иначе (None, None).
         """
         mapping = self.get_custom_fields_mapping()
         search_term_lower = search_term.lower().strip()
@@ -264,14 +445,26 @@ class AmoCRMClient:
             else:
                 name = str(field_obj).lower().strip()
             if search_term_lower == name or search_term_lower in name:
-                logger.debug(f"Found custom field '{name}' with id {key}")
+                self.logger.debug(f"Found custom field '{name}' with id {key}")
                 return int(key), field_obj
-        logger.debug(f"Custom field containing '{search_term}' not found.")
+        self.logger.debug(f"Custom field containing '{search_term}' not found.")
         return None, None
 
     def update_lead(self, lead_id, update_fields: dict, tags_to_add: list = None, tags_to_delete: list = None):
         """
         Обновляет сделку, задавая новые значения для стандартных и кастомных полей.
+
+        Для кастомных полей:
+          - Если значение передается как целое число, оно интерпретируется как идентификатор варианта (enum_id)
+            для полей типа select.
+          - Если значение передается как строка, используется ключ "value".
+
+        :param lead_id: ID сделки, которую нужно обновить.
+        :param update_fields: Словарь с полями для обновления. Ключи могут быть стандартными или названием кастомного поля.
+        :param tags_to_add: Список тегов для добавления к сделке.
+        :param tags_to_delete: Список тегов для удаления из сделки.
+        :return: Ответ API в формате JSON.
+        :raises Exception: Если одно из кастомных полей не найдено.
         """
         payload = {}
         standard_fields = {
@@ -282,7 +475,7 @@ class AmoCRMClient:
         for key, value in update_fields.items():
             if key in standard_fields:
                 payload[key] = value
-                logger.debug(f"Standard field {key} set to {value}")
+                self.logger.debug(f"Standard field {key} set to {value}")
             else:
                 if isinstance(value, int):
                     field_value_dict = {"enum_id": value}
@@ -291,12 +484,12 @@ class AmoCRMClient:
                 try:
                     field_id = int(key)
                     custom_fields.append({"field_id": field_id, "values": [field_value_dict]})
-                    logger.debug(f"Custom field by id {field_id} set to {value}")
+                    self.logger.debug(f"Custom field by id {field_id} set to {value}")
                 except ValueError:
                     field_id, field_obj = self.find_custom_field_id(key)
                     if field_id is not None:
                         custom_fields.append({"field_id": field_id, "values": [field_value_dict]})
-                        logger.debug(f"Custom field '{key}' found with id {field_id} set to {value}")
+                        self.logger.debug(f"Custom field '{key}' found with id {field_id} set to {value}")
                     else:
                         raise Exception(f"Custom field '{key}' не найден.")
         if custom_fields:
@@ -305,8 +498,177 @@ class AmoCRMClient:
             payload["tags_to_add"] = tags_to_add
         if tags_to_delete:
             payload["tags_to_delete"] = tags_to_delete
-        logger.debug("Update payload for lead {} prepared (содержимое payload не выводится полностью).".format(lead_id))
+        self.logger.debug("Update payload for lead {} prepared (содержимое payload не выводится полностью).".format(lead_id))
         endpoint = f"/api/v4/leads/{lead_id}"
         response = self._make_request("PATCH", endpoint, data=payload)
-        logger.debug("Update response received.")
-        return response
+        self.logger.debug("Update response received.")
+        return response
+    
+    def get_entity_notes(self, entity, entity_id, get_all=False, note_type=None, extra_params=None):
+        """
+        Получает список примечаний для указанной сущности и её ID.
+
+        Используется эндпоинт:
+        GET /api/v4/{entity_plural}/{entity_id}/notes
+
+        :param entity: Тип сущности (например, 'lead', 'contact', 'company', 'customer' и т.д.).
+                    Передаётся в единственном числе, для формирования конечной точки будет использована
+                    таблица преобразования (например, 'lead' -> 'leads').
+        :param entity_id: ID сущности.
+        :param get_all: Если True, метод автоматически проходит по всем страницам пагинации.
+        :param note_type: Фильтр по типу примечания. Может быть строкой (например, 'common') или списком строк.
+        :param extra_params: Словарь дополнительных GET-параметров, если требуется.
+        :return: Список примечаний (каждый элемент – словарь с данными примечания).
+        """
+        # Преобразуем тип сущности в форму во множественном числе (для известных типов)
+        mapping = {
+            'lead': 'leads',
+            'contact': 'contacts',
+            'company': 'companies',
+            'customer': 'customers'
+        }
+        plural = mapping.get(entity.lower(), entity.lower() + "s")
+        
+        endpoint = f"/api/v4/{plural}/{entity_id}/notes"
+        params = {
+            "page": 1,
+            "limit": 250
+        }
+        if note_type is not None:
+            params["filter[note_type]"] = note_type
+        if extra_params:
+            params.update(extra_params)
+        
+        notes = []
+        while True:
+            response = self._make_request("GET", endpoint, params=params)
+            if response and "_embedded" in response and "notes" in response["_embedded"]:
+                notes.extend(response["_embedded"]["notes"])
+            if not get_all:
+                break
+            total_pages = response.get("_page_count", params["page"])
+            if params["page"] >= total_pages:
+                break
+            params["page"] += 1
+        self.logger.debug(f"Retrieved {len(notes)} notes for {entity} {entity_id}")
+        return notes
+
+    def get_entity_note(self, entity, entity_id, note_id):
+        """
+        Получает расширенную информацию по конкретному примечанию для указанной сущности.
+
+        Используется эндпоинт:
+        GET /api/v4/{entity_plural}/{entity_id}/notes/{note_id}
+
+        :param entity: Тип сущности (например, 'lead', 'contact', 'company', 'customer' и т.д.).
+        :param entity_id: ID сущности.
+        :param note_id: ID примечания.
+        :return: Словарь с полной информацией о примечании.
+        :raises Exception: При ошибке запроса.
+        """
+        mapping = {
+            'lead': 'leads',
+            'contact': 'contacts',
+            'company': 'companies',
+            'customer': 'customers'
+        }
+        plural = mapping.get(entity.lower(), entity.lower() + "s")
+        endpoint = f"/api/v4/{plural}/{entity_id}/notes/{note_id}"
+        self.logger.debug(f"Fetching note {note_id} for {entity} {entity_id}")
+        note_data = self._make_request("GET", endpoint)
+        self.logger.debug(f"Note {note_id} for {entity} {entity_id} fetched successfully.")
+        return note_data
+
+    # Удобные обёртки для сделок и контактов:
+    def get_deal_notes(self, deal_id, **kwargs):
+        return self.get_entity_notes("lead", deal_id, **kwargs)
+
+    def get_deal_note(self, deal_id, note_id):
+        return self.get_entity_note("lead", deal_id, note_id)
+
+    def get_contact_notes(self, contact_id, **kwargs):
+        return self.get_entity_notes("contact", contact_id, **kwargs)
+
+    def get_contact_note(self, contact_id, note_id):
+        return self.get_entity_note("contact", contact_id, note_id)
+    
+    def get_entity_events(self, entity, entity_id=None, get_all=False, event_type=None, extra_params=None):
+        """
+        Получает список событий для указанной сущности.
+        Если entity_id не указан (None), возвращает события для всех сущностей данного типа.
+
+        :param entity: Тип сущности (например, 'lead', 'contact', 'company' и т.д.).
+        :param entity_id: ID сущности или None для получения событий по всем сущностям данного типа.
+        :param get_all: Если True, автоматически проходит по всем страницам пагинации.
+        :param event_type: Фильтр по типу события. Может быть строкой или списком строк.
+        :param extra_params: Словарь дополнительных GET-параметров.
+        :return: Список событий (каждый элемент – словарь с данными события).
+        """
+        params = {
+            'page': 1,
+            'limit': 100,
+            'filter[entity]': entity,
+        }
+        # Добавляем фильтр по ID, если он указан
+        if entity_id is not None:
+            params['filter[entity_id]'] = entity_id
+        # Фильтр по типу события
+        if event_type is not None:
+            params['filter[type]'] = event_type
+        if extra_params:
+            params.update(extra_params)
+
+        events = []
+        while True:
+            response = self._make_request("GET", "/api/v4/events", params=params)
+            if response and "_embedded" in response and "events" in response["_embedded"]:
+                events.extend(response["_embedded"]["events"])
+            # Если не нужно получать все страницы, выходим
+            if not get_all:
+                break
+            total_pages = response.get("_page_count", params['page'])
+            if params['page'] >= total_pages:
+                break
+            params['page'] += 1
+        return events
+
+    # Удобные обёртки:
+    def get_deal_events(self, deal_id, **kwargs):
+        return self.get_entity_events("lead", deal_id, **kwargs)
+
+    def get_contact_events(self, contact_id, **kwargs):
+        return self.get_entity_events("contact", contact_id, **kwargs)
+
+    def get_event(self, event_id):
+        """
+        Получает подробную информацию по конкретному событию по его ID.
+        
+        Используется эндпоинт:
+          GET /api/v4/events/{event_id}
+        
+        :param event_id: ID события.
+        :return: Словарь с подробной информацией о событии.
+        :raises Exception: При ошибке запроса.
+        """
+        endpoint = f"/api/v4/events/{event_id}"
+        self.logger.debug(f"Fetching event with ID {event_id}")
+        event_data = self._make_request("GET", endpoint)
+        self.logger.debug(f"Event {event_id} details fetched successfully.")
+        return event_data
+    
+    def get_pipelines(self):
+        """
+        Получает список всех воронок и их статусов из amoCRM.
+
+        :return: Список словарей, где каждый словарь содержит данные воронки, а также, если присутствует, вложенные статусы.
+        :raises Exception: Если данные не получены или структура ответа неверна.
+        """
+        endpoint = "/api/v4/leads/pipelines"
+        response = self._make_request("GET", endpoint)
+        if response and '_embedded' in response and 'pipelines' in response['_embedded']:
+            pipelines = response['_embedded']['pipelines']
+            self.logger.debug(f"Получено {len(pipelines)} воронок")
+            return pipelines
+        else:
+            self.logger.error("Не удалось получить воронки из amoCRM")
+            raise Exception("Ошибка получения воронок из amoCRM")

amochka/etl.py

@@ -0,0 +1,91 @@
+import logging
+from sqlalchemy import select, or_
+from sqlalchemy.dialects.postgresql import insert  # Правильный импорт для PostgreSQL
+from sqlalchemy.ext.asyncio import AsyncSession
+from amochka.models import Pipeline, Status
+
+logger = logging.getLogger(__name__)
+
+async def update_pipelines(session: AsyncSession, pipelines_data):
+    """
+    Обновляет таблицы воронок (Pipeline) и статусов (Status) в базе данных.
+    
+    :param session: Асинхронная сессия SQLAlchemy.
+    :param pipelines_data: Список воронок, полученных из API amoCRM.
+    """
+    if not pipelines_data:
+        logger.warning("Получен пустой список воронок, обновление не выполнено")
+        return
+        
+    account_id = 1111  # Пример: замените на актуальный идентификатор аккаунта
+    pipeline_values = []
+    all_statuses = []
+
+    # Подготавливаем данные для вставки в таблицу Pipeline и собираем статусы
+    for pipeline in pipelines_data:
+        pipeline_values.append({
+            'account_id': account_id,
+            'pipeline_id': pipeline['id'],
+            'name': pipeline['name'],
+            'sort': pipeline.get('sort'),
+            'is_main': pipeline.get('is_main'),
+            'is_archive': pipeline.get('is_archive'),
+        })
+        # Если воронка содержит статусы, обрабатываем их
+        if '_embedded' in pipeline and 'statuses' in pipeline['_embedded']:
+            for status in pipeline['_embedded']['statuses']:
+                all_statuses.append((pipeline['id'], status['id'], status))
+
+    # Массовая вставка/обновление данных в таблице Pipeline
+    stmt = insert(Pipeline).values(pipeline_values)
+    stmt = stmt.on_conflict_do_update(
+        index_elements=['pipeline_id'],
+        set_={
+            'name': stmt.excluded.name,
+            'sort': stmt.excluded.sort,
+            'is_main': stmt.excluded.is_main,
+            'is_archive': stmt.excluded.is_archive,
+        }
+    )
+    await session.execute(stmt)
+    logger.debug(f"Обновлено {len(pipeline_values)} воронок")
+
+    # Получаем сопоставление внутренних ID воронок по pipeline_id
+    result = await session.execute(select(Pipeline.id, Pipeline.pipeline_id))
+    pipeline_id_map = {row.pipeline_id: row.id for row in result}
+
+    # Подготавливаем данные для вставки в таблицу Status
+    status_values = []
+    for pipeline_id, status_id, status in all_statuses:
+        internal_pipeline_id = pipeline_id_map.get(pipeline_id)
+        if internal_pipeline_id is None:
+            logger.warning(f"Не найден внутренний ID для воронки {pipeline_id}, пропускаю статус {status_id}")
+            continue
+            
+        status_values.append({
+            'account_id': account_id,
+            'pipeline_id': internal_pipeline_id,
+            'status_id': status_id,
+            'name': status.get('name', ''),
+            'color': status.get('color', ''),
+            'sort': status.get('sort'),
+            'is_editable': status.get('is_editable'),
+            'type': status.get('type'),
+        })
+
+    if status_values:
+        stmt = insert(Status).values(status_values)
+        stmt = stmt.on_conflict_do_update(
+            index_elements=['pipeline_id', 'status_id'],
+            set_={
+                'name': stmt.excluded.name,
+                'color': stmt.excluded.color,
+                'sort': stmt.excluded.sort,
+                'is_editable': stmt.excluded.is_editable,
+                'type': stmt.excluded.type,
+            }
+        )
+        await session.execute(stmt)
+        logger.debug(f"Обновлено {len(status_values)} статусов")
+
+    logger.info(f"Обновлено {len(pipeline_values)} воронок и {len(status_values)} статусов.")

amochka/models.py

@@ -0,0 +1,50 @@
+from sqlalchemy import Column, Integer, String, Boolean, BigInteger, ForeignKey, UniqueConstraint
+from sqlalchemy.orm import declarative_base, relationship
+
+# Базовый класс для всех моделей
+Base = declarative_base()
+
+class Pipeline(Base):
+    """
+    Модель для хранения воронок из amoCRM.
+    """
+    __tablename__ = 'a_pipelines'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    account_id = Column(Integer, nullable=False)
+    pipeline_id = Column(BigInteger, nullable=False, unique=True)
+    name = Column(String)
+    sort = Column(Integer)
+    is_main = Column(Boolean)
+    is_archive = Column(Boolean)
+    
+    # Определяем связь с моделью статусов
+    statuses = relationship("Status", back_populates="pipeline")
+    
+    __table_args__ = (
+        UniqueConstraint('pipeline_id', name='uq_pipeline_id'),
+    )
+
+class Status(Base):
+    """
+    Модель для хранения статусов воронок.
+    """
+    __tablename__ = 'a_statuses'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    account_id = Column(Integer, nullable=False)
+    # Ссылка на внутренний id воронки (Pipeline.id)
+    pipeline_id = Column(Integer, ForeignKey('a_pipelines.id'), nullable=False)
+    status_id = Column(BigInteger, nullable=False)
+    name = Column(String)
+    color = Column(String)
+    sort = Column(Integer)
+    is_editable = Column(Boolean)
+    type = Column(Integer)
+    
+    # Определяем обратную связь с моделью Pipeline
+    pipeline = relationship("Pipeline", back_populates="statuses")
+    
+    __table_args__ = (
+        UniqueConstraint('pipeline_id', 'status_id', name='uq_pipeline_status_id'),
+    )

{amochka-0.1.3.dist-info → amochka-0.1.6.dist-info}/METADATA

@@ -1,18 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: amochka
-Version: 0.1.3
+Version: 0.1.6
 Summary: Библиотека для работы с API amoCRM
-Home-page: UNKNOWN
+Home-page: 
 Author: Timurka
 Author-email: timurdt@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Requires-Dist: requests
 Requires-Dist: ratelimit
-
-UNKNOWN
-
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

amochka-0.1.6.dist-info/RECORD

@@ -0,0 +1,8 @@
+amochka/__init__.py,sha256=JZT3Q9jG3SfTS-vhlOCWYBrP8pFmaXFhNpJ1nOqrP5M,161
+amochka/client.py,sha256=i0N6-9U7Pghh41yvKGlroVP2oDdIcdZyFSjiz9JKI6k,36284
+amochka/etl.py,sha256=6pc3ymr72QH57hyeFaKziERXbD7v9GuQpQyBMxeO5MY,4142
+amochka/models.py,sha256=clPPFuOf_Lk-mqTMxUix7JZ97ViD-wiKSZiC3l2slP4,1805
+amochka-0.1.6.dist-info/METADATA,sha256=c1sNI6Qv0j7MCRN-oQpd3EIYUKtTShkfDqG1pFSCqo8,516
+amochka-0.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+amochka-0.1.6.dist-info/top_level.txt,sha256=y5qXFXJUECmDwO6hyupsuYcTpZKZyByeE9e-1sa2U24,8
+amochka-0.1.6.dist-info/RECORD,,

{amochka-0.1.3.dist-info → amochka-0.1.6.dist-info}/WHEEL

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

amochka-0.1.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-amochka/__init__.py,sha256=92YIjNK3notY2wfG-l2jmGIIWjfE3ozpamc-e4LEILc,106
-amochka/client.py,sha256=59iYwOQ90XTJvnzQCxRG8sgpbLRaZkFfYkZCN_Zl4Y8,15354
-amochka-0.1.3.dist-info/METADATA,sha256=68jkHlxGXCk6acxCM8OVg4jluTZKy3yUdPfFOqzGK0U,445
-amochka-0.1.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-amochka-0.1.3.dist-info/top_level.txt,sha256=y5qXFXJUECmDwO6hyupsuYcTpZKZyByeE9e-1sa2U24,8
-amochka-0.1.3.dist-info/RECORD,,