channel3-sdk 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

channel3_sdk/_gen/fast_api_client/models/search_filter_price.py

@@ -0,0 +1,92 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SearchFilterPrice")
+
+
+@_attrs_define
+class SearchFilterPrice:
+    """Price filter. Values are inclusive.
+
+    Attributes:
+        min_price (Union[None, Unset, float]): Minimum price, in dollars and cents
+        max_price (Union[None, Unset, float]): Maximum price, in dollars and cents
+    """
+
+    min_price: Union[None, Unset, float] = UNSET
+    max_price: Union[None, Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        min_price: Union[None, Unset, float]
+        if isinstance(self.min_price, Unset):
+            min_price = UNSET
+        else:
+            min_price = self.min_price
+
+        max_price: Union[None, Unset, float]
+        if isinstance(self.max_price, Unset):
+            max_price = UNSET
+        else:
+            max_price = self.max_price
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if min_price is not UNSET:
+            field_dict["min_price"] = min_price
+        if max_price is not UNSET:
+            field_dict["max_price"] = max_price
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_min_price(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        min_price = _parse_min_price(d.pop("min_price", UNSET))
+
+        def _parse_max_price(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        max_price = _parse_max_price(d.pop("max_price", UNSET))
+
+        search_filter_price = cls(
+            min_price=min_price,
+            max_price=max_price,
+        )
+
+        search_filter_price.additional_properties = d
+        return search_filter_price
+
+    @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

channel3_sdk/_gen/fast_api_client/models/search_filters.py

@@ -0,0 +1,191 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.availability_status import AvailabilityStatus
+from ..models.search_filters_gender_type_0 import SearchFiltersGenderType0
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.search_filter_price import SearchFilterPrice
+
+
+T = TypeVar("T", bound="SearchFilters")
+
+
+@_attrs_define
+class SearchFilters:
+    """
+    Attributes:
+        brand_ids (Union[None, Unset, list[str]]): List of brand IDs
+        gender (Union[None, SearchFiltersGenderType0, Unset]):
+        price (Union['SearchFilterPrice', None, Unset]): Price filter. Values are inclusive.
+        availability (Union[None, Unset, list[AvailabilityStatus]]): List of availability statuses
+    """
+
+    brand_ids: Union[None, Unset, list[str]] = UNSET
+    gender: Union[None, SearchFiltersGenderType0, Unset] = UNSET
+    price: Union["SearchFilterPrice", None, Unset] = UNSET
+    availability: Union[None, Unset, list[AvailabilityStatus]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.search_filter_price import SearchFilterPrice
+
+        brand_ids: Union[None, Unset, list[str]]
+        if isinstance(self.brand_ids, Unset):
+            brand_ids = UNSET
+        elif isinstance(self.brand_ids, list):
+            brand_ids = self.brand_ids
+
+        else:
+            brand_ids = self.brand_ids
+
+        gender: Union[None, Unset, str]
+        if isinstance(self.gender, Unset):
+            gender = UNSET
+        elif isinstance(self.gender, SearchFiltersGenderType0):
+            gender = self.gender.value
+        else:
+            gender = self.gender
+
+        price: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.price, Unset):
+            price = UNSET
+        elif isinstance(self.price, SearchFilterPrice):
+            price = self.price.to_dict()
+        else:
+            price = self.price
+
+        availability: Union[None, Unset, list[str]]
+        if isinstance(self.availability, Unset):
+            availability = UNSET
+        elif isinstance(self.availability, list):
+            availability = []
+            for availability_type_0_item_data in self.availability:
+                availability_type_0_item = availability_type_0_item_data.value
+                availability.append(availability_type_0_item)
+
+        else:
+            availability = self.availability
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if brand_ids is not UNSET:
+            field_dict["brand_ids"] = brand_ids
+        if gender is not UNSET:
+            field_dict["gender"] = gender
+        if price is not UNSET:
+            field_dict["price"] = price
+        if availability is not UNSET:
+            field_dict["availability"] = availability
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.search_filter_price import SearchFilterPrice
+
+        d = dict(src_dict)
+
+        def _parse_brand_ids(data: object) -> Union[None, Unset, list[str]]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                brand_ids_type_0 = cast(list[str], data)
+
+                return brand_ids_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, list[str]], data)
+
+        brand_ids = _parse_brand_ids(d.pop("brand_ids", UNSET))
+
+        def _parse_gender(data: object) -> Union[None, SearchFiltersGenderType0, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                gender_type_0 = SearchFiltersGenderType0(data)
+
+                return gender_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, SearchFiltersGenderType0, Unset], data)
+
+        gender = _parse_gender(d.pop("gender", UNSET))
+
+        def _parse_price(data: object) -> Union["SearchFilterPrice", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                price_type_0 = SearchFilterPrice.from_dict(data)
+
+                return price_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["SearchFilterPrice", None, Unset], data)
+
+        price = _parse_price(d.pop("price", UNSET))
+
+        def _parse_availability(data: object) -> Union[None, Unset, list[AvailabilityStatus]]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                availability_type_0 = []
+                _availability_type_0 = data
+                for availability_type_0_item_data in _availability_type_0:
+                    availability_type_0_item = AvailabilityStatus(availability_type_0_item_data)
+
+                    availability_type_0.append(availability_type_0_item)
+
+                return availability_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, list[AvailabilityStatus]], data)
+
+        availability = _parse_availability(d.pop("availability", UNSET))
+
+        search_filters = cls(
+            brand_ids=brand_ids,
+            gender=gender,
+            price=price,
+            availability=availability,
+        )
+
+        search_filters.additional_properties = d
+        return search_filters
+
+    @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

