pinelabs-python 0.1.0__py3-none-any.whl

pinelabs/core/remove_none_from_dict.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Mapping, Optional
+
+
+def remove_none_from_dict(original: Mapping[str, Optional[Any]]) -> Dict[str, Any]:
+    new: Dict[str, Any] = {}
+    for key, value in original.items():
+        if value is not None:
+            new[key] = value
+    return new

pinelabs/core/request_options.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+try:
+    from typing import NotRequired  # type: ignore
+except ImportError:
+    from typing_extensions import NotRequired
+
+
+class RequestOptions(typing.TypedDict, total=False):
+    """
+    Additional options for request-specific configuration when calling APIs via the SDK.
+    This is used primarily as an optional final parameter for service functions.
+
+    Attributes:
+        - timeout_in_seconds: int. The number of seconds to await an API call before timing out.
+
+        - max_retries: int. The max number of retries to attempt if the API call fails.
+
+        - additional_headers: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's header dict
+
+        - additional_query_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's query parameters dict
+
+        - additional_body_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's body parameters dict
+
+        - chunk_size: int. The size, in bytes, to process each chunk of data being streamed back within the response. This equates to leveraging `chunk_size` within `requests` or `httpx`, and is only leveraged for file downloads.
+    """
+
+    timeout_in_seconds: NotRequired[int]
+    max_retries: NotRequired[int]
+    additional_headers: NotRequired[typing.Dict[str, typing.Any]]
+    additional_query_parameters: NotRequired[typing.Dict[str, typing.Any]]
+    additional_body_parameters: NotRequired[typing.Dict[str, typing.Any]]
+    chunk_size: NotRequired[int]

pinelabs/core/serialization.py

