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

amochka/__init__.py

@@ -2,5 +2,27 @@
 amochka: Библиотека для работы с API amoCRM.
 """
 
+__version__ = "0.1.8"
+
 from .client import AmoCRMClient, CacheConfig
-__all__ = ['AmoCRMClient', 'CacheConfig']
+from .etl import (
+    write_ndjson,
+    export_leads_to_ndjson,
+    export_contacts_to_ndjson,
+    export_notes_to_ndjson,
+    export_events_to_ndjson,
+    export_users_to_ndjson,
+    export_pipelines_to_ndjson,
+)
+
+__all__ = [
+    "AmoCRMClient",
+    "CacheConfig",
+    "write_ndjson",
+    "export_leads_to_ndjson",
+    "export_contacts_to_ndjson",
+    "export_notes_to_ndjson",
+    "export_events_to_ndjson",
+    "export_users_to_ndjson",
+    "export_pipelines_to_ndjson",
+]

amochka/client.py

@@ -4,6 +4,7 @@ import json
 import requests
 import logging
 from datetime import datetime
+from typing import Iterator, List, Optional, Sequence, Union
 from ratelimit import limits, sleep_and_retry
 
 # Создаём базовый логгер
@@ -222,7 +223,11 @@ class AmoCRMClient:
         token_file=None, 
         cache_config=None, 
         log_level=logging.INFO, 
-        disable_logging=False
+        disable_logging=False,
+        *,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
     ):
         """
         Инициализирует клиента, задавая базовый URL, токен авторизации и настройки кэша для кастомных полей.
@@ -237,6 +242,11 @@ class AmoCRMClient:
         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')
+
+        # OAuth2 credentials (используются для авто‑refresh токена)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
         
         # Создаем логгер для конкретного экземпляра клиента
         self.logger = logging.getLogger(f"{__name__}.{self.domain}")
@@ -265,15 +275,19 @@ class AmoCRMClient:
         
         self.logger.debug(f"AmoCRMClient initialized for domain {self.domain}")
         
-        self.token = self.load_token()
+        self.token = None
+        self.refresh_token = None
+        self.expires_at = None
+        self.load_token()
         self._custom_fields_mapping = None
 
     def load_token(self):
         """
         Загружает токен авторизации из файла или строки, проверяет его срок действия.
+        При наличии refresh_token и учётных данных пробует обновить токен.
 
         :return: Действительный access_token.
-        :raises Exception: Если токен не найден или истёк.
+        :raises Exception: Если токен не найден или истёк и нет возможности обновить.
         """
         data = None
         if os.path.exists(self.token_file):
@@ -287,21 +301,38 @@ class AmoCRMClient:
             except Exception as e:
                 raise Exception("Токен не найден и не удалось распарсить переданное содержимое.") from e
 
+        self.refresh_token = data.get('refresh_token', self.refresh_token)
+        self.client_id = data.get('client_id', self.client_id)
+        self.client_secret = data.get('client_secret', self.client_secret)
+        self.redirect_uri = data.get('redirect_uri', self.redirect_uri)
+
         expires_at_str = data.get('expires_at')
-        try:
-            expires_at = datetime.fromisoformat(expires_at_str).timestamp()
-        except Exception:
-            expires_at = float(expires_at_str)
-        
-        if expires_at and time.time() < expires_at:
+        expires_at = None
+        if expires_at_str:
+            try:
+                expires_at = datetime.fromisoformat(expires_at_str).timestamp()
+            except Exception:
+                try:
+                    expires_at = float(expires_at_str)
+                except Exception:
+                    expires_at = None
+        self.expires_at = expires_at
+
+        access_token = data.get('access_token')
+        if access_token and expires_at and time.time() < expires_at:
             self.logger.debug("Token is valid.")
-            return data.get('access_token')
-        else:
-            raise Exception("Токен найден, но он истёк. Обновите токен.")
+            self.token = access_token
+            return access_token
+
+        if self.refresh_token and self.client_id and self.client_secret and self.redirect_uri:
+            self.logger.info("Access token истёк, пробую обновить через refresh_token…")
+            return self._refresh_access_token()
+
+        raise Exception("Токен истёк или некорректен, и нет данных для refresh_token. Обновите токен.")
 
     @sleep_and_retry
     @limits(calls=RATE_LIMIT, period=1)
