finance_dev 0.9.0__py3-none-any.whl

finance_dev/utils/eventstreaming.py

@@ -0,0 +1,327 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: 67b2c14c3282
+
+import re
+import json
+from dataclasses import dataclass, asdict
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    List,
+    TypeVar,
+    Optional,
+    Generator,
+    AsyncGenerator,
+    Tuple,
+)
+import httpx
+
+T = TypeVar("T")
+
+
+class EventStream(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
+    response: httpx.Response
+    generator: Generator[T, None, None]
+    _closed: bool
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
+        data_required: bool = True,
+    ):
+        self.response = response
+        self.generator = stream_events(
+            response, decoder, sentinel, data_required=data_required
+        )
+        self.client_ref = client_ref
+        self._closed = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._closed:
+            raise StopIteration
+        return next(self.generator)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        self._closed = True
+        self.response.close()
+
+
+class EventStreamAsync(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
+    response: httpx.Response
+    generator: AsyncGenerator[T, None]
+    _closed: bool
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
+        data_required: bool = True,
+    ):
+        self.response = response
+        self.generator = stream_events_async(
+            response, decoder, sentinel, data_required=data_required
+        )
+        self.client_ref = client_ref
+        self._closed = False
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if self._closed:
+            raise StopAsyncIteration
+        return await self.generator.__anext__()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self):
+        self._closed = True
+        await self.response.aclose()
+
+
+@dataclass
+class ServerEvent:
+    id: Optional[str] = None
+    event: Optional[str] = None
+    data: Any = None
+    retry: Optional[int] = None
+
+
+MESSAGE_BOUNDARIES = [
+    b"\r\n\r\n",
+    b"\r\n\r",
+    b"\r\n\n",
+    b"\r\r\n",
+    b"\n\r\n",
+    b"\r\r",
+    b"\n\r",
+    b"\n\n",
+]
+MAX_BOUNDARY_LEN = max(len(b) for b in MESSAGE_BOUNDARIES)
+
+UTF8_BOM = b"\xef\xbb\xbf"
+
+
+async def stream_events_async(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+    data_required: bool = True,
+) -> AsyncGenerator[T, None]:
+    try:
+        buffer = bytearray()
+        position = 0
+        event_id: Optional[str] = None
+        async for chunk in response.aiter_bytes():
+            if len(buffer) == 0 and chunk.startswith(UTF8_BOM):
+                chunk = chunk[len(UTF8_BOM) :]
+            old_len = len(buffer)
+            buffer += chunk
+            search_start = max(position, old_len - MAX_BOUNDARY_LEN + 1)
+            for i in range(search_start, len(buffer)):
+                char = buffer[i : i + 1]
+                seq: Optional[bytes] = None
+                if char in [b"\r", b"\n"]:
+                    for boundary in MESSAGE_BOUNDARIES:
+                        seq = _peek_sequence(i, buffer, boundary)
+                        if seq is not None:
+                            break
+                if seq is None:
+                    continue
+
+                block = buffer[position:i]
+                position = i + len(seq)
+                event, discard, event_id = _parse_event(
+                    raw=block,
+                    decoder=decoder,
+                    sentinel=sentinel,
+                    event_id=event_id,
+                    data_required=data_required,
+                )
+                if event is not None:
+                    yield event
+                if discard:
+                    return
+
+            if position > 0:
+                buffer = buffer[position:]
+                position = 0
+
+        event, discard, _ = _parse_event(
+            raw=buffer,
+            decoder=decoder,
+            sentinel=sentinel,
+            event_id=event_id,
+            data_required=data_required,
+        )
+        if event is not None:
+            yield event
+    finally:
+        await response.aclose()
+
+
+def stream_events(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+    data_required: bool = True,
+) -> Generator[T, None, None]:
+    try:
+        buffer = bytearray()
+        position = 0
+        event_id: Optional[str] = None
+        for chunk in response.iter_bytes():
+            if len(buffer) == 0 and chunk.startswith(UTF8_BOM):
+                chunk = chunk[len(UTF8_BOM) :]
+            old_len = len(buffer)
+            buffer += chunk
+            search_start = max(position, old_len - MAX_BOUNDARY_LEN + 1)
+            for i in range(search_start, len(buffer)):
+                char = buffer[i : i + 1]
+                seq: Optional[bytes] = None
+                if char in [b"\r", b"\n"]:
+                    for boundary in MESSAGE_BOUNDARIES:
+                        seq = _peek_sequence(i, buffer, boundary)
+                        if seq is not None:
+                            break
+                if seq is None:
+                    continue
+
+                block = buffer[position:i]
+                position = i + len(seq)
+                event, discard, event_id = _parse_event(
+                    raw=block,
+                    decoder=decoder,
+                    sentinel=sentinel,
+                    event_id=event_id,
+                    data_required=data_required,
+                )
+                if event is not None:
+                    yield event
+                if discard:
+                    return
+
+            if position > 0:
+                buffer = buffer[position:]
+                position = 0
+
+        event, discard, _ = _parse_event(
+            raw=buffer,
+            decoder=decoder,
+            sentinel=sentinel,
+            event_id=event_id,
+            data_required=data_required,
+        )
+        if event is not None:
+            yield event
+    finally:
+        response.close()
+
+
+def _parse_event(
+    *,
+    raw: bytearray,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+    event_id: Optional[str] = None,
+    data_required: bool = True,
+) -> Tuple[Optional[T], bool, Optional[str]]:
+    block = raw.decode()
+    lines = re.split(r"\r?\n|\r", block)
+    publish = False
+    event = ServerEvent()
+    data_parts: List[str] = []
+    for line in lines:
+        if not line:
+            continue
+
+        delim = line.find(":")
+        if delim == 0:
+            continue
+
+        field = line
+        value = ""
+        if delim > 0:
+            field = line[0:delim]
+            value = line[delim + 1 :] if delim < len(line) - 1 else ""
+            if len(value) and value[0] == " ":
+                value = value[1:]
+
+        if field == "event":
+            event.event = value
+            publish = True
+        elif field == "data":
+            data_parts.append(value)
+            publish = True
+        elif field == "id":
+            publish = True
+            if "\x00" not in value:
+                event_id = value
+        elif field == "retry":
+            if value.isdigit():
+                event.retry = int(value)
+            publish = True
+
+    event.id = event_id
+    has_data = bool(data_parts)
+    data = "\n".join(data_parts)
+
+    if sentinel and has_data and data == sentinel:
+        return None, True, event_id
+
+    # Skip data-less events when data is required
+    if not has_data and publish and data_required:
+        return None, False, event_id
+
+    if has_data:
+        try:
+            event.data = json.loads(data)
+        except json.JSONDecodeError:
+            event.data = data
+
+    out = None
+    if publish:
+        out_dict = {
+            k: v
+            for k, v in asdict(event).items()
+            if v is not None or (k == "data" and has_data)
+        }
+        out = decoder(json.dumps(out_dict))
+
+    return out, False, event_id
+
+
+def _peek_sequence(position: int, buffer: bytearray, sequence: bytes):
+    if len(sequence) > (len(buffer) - position):
+        return None
+
+    for i, seq in enumerate(sequence):
+        if buffer[position + i] != seq:
+            return None
+
+    return sequence

finance_dev/utils/forms.py

@@ -0,0 +1,240 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: dffcb15025d6
+
+import io
+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)
+            if isinstance(content, io.TextIOBase):
+                content = content.read().encode(
+                    getattr(content, "encoding", None) or "utf-8"
+                )
+        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
+                array_field_name = f_name + "[]"
+                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(
+                            (array_field_name, (file_name, content, content_type))
+                        )
+                    else:
+                        files.append((array_field_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))
+
+                array_field_name = f_name + "[]"
+                form[array_field_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

finance_dev/utils/headers.py

@@ -0,0 +1,137 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+# @generated-id: c0a9cf7a8d13
+
+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