statuspro-openapi-client 0.1.0__py3-none-any.whl

statuspro_public_api_client/models/status_translations.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+if TYPE_CHECKING:
+    from ..models.locale_translation import LocaleTranslation
+
+
+T = TypeVar("T", bound="StatusTranslations")
+
+
+@_attrs_define
+class StatusTranslations:
+    additional_properties: dict[str, LocaleTranslation] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.locale_translation import LocaleTranslation
+
+        d = dict(src_dict)
+        status_translations = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = LocaleTranslation.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        status_translations.additional_properties = additional_properties
+        return status_translations
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> LocaleTranslation:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: LocaleTranslation) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

statuspro_public_api_client/models/update_order_status_request.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateOrderStatusRequest")
+
+
+@_attrs_define
+class UpdateOrderStatusRequest:
+    status_code: str
+    comment: str | Unset = UNSET
+    public: bool | Unset = False
+    email_customer: bool | Unset = True
+    email_additional: bool | Unset = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status_code = self.status_code
+
+        comment = self.comment
+
+        public = self.public
+
+        email_customer = self.email_customer
+
+        email_additional = self.email_additional
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status_code": status_code,
+            }
+        )
+        if comment is not UNSET:
+            field_dict["comment"] = comment
+        if public is not UNSET:
+            field_dict["public"] = public
+        if email_customer is not UNSET:
+            field_dict["email_customer"] = email_customer
+        if email_additional is not UNSET:
+            field_dict["email_additional"] = email_additional
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status_code = d.pop("status_code")
+
+        comment = d.pop("comment", UNSET)
+
+        public = d.pop("public", UNSET)
+
+        email_customer = d.pop("email_customer", UNSET)
+
+        email_additional = d.pop("email_additional", UNSET)
+
+        update_order_status_request = cls(
+            status_code=status_code,
+            comment=comment,
+            public=public,
+            email_customer=email_customer,
+            email_additional=email_additional,
+        )
+
+        update_order_status_request.additional_properties = d
+        return update_order_status_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

statuspro_public_api_client/models/validation_error_response.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error_response_errors import ValidationErrorResponseErrors
+
+
+T = TypeVar("T", bound="ValidationErrorResponse")
+
+
+@_attrs_define
+class ValidationErrorResponse:
+    message: str | Unset = UNSET
+    errors: ValidationErrorResponseErrors | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        errors: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.errors, Unset):
+            errors = self.errors.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if message is not UNSET:
+            field_dict["message"] = message
+        if errors is not UNSET:
+            field_dict["errors"] = errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.validation_error_response_errors import (
+            ValidationErrorResponseErrors,
+        )
+
+        d = dict(src_dict)
+        message = d.pop("message", UNSET)
+
+        _errors = d.pop("errors", UNSET)
+        errors: ValidationErrorResponseErrors | Unset
+        if isinstance(_errors, Unset):
+            errors = UNSET
+        else:
+            errors = ValidationErrorResponseErrors.from_dict(_errors)
+
+        validation_error_response = cls(
+            message=message,
+            errors=errors,
+        )
+
+        validation_error_response.additional_properties = d
+        return validation_error_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

statuspro_public_api_client/models/validation_error_response_errors.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+T = TypeVar("T", bound="ValidationErrorResponseErrors")
+
+
+@_attrs_define
+class ValidationErrorResponseErrors:
+    additional_properties: dict[str, list[str]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        validation_error_response_errors = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = cast(list[str], prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        validation_error_response_errors.additional_properties = additional_properties
+        return validation_error_response_errors
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str]) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

statuspro_public_api_client/models/viable_status.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import (
+    define as _attrs_define,
+    field as _attrs_field,
+)
+
+from ..client_types import UNSET, Unset
+
+T = TypeVar("T", bound="ViableStatus")
+
+
+@_attrs_define
+class ViableStatus:
+    code: str | Unset = UNSET
+    name: str | Unset = UNSET
+    description: str | Unset = UNSET
+    color: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        name = self.name
+
+        description = self.description
+
+        color = self.color
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if code is not UNSET:
+            field_dict["code"] = code
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+        if color is not UNSET:
+            field_dict["color"] = color
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        color = d.pop("color", UNSET)
+
+        viable_status = cls(
+            code=code,
+            name=name,
+            description=description,
+            color=color,
+        )
+
+        viable_status.additional_properties = d
+        return viable_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

statuspro_public_api_client/models_pydantic/__init__.py

