egain-api-python 0.1.1__py3-none-any.whl

egain_api_python/utils/forms.py

@@ -0,0 +1,223 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Tuple,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .serializers import marshal_json
+
+from .metadata import (
+    FormMetadata,
+    MultipartFormMetadata,
+    find_field_metadata,
+)
+from .values import _is_set, _val_to_string
+
+
+def _populate_form(
+    field_name: str,
+    explode: bool,
+    obj: Any,
+    delimiter: str,
+    form: Dict[str, List[str]],
+):
+    if not _is_set(obj):
+        return form
+
+    if isinstance(obj, BaseModel):
+        items = []
+
+        obj_fields: Dict[str, FieldInfo] = obj.__class__.model_fields
+        for name in obj_fields:
+            obj_field = obj_fields[name]
+            obj_field_name = obj_field.alias if obj_field.alias is not None else name
+            if obj_field_name == "":
+                continue
+
+            val = getattr(obj, name)
+            if not _is_set(val):
+                continue
+
+            if explode:
+                form[obj_field_name] = [_val_to_string(val)]
+            else:
+                items.append(f"{obj_field_name}{delimiter}{_val_to_string(val)}")
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join(items)]
+    elif isinstance(obj, Dict):
+        items = []
+        for key, value in obj.items():
+            if not _is_set(value):
+                continue
+
+            if explode:
+                form[key] = [_val_to_string(value)]
+            else:
+                items.append(f"{key}{delimiter}{_val_to_string(value)}")
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join(items)]
+    elif isinstance(obj, List):
+        items = []
+
+        for value in obj:
+            if not _is_set(value):
+                continue
+
+            if explode:
+                if not field_name in form:
+                    form[field_name] = []
+                form[field_name].append(_val_to_string(value))
+            else:
+                items.append(_val_to_string(value))
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join([str(item) for item in items])]
+    else:
+        form[field_name] = [_val_to_string(obj)]
+
+    return form
+
+
+def _extract_file_properties(file_obj: Any) -> Tuple[str, Any, Any]:
+    """Extract file name, content, and content type from a file object."""
+    file_fields: Dict[str, FieldInfo] = file_obj.__class__.model_fields
+
+    file_name = ""
+    content = None
+    content_type = None
+
+    for file_field_name in file_fields:
+        file_field = file_fields[file_field_name]
+
+        file_metadata = find_field_metadata(file_field, MultipartFormMetadata)
+        if file_metadata is None:
+            continue
+
+        if file_metadata.content:
+            content = getattr(file_obj, file_field_name, None)
+        elif file_field_name == "content_type":
+            content_type = getattr(file_obj, file_field_name, None)
+        else:
+            file_name = getattr(file_obj, file_field_name)
+
+    if file_name == "" or content is None:
+        raise ValueError("invalid multipart/form-data file")
+
+    return file_name, content, content_type
+
+
+def serialize_multipart_form(
+    media_type: str, request: Any
+) -> Tuple[str, Dict[str, Any], List[Tuple[str, Any]]]:
+    form: Dict[str, Any] = {}
+    files: List[Tuple[str, Any]] = []
+
+    if not isinstance(request, BaseModel):
+        raise TypeError("invalid request body type")
+
+    request_fields: Dict[str, FieldInfo] = request.__class__.model_fields
+    request_field_types = get_type_hints(request.__class__)
+
+    for name in request_fields:
+        field = request_fields[name]
+
+        val = getattr(request, name)
+        if not _is_set(val):
+            continue
+
+        field_metadata = find_field_metadata(field, MultipartFormMetadata)
+        if not field_metadata:
+            continue
+
+        f_name = field.alias if field.alias else name
+
+        if field_metadata.file:
+            if isinstance(val, List):
+                # Handle array of files
+                for file_obj in val:
+                    if not _is_set(file_obj):
+                        continue
+                        
+                    file_name, content, content_type = _extract_file_properties(file_obj)
+
+                    if content_type is not None:
+                        files.append((f_name + "[]", (file_name, content, content_type)))
+                    else:
+                        files.append((f_name + "[]", (file_name, content)))
+            else:
+                # Handle single file
+                file_name, content, content_type = _extract_file_properties(val)
+
+                if content_type is not None:
+                    files.append((f_name, (file_name, content, content_type)))
+                else:
+                    files.append((f_name, (file_name, content)))
+        elif field_metadata.json:
+            files.append((f_name, (
+                None,
+                marshal_json(val, request_field_types[name]),
+                "application/json",
+            )))
+        else:
+            if isinstance(val, List):
+                values = []
+
+                for value in val:
+                    if not _is_set(value):
+                        continue
+                    values.append(_val_to_string(value))
+
+                form[f_name + "[]"] = values
+            else:
+                form[f_name] = _val_to_string(val)
+    return media_type, form, files
+
+
+def serialize_form_data(data: Any) -> Dict[str, Any]:
+    form: Dict[str, List[str]] = {}
+
+    if isinstance(data, BaseModel):
+        data_fields: Dict[str, FieldInfo] = data.__class__.model_fields
+        data_field_types = get_type_hints(data.__class__)
+        for name in data_fields:
+            field = data_fields[name]
+
+            val = getattr(data, name)
+            if not _is_set(val):
+                continue
+
+            metadata = find_field_metadata(field, FormMetadata)
+            if metadata is None:
+                continue
+
+            f_name = field.alias if field.alias is not None else name
+
+            if metadata.json:
+                form[f_name] = [marshal_json(val, data_field_types[name])]
+            else:
+                if metadata.style == "form":
+                    _populate_form(
+                        f_name,
+                        metadata.explode,
+                        val,
+                        ",",
+                        form,
+                    )
+                else:
+                    raise ValueError(f"Invalid form style for field {name}")
+    elif isinstance(data, Dict):
+        for key, value in data.items():
+            if _is_set(value):
+                form[key] = [_val_to_string(value)]
+    else:
+        raise TypeError(f"Invalid request body type {type(data)} for form data")
+
+    return form