-    def _make_request(self, method, endpoint, params=None, data=None):
+    def _make_request(self, method, endpoint, params=None, data=None, timeout=10):
         """
         Выполняет HTTP-запрос к API amoCRM с учетом ограничения по скорости (rate limit).
 
@@ -309,6 +340,7 @@ class AmoCRMClient:
         :param endpoint: Конечная точка API (начинается с /api/v4/).
         :param params: GET-параметры запроса.
         :param data: Данные, отправляемые в JSON-формате.
+        :param timeout: Тайм‑аут запроса в секундах (по умолчанию 10).
         :return: Ответ в формате JSON или None (если статус 204).
         :raises Exception: При получении кода ошибки, отличного от 200/204.
         """
@@ -318,7 +350,14 @@ class AmoCRMClient:
             "Content-Type": "application/json"
         }
         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)
+        response = requests.request(method, url, headers=headers, params=params, json=data, timeout=timeout)
+
+        if response.status_code == 401 and self.refresh_token:
+            self.logger.info("Получен 401, пробую обновить токен и повторить запрос…")
+            self._refresh_access_token()
+            headers["Authorization"] = f"Bearer {self.token}"
+            response = requests.request(method, url, headers=headers, params=params, json=data, timeout=timeout)
+
         if response.status_code not in (200, 204):
             self.logger.error(f"Request error {response.status_code}: {response.text}")
             raise Exception(f"Ошибка запроса: {response.status_code}, {response.text}")
@@ -326,6 +365,363 @@ class AmoCRMClient:
             return None
         return response.json()
 
