lambdadb 0.1.2__py3-none-any.whl

lambdadb/utils/security.py

@@ -0,0 +1,192 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import base64
+
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    SecurityMetadata,
+    find_field_metadata,
+)
+import os
+
+
+def get_security(security: Any) -> Tuple[Dict[str, str], Dict[str, List[str]]]:
+    headers: Dict[str, str] = {}
+    query_params: Dict[str, List[str]] = {}
+
+    if security is None:
+        return headers, query_params
+
+    if not isinstance(security, BaseModel):
+        raise TypeError("security must be a pydantic model")
+
+    sec_fields: Dict[str, FieldInfo] = security.__class__.model_fields
+    for name in sec_fields:
+        sec_field = sec_fields[name]
+
+        value = getattr(security, name)
+        if value is None:
+            continue
+
+        metadata = find_field_metadata(sec_field, SecurityMetadata)
+        if metadata is None:
+            continue
+        if metadata.option:
+            _parse_security_option(headers, query_params, value)
+            return headers, query_params
+        if metadata.scheme:
+            # Special case for basic auth or custom auth which could be a flattened model
+            if metadata.sub_type in ["basic", "custom"] and not isinstance(
+                value, BaseModel
+            ):
+                _parse_security_scheme(headers, query_params, metadata, name, security)
+            else:
+                _parse_security_scheme(headers, query_params, metadata, name, value)
+
+    return headers, query_params
+
+
+def get_security_from_env(security: Any, security_class: Any) -> Optional[BaseModel]:
+    if security is not None:
+        return security
+
+    if not issubclass(security_class, BaseModel):
+        raise TypeError("security_class must be a pydantic model class")
+
+    security_dict: Any = {}
+
+    if os.getenv("LAMBDADB_PROJECT_API_KEY"):
+        security_dict["project_api_key"] = os.getenv("LAMBDADB_PROJECT_API_KEY")
+
+    return security_class(**security_dict) if security_dict else None
+
+
+def _parse_security_option(
+    headers: Dict[str, str], query_params: Dict[str, List[str]], option: Any
+):
+    if not isinstance(option, BaseModel):
+        raise TypeError("security option must be a pydantic model")
+
+    opt_fields: Dict[str, FieldInfo] = option.__class__.model_fields
+    for name in opt_fields:
+        opt_field = opt_fields[name]
+
+        metadata = find_field_metadata(opt_field, SecurityMetadata)
+        if metadata is None or not metadata.scheme:
+            continue
+        _parse_security_scheme(
+            headers, query_params, metadata, name, getattr(option, name)
+        )
+
+
+def _parse_security_scheme(
+    headers: Dict[str, str],
+    query_params: Dict[str, List[str]],
+    scheme_metadata: SecurityMetadata,
+    field_name: str,
+    scheme: Any,
+):
+    scheme_type = scheme_metadata.scheme_type
+    sub_type = scheme_metadata.sub_type
+
+    if isinstance(scheme, BaseModel):
+        if scheme_type == "http":
+            if sub_type == "basic":
+                _parse_basic_auth_scheme(headers, scheme)
+                return
+            if sub_type == "custom":
+                return
+
+        scheme_fields: Dict[str, FieldInfo] = scheme.__class__.model_fields
+        for name in scheme_fields:
+            scheme_field = scheme_fields[name]
+
+            metadata = find_field_metadata(scheme_field, SecurityMetadata)
+            if metadata is None or metadata.field_name is None:
+                continue
+
+            value = getattr(scheme, name)
+
+            _parse_security_scheme_value(
+                headers, query_params, scheme_metadata, metadata, name, value
+            )
+    else:
+        _parse_security_scheme_value(
+            headers, query_params, scheme_metadata, scheme_metadata, field_name, scheme
+        )
+
+
+def _parse_security_scheme_value(
+    headers: Dict[str, str],
+    query_params: Dict[str, List[str]],
+    scheme_metadata: SecurityMetadata,
+    security_metadata: SecurityMetadata,
+    field_name: str,
+    value: Any,
+):
+    scheme_type = scheme_metadata.scheme_type
+    sub_type = scheme_metadata.sub_type
+
+    header_name = security_metadata.get_field_name(field_name)
+
+    if scheme_type == "apiKey":
+        if sub_type == "header":
+            headers[header_name] = value
+        elif sub_type == "query":
+            query_params[header_name] = [value]
+        else:
+            raise ValueError("sub type {sub_type} not supported")
+    elif scheme_type == "openIdConnect":
+        headers[header_name] = _apply_bearer(value)
+    elif scheme_type == "oauth2":
+        if sub_type != "client_credentials":
+            headers[header_name] = _apply_bearer(value)
+    elif scheme_type == "http":
+        if sub_type == "bearer":
+            headers[header_name] = _apply_bearer(value)
+        elif sub_type == "custom":
+            return
+        else:
+            raise ValueError("sub type {sub_type} not supported")
+    else:
+        raise ValueError("scheme type {scheme_type} not supported")
+
+
+def _apply_bearer(token: str) -> str:
+    return token.lower().startswith("bearer ") and token or f"Bearer {token}"
+
+
+def _parse_basic_auth_scheme(headers: Dict[str, str], scheme: Any):
+    username = ""
+    password = ""
+
+    if not isinstance(scheme, BaseModel):
+        raise TypeError("basic auth scheme must be a pydantic model")
+
+    scheme_fields: Dict[str, FieldInfo] = scheme.__class__.model_fields
+    for name in scheme_fields:
+        scheme_field = scheme_fields[name]
+
+        metadata = find_field_metadata(scheme_field, SecurityMetadata)
+        if metadata is None or metadata.field_name is None:
+            continue
+
+        field_name = metadata.field_name
+        value = getattr(scheme, name)
+
+        if field_name == "username":
+            username = value
+        if field_name == "password":
+            password = value
+
+    data = f"{username}:{password}".encode()
+    headers["Authorization"] = f"Basic {base64.b64encode(data).decode()}"