@@ -0,0 +1,276 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import collections
+import inspect
+import typing
+
+import pydantic
+import typing_extensions
+
+
+class FieldMetadata:
+    """
+    Metadata class used to annotate fields to provide additional information.
+
+    Example:
+    class MyDict(TypedDict):
+        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
+
+    Will serialize: `{"field": "value"}`
+    To: `{"field_name": "value"}`
+    """
+
+    alias: str
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+
+def convert_and_respect_annotation_metadata(
+    *,
+    object_: typing.Any,
+    annotation: typing.Any,
+    inner_type: typing.Optional[typing.Any] = None,
+    direction: typing.Literal["read", "write"],
+) -> typing.Any:
+    """
+    Respect the metadata annotations on a field, such as aliasing. This function effectively
+    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
+    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
+    utilities, such as defaults.
+
+    Parameters
+    ----------
+    object_ : typing.Any
+
+    annotation : type
+        The type we're looking to apply typing annotations from
+
+    inner_type : typing.Optional[type]
+
+    Returns
+    -------
+    typing.Any
+    """
+
+    if object_ is None:
+        return None
+    if inner_type is None:
+        inner_type = annotation
+
+    clean_type = _remove_annotations(inner_type)
+    # Pydantic models
+    if (
+        inspect.isclass(clean_type)
+        and issubclass(clean_type, pydantic.BaseModel)
+        and isinstance(object_, typing.Mapping)
+    ):
+        return _convert_mapping(object_, clean_type, direction)
+    # TypedDicts
+    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
+        return _convert_mapping(object_, clean_type, direction)
+
+    if (
+        typing_extensions.get_origin(clean_type) == typing.Dict
+        or typing_extensions.get_origin(clean_type) == dict
+        or clean_type == typing.Dict
+    ) and isinstance(object_, typing.Dict):
+        key_type = typing_extensions.get_args(clean_type)[0]
+        value_type = typing_extensions.get_args(clean_type)[1]
+
+        return {
+            key: convert_and_respect_annotation_metadata(
+                object_=value,
+                annotation=annotation,
+                inner_type=value_type,
+                direction=direction,
+            )
+            for key, value in object_.items()
+        }
+
+    # If you're iterating on a string, do not bother to coerce it to a sequence.
+    if not isinstance(object_, str):
+        if (
+            typing_extensions.get_origin(clean_type) == typing.Set
+            or typing_extensions.get_origin(clean_type) == set
+            or clean_type == typing.Set
+        ) and isinstance(object_, typing.Set):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return {
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            }
+        elif (
+            (
+                typing_extensions.get_origin(clean_type) == typing.List
+                or typing_extensions.get_origin(clean_type) == list
+                or clean_type == typing.List
+            )
+            and isinstance(object_, typing.List)
+        ) or (
+            (
+                typing_extensions.get_origin(clean_type) == typing.Sequence
+                or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
+                or clean_type == typing.Sequence
+            )
+            and isinstance(object_, typing.Sequence)
+        ):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return [
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            ]
+
+    if typing_extensions.get_origin(clean_type) == typing.Union:
+        # We should be able to ~relatively~ safely try to convert keys against all
+        # member types in the union, the edge case here is if one member aliases a field
+        # of the same name to a different name from another member
+        # Or if another member aliases a field of the same name that another member does not.
+        for member in typing_extensions.get_args(clean_type):
+            object_ = convert_and_respect_annotation_metadata(
+                object_=object_,
+                annotation=annotation,
+                inner_type=member,
+                direction=direction,
+            )
+        return object_
+
+    annotated_type = _get_annotation(annotation)
+    if annotated_type is None:
+        return object_
+
+    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
+    # Then we can safely call it on the recursive conversion.
+    return object_
+
+
+def _convert_mapping(
+    object_: typing.Mapping[str, object],
+    expected_type: typing.Any,
+    direction: typing.Literal["read", "write"],
+) -> typing.Mapping[str, object]:
+    converted_object: typing.Dict[str, object] = {}
+    try:
+        annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
+    except NameError:
+        # The TypedDict contains a circular reference, so
+        # we use the __annotations__ attribute directly.
+        annotations = getattr(expected_type, "__annotations__", {})
+    aliases_to_field_names = _get_alias_to_field_name(annotations)
+    for key, value in object_.items():
+        if direction == "read" and key in aliases_to_field_names:
+            dealiased_key = aliases_to_field_names.get(key)
+            if dealiased_key is not None:
+                type_ = annotations.get(dealiased_key)
+        else:
+            type_ = annotations.get(key)
+        # Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
+        #
+        # So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
+        # then we can just pass the value through as is
+        if type_ is None:
+            converted_object[key] = value
+        elif direction == "read" and key not in aliases_to_field_names:
+            converted_object[key] = convert_and_respect_annotation_metadata(
+                object_=value, annotation=type_, direction=direction
+            )
+        else:
+            converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
+                convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
+            )
+    return converted_object
+
+
+def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return None
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        type_ = typing_extensions.get_args(type_)[0]
+        maybe_annotated_type = typing_extensions.get_origin(type_)
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return type_
+
+    return None
+
+
+def _remove_annotations(type_: typing.Any) -> typing.Any:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return type_
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    return type_
+
+
+def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_alias_to_field_name(annotations)
+
+
+def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_field_to_alias_name(annotations)
+
+
+def _get_alias_to_field_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[maybe_alias] = field
+    return aliases
+
+
+def _get_field_to_alias_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[field] = maybe_alias
+    return aliases
+
+
+def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
+    maybe_annotated_type = _get_annotation(type_)
+
+    if maybe_annotated_type is not None:
+        # The actual annotations are 1 onward, the first is the annotated type
+        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
+
+        for annotation in annotations:
+            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
+                return annotation.alias
+    return None
+
+
+def _alias_key(
+    key: str,
+    type_: typing.Any,
+    direction: typing.Literal["read", "write"],
+    aliases_to_field_names: typing.Dict[str, str],
+) -> str:
+    if direction == "read":
+        return aliases_to_field_names.get(key, key)
+    return _get_alias_from_type(type_=type_) or key

pinelabs/customers/__init__.py

@@ -0,0 +1,34 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .types import UpdateCustomerRequestStatus
+_dynamic_imports: typing.Dict[str, str] = {"UpdateCustomerRequestStatus": ".types"}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = ["UpdateCustomerRequestStatus"]