egain_api_python/utils/headers.py

@@ -0,0 +1,136 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+)
+from httpx import Headers
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    HeaderMetadata,
+    find_field_metadata,
+)
+
+from .values import _is_set, _populate_from_globals, _val_to_string
+
+
+def get_headers(headers_params: Any, gbls: Optional[Any] = None) -> Dict[str, str]:
+    headers: Dict[str, str] = {}
+
+    globals_already_populated = []
+    if _is_set(headers_params):
+        globals_already_populated = _populate_headers(headers_params, gbls, headers, [])
+    if _is_set(gbls):
+        _populate_headers(gbls, None, headers, globals_already_populated)
+
+    return headers
+
+
+def _populate_headers(
+    headers_params: Any,
+    gbls: Any,
+    header_values: Dict[str, str],
+    skip_fields: List[str],
+) -> List[str]:
+    globals_already_populated: List[str] = []
+
+    if not isinstance(headers_params, BaseModel):
+        return globals_already_populated
+
+    param_fields: Dict[str, FieldInfo] = headers_params.__class__.model_fields
+    for name in param_fields:
+        if name in skip_fields:
+            continue
+
+        field = param_fields[name]
+        f_name = field.alias if field.alias is not None else name
+
+        metadata = find_field_metadata(field, HeaderMetadata)
+        if metadata is None:
+            continue
+
+        value, global_found = _populate_from_globals(
+            name, getattr(headers_params, name), HeaderMetadata, gbls
+        )
+        if global_found:
+            globals_already_populated.append(name)
+        value = _serialize_header(metadata.explode, value)
+
+        if value != "":
+            header_values[f_name] = value
+
+    return globals_already_populated
+
+
+def _serialize_header(explode: bool, obj: Any) -> str:
+    if not _is_set(obj):
+        return ""
+
+    if isinstance(obj, BaseModel):
+        items = []
+        obj_fields: Dict[str, FieldInfo] = obj.__class__.model_fields
+        for name in obj_fields:
+            obj_field = obj_fields[name]
+            obj_param_metadata = find_field_metadata(obj_field, HeaderMetadata)
+
+            if not obj_param_metadata:
+                continue
+
+            f_name = obj_field.alias if obj_field.alias is not None else name
+
+            val = getattr(obj, name)
+            if not _is_set(val):
+                continue
+
+            if explode:
+                items.append(f"{f_name}={_val_to_string(val)}")
+            else:
+                items.append(f_name)
+                items.append(_val_to_string(val))
+
+        if len(items) > 0:
+            return ",".join(items)
+    elif isinstance(obj, Dict):
+        items = []
+
+        for key, value in obj.items():
+            if not _is_set(value):
+                continue
+
+            if explode:
+                items.append(f"{key}={_val_to_string(value)}")
+            else:
+                items.append(key)
+                items.append(_val_to_string(value))
+
+        if len(items) > 0:
+            return ",".join([str(item) for item in items])
+    elif isinstance(obj, List):
+        items = []
+
+        for value in obj:
+            if not _is_set(value):
+                continue
+
+            items.append(_val_to_string(value))
+
+        if len(items) > 0:
+            return ",".join(items)
+    elif _is_set(obj):
+        return f"{_val_to_string(obj)}"
+
+    return ""
+
+
+def get_response_headers(headers: Headers) -> Dict[str, List[str]]:
+    res: Dict[str, List[str]] = {}
+    for k, v in headers.items():
+        if not k in res:
+            res[k] = []
+
+        res[k].append(v)
+    return res

