refactor 1st stage
This commit is contained in:
Volobuev Andrey
@@ -1,134 +1,377 @@
|
||||
from typing import Optional, Dict, Any,BinaryIO,List
|
||||
import requests
|
||||
# [MODULE] Сетевой клиент для API
|
||||
# @contract: Инкапсулирует низкоуровневую HTTP-логику, аутентификацию, повторные попытки и обработку сетевых ошибок.
|
||||
# @semantic_layers:
|
||||
# 1. Инициализация сессии `requests` с настройками SSL и таймаутов.
|
||||
# 2. Управление аутентификацией (получение и обновление access/CSRF токенов).
|
||||
# 3. Выполнение HTTP-запросов (GET, POST и т.д.) с автоматическими заголовками.
|
||||
# 4. Обработка пагинации для API-ответов.
|
||||
# 5. Обработка загрузки файлов.
|
||||
# @coherence:
|
||||
# - Полностью независим от `SupersetClient`, предоставляя ему чистый API для сетевых операций.
|
||||
# - Использует `SupersetLogger` для внутреннего логирования.
|
||||
# - Всегда выбрасывает типизированные исключения из `superset_tool.exceptions`.
|
||||
|
||||
# [IMPORTS] Стандартная библиотека
|
||||
from typing import Optional, Dict, Any, BinaryIO, List, Union
|
||||
import json
|
||||
import urllib3
|
||||
from ..exceptions import AuthenticationError, NetworkError,DashboardNotFoundError,SupersetAPIError,PermissionDeniedError
|
||||
import io
|
||||
from pathlib import Path
|
||||
|
||||
# [IMPORTS] Сторонние библиотеки
|
||||
import requests
|
||||
import urllib3 # Для отключения SSL-предупреждений
|
||||
|
||||
# [IMPORTS] Локальные модули
|
||||
from ..exceptions import AuthenticationError, NetworkError, DashboardNotFoundError, SupersetAPIError, PermissionDeniedError
|
||||
from .logger import SupersetLogger # Импорт логгера
|
||||
|
||||
# [CONSTANTS]
|
||||
DEFAULT_RETRIES = 3
|
||||
DEFAULT_BACKOFF_FACTOR = 0.5
|
||||
|
||||
class APIClient:
|
||||
"""[NETWORK-CORE] Инкапсулирует HTTP-логику для работы с API.
|
||||
@contract: Гарантирует retry, SSL-валидацию и стандартные заголовки.
|
||||
@contract:
|
||||
- Гарантирует retry-механизмы для запросов.
|
||||
- Выполняет SSL-валидацию или отключает ее по конфигурации.
|
||||
- Автоматически управляет access и CSRF токенами.
|
||||
- Преобразует HTTP-ошибки в типизированные исключения `superset_tool.exceptions`.
|
||||
@pre:
|
||||
- `base_url` должен быть валидным URL.
|
||||
- `auth` должен содержать необходимые данные для аутентификации.
|
||||
- `logger` должен быть инициализирован.
|
||||
@post:
|
||||
- Аутентификация выполняется при первом запросе или явно через `authenticate()`.
|
||||
- `self._tokens` всегда содержит актуальные access/CSRF токены после успешной аутентификации.
|
||||
@invariant:
|
||||
- Сессия `requests` активна и настроена.
|
||||
- Все запросы используют актуальные токены.
|
||||
"""
|
||||
def __init__(
|
||||
self,
|
||||
base_url: str,
|
||||
auth: Dict[str, Any],
|
||||
verify_ssl: bool = False,
|
||||
timeout: int = 30
|
||||
verify_ssl: bool = True,
|
||||
timeout: int = 30,
|
||||
logger: Optional[SupersetLogger] = None
|
||||
):
|
||||
# [INIT] Основные параметры
|
||||
self.base_url = base_url
|
||||
self.auth = auth
|
||||
self.session = self._init_session(verify_ssl)
|
||||
self.verify_ssl = verify_ssl
|
||||
self.timeout = timeout
|
||||
self.logger = logger or SupersetLogger(name="APIClient") # [COHERENCE_CHECK_PASSED] Инициализация логгера
|
||||
|
||||
def _init_session(self, verify_ssl: bool) -> requests.Session:
|
||||
"""[NETWORK-INIT] Настройка сессии с адаптерами."""
|
||||
# [INIT] Сессия Requests
|
||||
self.session = self._init_session()
|
||||
self._tokens: Dict[str, str] = {} # [STATE] Хранилище токенов
|
||||
self._authenticated = False # [STATE] Флаг аутентификации
|
||||
|
||||
self.logger.debug(
|
||||
"[INIT] APIClient инициализирован.",
|
||||
extra={"base_url": self.base_url, "verify_ssl": self.verify_ssl}
|
||||
)
|
||||
|
||||
def _init_session(self) -> requests.Session:
|
||||
"""[HELPER] Настройка сессии `requests` с адаптерами и SSL-опциями.
|
||||
@semantic: Создает и конфигурирует объект `requests.Session`.
|
||||
"""
|
||||
session = requests.Session()
|
||||
session.mount('https://', requests.adapters.HTTPAdapter(max_retries=3))
|
||||
session.verify = verify_ssl
|
||||
if not verify_ssl:
|
||||
urllib3.disable_warnings()
|
||||
# [CONTRACT] Настройка повторных попыток
|
||||
retries = requests.adapters.Retry(
|
||||
total=DEFAULT_RETRIES,
|
||||
backoff_factor=DEFAULT_BACKOFF_FACTOR,
|
||||
status_forcelist=[500, 502, 503, 504],
|
||||
allowed_methods={"HEAD", "GET", "POST", "PUT", "DELETE"}
|
||||
)
|
||||
session.mount('http://', requests.adapters.HTTPAdapter(max_retries=retries))
|
||||
session.mount('https://', requests.adapters.HTTPAdapter(max_retries=retries))
|
||||
|
||||
session.verify = self.verify_ssl
|
||||
if not self.verify_ssl:
|
||||
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
||||
self.logger.warning("[SECURITY] Отключена проверка SSL-сертификатов. Не использовать в продакшене без явной необходимости.")
|
||||
return session
|
||||
|
||||
def authenticate(self) -> Dict[str, str]:
|
||||
"""[AUTH-FLOW] Получение access и CSRF токенов."""
|
||||
"""[AUTH-FLOW] Получение access и CSRF токенов.
|
||||
@pre:
|
||||
- `self.auth` содержит валидные учетные данные.
|
||||
@post:
|
||||
- `self._tokens` обновлен актуальными токенами.
|
||||
- Возвращает обновленные токены.
|
||||
- `self._authenticated` устанавливается в `True`.
|
||||
@raise:
|
||||
- `AuthenticationError`: При ошибках аутентификации (неверные credentials, проблемы с API security).
|
||||
- `NetworkError`: При проблемах с сетью.
|
||||
"""
|
||||
self.logger.info(f"[AUTH] Попытка аутентификации для {self.base_url}")
|
||||
try:
|
||||
# Шаг 1: Получение access_token
|
||||
login_url = f"{self.base_url}/security/login"
|
||||
response = self.session.post(
|
||||
f"{self.base_url}/security/login",
|
||||
json={**self.auth, "provider": "db", "refresh": True},
|
||||
login_url,
|
||||
json=self.auth, # Используем self.auth, который уже имеет "provider": "db", "refresh": True
|
||||
timeout=self.timeout
|
||||
)
|
||||
response.raise_for_status()
|
||||
response.raise_for_status() # Выбросит HTTPError для 4xx/5xx ответов
|
||||
access_token = response.json()["access_token"]
|
||||
|
||||
self.logger.debug("[AUTH] Access token успешно получен.")
|
||||
|
||||
# Шаг 2: Получение CSRF токена
|
||||
csrf_url = f"{self.base_url}/security/csrf_token/"
|
||||
csrf_response = self.session.get(
|
||||
f"{self.base_url}/security/csrf_token/",
|
||||
csrf_url,
|
||||
headers={"Authorization": f"Bearer {access_token}"},
|
||||
timeout=self.timeout
|
||||
)
|
||||
csrf_response.raise_for_status()
|
||||
csrf_token = csrf_response.json()["result"]
|
||||
self.logger.debug("[AUTH] CSRF token успешно получен.")
|
||||
|
||||
return {
|
||||
# [STATE] Сохранение токенов и обновление флага
|
||||
self._tokens = {
|
||||
"access_token": access_token,
|
||||
"csrf_token": csrf_response.json()["result"]
|
||||
"csrf_token": csrf_token
|
||||
}
|
||||
self._authenticated = True
|
||||
self.logger.info("[COHERENCE_CHECK_PASSED] Аутентификация успешно завершена.")
|
||||
return self._tokens
|
||||
|
||||
except requests.exceptions.HTTPError as e:
|
||||
error_msg = f"HTTP Error during authentication: {e.response.status_code} - {e.response.text}"
|
||||
self.logger.error(f"[AUTH_FAILED] {error_msg}", exc_info=True)
|
||||
if e.response.status_code == 401: # Unauthorized
|
||||
raise AuthenticationError(
|
||||
f"Неверные учетные данные или истекший токен.",
|
||||
url=login_url, username=self.auth.get("username"),
|
||||
status_code=e.response.status_code, response_text=e.response.text
|
||||
) from e
|
||||
elif e.response.status_code == 403: # Forbidden
|
||||
raise PermissionDeniedError(
|
||||
"Недостаточно прав для аутентификации.",
|
||||
url=login_url, username=self.auth.get("username"),
|
||||
status_code=e.response.status_code, response_text=e.response.text
|
||||
) from e
|
||||
else:
|
||||
raise SupersetAPIError(
|
||||
f"API ошибка при аутентификации: {error_msg}",
|
||||
url=login_url, status_code=e.response.status_code, response_text=e.response.text
|
||||
) from e
|
||||
except requests.exceptions.RequestException as e:
|
||||
raise NetworkError(f"Auth failed: {str(e)}")
|
||||
self.logger.error(f"[NETWORK_ERROR] Сетевая ошибка при аутентификации: {str(e)}", exc_info=True)
|
||||
raise NetworkError(f"Ошибка сети при аутентификации: {str(e)}", url=login_url) from e
|
||||
except KeyError as e:
|
||||
self.logger.error(f"[AUTH_FAILED] Некорректный формат ответа при аутентификации: {str(e)}", exc_info=True)
|
||||
raise AuthenticationError(f"Некорректный формат ответа API при аутентификации: {str(e)}") from e
|
||||
except Exception as e:
|
||||
self.logger.critical(f"[CRITICAL] Непредвиденная ошибка аутентификации: {str(e)}", exc_info=True)
|
||||
raise AuthenticationError(f"Непредвиденная ошибка аутентификации: {str(e)}") from e
|
||||
|
||||
@property
|
||||
def headers(self) -> Dict[str, str]:
|
||||
"""[INTERFACE] Возвращает стандартные заголовки с текущими токенами.
|
||||
@semantic: Если токены не получены, пытается выполнить аутентификацию.
|
||||
@post: Всегда возвращает словарь с 'Authorization' и 'X-CSRFToken'.
|
||||
@raise: `AuthenticationError` если аутентификация невозможна.
|
||||
"""
|
||||
if not self._authenticated:
|
||||
self.authenticate() # Попытка аутентификации при первом запросе заголовков
|
||||
|
||||
# [CONTRACT] Проверка наличия токенов
|
||||
if not self._tokens or "access_token" not in self._tokens or "csrf_token" not in self._tokens:
|
||||
self.logger.error("[CONTRACT_VIOLATION] Токены отсутствуют после попытки аутентификации.", extra={"tokens": self._tokens})
|
||||
raise AuthenticationError("Не удалось получить токены для заголовков.")
|
||||
|
||||
return {
|
||||
"Authorization": f"Bearer {self._tokens['access_token']}",
|
||||
"X-CSRFToken": self._tokens["csrf_token"],
|
||||
"Referer": self.base_url,
|
||||
"Content-Type": "application/json"
|
||||
}
|
||||
|
||||
def request(
|
||||
self,
|
||||
method: str,
|
||||
endpoint: str,
|
||||
headers: Optional[Dict] = None,
|
||||
raw_response: bool = False,
|
||||
**kwargs
|
||||
) -> requests.Response:
|
||||
"""[NETWORK-CORE] Обертка для запросов с обработкой ошибок."""
|
||||
try:
|
||||
response = self.session.request(
|
||||
method,
|
||||
f"{self.base_url}{endpoint}",
|
||||
headers=headers,
|
||||
timeout=self.timeout,
|
||||
**kwargs
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response
|
||||
except requests.exceptions.HTTPError as e:
|
||||
if e.response.status_code == 404:
|
||||
raise DashboardNotFoundError(endpoint)
|
||||
raise SupersetAPIError(str(e))
|
||||
|
||||
def upload_file(
|
||||
self,
|
||||
endpoint: str,
|
||||
file_obj: BinaryIO,
|
||||
file_name: str,
|
||||
form_field: str = "file",
|
||||
extra_data: Optional[Dict] = None,
|
||||
timeout: Optional[int] = None
|
||||
) -> Dict:
|
||||
"""[NETWORK] Отправка файла на сервер
|
||||
@params:
|
||||
endpoint: API endpoint
|
||||
file_obj: файловый объект
|
||||
file_name: имя файла
|
||||
form_field: имя поля формы
|
||||
extra_data: дополнительные данные
|
||||
timeout: таймаут запроса
|
||||
@return:
|
||||
Ответ сервера (JSON)
|
||||
) -> Union[requests.Response, Dict[str, Any]]:
|
||||
"""[NETWORK-CORE] Обертка для всех HTTP-запросов к Superset API.
|
||||
@semantic:
|
||||
- Выполняет запрос с заданными параметрами.
|
||||
- Автоматически добавляет базовые заголовки (токены, CSRF).
|
||||
- Обрабатывает HTTP-ошибки и преобразует их в типизированные исключения.
|
||||
- В случае 401/403, пытается обновить токен и повторить запрос один раз.
|
||||
@pre:
|
||||
- `method` - валидный HTTP-метод ('GET', 'POST', 'PUT', 'DELETE').
|
||||
- `endpoint` - валидный путь API.
|
||||
@post:
|
||||
- Возвращает объект `requests.Response` (если `raw_response=True`) или `dict` (JSON-ответ).
|
||||
@raise:
|
||||
- `AuthenticationError`, `PermissionDeniedError`, `NetworkError`, `SupersetAPIError`, `DashboardNotFoundError`.
|
||||
"""
|
||||
files = {form_field: (file_name, file_obj, 'application/x-zip-compressed')}
|
||||
headers = {
|
||||
k: v for k, v in self.headers.items()
|
||||
if k.lower() != 'content-type'
|
||||
}
|
||||
full_url = f"{self.base_url}{endpoint}"
|
||||
self.logger.debug(f"[REQUEST] Выполнение запроса: {method} {full_url}", extra={"kwargs_keys": list(kwargs.keys())})
|
||||
|
||||
# [STATE] Заголовки для текущего запроса
|
||||
_headers = self.headers.copy() # Получаем базовые заголовки с актуальными токенами
|
||||
if headers: # Объединяем с переданными кастомными заголовками (переданные имеют приоритет)
|
||||
_headers.update(headers)
|
||||
|
||||
retries_left = 1 # Одна попытка на обновление токена
|
||||
while retries_left >= 0:
|
||||
try:
|
||||
response = self.session.request(
|
||||
method,
|
||||
full_url,
|
||||
headers=_headers,
|
||||
#timeout=self.timeout,
|
||||
**kwargs
|
||||
)
|
||||
response.raise_for_status() # Проверяем статус сразу
|
||||
self.logger.debug(f"[COHERENCE_CHECK_PASSED] Запрос {method} {endpoint} успешно выполнен.")
|
||||
return response if raw_response else response.json()
|
||||
|
||||
except requests.exceptions.HTTPError as e:
|
||||
status_code = e.response.status_code
|
||||
error_context = {
|
||||
"method": method,
|
||||
"url": full_url,
|
||||
"status_code": status_code,
|
||||
"response_text": e.response.text
|
||||
}
|
||||
|
||||
if status_code in [401, 403] and retries_left > 0:
|
||||
self.logger.warning(f"[AUTH_REFRESH] Токен истек или недействителен ({status_code}). Попытка обновить и повторить...", extra=error_context)
|
||||
try:
|
||||
self.authenticate() # Попытка обновить токены
|
||||
_headers = self.headers.copy() # Обновляем заголовки с новыми токенами
|
||||
if headers:
|
||||
_headers.update(headers)
|
||||
retries_left -= 1
|
||||
continue # Повторяем цикл
|
||||
except AuthenticationError as auth_err:
|
||||
self.logger.error("[AUTH_FAILED] Не удалось обновить токены.", exc_info=True)
|
||||
raise PermissionDeniedError("Аутентификация не удалась или права отсутствуют после обновления токена.", **error_context) from auth_err
|
||||
|
||||
# [ERROR_MAPPING] Преобразование стандартных HTTP-ошибок в кастомные исключения
|
||||
if status_code == 404:
|
||||
raise DashboardNotFoundError(endpoint, context=error_context) from e
|
||||
elif status_code == 403:
|
||||
raise PermissionDeniedError("Доступ запрещен.", **error_context) from e
|
||||
elif status_code == 401:
|
||||
raise AuthenticationError("Аутентификация не удалась.", **error_context) from e
|
||||
else:
|
||||
raise SupersetAPIError(f"Ошибка API: {status_code} - {e.response.text}", **error_context) from e
|
||||
|
||||
except requests.exceptions.Timeout as e:
|
||||
self.logger.error(f"[NETWORK_ERROR] Таймаут запроса: {str(e)}", exc_info=True, extra={"url": full_url})
|
||||
raise NetworkError("Таймаут запроса", url=full_url) from e
|
||||
except requests.exceptions.ConnectionError as e:
|
||||
self.logger.error(f"[NETWORK_ERROR] Ошибка соединения: {str(e)}", exc_info=True, extra={"url": full_url})
|
||||
raise NetworkError("Ошибка соединения", url=full_url) from e
|
||||
except requests.exceptions.RequestException as e:
|
||||
self.logger.critical(f"[CRITICAL] Неизвестная ошибка запроса: {str(e)}", exc_info=True, extra={"url": full_url})
|
||||
raise NetworkError(f"Неизвестная сетевая ошибка: {str(e)}", url=full_url) from e
|
||||
except json.JSONDecodeError as e:
|
||||
self.logger.error(f"[API_FAILED] Ошибка парсинга JSON ответа: {str(e)}", exc_info=True, extra={"url": full_url, "response_text_sample": response.text[:200]})
|
||||
raise SupersetAPIError(f"Некорректный JSON ответ: {str(e)}", url=full_url) from e
|
||||
except Exception as e:
|
||||
self.logger.critical(f"[CRITICAL] Непредвиденная ошибка в APIClient.request: {str(e)}", exc_info=True, extra={"url": full_url})
|
||||
raise SupersetAPIError(f"Непредвиденная ошибка: {str(e)}", url=full_url) from e
|
||||
|
||||
# [COHERENCE_CHECK_FAILED] Если дошли сюда, значит, все повторные попытки провалились
|
||||
self.logger.error(f"[CONTRACT_VIOLATION] Все повторные попытки для запроса {method} {endpoint} исчерпаны.")
|
||||
raise SupersetAPIError(f"Все повторные попытки запроса {method} {endpoint} исчерпаны.")
|
||||
|
||||
|
||||
def upload_file(
|
||||
self,
|
||||
endpoint: str,
|
||||
file_obj: Union[str, Path, BinaryIO], # Может быть Path, str или байтовый поток
|
||||
file_name: str,
|
||||
form_field: str = "file",
|
||||
extra_data: Optional[Dict] = None,
|
||||
timeout: Optional[int] = None
|
||||
) -> Dict:
|
||||
"""[CONTRACT] Отправка файла на сервер через POST-запрос.
|
||||
@pre:
|
||||
- `endpoint` - валидный API endpoint для загрузки.
|
||||
- `file_obj` - путь к файлу или открытый бинарный файловый объект.
|
||||
- `file_name` - имя файла для отправки в форме.
|
||||
@post:
|
||||
- Возвращает JSON-ответ от сервера в виде словаря.
|
||||
@raise:
|
||||
- `FileNotFoundError`: Если `file_obj` является путем и файл не найден.
|
||||
- `PermissionDeniedError`: Если недостаточно прав.
|
||||
- `SupersetAPIError`, `NetworkError`.
|
||||
"""
|
||||
full_url = f"{self.base_url}{endpoint}"
|
||||
_headers = self.headers.copy()
|
||||
# [IMPORTANT] Content-Type для files формируется requests, поэтому удаляем его из общих заголовков
|
||||
_headers.pop('Content-Type', None)
|
||||
|
||||
files_payload = None
|
||||
should_close_file = False
|
||||
|
||||
if isinstance(file_obj, (str, Path)):
|
||||
file_path = Path(file_obj)
|
||||
if not file_path.exists():
|
||||
self.logger.error(f"[CONTRACT_VIOLATION] Файл для загрузки не найден: {file_path}", extra={"file_path": str(file_path)})
|
||||
raise FileNotFoundError(f"Файл {file_path} не найден для загрузки.")
|
||||
files_payload = {form_field: (file_name, open(file_path, 'rb'), 'application/x-zip-compressed')}
|
||||
should_close_file = True
|
||||
self.logger.debug(f"[UPLOAD] Загрузка файла из пути: {file_path}")
|
||||
elif isinstance(file_obj, io.BytesIO): # In-memory binary file
|
||||
files_payload = {form_field: (file_name, file_obj.getvalue(), 'application/x-zip-compressed')}
|
||||
self.logger.debug(f"[UPLOAD] Загрузка файла из байтового потока (in-memory).")
|
||||
elif hasattr(file_obj, 'read') and hasattr(file_obj, 'seek'): # Generic binary file-like object
|
||||
files_payload = {form_field: (file_name, file_obj, 'application/x-zip-compressed')}
|
||||
self.logger.debug(f"[UPLOAD] Загрузка файла из файлового объекта.")
|
||||
else:
|
||||
self.logger.error(f"[CONTRACT_VIOLATION] Неподдерживаемый тип файла для загрузки: {type(file_obj).__name__}")
|
||||
raise TypeError("Неподдерживаемый тип 'file_obj'. Ожидается Path, str, io.BytesIO или другой файлоподобный объект.")
|
||||
|
||||
try:
|
||||
response = self.session.post(
|
||||
url=f"{self.base_url}{endpoint}",
|
||||
files=files,
|
||||
url=full_url,
|
||||
files=files_payload,
|
||||
data=extra_data or {},
|
||||
headers=headers,
|
||||
headers=_headers,
|
||||
timeout=timeout or self.timeout
|
||||
)
|
||||
|
||||
if response.status_code == 403:
|
||||
raise PermissionDeniedError("Доступ запрещен")
|
||||
|
||||
response.raise_for_status()
|
||||
|
||||
# [COHERENCE_CHECK_PASSED] Файл успешно загружен.
|
||||
self.logger.info(f"[UPLOAD_SUCCESS] Файл '{file_name}' успешно загружен на {endpoint}.")
|
||||
return response.json()
|
||||
|
||||
except requests.exceptions.RequestException as e:
|
||||
error_ctx = {
|
||||
except requests.exceptions.HTTPError as e:
|
||||
error_context = {
|
||||
"endpoint": endpoint,
|
||||
"file": file_name,
|
||||
"status_code": getattr(e.response, 'status_code', None)
|
||||
"status_code": e.response.status_code,
|
||||
"response_text": e.response.text
|
||||
}
|
||||
self.logger.error(
|
||||
"[NETWORK_ERROR] Ошибка загрузки файла",
|
||||
extra=error_ctx
|
||||
)
|
||||
raise
|
||||
if e.response.status_code == 403:
|
||||
raise PermissionDeniedError("Доступ запрещен для загрузки файла.", **error_context) from e
|
||||
else:
|
||||
raise SupersetAPIError(f"Ошибка API при загрузке файла: {e.response.status_code} - {e.response.text}", **error_context) from e
|
||||
except requests.exceptions.RequestException as e:
|
||||
error_context = {"endpoint": endpoint, "file": file_name, "error_type": type(e).__name__}
|
||||
self.logger.error(f"[NETWORK_ERROR] Ошибка запроса при загрузке файла: {str(e)}", exc_info=True, extra=error_context)
|
||||
raise NetworkError(f"Ошибка сети при загрузке файла: {str(e)}", url=full_url) from e
|
||||
except Exception as e:
|
||||
error_context = {"endpoint": endpoint, "file": file_name, "error_type": type(e).__name__}
|
||||
self.logger.critical(f"[CRITICAL] Непредвиденная ошибка при загрузке файла: {str(e)}", exc_info=True, extra=error_context)
|
||||
raise SupersetAPIError(f"Непредвиденная ошибка загрузки файла: {str(e)}", context=error_context) from e
|
||||
finally:
|
||||
# Закрываем файл, если он был открыт в этом методе
|
||||
if should_close_file and files_payload and files_payload[form_field] and hasattr(files_payload[form_field][1], 'close'):
|
||||
files_payload[form_field][1].close()
|
||||
self.logger.debug(f"[UPLOAD] Закрыт файл '{file_name}'.")
|
||||
|
||||
def fetch_paginated_count(
|
||||
self,
|
||||
@@ -137,39 +380,44 @@ class APIClient:
|
||||
count_field: str = "count",
|
||||
timeout: Optional[int] = None
|
||||
) -> int:
|
||||
"""[NETWORK] Получение общего количества элементов в пагинированном API
|
||||
@params:
|
||||
endpoint: API endpoint без query-параметров
|
||||
query_params: параметры для пагинации
|
||||
count_field: поле с количеством в ответе
|
||||
timeout: таймаут запроса
|
||||
@return:
|
||||
Общее количество элементов
|
||||
@errors:
|
||||
- NetworkError: проблемы с соединением
|
||||
- KeyError: некорректный формат ответа
|
||||
"""[CONTRACT] Получение общего количества элементов в пагинированном API.
|
||||
@delegates:
|
||||
- Использует `self.request` для выполнения HTTP-запроса.
|
||||
@pre:
|
||||
- `endpoint` должен указывать на пагинированный ресурс.
|
||||
- `query_params` должны быть валидны для запроса количества.
|
||||
@post:
|
||||
- Возвращает целочисленное количество элементов.
|
||||
@raise:
|
||||
- `NetworkError`, `SupersetAPIError`, `KeyError` (если `count_field` не найден).
|
||||
"""
|
||||
self.logger.debug(f"[PAGINATION] Запрос количества элементов для {endpoint} с параметрами: {query_params}")
|
||||
try:
|
||||
response = self.request(
|
||||
response_json = self.request(
|
||||
method="GET",
|
||||
endpoint=endpoint,
|
||||
params={"q": json.dumps(query_params)},
|
||||
timeout=timeout or self.timeout
|
||||
)
|
||||
|
||||
if count_field not in response:
|
||||
raise KeyError(f"Ответ API не содержит поле {count_field}")
|
||||
|
||||
return response[count_field]
|
||||
if count_field not in response_json:
|
||||
self.logger.error(
|
||||
f"[CONTRACT_VIOLATION] Ответ API для {endpoint} не содержит поле '{count_field}'",
|
||||
extra={"response_keys": list(response_json.keys())}
|
||||
)
|
||||
raise KeyError(f"Ответ API для {endpoint} не содержит поле '{count_field}'")
|
||||
|
||||
except requests.exceptions.RequestException as e:
|
||||
error_ctx = {
|
||||
"endpoint": endpoint,
|
||||
"params": query_params,
|
||||
"error": str(e)
|
||||
}
|
||||
self.logger.error("[PAGINATION_ERROR]", extra=error_ctx)
|
||||
raise NetworkError(f"Ошибка пагинации: {str(e)}") from e
|
||||
count = response_json[count_field]
|
||||
self.logger.debug(f"[COHERENCE_CHECK_PASSED] Получено количество: {count} для {endpoint}.")
|
||||
return count
|
||||
|
||||
except (KeyError, SupersetAPIError, NetworkError, PermissionDeniedError, DashboardNotFoundError) as e:
|
||||
self.logger.error(f"[ERROR] Ошибка получения количества элементов для {endpoint}: {str(e)}", exc_info=True, extra=getattr(e, 'context', {}))
|
||||
raise
|
||||
except Exception as e:
|
||||
error_ctx = {"endpoint": endpoint, "params": query_params, "error_type": type(e).__name__}
|
||||
self.logger.critical(f"[CRITICAL] Непредвиденная ошибка при получении количества: {str(e)}", exc_info=True, extra=error_ctx)
|
||||
raise SupersetAPIError(f"Непредвиденная ошибка при получении count для {endpoint}: {str(e)}", context=error_ctx) from e
|
||||
|
||||
def fetch_paginated_data(
|
||||
self,
|
||||
@@ -179,37 +427,53 @@ class APIClient:
|
||||
results_field: str = "result",
|
||||
timeout: Optional[int] = None
|
||||
) -> List[Any]:
|
||||
"""[NETWORK] Получение всех данных с пагинированного API
|
||||
@params:
|
||||
endpoint: API endpoint
|
||||
base_query: базовые параметры запроса (без page)
|
||||
total_count: общее количество элементов
|
||||
results_field: поле с данными в ответе
|
||||
timeout: таймаут для запросов
|
||||
@return:
|
||||
Собранные данные со всех страниц
|
||||
"""[CONTRACT] Получение всех данных с пагинированного API.
|
||||
@delegates:
|
||||
- Использует `self.request` для выполнения запросов по страницам.
|
||||
@pre:
|
||||
- `base_query` должен содержать 'page_size'.
|
||||
- `total_count` должен быть корректным общим количеством элементов.
|
||||
@post:
|
||||
- Возвращает список всех собранных данных со всех страниц.
|
||||
@raise:
|
||||
- `NetworkError`, `SupersetAPIError`, `ValueError` (если `page_size` невалиден), `KeyError`.
|
||||
"""
|
||||
page_size = base_query['page_size']
|
||||
self.logger.debug(f"[PAGINATION] Запуск получения всех данных для {endpoint}. Total: {total_count}, Base Query: {base_query}")
|
||||
page_size = base_query.get('page_size')
|
||||
if not page_size or page_size <= 0:
|
||||
self.logger.error("[CONTRACT_VIOLATION] 'page_size' в базовом запросе невалиден.", extra={"page_size": page_size})
|
||||
raise ValueError("Параметр 'page_size' должен быть положительным числом.")
|
||||
|
||||
total_pages = (total_count + page_size - 1) // page_size
|
||||
results = []
|
||||
|
||||
for page in range(total_pages):
|
||||
query = {**base_query, 'page': page}
|
||||
|
||||
response = self._execute_request(
|
||||
method="GET",
|
||||
endpoint=endpoint,
|
||||
params={"q": json.dumps(query)},
|
||||
timeout=timeout or self.timeout
|
||||
)
|
||||
|
||||
if results_field not in response:
|
||||
self.logger.warning(
|
||||
f"Ответ не содержит поле {results_field}",
|
||||
extra={"response": response.keys()}
|
||||
self.logger.debug(f"[PAGINATION] Запрос страницы {page+1}/{total_pages} для {endpoint}.")
|
||||
try:
|
||||
response_json = self.request(
|
||||
method="GET",
|
||||
endpoint=endpoint,
|
||||
params={"q": json.dumps(query)},
|
||||
timeout=timeout or self.timeout
|
||||
)
|
||||
continue
|
||||
|
||||
results.extend(response[results_field])
|
||||
if results_field not in response_json:
|
||||
self.logger.warning(
|
||||
f"[CONTRACT_VIOLATION] Ответ API для {endpoint} на странице {page} не содержит поле '{results_field}'",
|
||||
extra={"response_keys": list(response_json.keys())}
|
||||
)
|
||||
# Если поле результатов отсутствует на одной странице, это может быть не фатально, но надо залогировать.
|
||||
continue
|
||||
|
||||
results.extend(response_json[results_field])
|
||||
except (SupersetAPIError, NetworkError, PermissionDeniedError, DashboardNotFoundError) as e:
|
||||
self.logger.error(f"[ERROR] Ошибка получения страницы {page+1} для {endpoint}: {str(e)}", exc_info=True, extra=getattr(e, 'context', {}))
|
||||
raise # Пробрасываем ошибку выше, так как не можем продолжить пагинацию
|
||||
except Exception as e:
|
||||
error_ctx = {"endpoint": endpoint, "page": page, "error_type": type(e).__name__}
|
||||
self.logger.critical(f"[CRITICAL] Непредвиденная ошибка при получении страницы {page+1} для {endpoint}: {str(e)}", exc_info=True, extra=error_ctx)
|
||||
raise SupersetAPIError(f"Непредвиденная ошибка пагинации для {endpoint}: {str(e)}", context=error_ctx) from e
|
||||
|
||||
return results
|
||||
self.logger.debug(f"[COHERENCE_CHECK_PASSED] Все данные с пагинацией для {endpoint} успешно собраны. Всего элементов: {len(results)}")
|
||||
return results
|
||||
|
||||
Reference in New Issue
Block a user