channel3_sdk/_gen/fast_api_client/models/search_filters_gender_type_0.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SearchFiltersGenderType0(str, Enum):
+    FEMALE = "female"
+    MALE = "male"
+    UNISEX = "unisex"
+
+    def __str__(self) -> str:
+        return str(self.value)

channel3_sdk/_gen/fast_api_client/models/search_request.py

@@ -0,0 +1,191 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.search_config import SearchConfig
+    from ..models.search_filters import SearchFilters
+
+
+T = TypeVar("T", bound="SearchRequest")
+
+
+@_attrs_define
+class SearchRequest:
+    """
+    Attributes:
+        query (Union[None, Unset, str]):
+        image_url (Union[None, Unset, str]):
+        base64_image (Union[None, Unset, str]):
+        limit (Union[None, Unset, int]):  Default: 20.
+        filters (Union[Unset, SearchFilters]):
+        config (Union[Unset, SearchConfig]): Configuration for a search request
+        context (Union[None, Unset, str]): Context for the search
+    """
+
+    query: Union[None, Unset, str] = UNSET
+    image_url: Union[None, Unset, str] = UNSET
+    base64_image: Union[None, Unset, str] = UNSET
+    limit: Union[None, Unset, int] = 20
+    filters: Union[Unset, "SearchFilters"] = UNSET
+    config: Union[Unset, "SearchConfig"] = UNSET
+    context: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query: Union[None, Unset, str]
+        if isinstance(self.query, Unset):
+            query = UNSET
+        else:
+            query = self.query
+
+        image_url: Union[None, Unset, str]
+        if isinstance(self.image_url, Unset):
+            image_url = UNSET
+        else:
+            image_url = self.image_url
+
+        base64_image: Union[None, Unset, str]
+        if isinstance(self.base64_image, Unset):
+            base64_image = UNSET
+        else:
+            base64_image = self.base64_image
+
+        limit: Union[None, Unset, int]
+        if isinstance(self.limit, Unset):
+            limit = UNSET
+        else:
+            limit = self.limit
+
+        filters: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.filters, Unset):
+            filters = self.filters.to_dict()
+
+        config: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.config, Unset):
+            config = self.config.to_dict()
+
+        context: Union[None, Unset, str]
+        if isinstance(self.context, Unset):
+            context = UNSET
+        else:
+            context = self.context
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if query is not UNSET:
+            field_dict["query"] = query
+        if image_url is not UNSET:
+            field_dict["image_url"] = image_url
+        if base64_image is not UNSET:
+            field_dict["base64_image"] = base64_image
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if filters is not UNSET:
+            field_dict["filters"] = filters
+        if config is not UNSET:
+            field_dict["config"] = config
+        if context is not UNSET:
+            field_dict["context"] = context
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.search_config import SearchConfig
+        from ..models.search_filters import SearchFilters
+
+        d = dict(src_dict)
+
+        def _parse_query(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        query = _parse_query(d.pop("query", UNSET))
+
+        def _parse_image_url(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        image_url = _parse_image_url(d.pop("image_url", UNSET))
+
+        def _parse_base64_image(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        base64_image = _parse_base64_image(d.pop("base64_image", UNSET))
+
+        def _parse_limit(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        limit = _parse_limit(d.pop("limit", UNSET))
+
+        _filters = d.pop("filters", UNSET)
+        filters: Union[Unset, SearchFilters]
+        if isinstance(_filters, Unset):
+            filters = UNSET
+        else:
+            filters = SearchFilters.from_dict(_filters)
+
+        _config = d.pop("config", UNSET)
+        config: Union[Unset, SearchConfig]
+        if isinstance(_config, Unset):
+            config = UNSET
+        else:
+            config = SearchConfig.from_dict(_config)
+
+        def _parse_context(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        context = _parse_context(d.pop("context", UNSET))
+
+        search_request = cls(
+            query=query,
+            image_url=image_url,
+            base64_image=base64_image,
+            limit=limit,
+            filters=filters,
+            config=config,
+            context=context,
+        )
+
+        search_request.additional_properties = d
+        return search_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

channel3_sdk/_gen/fast_api_client/models/variant.py

@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Variant")
+
+
+@_attrs_define
+class Variant:
+    """
+    Attributes:
+        product_id (str):
+        title (str):
+        image_url (str):
+    """
+
+    product_id: str
+    title: str
+    image_url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        product_id = self.product_id
+
+        title = self.title
+
+        image_url = self.image_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "product_id": product_id,
+                "title": title,
+                "image_url": image_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        product_id = d.pop("product_id")
+
+        title = d.pop("title")
+
+        image_url = d.pop("image_url")
+
+        variant = cls(
+            product_id=product_id,
+            title=title,
+            image_url=image_url,
+        )
+
+        variant.additional_properties = d
+        return variant
+
+    @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

channel3_sdk/_gen/fast_api_client/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

channel3_sdk/_gen/fast_api_client/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # (filename, file (or bytes), content_type)
+    tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

channel3_sdk/_gen/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "fast-api-client"
+version = "0.1.0"
+description = "A client library for accessing FastAPI"
+authors = []
+readme = "README.md"
+packages = [
+    { include = "fast_api_client" },
+]
+include = ["CHANGELOG.md", "fast_api_client/py.typed"]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+httpx = ">=0.23.0,<0.29.0"
+attrs = ">=22.2.0"
+python-dateutil = "^2.8.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["F", "I", "UP"]