AssistagroAPI 0.1.0__py3-none-any.whl

assistagro_client/__init__.py

@@ -0,0 +1,17 @@
+"""AssistAgro API Client."""
+
+from .client import AssistAgroClient
+from .auth import Auth, AuthTokens, SignInRequest, OTPResponse
+from .exceptions import AssistAgroError, AuthenticationError, APIError, TimeoutError
+
+__all__ = [
+    "AssistAgroClient",
+    "Auth",
+    "AuthTokens",
+    "SignInRequest",
+    "OTPResponse",
+    "AssistAgroError",
+    "AuthenticationError",
+    "APIError",
+    "TimeoutError",
+]

assistagro_client/api/__init__.py

@@ -0,0 +1 @@
+"""API v1 endpoints."""

assistagro_client/api/v1/__init__.py

@@ -0,0 +1 @@
+"""API v1 endpoints."""

assistagro_client/api/v1/accounts.py

@@ -0,0 +1,53 @@
+"""Accounts 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 Company(BaseModel):
+    guid: UUID
+    name: str
+    parent_guid: UUID | None = None
+
+
+class UserProfile(BaseModel):
+    company: Company
+    user_guid: UUID
+    permissions: list[str]
+    is_current: bool
+    is_confirmed: bool
+
+
+class AccountsAPI:
+    """Accounts API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def get_users(self, account_guid: UUID | None = None) -> list[UserProfile]:
+        """Get user profiles."""
+        params = {}
+        if account_guid:
+            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()]
+
+    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()
+
+    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()

assistagro_client/api/v1/companies.py

@@ -0,0 +1,39 @@
+"""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()]

assistagro_client/api/v1/dictionaries.py

@@ -0,0 +1,69 @@
+"""Dictionaries API endpoints."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class DictionariesAPI:
+    """Dictionaries API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def get_crops(self) -> list[dict[str, Any]]:
+        """Get crops dictionary."""
+        response = await self._client.get("/dictionaries/crops")
+        response.raise_for_status()
+        return response.json()
+
+    async def get_crop_products(self) -> list[dict[str, Any]]:
+        """Get crop products dictionary."""
+        response = await self._client.get("/dictionaries/crop_products")
+        response.raise_for_status()
+        return response.json()
+
+    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()
+
+    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()
+
+    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()
+
+    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()
+
+    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()
+
+    async def get_meteostations(self) -> list[dict[str, Any]]:
+        """Get meteostations."""
+        response = await self._client.get("/meteostations")
+        response.raise_for_status()
+        return response.json()
+
+    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()

assistagro_client/api/v1/fields.py

@@ -0,0 +1,62 @@
+"""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()

assistagro_client/api/v1/meteostations.py

@@ -0,0 +1,31 @@
+"""Meteostations 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 Meteostation(BaseModel):
+    guid: UUID
+    name: str
+    latitude: float
+    longitude: float
+
+
+class MeteostationsAPI:
+    """Meteostations API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def list_(self) -> list[Meteostation]:
+        """List all meteostations."""
+        response = await self._client.get("/meteostations")
+        response.raise_for_status()
+        return [Meteostation(**item) for item in response.json()]

assistagro_client/api/v1/reports.py

@@ -0,0 +1,67 @@
+"""Reports 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 Report(BaseModel):
+    guid: UUID
+    task_guid: UUID | None = None
+    season_id: int
+    entity_guid: UUID | None = None
+    entity_type: str | None = None
+    status_id: int
+    name: str
+    created_at: datetime
+    updated_at: datetime
+
+
+class ReportCreateRequest(BaseModel):
+    task_guid: UUID | None = None
+    season_id: int
+    entity_guid: UUID | None = None
+    entity_type: str | None = None
+    entity_data: dict[str, Any]
+    datetimes: dict
+    history: list[dict]
+
+
+class ReportsAPI:
+    """Reports API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def create(
+        self,
+        season_id: int,
+        entity_data: dict[str, Any],
+        datetimes: dict,
+        history: list[dict],
+        task_guid: UUID | None = None,
+        entity_guid: UUID | None = None,
+        entity_type: str | None = None,
+    ) -> Report:
+        """Create a report."""
+        response = await self._client.post(
+            "/reports",
+            json={
+                "task_guid": str(task_guid) if task_guid else None,
+                "season_id": season_id,
+                "entity_guid": str(entity_guid) if entity_guid else None,
+                "entity_type": entity_type,
+                "entity_data": entity_data,
+                "datetimes": datetimes,
+                "history": history,
+            },
+        )
+        response.raise_for_status()
+        return Report(**response.json())

