aegro 0.2.0__py3-none-any.whl

aegro/__init__.py

@@ -0,0 +1,4 @@
+try:
+    from aegro._version import __version__
+except ImportError:
+    __version__ = "0.0.0+unknown"

aegro/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = None

aegro/api_client.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import asyncio
+
+import structlog
+import httpx
+
+from aegro.errors import AegroAPIError, translate_api_error
+
+logger = structlog.get_logger()
+
+
+class AegroClient:
+    def __init__(
+        self,
+        base_url: str = "https://app.aegro.com.br",
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._http: httpx.AsyncClient | None = None
+
+    def _get_http(self) -> httpx.AsyncClient:
+        if self._http is None or self._http.is_closed:
+            self._http = httpx.AsyncClient(timeout=self._timeout)
+        return self._http
+
+    async def close(self) -> None:
+        if self._http is not None and not self._http.is_closed:
+            await self._http.aclose()
+            self._http = None
+
+    def _headers(self, api_key: str) -> dict[str, str]:
+        return {
+            "Aegro-Public-API-Key": api_key,
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+    async def _request(
+        self, method: str, path: str, api_key: str, json_body: dict | None = None
+    ) -> dict | list | None:
+        url = f"{self._base_url}{path}"
+        attempt = 0
+        last_response = None
+        http = self._get_http()
+
+        while attempt <= self._max_retries:
+            try:
+                response = await http.request(
+                    method, url, headers=self._headers(api_key), json=json_body
+                )
+                last_response = response
+                if response.status_code == 204:
+                    return None
+                if response.status_code in (200, 201):
+                    return response.json()
+                if response.status_code >= 500 and attempt < self._max_retries:
+                    attempt += 1
+                    logger.warning(
+                        "aegro_api_retry", path=path, status=response.status_code, attempt=attempt
+                    )
+                    await asyncio.sleep(2**attempt)
+                    continue
+                body = {}
+                try:
+                    body = response.json()
+                except Exception:
+                    pass
+                raise translate_api_error(response.status_code, body)
+            except httpx.TimeoutException:
+                if attempt < self._max_retries:
+                    attempt += 1
+                    logger.warning("aegro_api_timeout", path=path, attempt=attempt)
+                    await asyncio.sleep(2**attempt)
+                    continue
+                raise AegroAPIError(
+                    504, "Timeout ao conectar com o servico Aegro. Tente novamente.", retryable=True
+                )
+            except AegroAPIError:
+                raise
+            except httpx.HTTPError as exc:
+                raise AegroAPIError(
+                    502,
+                    f"Erro de conexao com o servico Aegro: {type(exc).__name__}",
+                    retryable=True,
+                ) from exc
+
+        if last_response is not None:
+            body = {}
+            try:
+                body = last_response.json()
+            except Exception:
+                pass
+            raise translate_api_error(last_response.status_code, body)
+        raise AegroAPIError(502, "Erro inesperado de conexao.", retryable=True)
+
+    async def get(self, path: str, *, api_key: str) -> dict | list | None:
+        return await self._request("GET", path, api_key)
+
+    async def post(
+        self, path: str, *, api_key: str, json_body: dict | None = None
+    ) -> dict | list | None:
+        return await self._request("POST", path, api_key, json_body)
+
+    async def put(
+        self, path: str, *, api_key: str, json_body: dict | None = None
+    ) -> dict | list | None:
+        return await self._request("PUT", path, api_key, json_body)
+
+    async def delete(self, path: str, *, api_key: str) -> dict | list | None:
+        return await self._request("DELETE", path, api_key)
+
+    async def get_user_identity(self, api_key: str) -> str | None:
+        """Return the email address associated with the given API key.
+
+        Calls ``/pub/v1/users/me`` and extracts the ``email`` field.
+        Returns ``None`` when the endpoint does not return a usable email.
+        """
+        try:
+            data = await self.get("/pub/v1/users/me", api_key=api_key)
+            if isinstance(data, dict):
+                return data.get("email")
+        except (AegroAPIError, httpx.HTTPError):
+            logger.warning("identity_lookup_failed", exc_info=True)
+        return None

aegro/cli/__init__.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import typer
+
+app = typer.Typer(
+    name="aegro",
+    help="CLI para gerenciamento agricola via API Aegro.",
+    invoke_without_command=True,
+)
+
+
+@app.callback(invoke_without_command=True)
+def _callback(ctx: typer.Context) -> None:
+    """CLI para gerenciamento agricola via API Aegro."""
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+from aegro.cli.activities import activities_app  # noqa: E402
+from aegro.cli.assets import assets_app  # noqa: E402
+from aegro.cli.auth import auth_app  # noqa: E402
+from aegro.cli.bank_accounts import bank_accounts_app  # noqa: E402
+from aegro.cli.catalogs import catalogs_app  # noqa: E402
+from aegro.cli.companies import companies_app  # noqa: E402
+from aegro.cli.crop_glebes import crop_glebes_app  # noqa: E402
+from aegro.cli.crops import crops_app  # noqa: E402
+from aegro.cli.elements import elements_app  # noqa: E402
+from aegro.cli.farms import farms_app  # noqa: E402
+from aegro.cli.financial import financial_app  # noqa: E402
+from aegro.cli.financial_categories import fin_categories_app  # noqa: E402
+from aegro.cli.fuel_supplies import fuel_supplies_app  # noqa: E402
+from aegro.cli.glebes import glebes_app  # noqa: E402
+from aegro.cli.harvest_logs import harvest_logs_app  # noqa: E402
+from aegro.cli.maintenances import maintenances_app  # noqa: E402
+from aegro.cli.purchase_orders import purchase_orders_app  # noqa: E402
+from aegro.cli.stock import stock_app  # noqa: E402
+from aegro.cli.tags import tags_app  # noqa: E402
+from aegro.cli.weather import weather_app  # noqa: E402
+
+app.add_typer(activities_app, name="activities")
+app.add_typer(assets_app, name="assets")
+app.add_typer(auth_app, name="auth")
+app.add_typer(bank_accounts_app, name="bank-accounts")
+app.add_typer(catalogs_app, name="catalogs")
+app.add_typer(companies_app, name="companies")
+app.add_typer(crop_glebes_app, name="crop-glebes")
+app.add_typer(crops_app, name="crops")
+app.add_typer(elements_app, name="elements")
+app.add_typer(farms_app, name="farms")
+app.add_typer(financial_app, name="financial")
+app.add_typer(fin_categories_app, name="fin-categories")
+app.add_typer(fuel_supplies_app, name="fuel-supplies")
+app.add_typer(glebes_app, name="glebes")
+app.add_typer(harvest_logs_app, name="harvest-logs")
+app.add_typer(maintenances_app, name="maintenances")
+app.add_typer(purchase_orders_app, name="purchase-orders")
+app.add_typer(stock_app, name="stock")
+app.add_typer(tags_app, name="tags")
+app.add_typer(weather_app, name="weather")
+
+
+def main() -> None:
+    """Entry point for the aegro CLI."""
+    app()

aegro/cli/_auth.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "aegro"
+CREDENTIALS_FILE_NAME = "credentials.json"
+
+
+def _warn(msg: str) -> None:
+    print(f"aegro: aviso: {msg}", file=sys.stderr)
+
+
+def load_credentials() -> dict[str, str]:
+    """Load farm name -> API key mapping.
+
+    Priority:
+      1. AEGRO_FARMS env var (JSON string)
+      2. AEGRO_FARMS_FILE env var (path to JSON file)
+      3. ~/.config/aegro/credentials.json (interactive setup)
+    """
+    env_farms = os.environ.get("AEGRO_FARMS")
+    if env_farms:
+        try:
+            farms = json.loads(env_farms)
+        except json.JSONDecodeError as exc:
+            _warn(f"AEGRO_FARMS contem JSON invalido: {exc}")
+            return {}
+        if not isinstance(farms, dict):
+            _warn(f"AEGRO_FARMS deve ser um objeto JSON, recebeu {type(farms).__name__}")
+            return {}
+        return farms
+
+    env_file = os.environ.get("AEGRO_FARMS_FILE")
+    if env_file:
+        try:
+            with open(env_file) as f:
+                farms = json.load(f)
+        except json.JSONDecodeError as exc:
+            _warn(f"AEGRO_FARMS_FILE ({env_file}) contem JSON invalido: {exc}")
+            return {}
+        except OSError as exc:
+            _warn(f"Nao foi possivel ler AEGRO_FARMS_FILE ({env_file}): {exc}")
+            return {}
+        if not isinstance(farms, dict):
+            _warn(f"AEGRO_FARMS_FILE deve conter um objeto JSON, recebeu {type(farms).__name__}")
+            return {}
+        return farms
+
+    cred_file = CONFIG_DIR / CREDENTIALS_FILE_NAME
+    if cred_file.exists():
+        try:
+            data = json.loads(cred_file.read_text())
+        except json.JSONDecodeError as exc:
+            _warn(
+                f"Arquivo de credenciais corrompido ({cred_file}): {exc}. "
+                "Execute 'aegro auth login' novamente."
+            )
+            return {}
+        except OSError as exc:
+            _warn(f"Nao foi possivel ler {cred_file}: {exc}")
+            return {}
+        farms = data.get("farms", {})
+        if not isinstance(farms, dict):
+            _warn(
+                f"Arquivo de credenciais corrompido ({cred_file}): 'farms' nao e um objeto. "
+                "Execute 'aegro auth login' novamente."
+            )
+            return {}
+        return farms
+
+    return {}
+
+
+def save_credentials(farms: dict[str, str]) -> None:
+    """Save farm credentials atomically to ~/.config/aegro/credentials.json."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    cred_file = CONFIG_DIR / CREDENTIALS_FILE_NAME
+    data = {"farms": farms, "auth_method": "api-key"}
+    content = json.dumps(data, indent=2, ensure_ascii=False)
+
+    fd, tmp_path = tempfile.mkstemp(dir=CONFIG_DIR, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(content)
+        os.chmod(tmp_path, 0o600)
+        os.replace(tmp_path, str(cred_file))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def remove_credentials() -> bool:
+    """Remove stored credentials. Returns True if file existed."""
+    cred_file = CONFIG_DIR / CREDENTIALS_FILE_NAME
+    if cred_file.exists():
+        cred_file.unlink()
+        return True
+    return False
+
+
+def validate_api_key(key: str) -> bool:
+    """Basic validation that an API key is non-empty and non-whitespace."""
+    return bool(key and key.strip())

aegro/cli/_client.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import asyncio
+
+from aegro.api_client import AegroClient
+
+
+class SyncAegroClient:
+    """Synchronous wrapper over async AegroClient for CLI use.
+
+    Creates a fresh AegroClient per call to avoid event loop reuse issues.
+    asyncio.run() creates and destroys an event loop each time, so reusing
+    an async httpx.AsyncClient across calls would cause 'attached to a
+    different loop' errors.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "https://app.aegro.com.br",
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        self._base_url = base_url
+        self._timeout = timeout
+        self._max_retries = max_retries
+
+    def _make_client(self) -> AegroClient:
+        return AegroClient(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            max_retries=self._max_retries,
+        )
+
+    def get(self, path: str, *, api_key: str) -> dict | list | None:
+        async def _do() -> dict | list | None:
+            client = self._make_client()
+            try:
+                return await client.get(path, api_key=api_key)
+            finally:
+                await client.close()
+
+        return asyncio.run(_do())
+
+    def post(self, path: str, *, api_key: str, json_body: dict | None = None) -> dict | list | None:
+        async def _do() -> dict | list | None:
+            client = self._make_client()
+            try:
+                return await client.post(path, api_key=api_key, json_body=json_body)
+            finally:
+                await client.close()
+
+        return asyncio.run(_do())
+
+    def put(self, path: str, *, api_key: str, json_body: dict | None = None) -> dict | list | None:
+        async def _do() -> dict | list | None:
+            client = self._make_client()
+            try:
+                return await client.put(path, api_key=api_key, json_body=json_body)
+            finally:
+                await client.close()
+
+        return asyncio.run(_do())
+
+    def delete(self, path: str, *, api_key: str) -> dict | list | None:
+        async def _do() -> dict | list | None:
+            client = self._make_client()
+            try:
+                return await client.delete(path, api_key=api_key)
+            finally:
+                await client.close()
+
+        return asyncio.run(_do())

aegro/cli/_config.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+from aegro.config import Settings
+from aegro.errors import FarmNotFoundError, NoFarmSelectedError
+from aegro.cli._auth import load_credentials
+from aegro.cli._client import SyncAegroClient
+
+STATE_DIR = Path.home() / ".config" / "aegro"
+
+_settings: Settings | None = None
+_client: SyncAegroClient | None = None
+
+
+def get_settings() -> Settings:
+    """Build Settings merging credentials from _auth.py.
+
+    Priority: env vars (AEGRO_FARMS, AEGRO_FARMS_FILE) > credentials.json.
+    The _auth.load_credentials() handles this priority order internally.
+    """
+    global _settings
+    if _settings is None:
+        farms = load_credentials()
+        _settings = Settings(farms=farms) if farms else Settings()
+    return _settings
+
+
+def get_client() -> SyncAegroClient:
+    global _client
+    if _client is None:
+        s = get_settings()
+        _client = SyncAegroClient(
+            base_url=s.aegro_api_base_url,
+            timeout=s.api_timeout,
+            max_retries=s.api_max_retries,
+        )
+    return _client
+
+
+def get_selected_farm() -> str | None:
+    state_file = STATE_DIR / "state.json"
+    if not state_file.exists():
+        return None
+    try:
+        data = json.loads(state_file.read_text())
+        return data.get("selected_farm")
+    except json.JSONDecodeError:
+        print(
+            f"aegro: aviso: state.json corrompido ({state_file}). "
+            "Execute 'aegro farms select <nome>' novamente.",
+            file=sys.stderr,
+        )
+        return None
+    except OSError as exc:
+        print(f"aegro: aviso: nao foi possivel ler {state_file}: {exc}", file=sys.stderr)
+        return None
+
+
+def set_selected_farm(farm_name: str) -> None:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state_file = STATE_DIR / "state.json"
+    data: dict = {}
+    if state_file.exists():
+        try:
+            data = json.loads(state_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            data = {}
+
+    data["selected_farm"] = farm_name
+    content = json.dumps(data, indent=2)
+
+    # Atomic write
+    fd, tmp_path = tempfile.mkstemp(dir=STATE_DIR, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(content)
+        os.replace(tmp_path, str(state_file))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def require_farm(settings: Settings | None = None) -> tuple[str, str]:
+    """Get selected farm name and API key, or raise."""
+    if settings is None:
+        settings = get_settings()
+    farm_name = get_selected_farm()
+    if farm_name is None:
+        raise NoFarmSelectedError()
+    api_key = settings.get_api_key(farm_name)
+    if api_key is None:
+        raise FarmNotFoundError(farm_name)
+    return farm_name, api_key

aegro/cli/_errors.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+import sys
+import traceback
+
+from aegro.errors import (
+    AegroAPIError,
+    FarmNotFoundError,
+    InvalidKeyError,
+    NoFarmSelectedError,
+)
+
+EXIT_OK = 0
+EXIT_ERROR = 1
+EXIT_AUTH = 2
+EXIT_NOT_FOUND = 3
+EXIT_VALIDATION = 4
+
+
+def handle_error(exc: Exception) -> None:
+    """Print structured JSON error to stderr and exit with semantic code."""
+    if isinstance(exc, NoFarmSelectedError):
+        _exit_json("NO_FARM_SELECTED", str(exc), EXIT_AUTH)
+    elif isinstance(exc, FarmNotFoundError):
+        _exit_json("FARM_NOT_FOUND", str(exc), EXIT_NOT_FOUND)
+    elif isinstance(exc, InvalidKeyError):
+        _exit_json("INVALID_KEY", str(exc), EXIT_VALIDATION)
+    elif isinstance(exc, AegroAPIError):
+        if exc.status_code in (401, 403):
+            _exit_json("AUTH_ERROR", exc.user_message, EXIT_AUTH, status=exc.status_code)
+        else:
+            _exit_json("API_ERROR", exc.user_message, EXIT_ERROR, status=exc.status_code)
+    else:
+        traceback.print_exc(file=sys.stderr)
+        _exit_json("UNEXPECTED", str(exc), EXIT_ERROR)
+
+
+def _exit_json(code: str, message: str, exit_code: int, *, status: int | None = None) -> None:
+    error: dict = {"code": code, "message": message}
+    if status is not None:
+        error["status"] = status
+    print(json.dumps({"error": error}), file=sys.stderr)
+    raise SystemExit(exit_code)

aegro/cli/_output.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import csv
+import io
+import json
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    json = "json"
+    table = "table"
+    csv = "csv"
+
+
+def _cell_str(v: object) -> str:
+    """Format a cell value for table/CSV display."""
+    if v is None:
+        return ""
+    if isinstance(v, (dict, list)):
+        return json.dumps(v, ensure_ascii=False)
+    return str(v)
+
+
+def format_output(data: dict | list | str | None, fmt: OutputFormat) -> str:
+    """Format data for CLI output. Returns a string ready to print."""
+    if fmt == OutputFormat.json:
+        return json.dumps(data, ensure_ascii=False, indent=2)
+
+    if fmt == OutputFormat.csv:
+        return _format_csv(data)
+
+    if fmt == OutputFormat.table:
+        return _format_table(data)
+
+    return json.dumps(data, ensure_ascii=False, indent=2)
+
+
+def _format_csv(data: dict | list | str | None) -> str:
+    if data is None:
+        return ""
+    if isinstance(data, dict):
+        data = [data]
+    if isinstance(data, str):
+        return data
+    if not isinstance(data, list) or not data:
+        return ""
+    rows = data if isinstance(data[0], dict) else [{"value": r} for r in data]
+    # Collect ALL keys across all rows
+    all_keys = dict.fromkeys(k for row in rows for k in row.keys())
+    buf = io.StringIO()
+    writer = csv.DictWriter(buf, fieldnames=all_keys.keys(), extrasaction="ignore")
+    writer.writeheader()
+    for row in rows:
+        writer.writerow({k: _cell_str(v) for k, v in row.items()})
+    return buf.getvalue()
+
+
+def _format_table(data: dict | list | str | None) -> str:
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console(file=io.StringIO(), force_terminal=False)
+
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        all_keys = list(dict.fromkeys(k for row in data for k in row.keys()))
+        table = Table()
+        for key in all_keys:
+            table.add_column(key)
+        for row in data:
+            table.add_row(*[_cell_str(row.get(col)) for col in all_keys])
+        console.print(table)
+    elif isinstance(data, dict):
+        table = Table()
+        table.add_column("Field")
+        table.add_column("Value")
+        for k, v in data.items():
+            table.add_row(str(k), _cell_str(v))
+        console.print(table)
+    else:
+        console.print(str(data))
+
+    return console.file.getvalue()