+    def _refresh_access_token(self):
+        """Обновляет access_token по refresh_token и сохраняет его в token_file."""
+        if not all([self.refresh_token, self.client_id, self.client_secret, self.redirect_uri]):
+            raise Exception("Нельзя обновить токен: отсутствует refresh_token или client_id/client_secret/redirect_uri")
+
+        payload = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "grant_type": "refresh_token",
+            "refresh_token": self.refresh_token,
+            "redirect_uri": self.redirect_uri,
+        }
+        token_url = f"{self.base_url}/oauth2/access_token"
+        self.logger.debug(f"Refreshing token via {token_url}")
+        resp = requests.post(token_url, json=payload, timeout=10)
+        if resp.status_code != 200:
+            self.logger.error(f"Не удалось обновить токен: {resp.status_code} {resp.text}")
+            raise Exception(f"Не удалось обновить токен: {resp.status_code}")
+
+        data = resp.json() or {}
+        access_token = data.get("access_token")
+        refresh_token = data.get("refresh_token", self.refresh_token)
+        expires_in = data.get("expires_in")
+        if not access_token:
+            raise Exception("Ответ на refresh не содержит access_token")
+
+        expires_at = None
+        if expires_in:
+            expires_at = time.time() + int(expires_in)
+
+        self.token = access_token
+        self.refresh_token = refresh_token
+        self.expires_at = expires_at
+
+        if self.token_file:
+            try:
+                with open(self.token_file, "w") as f:
+                    json.dump({
+                        "access_token": access_token,
+                        "refresh_token": refresh_token,
+                        "expires_at": datetime.fromtimestamp(expires_at).isoformat() if expires_at else None,
+                        "client_id": self.client_id,
+                        "client_secret": self.client_secret,
+                        "redirect_uri": self.redirect_uri,
+                    }, f)
+                self.logger.debug(f"Новый токен сохранён в {self.token_file}")
+            except Exception as exc:
+                self.logger.error(f"Не удалось сохранить обновлённый токен: {exc}")
+
+        return access_token
+
+    def _to_timestamp(self, value: Optional[Union[int, float, str, datetime]]) -> Optional[int]:
+        """
+        Преобразует значение даты/времени в Unix timestamp.
+        Возвращает None, если значение не указано.
+        """
+        if value is None:
+            return None
+        if isinstance(value, datetime):
+            return int(value.timestamp())
+        if isinstance(value, (int, float)):
+            return int(value)
+        if isinstance(value, str):
+            try:
+                return int(datetime.fromisoformat(value).timestamp())
+            except ValueError as exc:
+                raise ValueError(f"Не удалось преобразовать '{value}' в timestamp") from exc
+        raise TypeError(f"Неподдерживаемый тип для timestamp: {type(value)}")
+
+    def _format_filter_values(self, values: Optional[Union[int, Sequence[Union[int, str]], str]]) -> Optional[Union[str, Sequence[Union[int, str]]]]:
+        """
+        Преобразует значение или последовательность значений для передачи в запрос.
+        """
+        if values is None:
+            return None
+        if isinstance(values, (list, tuple, set)):
+            return [str(v) for v in values]
+        return str(values)
+
+    def _extract_collection(self, response: dict, data_path: Sequence[str]) -> list:
+        """
+        Извлекает коллекцию элементов из ответа API по указанному пути ключей.
+        """
+        data = response or {}
+        for key in data_path:
+            if not isinstance(data, dict):
+                return []
+            data = data.get(key)
+            if data is None:
+                return []
+        if isinstance(data, list):
+            return data
+        return []
+
+    def _iterate_paginated(
+        self,
+        endpoint: str,
+        params: Optional[dict] = None,
+        data_path: Sequence[str] = ("_embedded",),
+    ) -> Iterator[dict]:
+        """
+        Возвращает генератор, проходящий по всем страницам ответа API и
+        yielding элементы коллекции.
+        """
+        query = dict(params or {})
+        query.setdefault("page", 1)
+        query.setdefault("limit", 250)
+
+        while True:
+            response = self._make_request("GET", endpoint, params=query)
+            if not response:
+                break
+            items = self._extract_collection(response, data_path)
+            if not items:
+                break
+            for item in items:
+                yield item
+
+            total_pages = response.get("_page_count")
+            if total_pages is not None:
+                has_next = query["page"] < total_pages
+            else:
+                links = response.get("_links") or {}
+                next_link = links.get("next") if isinstance(links, dict) else None
+                has_next = bool(next_link)
+            if not has_next:
+                break
+            query["page"] += 1
+
+    def iter_leads(
+        self,
+        updated_from: Optional[Union[int, float, str, datetime]] = None,
+        updated_to: Optional[Union[int, float, str, datetime]] = None,
+        pipeline_ids: Optional[Union[int, Sequence[Union[int, str]]]] = None,
+        include_contacts: bool = False,
+        include: Optional[Union[str, Sequence[str]]] = None,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор сделок с фильтрацией по диапазону обновления и воронкам.
+        """
+        params = {"limit": limit, "page": 1}
+        start_ts = self._to_timestamp(updated_from)
+        end_ts = self._to_timestamp(updated_to)
+        if start_ts is not None:
+            params["filter[updated_at][from]"] = start_ts
+        if end_ts is not None:
+            params["filter[updated_at][to]"] = end_ts
+        pipeline_param = self._format_filter_values(pipeline_ids)
+        if pipeline_param:
+            params["filter[pipeline_id]"] = pipeline_param
+
+        include_parts: List[str] = []
+        if include_contacts:
+            include_parts.append("contacts")
+        if include:
+            if isinstance(include, str):
+                include_parts.append(include)
+            else:
+                include_parts.extend([str(item) for item in include])
+        if include_parts:
+            params["with"] = ",".join(sorted(set(include_parts)))
+        if extra_params:
+            params.update(extra_params)
+
+        yield from self._iterate_paginated(
+            "/api/v4/leads", params=params, data_path=("_embedded", "leads")
+        )
+
+    def fetch_leads(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список сделок. Обёртка над iter_leads.
+        """
+        return list(self.iter_leads(*args, **kwargs))
+
+    def iter_contacts(
+        self,
+        updated_from: Optional[Union[int, float, str, datetime]] = None,
+        updated_to: Optional[Union[int, float, str, datetime]] = None,
+        contact_ids: Optional[Union[int, Sequence[Union[int, str]]]] = None,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор контактов с фильтрацией по диапазону обновления или списку ID.
+        """
+        params = {"limit": limit, "page": 1}
+        start_ts = self._to_timestamp(updated_from)
+        end_ts = self._to_timestamp(updated_to)
+        if start_ts is not None:
+            params["filter[updated_at][from]"] = start_ts
+        if end_ts is not None:
+            params["filter[updated_at][to]"] = end_ts
+        contact_param = self._format_filter_values(contact_ids)
+        if contact_param:
+            params["filter[id][]"] = contact_param
+        if extra_params:
+            params.update(extra_params)
+
+        yield from self._iterate_paginated(
+            "/api/v4/contacts", params=params, data_path=("_embedded", "contacts")
+        )
+
+    def fetch_contacts(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список контактов. Обёртка над iter_contacts.
+        """
+        return list(self.iter_contacts(*args, **kwargs))
+
+    def get_contact_by_id(self, contact_id: Union[int, str], include: Optional[Union[str, Sequence[str]]] = None) -> dict:
+        """
+        Получает данные контакта по его ID.
+        """
+        endpoint = f"/api/v4/contacts/{contact_id}"
+        params = {}
+        if include:
+            if isinstance(include, str):
+                params["with"] = include
+            else:
+                params["with"] = ",".join(str(item) for item in include)
+        data = self._make_request("GET", endpoint, params=params)
+        if not data or not isinstance(data, dict) or "id" not in data:
+            raise Exception(f"Contact {contact_id} not found or invalid response.")
+        return data
+
+    def iter_notes(
+        self,
+        entity: str = "lead",
+        updated_from: Optional[Union[int, float, str, datetime]] = None,
+        updated_to: Optional[Union[int, float, str, datetime]] = None,
+        note_type: Optional[Union[str, Sequence[str]]] = None,
+        entity_ids: Optional[Union[int, Sequence[Union[int, str]]]] = None,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор примечаний для заданной сущности.
+        """
+        mapping = {
+            "lead": "leads",
+            "contact": "contacts",
+            "company": "companies",
+            "customer": "customers",
+        }
+        plural = mapping.get(entity.lower(), entity.lower() + "s")
+        endpoint = f"/api/v4/{plural}/notes"
+
+        params = {"limit": limit, "page": 1}
+        start_ts = self._to_timestamp(updated_from)
+        end_ts = self._to_timestamp(updated_to)
+        if start_ts is not None:
+            params["filter[updated_at][from]"] = start_ts
+        if end_ts is not None:
+            params["filter[updated_at][to]"] = end_ts
+        note_type_param = self._format_filter_values(note_type)
+        if note_type_param:
+            params["filter[note_type]"] = note_type_param
+        entity_param = self._format_filter_values(entity_ids)
+        if entity_param:
+            params["filter[entity_id]"] = entity_param
+        if extra_params:
+            params.update(extra_params)
+
+        yield from self._iterate_paginated(
+            endpoint, params=params, data_path=("_embedded", "notes")
+        )
+
+    def fetch_notes(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список примечаний. Обёртка над iter_notes.
+        """
+        return list(self.iter_notes(*args, **kwargs))
+
+    def iter_events(
+        self,
+        entity: Optional[str] = None,
+        entity_ids: Optional[Union[int, Sequence[Union[int, str]]]] = None,
+        event_type: Optional[Union[str, Sequence[str]]] = None,
+        created_from: Optional[Union[int, float, str, datetime]] = None,
+        created_to: Optional[Union[int, float, str, datetime]] = None,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор событий с фильтрацией по сущности, типам и диапазону дат.
+        """
+        params = {"limit": limit, "page": 1}
+        if entity:
+            params["filter[entity]"] = entity
+        entity_param = self._format_filter_values(entity_ids)
+        if entity_param:
+            params["filter[entity_id]"] = entity_param
+        event_type_param = self._format_filter_values(event_type)
+        if event_type_param:
+            params["filter[type]"] = event_type_param
+        start_ts = self._to_timestamp(created_from)
+        end_ts = self._to_timestamp(created_to)
+        if start_ts is not None:
+            params["filter[created_at][from]"] = start_ts
+        if end_ts is not None:
+            params["filter[created_at][to]"] = end_ts
+        if extra_params:
+            params.update(extra_params)
+
+        yield from self._iterate_paginated(
+            "/api/v4/events", params=params, data_path=("_embedded", "events")
+        )
+
+    def fetch_events(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список событий. Обёртка над iter_events.
+        """
+        return list(self.iter_events(*args, **kwargs))
+
+    def iter_users(
+        self,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор пользователей аккаунта.
+        """
+        params = {"limit": limit, "page": 1}
+        if extra_params:
+            params.update(extra_params)
+        yield from self._iterate_paginated(
+            "/api/v4/users", params=params, data_path=("_embedded", "users")
+        )
+
+    def fetch_users(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список пользователей. Обёртка над iter_users.
+        """
+        return list(self.iter_users(*args, **kwargs))
+
+    def iter_pipelines(
+        self,
+        limit: int = 250,
+        extra_params: Optional[dict] = None,
+    ) -> Iterator[dict]:
+        """
+        Итератор воронок со статусами.
+        """
+        params = {"limit": limit, "page": 1}
+        if extra_params:
+            params.update(extra_params)
+        yield from self._iterate_paginated(
+            "/api/v4/leads/pipelines", params=params, data_path=("_embedded", "pipelines")
+        )
+
+    def fetch_pipelines(self, *args, **kwargs) -> List[dict]:
+        """
+        Возвращает список воронок. Обёртка над iter_pipelines.
+        """
+        return list(self.iter_pipelines(*args, **kwargs))
+
     def get_deal_by_id(self, deal_id, skip_fields_mapping=False):
         """
         Получает данные сделки по её ID и возвращает объект Deal.
@@ -639,6 +1035,40 @@ class AmoCRMClient:
     def get_contact_events(self, contact_id, **kwargs):
         return self.get_entity_events("contact", contact_id, **kwargs)
 
+    def fetch_updated_leads_raw(
+        self,
+        pipeline_id,
+        updated_from,
+        updated_to=None,
+        save_to_file=None,
+        limit=250,
+        include_contacts=False,
+    ):
+        """Возвращает сделки из указанной воронки, обновленные в заданный период.
+
+        :param pipeline_id: ID воронки.
+        :param updated_from: datetime, начиная с которого искать изменения.
+        :param updated_to: datetime окончания диапазона (опционально).
+        :param save_to_file: путь к файлу для сохранения результатов в формате JSON.
+        :param limit: количество элементов на страницу (максимум 250).
+        :param include_contacts: если True, в ответ будут включены данные контактов.
+        :return: список словарей со сделками.
+        """
+
+        all_leads = self.fetch_leads(
+            updated_from=updated_from,
+            updated_to=updated_to,
+            pipeline_ids=pipeline_id,
+            include_contacts=include_contacts,
+            limit=limit,
+        )
+        if save_to_file:
+            with open(save_to_file, "w", encoding="utf-8") as f:
+                json.dump(all_leads, f, ensure_ascii=False, indent=2)
+
+        self.logger.debug(f"Fetched {len(all_leads)} leads from pipeline {pipeline_id}")
+        return all_leads
+
     def get_event(self, event_id):
         """
         Получает подробную информацию по конкретному событию по его ID.
@@ -663,12 +1093,9 @@ class AmoCRMClient:
         :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']
+        pipelines = self.fetch_pipelines()
+        if pipelines:
             self.logger.debug(f"Получено {len(pipelines)} воронок")
             return pipelines
-        else:
-            self.logger.error("Не удалось получить воронки из amoCRM")
-            raise Exception("Ошибка получения воронок из amoCRM")
+        self.logger.error("Не удалось получить воронки из amoCRM")
+        raise Exception("Ошибка получения воронок из amoCRM")

amochka/etl.py

@@ -1,91 +1,302 @@
-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
+import json
+from pathlib import Path
+from typing import Callable, Iterable, List, Optional, Sequence, Set, Union
 
-logger = logging.getLogger(__name__)
+from .client import AmoCRMClient
 
-async def update_pipelines(session: AsyncSession, pipelines_data):
+
+def _ensure_path(path: Union[str, Path]) -> Path:
+    output_path = Path(path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    return output_path
+
+
+def _resolve_timestamp(record: dict, timestamp_fields: Sequence[str]) -> Optional[Union[int, float, str]]:
+    for field in timestamp_fields:
+        if not field:
+            continue
+        value = record.get(field)
+        if value is not None:
+            return value
+    return None
+
+
+def write_ndjson(
+    records: Iterable[dict],
+    output_path: Union[str, Path],
+    *,
+    entity: str,
+    account_id: Optional[Union[int, str]] = None,
+    timestamp_fields: Sequence[str] = ("updated_at", "created_at"),
+    transform: Optional[Callable[[dict], dict]] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
     """
-    Обновляет таблицы воронок (Pipeline) и статусов (Status) в базе данных.
-    
-    :param session: Асинхронная сессия SQLAlchemy.
-    :param pipelines_data: Список воронок, полученных из API amoCRM.
+    Записывает переданные записи в формат NDJSON.
+
+    Возвращает количество записанных строк.
     """
-    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,
+    path = _ensure_path(output_path)
+    count = 0
+    with path.open("w", encoding="utf-8") as handler:
+        for original in records:
+            payload = transform(original) if transform else original
+            timestamp = _resolve_timestamp(original, timestamp_fields)
+            line = {
+                "entity": entity,
+                "account_id": account_id,
+                "updated_at": timestamp,
+                "payload": payload,
             }
-        )
-        await session.execute(stmt)
-        logger.debug(f"Обновлено {len(status_values)} статусов")
+            handler.write(json.dumps(line, ensure_ascii=False))
+            handler.write("\n")
+            count += 1
+            if on_record:
+                on_record(original)
+    return count
+
+
+def export_leads_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    start=None,
+    end=None,
+    pipeline_ids=None,
+    include_contacts: bool = True,
+    include=None,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает сделки и записывает их в NDJSON.
+    """
+    records = client.iter_leads(
+        updated_from=start,
+        updated_to=end,
+        pipeline_ids=pipeline_ids,
+        include_contacts=include_contacts,
+        include=include,
+        limit=limit,
+        extra_params=extra_params,
+    )
+    return write_ndjson(
+        records,
+        output_path,
+        entity="lead",
+        account_id=account_id,
+        timestamp_fields=("updated_at", "created_at"),
+        on_record=on_record,
+    )
+
+
+def export_contacts_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    start=None,
+    end=None,
+    contact_ids=None,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает контакты и записывает их в NDJSON.
+    """
+    contact_id_list: Optional[List[int]] = None
+    if contact_ids is not None:
+        if isinstance(contact_ids, (list, tuple, set)):
+            contact_id_list = [int(cid) for cid in contact_ids if cid is not None]
+        else:
+            contact_id_list = [int(contact_ids)]
+
+    def _iter_contacts():
+        seen: Set[int] = set()
+        if contact_id_list:
+            params = dict(extra_params or {})
+            params["filter[id][]"] = [str(cid) for cid in contact_id_list]
+            params["page"] = 1
+            params["limit"] = limit
+            while True:
+                response = client._make_request("GET", "/api/v4/contacts", params=params)
+                embedded = (response or {}).get("_embedded", {})
+                contacts = embedded.get("contacts") or []
+                if not contacts:
+                    break
+                for contact in contacts:
+                    cid = contact.get("id")
+                    if cid is not None:
+                        seen.add(int(cid))
+                    yield contact
+                total_pages = response.get("_page_count", params["page"])
+                if params["page"] >= total_pages:
+                    break
+                params["page"] += 1
+        else:
+            for contact in client.iter_contacts(
+                updated_from=start,
+                updated_to=end,
+                contact_ids=None,
+                limit=limit,
+                extra_params=extra_params,
+            ):
+                cid = contact.get("id")
+                if cid is not None:
+                    seen.add(int(cid))
+                yield contact
+
+        if contact_id_list:
+            missing = [cid for cid in contact_id_list if cid not in seen]
+            for cid in missing:
+                try:
+                    contact = client.get_contact_by_id(cid)
+                except Exception:
+                    continue
+                retrieved_id = contact.get("id")
+                if retrieved_id is not None and int(retrieved_id) not in seen:
+                    seen.add(int(retrieved_id))
+                    yield contact
+
+    return write_ndjson(
+        _iter_contacts(),
+        output_path,
+        entity="contact",
+        account_id=account_id,
+        timestamp_fields=("updated_at", "created_at"),
+        on_record=on_record,
+    )
+
+
+def export_notes_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    entity: str = "lead",
+    start=None,
+    end=None,
+    note_type=None,
+    entity_ids=None,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает примечания и записывает их в NDJSON.
+    """
+    records = client.iter_notes(
+        entity=entity,
+        updated_from=start,
+        updated_to=end,
+        note_type=note_type,
+        entity_ids=entity_ids,
+        limit=limit,
+        extra_params=extra_params,
+    )
+    entity_name = f"{entity}_note" if entity else "note"
+    return write_ndjson(
+        records,
+        output_path,
+        entity=entity_name,
+        account_id=account_id,
+        timestamp_fields=("updated_at", "created_at"),
+        on_record=on_record,
+    )
+
+
+def export_events_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    entity: Optional[str] = "lead",
+    start=None,
+    end=None,
+    event_type=None,
+    entity_ids=None,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает события и записывает их в NDJSON.
+    """
+    records = client.iter_events(
+        entity=entity,
+        entity_ids=entity_ids,
+        event_type=event_type,
+        created_from=start,
+        created_to=end,
+        limit=limit,
+        extra_params=extra_params,
+    )
+    entity_name = f"{entity}_event" if entity else "event"
+    return write_ndjson(
+        records,
+        output_path,
+        entity=entity_name,
+        account_id=account_id,
+        timestamp_fields=("created_at", "updated_at"),
+        on_record=on_record,
+    )
+
+
+def export_users_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает пользователей и записывает их в NDJSON.
+    """
+    records = client.iter_users(limit=limit, extra_params=extra_params)
+    return write_ndjson(
+        records,
+        output_path,
+        entity="user",
+        account_id=account_id,
+        timestamp_fields=("updated_at", "created_at"),
+        on_record=on_record,
+    )
+
+
+def export_pipelines_to_ndjson(
+    client: AmoCRMClient,
+    output_path: Union[str, Path],
+    account_id: Union[int, str],
+    *,
+    limit: int = 250,
+    extra_params: Optional[dict] = None,
+    on_record: Optional[Callable[[dict], None]] = None,
+) -> int:
+    """
+    Выгружает воронки и записывает их в NDJSON.
+    """
+    records = client.iter_pipelines(limit=limit, extra_params=extra_params)
+    return write_ndjson(
+        records,
+        output_path,
+        entity="pipeline",
+        account_id=account_id,
+        timestamp_fields=("updated_at", "created_at"),
+        on_record=on_record,
+    )
+
 
-    logger.info(f"Обновлено {len(pipeline_values)} воронок и {len(status_values)} статусов.")
+__all__ = [
+    "write_ndjson",
+    "export_leads_to_ndjson",
+    "export_contacts_to_ndjson",
+    "export_notes_to_ndjson",
+    "export_events_to_ndjson",
+    "export_users_to_ndjson",
+    "export_pipelines_to_ndjson",
+]

amochka-0.1.8.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: amochka
+Version: 0.1.8
+Summary: Библиотека для работы с API amoCRM
+Home-page: 
+Author: Timurka
+Author-email: timurdt@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: ratelimit
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# amochka
+
+**amochka** — библиотека для работы с API amoCRM на Python. Она поддерживает:
+- Получение данных сделок с вложенными сущностями (контакты, компании, теги, и т.д.)
+- Редактирование сделок, включая обновление стандартных и кастомных полей
+- Поддержку нескольких amoCRM-аккаунтов с персистентным кэшированием кастомных полей для каждого аккаунта отдельно
+- Ограничение запросов (7 запросов в секунду) с использованием декораторов из библиотеки `ratelimit`
+
+## Установка
+
+Установить библиотеку можно из PyPI (после публикации):
+
+pip install amochka
+
+## Кэширование кастомных полей
+
+Для уменьшения количества запросов к API кастомные поля кэшируются персистентно. Если параметр cache_file не указан, имя файла кэша генерируется автоматически на основе домена amoCRM-аккаунта. Вы можете обновлять кэш принудительно, передавая параметр force_update=True в метод get_custom_fields_mapping() или настроить время жизни кэша (по умолчанию — 24 часа).

amochka-0.1.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+amochka/__init__.py,sha256=LTjIPz4-miZ7A90vIUnbBKIpc_CyEPqRgnoqzEZngtw,620
+amochka/client.py,sha256=zs72v79nplCiRvI-ccVauctCQRILYrWfvbol8G8w2L0,54392
+amochka/etl.py,sha256=N8rXNFbtmlKfsYpgr7HDcP4enoj63XQPWuTDxGuMhw4,8901
+amochka-0.1.8.dist-info/METADATA,sha256=BQXYM8C4pmHBUvl-siS3luV-YKMOuFvuNg05t9Hh7Iw,2218
+amochka-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amochka-0.1.8.dist-info/top_level.txt,sha256=y5qXFXJUECmDwO6hyupsuYcTpZKZyByeE9e-1sa2U24,8
+amochka-0.1.8.dist-info/RECORD,,

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

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

amochka/models.py

@@ -1,50 +0,0 @@
-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.6.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: amochka
-Version: 0.1.6
-Summary: Библиотека для работы с API amoCRM
-Home-page: 
-Author: Timurka
-Author-email: timurdt@gmail.com
-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
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

amochka-0.1.6.dist-info/RECORD

@@ -1,8 +0,0 @@
-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,,