egain_api_python/utils/logger.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+import logging
+import os
+from typing import Any, Protocol
+
+
+class Logger(Protocol):
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        pass
+
+
+class NoOpLogger:
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        pass
+
+
+def get_body_content(req: httpx.Request) -> str:
+    return "<streaming body>" if not hasattr(req, "_content") else str(req.content)
+
+
+def get_default_logger() -> Logger:
+    if os.getenv("EGAIN_DEBUG"):
+        logging.basicConfig(level=logging.DEBUG)
+        return logging.getLogger("egain_api_python")
+    return NoOpLogger()

egain_api_python/utils/metadata.py

@@ -0,0 +1,118 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import Optional, Type, TypeVar, Union
+from dataclasses import dataclass
+from pydantic.fields import FieldInfo
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class SecurityMetadata:
+    option: bool = False
+    scheme: bool = False
+    scheme_type: Optional[str] = None
+    sub_type: Optional[str] = None
+    field_name: Optional[str] = None
+
+    def get_field_name(self, default: str) -> str:
+        return self.field_name or default
+
+
+@dataclass
+class ParamMetadata:
+    serialization: Optional[str] = None
+    style: str = "simple"
+    explode: bool = False
+
+
+@dataclass
+class PathParamMetadata(ParamMetadata):
+    pass
+
+
+@dataclass
+class QueryParamMetadata(ParamMetadata):
+    style: str = "form"
+    explode: bool = True
+
+
+@dataclass
+class HeaderMetadata(ParamMetadata):
+    pass
+
+
+@dataclass
+class RequestMetadata:
+    media_type: str = "application/octet-stream"
+
+
+@dataclass
+class MultipartFormMetadata:
+    file: bool = False
+    content: bool = False
+    json: bool = False
+
+
+@dataclass
+class FormMetadata:
+    json: bool = False
+    style: str = "form"
+    explode: bool = True
+
+
+class FieldMetadata:
+    security: Optional[SecurityMetadata] = None
+    path: Optional[PathParamMetadata] = None
+    query: Optional[QueryParamMetadata] = None
+    header: Optional[HeaderMetadata] = None
+    request: Optional[RequestMetadata] = None
+    form: Optional[FormMetadata] = None
+    multipart: Optional[MultipartFormMetadata] = None
+
+    def __init__(
+        self,
+        security: Optional[SecurityMetadata] = None,
+        path: Optional[Union[PathParamMetadata, bool]] = None,
+        query: Optional[Union[QueryParamMetadata, bool]] = None,
+        header: Optional[Union[HeaderMetadata, bool]] = None,
+        request: Optional[Union[RequestMetadata, bool]] = None,
+        form: Optional[Union[FormMetadata, bool]] = None,
+        multipart: Optional[Union[MultipartFormMetadata, bool]] = None,
+    ):
+        self.security = security
+        self.path = PathParamMetadata() if isinstance(path, bool) else path
+        self.query = QueryParamMetadata() if isinstance(query, bool) else query
+        self.header = HeaderMetadata() if isinstance(header, bool) else header
+        self.request = RequestMetadata() if isinstance(request, bool) else request
+        self.form = FormMetadata() if isinstance(form, bool) else form
+        self.multipart = (
+            MultipartFormMetadata() if isinstance(multipart, bool) else multipart
+        )
+
+
+def find_field_metadata(field_info: FieldInfo, metadata_type: Type[T]) -> Optional[T]:
+    metadata = find_metadata(field_info, FieldMetadata)
+    if not metadata:
+        return None
+
+    fields = metadata.__dict__
+
+    for field in fields:
+        if isinstance(fields[field], metadata_type):
+            return fields[field]
+
+    return None
+
+
+def find_metadata(field_info: FieldInfo, metadata_type: Type[T]) -> Optional[T]:
+    metadata = field_info.metadata
+    if not metadata:
+        return None
+
+    for md in metadata:
+        if isinstance(md, metadata_type):
+            return md
+
+    return None

egain_api_python/utils/queryparams.py