lambdadb/utils/serializers.py

@@ -0,0 +1,248 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from decimal import Decimal
+import functools
+import json
+import typing
+from typing import Any, Dict, List, Tuple, Union, get_args
+import typing_extensions
+from typing_extensions import get_origin
+
+import httpx
+from pydantic import ConfigDict, create_model
+from pydantic_core import from_json
+
+from ..types.basemodel import BaseModel, Nullable, OptionalNullable, Unset
+
+
+def serialize_decimal(as_str: bool):
+    def serialize(d):
+        # Optional[T] is a Union[T, None]
+        if is_union(type(d)) and type(None) in get_args(type(d)) and d is None:
+            return None
+        if isinstance(d, Unset):
+            return d
+
+        if not isinstance(d, Decimal):
+            raise ValueError("Expected Decimal object")
+
+        return str(d) if as_str else float(d)
+
+    return serialize
+
+
+def validate_decimal(d):
+    if d is None:
+        return None
+
+    if isinstance(d, (Decimal, Unset)):
+        return d
+
+    if not isinstance(d, (str, int, float)):
+        raise ValueError("Expected string, int or float")
+
+    return Decimal(str(d))
+
+
+def serialize_float(as_str: bool):
+    def serialize(f):
+        # Optional[T] is a Union[T, None]
+        if is_union(type(f)) and type(None) in get_args(type(f)) and f is None:
+            return None
+        if isinstance(f, Unset):
+            return f
+
+        if not isinstance(f, float):
+            raise ValueError("Expected float")
+
+        return str(f) if as_str else f
+
+    return serialize
+
+
+def validate_float(f):
+    if f is None:
+        return None
+
+    if isinstance(f, (float, Unset)):
+        return f
+
+    if not isinstance(f, str):
+        raise ValueError("Expected string")
+
+    return float(f)
+
+
+def serialize_int(as_str: bool):
+    def serialize(i):
+        # Optional[T] is a Union[T, None]
+        if is_union(type(i)) and type(None) in get_args(type(i)) and i is None:
+            return None
+        if isinstance(i, Unset):
+            return i
+
+        if not isinstance(i, int):
+            raise ValueError("Expected int")
+
+        return str(i) if as_str else i
+
+    return serialize
+
+
+def validate_int(b):
+    if b is None:
+        return None
+
+    if isinstance(b, (int, Unset)):
+        return b
+
+    if not isinstance(b, str):
+        raise ValueError("Expected string")
+
+    return int(b)
+
+
+def validate_open_enum(is_int: bool):
+    def validate(e):
+        if e is None:
+            return None
+
+        if isinstance(e, Unset):
+            return e
+
+        if is_int:
+            if not isinstance(e, int):
+                raise ValueError("Expected int")
+        else:
+            if not isinstance(e, str):
+                raise ValueError("Expected string")
+
+        return e
+
+    return validate
+
+
+def validate_const(v):
+    def validate(c):
+        # Optional[T] is a Union[T, None]
+        if is_union(type(c)) and type(None) in get_args(type(c)) and c is None:
+            return None
+
+        if v != c:
+            raise ValueError(f"Expected {v}")
+
+        return c
+
+    return validate
+
+
+def unmarshal_json(raw, typ: Any) -> Any:
+    return unmarshal(from_json(raw), typ)
+
+
+def unmarshal(val, typ: Any) -> Any:
+    unmarshaller = create_model(
+        "Unmarshaller",
+        body=(typ, ...),
+        __config__=ConfigDict(populate_by_name=True, arbitrary_types_allowed=True),
+    )
+
+    m = unmarshaller(body=val)
+
+    # pyright: ignore[reportAttributeAccessIssue]
+    return m.body  # type: ignore
+
+
+def marshal_json(val, typ):
+    if is_nullable(typ) and val is None:
+        return "null"
+
+    marshaller = create_model(
+        "Marshaller",
+        body=(typ, ...),
+        __config__=ConfigDict(populate_by_name=True, arbitrary_types_allowed=True),
+    )
+
+    m = marshaller(body=val)
+
+    d = m.model_dump(by_alias=True, mode="json", exclude_none=True)
+
+    if len(d) == 0:
+        return ""
+
+    return json.dumps(d[next(iter(d))], separators=(",", ":"))
+
+
+def is_nullable(field):
+    origin = get_origin(field)
+    if origin is Nullable or origin is OptionalNullable:
+        return True
+
+    if not origin is Union or type(None) not in get_args(field):
+        return False
+
+    for arg in get_args(field):
+        if get_origin(arg) is Nullable or get_origin(arg) is OptionalNullable:
+            return True
+
+    return False
+
+
+def is_union(obj: object) -> bool:
+    """
+    Returns True if the given object is a typing.Union or typing_extensions.Union.
+    """
+    return any(obj is typing_obj for typing_obj in _get_typing_objects_by_name_of("Union"))
+
+
+def stream_to_text(stream: httpx.Response) -> str:
+    return "".join(stream.iter_text())
+
+
+async def stream_to_text_async(stream: httpx.Response) -> str:
+    return "".join([chunk async for chunk in stream.aiter_text()])
+
+
+def stream_to_bytes(stream: httpx.Response) -> bytes:
+    return stream.content
+
+
+async def stream_to_bytes_async(stream: httpx.Response) -> bytes:
+    return await stream.aread()
+
+
+def get_pydantic_model(data: Any, typ: Any) -> Any:
+    if not _contains_pydantic_model(data):
+        return unmarshal(data, typ)
+
+    return data
+
+
+def _contains_pydantic_model(data: Any) -> bool:
+    if isinstance(data, BaseModel):
+        return True
+    if isinstance(data, List):
+        return any(_contains_pydantic_model(item) for item in data)
+    if isinstance(data, Dict):
+        return any(_contains_pydantic_model(value) for value in data.values())
+
+    return False
+
+
+@functools.cache
+def _get_typing_objects_by_name_of(name: str) -> Tuple[Any, ...]:
+    """
+    Get typing objects by name from typing and typing_extensions.
+    Reference: https://typing-extensions.readthedocs.io/en/latest/#runtime-use-of-types
+    """
+    result = tuple(
+        getattr(module, name)
+        for module in (typing, typing_extensions)
+        if hasattr(module, name)
+    )
+    if not result:
+        raise ValueError(
+            f"Neither typing nor typing_extensions has an object called {name!r}"
+        )
+    return result
+