@@ -0,0 +1,122 @@
+"""Pydantic v2 models for StatusPro API.
+
+This module provides Pydantic v2 models that mirror the attrs models
+in the main `models/` package. These models offer:
+
+- **Strong validation**: Pydantic's validation ensures data integrity
+- **Immutability**: All models are frozen to prevent accidental modification
+- **Serialization**: Easy conversion to/from JSON and dictionaries
+- **IDE support**: Full type hints and autocomplete
+
+## Usage
+
+### Converting from API Responses
+
+```python
+from statuspro_public_api_client import StatusProClient
+from statuspro_public_api_client.api.product import get_all_products
+from statuspro_public_api_client.models_pydantic import Product
+from statuspro_public_api_client.models_pydantic.converters import (
+    convert_response,
+)
+
+async with StatusProClient() as client:
+    response = await get_all_products.asyncio_detailed(client=client)
+    products: list[Product] = convert_response(response, Product)
+
+    for product in products:
+        print(f"{product.name}: {product.id}")
+```
+
+### Converting Individual Objects
+
+```python
+from statuspro_public_api_client.models_pydantic import Product
+from statuspro_public_api_client.models_pydantic.converters import (
+    to_pydantic,
+    to_attrs,
+)
+
+# Convert attrs -> pydantic
+pydantic_product = Product.from_attrs(attrs_product)
+
+# Or use the convenience function
+pydantic_product = to_pydantic(attrs_product)
+
+# Convert back to attrs for API calls
+attrs_product = pydantic_product.to_attrs()
+```
+
+## Model Layers
+
+This package contains three distinct model layers:
+
+1. **`models/`** (attrs): Auto-generated from OpenAPI, used by API transport
+2. **`models_pydantic/`** (pydantic): Auto-generated from OpenAPI, user-facing
+3. **`domain/`** (hand-written): Custom business logic models (e.g., ItemSearchResult)
+
+The Pydantic models here are designed for user-facing operations while the attrs
+models handle API communication internally.
+"""
+
+# Import generated models (populated by generation script)
+# This will be updated by the generate_pydantic_models.py script
+import logging
+
+from ._base import StatusProPydanticBase
+from ._registry import (
+    get_attrs_class,
+    get_attrs_class_by_name,
+    get_pydantic_class,
+    get_pydantic_class_by_name,
+    get_registration_stats,
+    is_registered,
+    list_registered_models,
+    register,
+)
+
+_logger = logging.getLogger(__name__)
+
+# Try to import generated models
+try:
+    from ._generated import *  # noqa: F403
+
+    _GENERATED_MODELS_AVAILABLE = True
+except ImportError as e:
+    # Generated models not yet created - this is expected before running
+    # the generation script for the first time
+    _GENERATED_MODELS_AVAILABLE = False
+    _logger.debug(
+        "Pydantic models not yet generated. Run 'uv run poe generate-pydantic' "
+        "to generate them. Import error: %s",
+        e,
+    )
+
+# Import auto-registration (populated by generation script)
+try:
+    from ._auto_registry import register_all_models as _register_all
+
+    _register_all()
+    _REGISTRY_AVAILABLE = True
+except ImportError as e:
+    # Auto-registry not yet created - this is expected before generation
+    _REGISTRY_AVAILABLE = False
+    _logger.debug(
+        "Auto-registry not yet generated. Run 'uv run poe generate-pydantic' "
+        "to generate it. Import error: %s",
+        e,
+    )
+
+__all__ = [
+    # Base class
+    "StatusProPydanticBase",
+    "get_attrs_class",
+    "get_attrs_class_by_name",
+    "get_pydantic_class",
+    "get_pydantic_class_by_name",
+    "get_registration_stats",
+    "is_registered",
+    "list_registered_models",
+    # Registry functions
+    "register",
+]

statuspro_public_api_client/models_pydantic/_auto_registry.py