@@ -0,0 +1,205 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Optional,
+)
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    QueryParamMetadata,
+    find_field_metadata,
+)
+from .values import (
+    _get_serialized_params,
+    _is_set,
+    _populate_from_globals,
+    _val_to_string,
+)
+from .forms import _populate_form
+
+
+def get_query_params(
+    query_params: Any,
+    gbls: Optional[Any] = None,
+) -> Dict[str, List[str]]:
+    params: Dict[str, List[str]] = {}
+
+    globals_already_populated = _populate_query_params(query_params, gbls, params, [])
+    if _is_set(gbls):
+        _populate_query_params(gbls, None, params, globals_already_populated)
+
+    return params
+
+
+def _populate_query_params(
+    query_params: Any,
+    gbls: Any,
+    query_param_values: Dict[str, List[str]],
+    skip_fields: List[str],
+) -> List[str]:
+    globals_already_populated: List[str] = []
+
+    if not isinstance(query_params, BaseModel):
+        return globals_already_populated
+
+    param_fields: Dict[str, FieldInfo] = query_params.__class__.model_fields
+    param_field_types = get_type_hints(query_params.__class__)
+    for name in param_fields:
+        if name in skip_fields:
+            continue
+
+        field = param_fields[name]
+
+        metadata = find_field_metadata(field, QueryParamMetadata)
+        if not metadata:
+            continue
+
+        value = getattr(query_params, name) if _is_set(query_params) else None
+
+        value, global_found = _populate_from_globals(
+            name, value, QueryParamMetadata, gbls
+        )
+        if global_found:
+            globals_already_populated.append(name)
+
+        f_name = field.alias if field.alias is not None else name
+        serialization = metadata.serialization
+        if serialization is not None:
+            serialized_parms = _get_serialized_params(
+                metadata, f_name, value, param_field_types[name]
+            )
+            for key, value in serialized_parms.items():
+                if key in query_param_values:
+                    query_param_values[key].extend(value)
+                else:
+                    query_param_values[key] = [value]
+        else:
+            style = metadata.style
+            if style == "deepObject":
+                _populate_deep_object_query_params(f_name, value, query_param_values)
+            elif style == "form":
+                _populate_delimited_query_params(
+                    metadata, f_name, value, ",", query_param_values
+                )
+            elif style == "pipeDelimited":
+                _populate_delimited_query_params(
+                    metadata, f_name, value, "|", query_param_values
+                )
+            else:
+                raise NotImplementedError(
+                    f"query param style {style} not yet supported"
+                )
+
+    return globals_already_populated
+
+
+def _populate_deep_object_query_params(
+    field_name: str,
+    obj: Any,
+    params: Dict[str, List[str]],
+):
+    if not _is_set(obj):
+        return
+
+    if isinstance(obj, BaseModel):
+        _populate_deep_object_query_params_basemodel(field_name, obj, params)
+    elif isinstance(obj, Dict):
+        _populate_deep_object_query_params_dict(field_name, obj, params)
+
+
+def _populate_deep_object_query_params_basemodel(
+    prior_params_key: str,
+    obj: Any,
+    params: Dict[str, List[str]],
+):
+    if not _is_set(obj) or not isinstance(obj, BaseModel):
+        return
+
+    obj_fields: Dict[str, FieldInfo] = obj.__class__.model_fields
+    for name in obj_fields:
+        obj_field = obj_fields[name]
+
+        f_name = obj_field.alias if obj_field.alias is not None else name
+
+        params_key = f"{prior_params_key}[{f_name}]"
+
+        obj_param_metadata = find_field_metadata(obj_field, QueryParamMetadata)
+        if not _is_set(obj_param_metadata):
+            continue
+
+        obj_val = getattr(obj, name)
+        if not _is_set(obj_val):
+            continue
+
+        if isinstance(obj_val, BaseModel):
+            _populate_deep_object_query_params_basemodel(params_key, obj_val, params)
+        elif isinstance(obj_val, Dict):
+            _populate_deep_object_query_params_dict(params_key, obj_val, params)
+        elif isinstance(obj_val, List):
+            _populate_deep_object_query_params_list(params_key, obj_val, params)
+        else:
+            params[params_key] = [_val_to_string(obj_val)]
+
+
+def _populate_deep_object_query_params_dict(
+    prior_params_key: str,
+    value: Dict,
+    params: Dict[str, List[str]],
+):
+    if not _is_set(value):
+        return
+
+    for key, val in value.items():
+        if not _is_set(val):
+            continue
+
+        params_key = f"{prior_params_key}[{key}]"
+
+        if isinstance(val, BaseModel):
+            _populate_deep_object_query_params_basemodel(params_key, val, params)
+        elif isinstance(val, Dict):
+            _populate_deep_object_query_params_dict(params_key, val, params)
+        elif isinstance(val, List):
+            _populate_deep_object_query_params_list(params_key, val, params)
+        else:
+            params[params_key] = [_val_to_string(val)]
+
+
+def _populate_deep_object_query_params_list(
+    params_key: str,
+    value: List,
+    params: Dict[str, List[str]],
+):
+    if not _is_set(value):
+        return
+
+    for val in value:
+        if not _is_set(val):
+            continue
+
+        if params.get(params_key) is None:
+            params[params_key] = []
+
+        params[params_key].append(_val_to_string(val))
+
+
+def _populate_delimited_query_params(
+    metadata: QueryParamMetadata,
+    field_name: str,
+    obj: Any,
+    delimiter: str,
+    query_param_values: Dict[str, List[str]],
+):
+    _populate_form(
+        field_name,
+        metadata.explode,
+        obj,
+        delimiter,
+        query_param_values,
+    )