lambdadb/utils/url.py

@@ -0,0 +1,155 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from decimal import Decimal
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    PathParamMetadata,
+    find_field_metadata,
+)
+from .values import (
+    _get_serialized_params,
+    _is_set,
+    _populate_from_globals,
+    _val_to_string,
+)
+
+
+def generate_url(
+    server_url: str,
+    path: str,
+    path_params: Any,
+    gbls: Optional[Any] = None,
+) -> str:
+    path_param_values: Dict[str, str] = {}
+
+    globals_already_populated = _populate_path_params(
+        path_params, gbls, path_param_values, []
+    )
+    if _is_set(gbls):
+        _populate_path_params(gbls, None, path_param_values, globals_already_populated)
+
+    for key, value in path_param_values.items():
+        path = path.replace("{" + key + "}", value, 1)
+
+    return remove_suffix(server_url, "/") + path
+
+
+def _populate_path_params(
+    path_params: Any,
+    gbls: Any,
+    path_param_values: Dict[str, str],
+    skip_fields: List[str],
+) -> List[str]:
+    globals_already_populated: List[str] = []
+
+    if not isinstance(path_params, BaseModel):
+        return globals_already_populated
+
+    path_param_fields: Dict[str, FieldInfo] = path_params.__class__.model_fields
+    path_param_field_types = get_type_hints(path_params.__class__)
+    for name in path_param_fields:
+        if name in skip_fields:
+            continue
+
+        field = path_param_fields[name]
+
+        param_metadata = find_field_metadata(field, PathParamMetadata)
+        if param_metadata is None:
+            continue
+
+        param = getattr(path_params, name) if _is_set(path_params) else None
+        param, global_found = _populate_from_globals(
+            name, param, PathParamMetadata, gbls
+        )
+        if global_found:
+            globals_already_populated.append(name)
+
+        if not _is_set(param):
+            continue
+
+        f_name = field.alias if field.alias is not None else name
+        serialization = param_metadata.serialization
+        if serialization is not None:
+            serialized_params = _get_serialized_params(
+                param_metadata, f_name, param, path_param_field_types[name]
+            )
+            for key, value in serialized_params.items():
+                path_param_values[key] = value
+        else:
+            pp_vals: List[str] = []
+            if param_metadata.style == "simple":
+                if isinstance(param, List):
+                    for pp_val in param:
+                        if not _is_set(pp_val):
+                            continue
+                        pp_vals.append(_val_to_string(pp_val))
+                    path_param_values[f_name] = ",".join(pp_vals)
+                elif isinstance(param, Dict):
+                    for pp_key in param:
+                        if not _is_set(param[pp_key]):
+                            continue
+                        if param_metadata.explode:
+                            pp_vals.append(f"{pp_key}={_val_to_string(param[pp_key])}")
+                        else:
+                            pp_vals.append(f"{pp_key},{_val_to_string(param[pp_key])}")
+                    path_param_values[f_name] = ",".join(pp_vals)
+                elif not isinstance(param, (str, int, float, complex, bool, Decimal)):
+                    param_fields: Dict[str, FieldInfo] = param.__class__.model_fields
+                    for name in param_fields:
+                        param_field = param_fields[name]
+
+                        param_value_metadata = find_field_metadata(
+                            param_field, PathParamMetadata
+                        )
+                        if param_value_metadata is None:
+                            continue
+
+                        param_name = (
+                            param_field.alias if param_field.alias is not None else name
+                        )
+
+                        param_field_val = getattr(param, name)
+                        if not _is_set(param_field_val):
+                            continue
+                        if param_metadata.explode:
+                            pp_vals.append(
+                                f"{param_name}={_val_to_string(param_field_val)}"
+                            )
+                        else:
+                            pp_vals.append(
+                                f"{param_name},{_val_to_string(param_field_val)}"
+                            )
+                    path_param_values[f_name] = ",".join(pp_vals)
+                elif _is_set(param):
+                    path_param_values[f_name] = _val_to_string(param)
+
+    return globals_already_populated
+
+
+def is_optional(field):
+    return get_origin(field) is Union and type(None) in get_args(field)
+
+
+def template_url(url_with_params: str, params: Dict[str, str]) -> str:
+    for key, value in params.items():
+        url_with_params = url_with_params.replace("{" + key + "}", value)
+
+    return url_with_params
+
+
+def remove_suffix(input_string, suffix):
+    if suffix and input_string.endswith(suffix):
+        return input_string[: -len(suffix)]
+    return input_string