assistagro_client/api/v1/structures.py

@@ -0,0 +1,30 @@
+"""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()]

assistagro_client/api/v1/tasks.py

@@ -0,0 +1,93 @@
+"""Tasks 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 Task(BaseModel):
+    guid: UUID
+    task_ext_id: str | None = None
+    season_id: int
+    priority_id: int
+    entity_guid: UUID | None = None
+    entity_type: str | None = None
+    status_id: int
+    name: str
+    description: str | None = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class TaskCreateRequest(BaseModel):
+    season_id: int
+    priority_id: int
+    entity_data: dict
+    datetimes: dict
+    history: list[dict]
+
+
+class TasksAPI:
+    """Tasks API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def create(
+        self,
+        season_id: int,
+        priority_id: int,
+        entity_data: dict,
+        datetimes: dict,
+        history: list[dict],
+        task_ext_id: str | None = None,
+        check_deleted_objects: bool = True,
+    ) -> Task:
+        """Create a task."""
+        params = {}
+        if not check_deleted_objects:
+            params["check_deleted_objects"] = "false"
+        response = await self._client.post(
+            "/tasks",
+            params=params,
+            json={
+                "season_id": season_id,
+                "priority_id": priority_id,
+                "entity_data": entity_data,
+                "datetimes": datetimes,
+                "history": history,
+                "task_ext_id": task_ext_id,
+            },
+        )
+        response.raise_for_status()
+        return Task(**response.json())
+
+    async def list_(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        season_id: int | None = None,
+        status_id: int | None = None,
+    ) -> list[Task]:
+        """List tasks with filters."""
+        params = {"limit": limit, "offset": offset}
+        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()]
+
+    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()

assistagro_client/api/v1/techmaps.py

@@ -0,0 +1,83 @@
+"""Techmaps API endpoints."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from .client import AssistAgroClient
+
+
+class TechmapOperation(BaseModel):
+    techoperation_guid: UUID
+    begin_date: date
+    end_date: date
+    name: str
+
+
+class Techmap(BaseModel):
+    guid: UUID
+    season_id: int
+    crop_id: int
+    structure_guid: UUID
+    name: str
+    technology: str | None = None
+    techoperations: list[TechmapOperation]
+    created_at: datetime
+    updated_at: datetime
+
+
+class TechmapCreateRequest(BaseModel):
+    season_id: int
+    crop_id: int
+    structure_guid: UUID
+    name: str
+    technology: str | None = None
+    techoperations: list[dict]
+
+
+class TechmapsAPI:
+    """Techmaps API endpoints."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def create(
+        self,
+        season_id: int,
+        crop_id: int,
+        structure_guid: UUID,
+        name: str,
+        techoperations: list[dict],
+        technology: str | None = None,
+    ) -> Techmap:
+        """Create a techmap."""
+        response = await self._client.post(
+            "/techmaps",
+            json={
+                "season_id": season_id,
+                "crop_id": crop_id,
+                "structure_guid": str(structure_guid),
+                "name": name,
+                "technology": technology,
+                "techoperations": techoperations,
+            },
+        )
+        response.raise_for_status()
+        return Techmap(**response.json())
+
+    async def list_(self) -> list[Techmap]:
+        """List techmaps."""
+        response = await self._client.get("/techmaps/list")
+        response.raise_for_status()
+        return [Techmap(**item) for item in response.json()]
+
+    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())

assistagro_client/auth.py

@@ -0,0 +1,100 @@
+"""Authentication module."""
+
+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
+
+from .exceptions import AuthenticationError
+
+
+class SignInRequest(BaseModel):
+    email: str = Field(..., min_length=7, max_length=255)
+    password: str = Field(..., min_length=12, max_length=255)
+
+
+class OTPResponse(BaseModel):
+    session_guid: str
+    attempts: int
+    max_attempts: int
+    expires_at: datetime
+    next_request_available_at: datetime
+    code_request: int
+    max_code_request: int
+
+
+class AuthTokens(BaseModel):
+    access_token: str
+    access_token_expires_in: float
+    refresh_token: str
+    refresh_token_expires_in: float
+    superset_token: str | None = None
+    superset_token_expires_in: float | None = None
+
+
+class RefreshTokensRequest(BaseModel):
+    refresh_token: str
+
+
+class Auth:
+    """Authentication handler."""
+
+    def __init__(self, client: AssistAgroClient):
+        self._client = client
+
+    async def sign_in(self, email: str, password: str) -> AuthTokens | OTPResponse:
+        """Sign in with email and password.
+
+        Returns AuthTokens if 2FA is disabled, OTPResponse if enabled.
+        """
+        response = await self._client.post(
+            "/account/sign_in",
+            json={"email": email, "password": password},
+        )
+        if response.status_code == 401:
+            raise AuthenticationError("Invalid email or password")
+        response.raise_for_status()
+        data = response.json()
+        if "session_guid" in data:
+            return OTPResponse(**data)
+        tokens = AuthTokens(**data)
+        self._client.set_auth_tokens(tokens)
+        return tokens
+
+    async def confirm_otp(self, session_guid: str, code: str) -> AuthTokens:
+        """Confirm OTP code."""
+        response = await self._client.post(
+            "/account/otp/validation",
+            json={"session_guid": session_guid, "code": code},
+        )
+        if response.status_code == 401:
+            raise AuthenticationError("Invalid OTP code")
+        response.raise_for_status()
+        tokens = AuthTokens(**response.json())
+        self._client.set_auth_tokens(tokens)
+        return tokens
+
+    async def refresh_tokens(self, refresh_token: str) -> AuthTokens:
+        """Refresh access token."""
+        response = await self._client.post(
+            "/account/refresh_tokens",
+            json={"refresh_token": refresh_token},
+        )
+        if response.status_code == 401:
+            raise AuthenticationError("Invalid refresh token")
+        response.raise_for_status()
+        tokens = AuthTokens(**response.json())
+        self._client.set_auth_tokens(tokens)
+        return tokens
+
+    async def logout(self) -> None:
+        """Log out and invalidate tokens."""
+        await self._client.post("/account/logout")
+        self._client.token = None
+        self._client.set_user_data({})
+        self._client.set_permissions([])

assistagro_client/client.py

@@ -0,0 +1,218 @@
+"""Main async client for AssistAgro API."""
+
+from __future__ import annotations
+
+import httpx
+from typing import Any, TYPE_CHECKING
+
+from .config import settings
+from .exceptions import APIError, TimeoutError, AssistAgroError
+from .auth import Auth, AuthTokens
+
+if TYPE_CHECKING:
+    from .api.v1.accounts import AccountsAPI
+    from .api.v1.companies import CompaniesAPI
+    from .api.v1.fields import FieldsAPI
+    from .api.v1.tasks import TasksAPI
+    from .api.v1.techmaps import TechmapsAPI
+    from .api.v1.reports import ReportsAPI
+    from .api.v1.dictionaries import DictionariesAPI
+    from .api.v1.meteostations import MeteostationsAPI
+    from .api.v1.structures import StructuresAPI
+
+
+class AssistAgroClient:
+    """Async HTTP client for AssistAgro API."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        timeout: int | None = None,
+        token: str | None = None,
+    ):
+        self.base_url = base_url or settings.base_url
+        self.timeout = timeout or settings.timeout
+        self._token = token
+        self._user_data: dict[str, Any] = {}
+        self._permissions: list[str] = []
+        self._client: httpx.AsyncClient | None = None
+        self._auth: Auth | None = None
+        self._auth_tokens: AuthTokens | None = None
+        self._accounts: AccountsAPI | None = None
+        self._companies: CompaniesAPI | None = None
+        self._fields: FieldsAPI | None = None
+        self._tasks: TasksAPI | None = None
+        self._techmaps: TechmapsAPI | None = None
+        self._reports: ReportsAPI | None = None
+        self._dictionaries: DictionariesAPI | None = None
+        self._meteostations: MeteostationsAPI | None = None
+        self._structures: StructuresAPI | None = None
+
+    @property
+    def token(self) -> str | None:
+        return self._token
+
+    @token.setter
+    def token(self, value: str | None) -> None:
+        self._token = value
+
+    def set_user_data(self, user_data: dict[str, Any]) -> None:
+        self._user_data = user_data
+
+    def set_permissions(self, permissions: list[str]) -> None:
+        self._permissions = permissions
+
+    @property
+    def auth(self) -> Auth:
+        if self._auth is None:
+            self._auth = Auth(self)
+        return self._auth
+
+    def set_auth_tokens(self, tokens: AuthTokens) -> None:
+        self._auth_tokens = tokens
+        self._token = tokens.access_token
+
+    @property
+    def accounts(self) -> AccountsAPI:
+        if self._accounts is None:
+            from .api.v1.accounts import AccountsAPI
+
+            self._accounts = AccountsAPI(self)
+        return self._accounts
+
+    @property
+    def companies(self) -> CompaniesAPI:
+        if self._companies is None:
+            from .api.v1.companies import CompaniesAPI
+
+            self._companies = CompaniesAPI(self)
+        return self._companies
+
+    @property
+    def fields(self) -> FieldsAPI:
+        if self._fields is None:
+            from .api.v1.fields import FieldsAPI
+
+            self._fields = FieldsAPI(self)
+        return self._fields
+
+    @property
+    def tasks(self) -> TasksAPI:
+        if self._tasks is None:
+            from .api.v1.tasks import TasksAPI
+
+            self._tasks = TasksAPI(self)
+        return self._tasks
+
+    @property
+    def techmaps(self) -> TechmapsAPI:
+        if self._techmaps is None:
+            from .api.v1.techmaps import TechmapsAPI
+
+            self._techmaps = TechmapsAPI(self)
+        return self._techmaps
+
+    @property
+    def reports(self) -> ReportsAPI:
+        if self._reports is None:
+            from .api.v1.reports import ReportsAPI
+
+            self._reports = ReportsAPI(self)
+        return self._reports
+
+    @property
+    def dictionaries(self) -> DictionariesAPI:
+        if self._dictionaries is None:
+            from .api.v1.dictionaries import DictionariesAPI
+
+            self._dictionaries = DictionariesAPI(self)
+        return self._dictionaries
+
+    @property
+    def meteostations(self) -> MeteostationsAPI:
+        if self._meteostations is None:
+            from .api.v1.meteostations import MeteostationsAPI
+
+            self._meteostations = MeteostationsAPI(self)
+        return self._meteostations
+
+    @property
+    def structures(self) -> StructuresAPI:
+        if self._structures is None:
+            from .api.v1.structures import StructuresAPI
+
+            self._structures = StructuresAPI(self)
+        return self._structures
+
+    def _get_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {
+            "Content-Type": "application/json",
+        }
+        if self._token:
+            headers["x-token"] = self._token
+        if self._user_data:
+            headers["x-user-data"] = str(self._user_data)
+        if self._permissions:
+            headers["x-permissions"] = ",".join(self._permissions)
+        return headers
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=self.timeout,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> "AssistAgroClient":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.close()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """Make HTTP request."""
+        client = await self._get_client()
+        try:
+            response = await client.request(
+                method=method,
+                url=path,
+                headers=self._get_headers(),
+                **kwargs,
+            )
+            if response.status_code >= 400:
+                raise APIError(
+                    message=response.text or response.reason_phrase,
+                    status_code=response.status_code,
+                )
+            return response
+        except httpx.TimeoutException as e:
+            raise TimeoutError(f"Request to {path} timed out") from e
+        except httpx.HTTPError as e:
+            raise AssistAgroError(f"HTTP error: {e}") from e
+
+    async def get(self, path: str, **kwargs: Any) -> httpx.Response:
+        """GET request."""
+        return await self.request("GET", path, **kwargs)
+
+    async def post(self, path: str, **kwargs: Any) -> httpx.Response:
+        """POST request."""
+        return await self.request("POST", path, **kwargs)
+
+    async def put(self, path: str, **kwargs: Any) -> httpx.Response:
+        """PUT request."""
+        return await self.request("PUT", path, **kwargs)
+
+    async def delete(self, path: str, **kwargs: Any) -> httpx.Response:
+        """DELETE request."""
+        return await self.request("DELETE", path, **kwargs)