@@ -0,0 +1,115 @@
+"""Auto-generated registry mapping attrs <-> Pydantic model classes.
+
+DO NOT EDIT - This file is generated by scripts/generate_pydantic_models.py
+
+To regenerate, run:
+    uv run poe generate-pydantic
+"""
+
+# Import all model classes
+from statuspro_public_api_client.models.add_order_comment_request import (
+    AddOrderCommentRequest as AttrsAddOrderCommentRequest,
+)
+from statuspro_public_api_client.models.bulk_status_update_request import (
+    BulkStatusUpdateRequest as AttrsBulkStatusUpdateRequest,
+)
+from statuspro_public_api_client.models.bulk_status_update_response import (
+    BulkStatusUpdateResponse as AttrsBulkStatusUpdateResponse,
+)
+from statuspro_public_api_client.models.customer import Customer as AttrsCustomer
+from statuspro_public_api_client.models.error_response import (
+    ErrorResponse as AttrsErrorResponse,
+)
+from statuspro_public_api_client.models.history_item import (
+    HistoryItem as AttrsHistoryItem,
+)
+from statuspro_public_api_client.models.locale_translation import (
+    LocaleTranslation as AttrsLocaleTranslation,
+)
+from statuspro_public_api_client.models.mail_log import MailLog as AttrsMailLog
+from statuspro_public_api_client.models.message_response import (
+    MessageResponse as AttrsMessageResponse,
+)
+from statuspro_public_api_client.models.order_list_item import (
+    OrderListItem as AttrsOrderListItem,
+)
+from statuspro_public_api_client.models.order_list_meta import (
+    OrderListMeta as AttrsOrderListMeta,
+)
+from statuspro_public_api_client.models.order_list_response import (
+    OrderListResponse as AttrsOrderListResponse,
+)
+from statuspro_public_api_client.models.order_response import (
+    OrderResponse as AttrsOrderResponse,
+)
+from statuspro_public_api_client.models.progress_timeline_item import (
+    ProgressTimelineItem as AttrsProgressTimelineItem,
+)
+from statuspro_public_api_client.models.set_due_date_request import (
+    SetDueDateRequest as AttrsSetDueDateRequest,
+)
+from statuspro_public_api_client.models.status import Status as AttrsStatus
+from statuspro_public_api_client.models.status_definition import (
+    StatusDefinition as AttrsStatusDefinition,
+)
+from statuspro_public_api_client.models.update_order_status_request import (
+    UpdateOrderStatusRequest as AttrsUpdateOrderStatusRequest,
+)
+from statuspro_public_api_client.models.validation_error_response import (
+    ValidationErrorResponse as AttrsValidationErrorResponse,
+)
+from statuspro_public_api_client.models.viable_status import (
+    ViableStatus as AttrsViableStatus,
+)
+
+from ._generated.errors import (
+    ErrorResponse as PydanticErrorResponse,
+    MessageResponse as PydanticMessageResponse,
+    ValidationErrorResponse as PydanticValidationErrorResponse,
+)
+from ._generated.orders import (
+    AddOrderCommentRequest as PydanticAddOrderCommentRequest,
+    BulkStatusUpdateRequest as PydanticBulkStatusUpdateRequest,
+    BulkStatusUpdateResponse as PydanticBulkStatusUpdateResponse,
+    Customer as PydanticCustomer,
+    HistoryItem as PydanticHistoryItem,
+    LocaleTranslation as PydanticLocaleTranslation,
+    MailLog as PydanticMailLog,
+    OrderListItem as PydanticOrderListItem,
+    OrderListMeta as PydanticOrderListMeta,
+    OrderListResponse as PydanticOrderListResponse,
+    OrderResponse as PydanticOrderResponse,
+    ProgressTimelineItem as PydanticProgressTimelineItem,
+    SetDueDateRequest as PydanticSetDueDateRequest,
+    Status as PydanticStatus,
+    UpdateOrderStatusRequest as PydanticUpdateOrderStatusRequest,
+)
+from ._generated.statuses import (
+    StatusDefinition as PydanticStatusDefinition,
+    ViableStatus as PydanticViableStatus,
+)
+from ._registry import register
+
+
+def register_all_models() -> None:
+    """Register all attrs <-> Pydantic model mappings."""
+    register(AttrsAddOrderCommentRequest, PydanticAddOrderCommentRequest)
+    register(AttrsBulkStatusUpdateRequest, PydanticBulkStatusUpdateRequest)
+    register(AttrsBulkStatusUpdateResponse, PydanticBulkStatusUpdateResponse)
+    register(AttrsCustomer, PydanticCustomer)
+    register(AttrsErrorResponse, PydanticErrorResponse)
+    register(AttrsHistoryItem, PydanticHistoryItem)
+    register(AttrsLocaleTranslation, PydanticLocaleTranslation)
+    register(AttrsMailLog, PydanticMailLog)
+    register(AttrsMessageResponse, PydanticMessageResponse)
+    register(AttrsOrderListItem, PydanticOrderListItem)
+    register(AttrsOrderListMeta, PydanticOrderListMeta)
+    register(AttrsOrderListResponse, PydanticOrderListResponse)
+    register(AttrsOrderResponse, PydanticOrderResponse)
+    register(AttrsProgressTimelineItem, PydanticProgressTimelineItem)
+    register(AttrsSetDueDateRequest, PydanticSetDueDateRequest)
+    register(AttrsStatus, PydanticStatus)
+    register(AttrsStatusDefinition, PydanticStatusDefinition)
+    register(AttrsUpdateOrderStatusRequest, PydanticUpdateOrderStatusRequest)
+    register(AttrsValidationErrorResponse, PydanticValidationErrorResponse)
+    register(AttrsViableStatus, PydanticViableStatus)