permitstack 1.0.0__py3-none-any.whl

permitstack/utils/eventstreaming.py

@@ -0,0 +1,309 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import re
+import json
+from dataclasses import dataclass, asdict
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    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._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):
+        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",
+]
+
+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]:
+    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) :]
+        buffer += chunk
+        for i in range(position, 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:
+                await response.aclose()
+                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
+
+
+def stream_events(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+    data_required: bool = True,
+) -> Generator[T, None, None]:
+    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) :]
+        buffer += chunk
+        for i in range(position, 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:
+                response.close()
+                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
+
+
+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 = ""
+    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 += value + "\n"
+            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
+
+    if sentinel and data == f"{sentinel}\n":
+        return None, True, event_id
+
+    # Skip data-less events when data is required
+    if not data and publish and data_required:
+        return None, False, event_id
+
+    if data:
+        data = data[:-1]
+        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 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

permitstack/utils/forms.py

@@ -0,0 +1,234 @@
+"""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
+                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

permitstack/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

permitstack/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("PERMITSTACK_DEBUG"):
+        logging.basicConfig(level=logging.DEBUG)
+        return logging.getLogger("permitstack")
+    return NoOpLogger()