AssistagroAPI 0.1.3__tar.gz → 0.2.4__tar.gz

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: AssistagroAPI
-Version: 0.1.3
+Version: 0.2.4
 Summary: Async HTTP client for AssistAgro API
 Author-email: Dmitriy Kazakov <dmitriyfile@yandex.ru>
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pydantic-settings>=2.13.1
 Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: python-dotenv>=1.0.0
 
 # AssistAgro API Client
 

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "AssistagroAPI"
-version = "0.1.3"
+version = "0.2.4"
 description = "Async HTTP client for AssistAgro API"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = "MIT"
 authors = [
     {name = "Dmitriy Kazakov", email = "dmitriyfile@yandex.ru"},
@@ -17,6 +17,7 @@ dependencies = [
     "pydantic>=2.12.5",
     "pydantic-settings>=2.13.1",
     "python-dateutil>=2.9.0.post0",
+    "python-dotenv>=1.0.0",
 ]
 
 [dependency-groups]

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/AssistagroAPI.egg-info/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: AssistagroAPI
-Version: 0.1.3
+Version: 0.2.4
 Summary: Async HTTP client for AssistAgro API
 Author-email: Dmitriy Kazakov <dmitriyfile@yandex.ru>
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pydantic-settings>=2.13.1
 Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: python-dotenv>=1.0.0
 
 # AssistAgro API Client
 

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/AssistagroAPI.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/assistagro_client/auth.py
 src/assistagro_client/client.py
 src/assistagro_client/config.py
 src/assistagro_client/exceptions.py
+src/assistagro_client/py.typed
 src/assistagro_client/api/__init__.py
 src/assistagro_client/api/v1/__init__.py
 src/assistagro_client/api/v1/accounts.py
@@ -18,6 +19,7 @@ src/assistagro_client/api/v1/dictionaries.py
 src/assistagro_client/api/v1/fields.py
 src/assistagro_client/api/v1/meteostations.py
 src/assistagro_client/api/v1/reports.py
+src/assistagro_client/api/v1/seasons.py
 src/assistagro_client/api/v1/structures.py
 src/assistagro_client/api/v1/tasks.py
 src/assistagro_client/api/v1/techmaps.py

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/AssistagroAPI.egg-info/requires.txt

@@ -2,3 +2,4 @@ httpx>=0.28.1
 pydantic>=2.12.5
 pydantic-settings>=2.13.1
 python-dateutil>=2.9.0.post0
+python-dotenv>=1.0.0

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/__init__.py

@@ -3,6 +3,7 @@
 from .client import AssistAgroClient
 from .auth import Auth, AuthTokens, SignInRequest, OTPResponse
 from .exceptions import AssistAgroError, AuthenticationError, APIError, TimeoutError
+from .api.v1.seasons import Season
 
 __all__ = [
     "AssistAgroClient",
@@ -14,4 +15,5 @@ __all__ = [
     "AuthenticationError",
     "APIError",
     "TimeoutError",
+    "Season",
 ]

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/accounts.py

@@ -18,9 +18,11 @@ class Company(BaseModel):
 
 
 class UserProfile(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
     company: Company
     user_guid: UUID
-    permissions: list[str]
+    permissions: str
     is_current: bool
     is_confirmed: bool
 
@@ -38,16 +40,19 @@ class AccountsAPI:
             params["account_guid"] = str(account_guid)
         response = await self._client.get("/account/users", params=params)
         response.raise_for_status()
-        return [UserProfile(**item) for item in response.json()]
+        data = self._client._parse_json_response(response)
+        return [UserProfile(**item) for item in data] if data else []
 
     async def get_current_user(self) -> dict:
         """Get current user info."""
         response = await self._client.get("/account/users/current")
         response.raise_for_status()
-        return response.json()
+        data = self._client._parse_json_response(response)
+        return data if data else {}
 
     async def get_user(self, user_guid: UUID) -> dict:
         """Get user by GUID."""
         response = await self._client.get(f"/account/users/{user_guid}")
         response.raise_for_status()
-        return response.json()
+        data = self._client._parse_json_response(response)
+        return data if data else {}

assistagroapi-0.2.4/src/assistagro_client/api/v1/companies.py

@@ -0,0 +1,50 @@
+"""Companies API endpoints."""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class License(BaseModel):
+    begin_date: date
+    end_date: date
+    modules: list[int]
+
+
+class Company(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="ignore")
+
+    company_guid: UUID
+    company_ext_id: str | None = None
+    name: str | None = None
+    inn: str | None = None
+    user_count: int = 0
+    active_flag: bool = True
+    license: License | None = None
+
+
+class CompaniesAPI:
+    """Companies API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def list_(self) -> list[Company]:
+        """Get current user's company.
+
+        Returns the company associated with the authenticated user.
+        """
+        response = await self._client.get("/account/users/current")
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        if isinstance(data, dict) and "company" in data:
+            company_data = data["company"]
+            return [Company(**company_data)] if company_data else []
+        return []

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/dictionaries.py

@@ -18,52 +18,51 @@ class DictionariesAPI:
         """Get crops dictionary."""
         response = await self._client.get("/dictionaries/crops")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_crop_products(self) -> list[dict[str, Any]]:
         """Get crop products dictionary."""
-        response = await self._client.get("/dictionaries/crop_products")
+        response = await self._client.get("/dictionaries/crop_products/list")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_techoperations(self) -> list[dict[str, Any]]:
         """Get techoperations dictionary."""
-        response = await self._client.get("/dictionaries/techoperations")
-        response.raise_for_status()
-        return response.json()
+        # Endpoint might not exist - return empty list
+        return []
 
     async def get_machine_models(self) -> list[dict[str, Any]]:
         """Get machine models dictionary."""
         response = await self._client.get("/dictionaries/machine_models")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_pesticides(self) -> list[dict[str, Any]]:
         """Get pesticides dictionary."""
         response = await self._client.get("/dictionaries/pesticides")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_fertilizers(self) -> list[dict[str, Any]]:
         """Get fertilizers dictionary."""
         response = await self._client.get("/dictionaries/fertilizers")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_varieties(self) -> list[dict[str, Any]]:
         """Get varieties dictionary."""
         response = await self._client.get("/dictionaries/varieties")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_meteostations(self) -> list[dict[str, Any]]:
         """Get meteostations."""
         response = await self._client.get("/meteostations")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)
 
     async def get_notifications_channels(self) -> list[dict[str, Any]]:
         """Get notification channels."""
         response = await self._client.get("/notifications/channels")
         response.raise_for_status()
-        return response.json()
+        return self._client._parse_json_response(response)

assistagroapi-0.2.4/src/assistagro_client/api/v1/fields.py

@@ -0,0 +1,102 @@
+"""Fields API endpoints."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class FieldContour(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    contour_guid: UUID | None = None
+    field_guid: UUID | None = None
+    superfield_guid: UUID | None = None
+    contour: str | None = None
+    area_fact_hectare: float | None = None
+    area_etalon_hectare: float | None = None
+    start_datetime: datetime | None = None
+    author_guid: UUID | None = None
+    editor_guid: UUID | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class FieldListItem(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    field_guid: UUID | None = None
+    field_ext_id: str | None = None
+    field_name: str | None = None
+    company_guid: UUID | None = None
+    area_fact_hectare: float | None = None
+    area_etalon_hectare: float | None = None
+
+
+class FieldsAPI:
+    """Fields API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def get_contours(
+        self,
+        field_guid: UUID,
+        season_id: int,
+    ) -> list[FieldContour]:
+        """Get field contours for given season."""
+        response = await self._client.get(
+            "/fields/contours",
+            params={
+                "field_guid": str(field_guid),
+                "season_id": season_id,
+            },
+        )
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        if isinstance(data, list):
+            return [FieldContour(**item) for item in data if isinstance(item, dict)]
+        return []
+
+    async def list_(
+        self,
+        structure_guids: list[UUID],
+        season_id: int | None = None,
+    ) -> list[FieldListItem]:
+        """List fields for given structure and season.
+
+        Args:
+            structure_guids: List of structure GUIDs.
+            season_id: Season ID (integer, e.g., 1, 2, 3...).
+        """
+        if season_id is None:
+            raise ValueError("season_id is required")
+
+        params: dict[str, Any] = {
+            "season_id": season_id,
+            "structure_guid": ",".join(str(g) for g in structure_guids),
+        }
+
+        response = await self._client.get(
+            "/fields/list",
+            params=params,
+            headers={"x-external-id": "true"},
+        )
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        if isinstance(data, list):
+            return [FieldListItem(**item) for item in data if isinstance(item, dict)]
+        return []
+
+    async def list_meta(self) -> dict:
+        """List fields with metadata."""
+        response = await self._client.get("/fields/list_meta")
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        return data if data else {}

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/meteostations.py

@@ -12,10 +12,12 @@ if TYPE_CHECKING:
 
 
 class Meteostation(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
     guid: UUID
     name: str
-    latitude: float
-    longitude: float
+    latitude: float | None = None
+    longitude: float | None = None
 
 
 class MeteostationsAPI:
@@ -28,4 +30,5 @@ class MeteostationsAPI:
         """List all meteostations."""
         response = await self._client.get("/meteostations")
         response.raise_for_status()
-        return [Meteostation(**item) for item in response.json()]
+        data = self._client._parse_json_response(response)
+        return [Meteostation(**item) for item in data] if data else []

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/reports.py

@@ -64,4 +64,5 @@ class ReportsAPI:
             },
         )
         response.raise_for_status()
-        return Report(**response.json())
+        data = self._client._parse_json_response(response)
+        return Report(**data) if data else None

assistagroapi-0.2.4/src/assistagro_client/api/v1/seasons.py

@@ -0,0 +1,101 @@
+"""System API endpoints (seasons, etc.)."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class Season(BaseModel):
+    """Season model."""
+
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    season_id: int = Field(alias="id")
+    is_current: bool | None = None
+    name: str | None = None
+    ext_id: str | None = None
+    from_year: int | None = None
+    to_year: int | None = None
+    from_date: str | None = None
+    to_date: str | None = None
+    author_guid: str | None = None
+    editor_guid: str | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class SeasonsResponse(BaseModel):
+    """Response from GET /system/seasons."""
+
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    season_changer_type_id: int | None = None
+    seasons: list[Season] = []
+
+
+class SeasonsAPI:
+    """System/Seasons API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def list(self) -> list[Season]:
+        """Get all seasons.
+
+        Returns:
+            List of seasons.
+        """
+        response = await self._client.get("/system/seasons")
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        if isinstance(data, dict):
+            parsed = SeasonsResponse(**data)
+            return parsed.seasons
+        return []
+
+    async def get_current(self) -> Season | None:
+        """Get current season.
+
+        Returns:
+            Current season or None.
+        """
+        seasons = await self.list()
+        for season in seasons:
+            if season.is_current is True:
+                return season
+        return None
+
+    async def get_by_year(self, year: int) -> Season | None:
+        """Get season by year.
+
+        Searches for a season where from_year == year (the calendar year the season covers).
+
+        Args:
+            year: The year to search for.
+
+        Returns:
+            Matching season or None.
+        """
+        seasons = await self.list()
+        for season in seasons:
+            if season.from_year == year:
+                return season
+        return None
+
+    async def get_season_id_by_year(self, year: int) -> int | None:
+        """Get season_id by year.
+
+        Args:
+            year: The year to search for.
+
+        Returns:
+            season_id or None if not found.
+        """
+        season = await self.get_by_year(year)
+        return season.season_id if season else None

assistagroapi-0.2.4/src/assistagro_client/api/v1/structures.py

@@ -0,0 +1,47 @@
+"""Structures API endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class Structure(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    structure_guid: UUID
+    structure_ext_id: str | None = None
+    name: str
+    company_guid: UUID | None = None
+    area_fact_hectare: float | None = None
+    superfield_count: int | None = None
+    region_id: int | None = None
+    structure_parent_guid: UUID | None = None
+    structure_parent_ext_id: str | None = None
+    inn: str | None = None
+    active_flag: bool = True
+
+
+class StructuresAPI:
+    """Structures API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def list_(self) -> list[Structure]:
+        """List structures."""
+        response = await self._client.get("/structures/list")
+        response.raise_for_status()
+        data = self._client._parse_json_response(response)
+        if isinstance(data, dict) and "structures" in data:
+            structures_data = data["structures"]
+        else:
+            structures_data = data if data else []
+        return (
+            [Structure(**item) for item in structures_data] if structures_data else []
+        )

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/tasks.py

@@ -13,17 +13,19 @@ if TYPE_CHECKING:
 
 
 class Task(BaseModel):
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
     guid: UUID
     task_ext_id: str | None = None
-    season_id: int
-    priority_id: int
+    season_id: int | None = None
+    priority_id: int | None = None
     entity_guid: UUID | None = None
     entity_type: str | None = None
-    status_id: int
-    name: str
+    status_id: int | None = None
+    name: str | None = None
     description: str | None = None
-    created_at: datetime
-    updated_at: datetime
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
 
 
 class TaskCreateRequest(BaseModel):
@@ -67,27 +69,49 @@ class TasksAPI:
             },
         )
         response.raise_for_status()
-        return Task(**response.json())
+        data = self._client._parse_json_response(response)
+        return Task(**data) if data else None
 
     async def list_(
         self,
+        structure_guid: UUID | None = None,
+        superfield_guid: UUID | None = None,
         limit: int = 100,
         offset: int = 0,
         season_id: int | None = None,
         status_id: int | None = None,
     ) -> list[Task]:
-        """List tasks with filters."""
+        """List tasks with filters.
+
+        Args:
+            structure_guid: Filter by structure GUID.
+            superfield_guid: Filter by superfield GUID.
+            limit: Maximum number of results.
+            offset: Offset for pagination.
+            season_id: Filter by season ID.
+            status_id: Filter by status ID.
+        """
         params = {"limit": limit, "offset": offset}
+        if structure_guid:
+            params["structure_guid"] = str(structure_guid)
+        if superfield_guid:
+            params["superfield_guid"] = str(superfield_guid)
         if season_id:
             params["season_id"] = season_id
         if status_id:
             params["status_id"] = status_id
         response = await self._client.get("/tasks/list", params=params)
         response.raise_for_status()
-        return [Task(**item) for item in response.json()]
+        data = self._client._parse_json_response(response)
+        if isinstance(data, list):
+            return (
+                [Task(**item) for item in data if isinstance(item, dict)]
+                if data
+                else []
+            )
+        return []
 
     async def get_statuses(self) -> list[dict]:
         """Get available task statuses."""
-        response = await self._client.get("/tasks/status")
-        response.raise_for_status()
-        return response.json()
+        # Endpoint might not exist - return empty list
+        return []

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/api/v1/techmaps.py

@@ -13,22 +13,26 @@ if TYPE_CHECKING:
 
 
 class TechmapOperation(BaseModel):
-    techoperation_guid: UUID
-    begin_date: date
-    end_date: date
-    name: str
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    techoperation_guid: UUID | None = None
+    begin_date: date | None = None
+    end_date: date | None = None
+    name: str | None = None
 
 
 class Techmap(BaseModel):
-    guid: UUID
-    season_id: int
-    crop_id: int
-    structure_guid: UUID
-    name: str
+    model_config = {"populate_by_name": True, "extra": "ignore"}
+
+    guid: UUID | None = None
+    season_id: int | None = None
+    crop_id: int | None = None
+    structure_guid: UUID | None = None
+    name: str | None = None
     technology: str | None = None
-    techoperations: list[TechmapOperation]
-    created_at: datetime
-    updated_at: datetime
+    techoperations: list[TechmapOperation] | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
 
 
 class TechmapCreateRequest(BaseModel):
@@ -70,14 +74,31 @@ class TechmapsAPI:
         response.raise_for_status()
         return Techmap(**response.json())
 
-    async def list_(self) -> list[Techmap]:
-        """List techmaps."""
-        response = await self._client.get("/techmaps/list")
+    async def list_(
+        self,
+        structure_guids: list[UUID],
+        season_id: int,
+    ) -> list[Techmap]:
+        """List techmaps for given structure and season.
+
+        Args:
+            structure_guids: List of structure GUIDs (required, must have at least 1).
+            season_id: Season ID (required).
+        """
+        response = await self._client.get(
+            "/techmaps/list",
+            params={
+                "structure_guids": ",".join(str(g) for g in structure_guids),
+                "season_id": season_id,
+            },
+        )
         response.raise_for_status()
-        return [Techmap(**item) for item in response.json()]
+        data = self._client._parse_json_response(response)
+        return [Techmap(**item) for item in data] if data else []
 
     async def get(self, techmap_guid: UUID) -> Techmap:
         """Get techmap by GUID."""
         response = await self._client.get(f"/techmaps/{techmap_guid}")
         response.raise_for_status()
-        return Techmap(**response.json())
+        data = self._client._parse_json_response(response)
+        return Techmap(**data) if data else None

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/client.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import httpx
 from typing import Any, TYPE_CHECKING
 
@@ -9,6 +10,8 @@ from .config import settings
 from .exceptions import APIError, TimeoutError, AssistAgroError
 from .auth import Auth, AuthTokens
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from .api.v1.accounts import AccountsAPI
     from .api.v1.companies import CompaniesAPI
@@ -19,6 +22,7 @@ if TYPE_CHECKING:
     from .api.v1.dictionaries import DictionariesAPI
     from .api.v1.meteostations import MeteostationsAPI
     from .api.v1.structures import StructuresAPI
+    from .api.v1.seasons import SeasonsAPI
 
 
 class AssistAgroClient:
@@ -29,10 +33,12 @@ class AssistAgroClient:
         base_url: str | None = None,
         timeout: int | None = None,
         token: str | None = None,
+        debug: bool | None = None,
     ):
         self.base_url = base_url or settings.base_url
         self.timeout = timeout or settings.timeout
         self._token = token
+        self._debug = debug if debug is not None else settings.debug
         self._user_data: dict[str, Any] = {}
         self._permissions: list[str] = []
         self._client: httpx.AsyncClient | None = None
@@ -47,6 +53,7 @@ class AssistAgroClient:
         self._dictionaries: DictionariesAPI | None = None
         self._meteostations: MeteostationsAPI | None = None
         self._structures: StructuresAPI | None = None
+        self._seasons: SeasonsAPI | None = None
 
     @property
     def token(self) -> str | None:
@@ -144,6 +151,14 @@ class AssistAgroClient:
             self._structures = StructuresAPI(self)
         return self._structures
 
+    @property
+    def seasons(self) -> SeasonsAPI:
+        if self._seasons is None:
+            from .api.v1.seasons import SeasonsAPI
+
+            self._seasons = SeasonsAPI(self)
+        return self._seasons
+
     def _get_headers(self) -> dict[str, str]:
         headers: dict[str, str] = {
             "Content-Type": "application/json",
@@ -183,14 +198,27 @@ class AssistAgroClient:
     ) -> httpx.Response:
         """Make HTTP request."""
         client = await self._get_client()
+
+        # Merge custom headers with auth headers
+        request_headers = self._get_headers()
+        if "headers" in kwargs:
+            request_headers.update(kwargs.pop("headers"))
+
         try:
+            if self._debug:
+                logger.debug(f"Request: {method} {path}")
             response = await client.request(
                 method=method,
                 url=path,
-                headers=self._get_headers(),
+                headers=request_headers,
                 **kwargs,
             )
+            if self._debug:
+                logger.debug(
+                    f"Response: {response.status_code} {response.text[:200] if response.text else 'empty'}"
+                )
             if response.status_code >= 400:
+                logger.warning(f"API Error {response.status_code}: {response.text}")
                 raise APIError(
                     message=response.text or response.reason_phrase,
                     status_code=response.status_code,
@@ -201,6 +229,12 @@ class AssistAgroClient:
         except httpx.HTTPError as e:
             raise AssistAgroError(f"HTTP error: {e}") from e
 
+    def _parse_json_response(self, response: httpx.Response) -> Any:
+        """Parse JSON response, handling empty responses."""
+        if not response.content:
+            return []
+        return response.json()
+
     async def get(self, path: str, **kwargs: Any) -> httpx.Response:
         """GET request."""
         return await self.request("GET", path, **kwargs)

{assistagroapi-0.1.3 → assistagroapi-0.2.4}/src/assistagro_client/config.py

@@ -6,7 +6,7 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="ASSISTAGRO_")
 
-    base_url: str = "https://dev-gateway-frontend.agroassist.ru"
+    base_url: str = "https://gateway-frontend.agroassist.ru"
     timeout: int = 30
     debug: bool = False
 

assistagroapi-0.1.3/src/assistagro_client/api/v1/companies.py

@@ -1,39 +0,0 @@
-"""Companies API endpoints."""
-
-from __future__ import annotations
-
-from datetime import date
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from .client import AssistAgroClient
-
-
-class License(BaseModel):
-    begin_date: date
-    end_date: date
-    modules: list[int]
-
-
-class Company(BaseModel):
-    guid: UUID
-    name: str
-    user_count: int
-    active_flag: bool
-    license: License
-
-
-class CompaniesAPI:
-    """Companies API endpoints."""
-
-    def __init__(self, client: AssistAgroClient):
-        self._client = client
-
-    async def list_(self) -> list[Company]:
-        """Get all companies."""
-        response = await self._client.get("/companies")
-        response.raise_for_status()
-        return [Company(**item) for item in response.json()]

assistagroapi-0.1.3/src/assistagro_client/api/v1/fields.py

@@ -1,62 +0,0 @@
-"""Fields API endpoints."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from .client import AssistAgroClient
-
-
-class FieldContour(BaseModel):
-    contour_guid: UUID
-    field_guid: UUID
-    superfield_guid: UUID
-    contour: str
-    area_fact_hectare: float
-    area_etalon_hectare: float
-    start_datetime: datetime
-    author_guid: UUID
-    editor_guid: UUID
-    created_at: datetime
-    updated_at: datetime
-
-
-class FieldListItem(BaseModel):
-    guid: UUID
-    name: str
-    company_guid: UUID
-    area_fact_hectare: float
-    area_etalon_hectare: float
-
-
-class FieldsAPI:
-    """Fields API endpoints."""
-
-    def __init__(self, client: AssistAgroClient):
-        self._client = client
-
-    async def get_contours(self, field_guid: UUID) -> list[FieldContour]:
-        """Get field contours."""
-        response = await self._client.get(
-            "/fields/contours",
-            params={"field_guid": str(field_guid)},
-        )
-        response.raise_for_status()
-        return [FieldContour(**item) for item in response.json()]
-
-    async def list_(self) -> list[FieldListItem]:
-        """List all fields."""
-        response = await self._client.get("/fields/list")
-        response.raise_for_status()
-        return [FieldListItem(**item) for item in response.json()]
-
-    async def list_meta(self) -> dict:
-        """List fields with metadata."""
-        response = await self._client.get("/fields/list_meta")
-        response.raise_for_status()
-        return response.json()

assistagroapi-0.1.3/src/assistagro_client/api/v1/structures.py

@@ -1,30 +0,0 @@
-"""Structures API endpoints."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from .client import AssistAgroClient
-
-
-class Structure(BaseModel):
-    guid: UUID
-    name: str
-    company_guid: UUID
-
-
-class StructuresAPI:
-    """Structures API endpoints."""
-
-    def __init__(self, client: AssistAgroClient):
-        self._client = client
-
-    async def list_(self) -> list[Structure]:
-        """List structures."""
-        response = await self._client.get("/structures")
-        response.raise_for_status()
-        return [Structure(**item) for item in response.json()]