assistagro_client/config.py

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

assistagro_client/exceptions.py

@@ -0,0 +1,27 @@
+"""Custom exceptions."""
+
+
+class AssistAgroError(Exception):
+    """Base exception for AssistAgro client."""
+
+    pass
+
+
+class AuthenticationError(AssistAgroError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class APIError(AssistAgroError):
+    """Raised when API returns an error."""
+
+    def __init__(self, message: str, status_code: int):
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class TimeoutError(AssistAgroError):
+    """Raised when request times out."""
+
+    pass

assistagro_client/models/__init__.py

@@ -0,0 +1 @@
+"""Pydantic models."""

assistagroapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: AssistagroAPI
+Version: 0.1.0
+Summary: Async HTTP client for AssistAgro API
+Author-email: Dmitriy Kazakov <dmitriyfile@yandex.ru>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13
+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
+
+# AssistAgro API Client
+
+Асинхронный HTTP-клиент для AssistAgro API.
+
+## Установка
+
+```bash
+pip install assistagro-client
+```
+
+## Использование
+
+```python
+import asyncio
+from assistagro_client import AssistAgroClient
+
+async def main():
+    async with AssistAgroClient(base_url="https://dev-gateway-frontend.agroassist.ru") as client:
+        tokens = await client.auth.sign_in(
+            email="user@example.com",
+            password="password123"
+        )
+        print(f"Access token: {tokens.access_token[:20]}...")
+
+        fields = await client.fields.list_()
+        print(f"Найдено полей: {len(fields)}")
+
+        tasks = await client.tasks.list_(limit=10)
+        print(f"Найдено задач: {len(tasks)}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## API эндпоинты
+
+- **auth** - Аутентификация (sign_in, refresh_tokens, logout)
+- **accounts** - Профили пользователей и аккаунты
+- **companies** - Управление компаниями
+- **fields** - Поля и контуры
+- **tasks** - Управление задачами
+- **techmaps** - Технологические карты
+- **reports** - Отчёты
+- **dictionaries** - Справочники (культуры, пестициды и т.д.)
+- **meteostations** - Метеостанции
+- **structures** - Структуры
+
+## Разработка
+
+```bash
+# Установить зависимости
+uv sync
+
+# Запустить тесты
+uv run pytest
+
+# Запустить линтер
+uv run ruff check .
+```
+
+## Лицензия
+
+MIT

assistagroapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+assistagro_client/__init__.py,sha256=JZKliTFyaO-37o2WSnhZJ8hVZnlgYIDYgTzDgnMvbEo,410
+assistagro_client/auth.py,sha256=z1pFZ7B3PWYs2n6XEDzDxPvpi-y8ZtpHIV9QA2ecI0E,3035
+assistagro_client/client.py,sha256=9z76ngXYDtkbr-UPrbClty7zF05nTbgl24rDSfvvFHw,6896
+assistagro_client/config.py,sha256=X4HlaMR-dDhWbneCD66TCQv1B58opprhOUe-frkwVjU,326
+assistagro_client/exceptions.py,sha256=_H5wD4r-bRFtFiyonnUJ_jlUr7QSJtXFhqwfHaS4o_g,518
+assistagro_client/api/__init__.py,sha256=eeTfLUYpfMqfFWpzfPbjzjHIiYLsQsUakOM5ETC_l5A,24
+assistagro_client/api/v1/__init__.py,sha256=eeTfLUYpfMqfFWpzfPbjzjHIiYLsQsUakOM5ETC_l5A,24
+assistagro_client/api/v1/accounts.py,sha256=Z3J5MMyzbJuTn_Sbn3tf5oFEKeRbH3K54QRVW0eWgvw,1430
+assistagro_client/api/v1/companies.py,sha256=5Vk-PyLKorEQd9xRAZfxcK5LIH6E1VQ6IKBK8ydS9EA,821
+assistagro_client/api/v1/dictionaries.py,sha256=dZli1ZLFDZw7ZE7K5FjZ4-aaOcXryDK49fdbyz8kyLw,2478
+assistagro_client/api/v1/fields.py,sha256=tAwCpC6j3sethez4_TdjpixsE2GuGa3QTo1QPIf-L9Q,1625
+assistagro_client/api/v1/meteostations.py,sha256=6Zn6iVgGTN3A7w3c0ntP_YJHGxhNpVGZapxWgv9f050,718
+assistagro_client/api/v1/reports.py,sha256=7Pu3E3OKERvucGZKu22YBTZ_e2FMh367UcuBu_7yNFM,1726
+assistagro_client/api/v1/structures.py,sha256=pGE1CDat_tzHsm808owMUnUJK_Ll7mGYe0wRBYJJJmY,672
+assistagro_client/api/v1/tasks.py,sha256=_6QJSUFcNoFq4V56RJ-Ww3AmVCkIC-heory4vXHlg04,2478
+assistagro_client/api/v1/techmaps.py,sha256=XqfHOZOWx4YQfD9qeSfoKN9-dRei5CKNsH4pwTe6xEM,2105
+assistagro_client/models/__init__.py,sha256=jMtBC6F3WbzMeidPz9xrX0NJRysvfXbnbGP3niuYG3c,23
+assistagroapi-0.1.0.dist-info/METADATA,sha256=UdZRm98g0E9K1h-_tUAqSwEVpVeymT7-dOkJ1g-ET-M,2190
+assistagroapi-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+assistagroapi-0.1.0.dist-info/top_level.txt,sha256=juHIdi9P2pELResos6x4pj04kflxszIvVi1DDMZMq40,18
+assistagroapi-0.1.0.dist-info/RECORD,,

assistagroapi-0.1.0.dist-info/WHEEL

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

assistagroapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+assistagro_client