train-travel 0.0.7__py3-none-any.whl

train_travel/trips.py

@@ -0,0 +1,291 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basesdk import BaseSDK
+from datetime import datetime
+from enum import Enum
+from train_travel import errors, models, utils
+from train_travel._hooks import HookContext
+from train_travel.types import OptionalNullable, UNSET
+from train_travel.utils import get_security_from_env
+from train_travel.utils.unmarshal_json_response import unmarshal_json_response
+from typing import Mapping, Optional
+
+
+class GetTripsAcceptEnum(str, Enum):
+    APPLICATION_JSON = "application/json"
+    APPLICATION_XML = "application/xml"
+
+
+class Trips(BaseSDK):
+    r"""Timetables and routes for train trips between stations, including pricing
+    and availability.
+
+    """
+
+    def get_trips(
+        self,
+        *,
+        origin: str,
+        destination: str,
+        date_: datetime,
+        page: Optional[int] = 1,
+        limit: Optional[int] = 10,
+        bicycles: Optional[bool] = False,
+        dogs: Optional[bool] = False,
+        retries: OptionalNullable[utils.RetryConfig] = UNSET,
+        server_url: Optional[str] = None,
+        timeout_ms: Optional[int] = None,
+        accept_header_override: Optional[GetTripsAcceptEnum] = None,
+        http_headers: Optional[Mapping[str, str]] = None,
+    ) -> models.GetTripsResponse:
+        r"""Get available train trips
+
+        Returns a list of available train trips between the specified origin and destination stations on the given date, and allows for filtering by bicycle and dog allowances.
+
+
+        :param origin: The ID of the origin station
+        :param destination: The ID of the destination station
+        :param date_: The date and time of the trip in ISO 8601 format in origin station's timezone.
+        :param page: The page number to return
+        :param limit: The number of items to return per page
+        :param bicycles: Only return trips where bicycles are known to be allowed
+        :param dogs: Only return trips where dogs are known to be allowed
+        :param retries: Override the default retry configuration for this method
+        :param server_url: Override the default server URL for this method
+        :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
+        :param accept_header_override: Override the default accept header for this method
+        :param http_headers: Additional headers to set or replace on requests.
+        """
+        base_url = None
+        url_variables = None
+        if timeout_ms is None:
+            timeout_ms = self.sdk_configuration.timeout_ms
+
+        if server_url is not None:
+            base_url = server_url
+        else:
+            base_url = self._get_url(base_url, url_variables)
+
+        request = models.GetTripsRequest(
+            page=page,
+            limit=limit,
+            origin=origin,
+            destination=destination,
+            date_=date_,
+            bicycles=bicycles,
+            dogs=dogs,
+        )
+
+        req = self._build_request(
+            method="GET",
+            path="/trips",
+            base_url=base_url,
+            url_variables=url_variables,
+            request=request,
+            request_body_required=False,
+            request_has_path_params=False,
+            request_has_query_params=True,
+            user_agent_header="user-agent",
+            accept_header_value=accept_header_override.value
+            if accept_header_override is not None
+            else "application/json;q=1, application/xml;q=0",
+            http_headers=http_headers,
+            security=self.sdk_configuration.security,
+            allow_empty_value=None,
+            timeout_ms=timeout_ms,
+        )
+
+        if retries == UNSET:
+            if self.sdk_configuration.retry_config is not UNSET:
+                retries = self.sdk_configuration.retry_config
+            else:
+                retries = utils.RetryConfig(
+                    "backoff", utils.BackoffStrategy(500, 60000, 1.5, 3600000), True
+                )
+
+        retry_config = None
+        if isinstance(retries, utils.RetryConfig):
+            retry_config = (retries, ["5XX"])
+
+        http_res = self.do_request(
+            hook_ctx=HookContext(
+                config=self.sdk_configuration,
+                base_url=base_url or "",
+                operation_id="get-trips",
+                oauth2_scopes=None,
+                security_source=get_security_from_env(
+                    self.sdk_configuration.security, models.Security
+                ),
+            ),
+            request=req,
+            error_status_codes=["400", "401", "403", "429", "4XX", "500", "5XX"],
+            retry_config=retry_config,
+        )
+
+        if utils.match_response(http_res, "200", "application/json"):
+            return models.GetTripsResponse(
+                result=unmarshal_json_response(models.GetTripsResponseBody, http_res),
+                headers=utils.get_response_headers(http_res.headers),
+            )
+        if utils.match_response(http_res, "200", "application/xml"):
+            http_res_bytes = utils.stream_to_bytes(http_res)
+            return models.GetTripsResponse(
+                result=http_res_bytes,
+                headers=utils.get_response_headers(http_res.headers),
+            )
+        if utils.match_response(http_res, ["400", "401", "403", "429"], "*"):
+            http_res_text = utils.stream_to_text(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "500", "*"):
+            http_res_text = utils.stream_to_text(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "4XX", "*"):
+            http_res_text = utils.stream_to_text(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "5XX", "*"):
+            http_res_text = utils.stream_to_text(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+
+        raise errors.TrainTravelDefaultError("Unexpected response received", http_res)
+
+    async def get_trips_async(
+        self,
+        *,
+        origin: str,
+        destination: str,
+        date_: datetime,
+        page: Optional[int] = 1,
+        limit: Optional[int] = 10,
+        bicycles: Optional[bool] = False,
+        dogs: Optional[bool] = False,
+        retries: OptionalNullable[utils.RetryConfig] = UNSET,
+        server_url: Optional[str] = None,
+        timeout_ms: Optional[int] = None,
+        accept_header_override: Optional[GetTripsAcceptEnum] = None,
+        http_headers: Optional[Mapping[str, str]] = None,
+    ) -> models.GetTripsResponse:
+        r"""Get available train trips
+
+        Returns a list of available train trips between the specified origin and destination stations on the given date, and allows for filtering by bicycle and dog allowances.
+
+
+        :param origin: The ID of the origin station
+        :param destination: The ID of the destination station
+        :param date_: The date and time of the trip in ISO 8601 format in origin station's timezone.
+        :param page: The page number to return
+        :param limit: The number of items to return per page
+        :param bicycles: Only return trips where bicycles are known to be allowed
+        :param dogs: Only return trips where dogs are known to be allowed
+        :param retries: Override the default retry configuration for this method
+        :param server_url: Override the default server URL for this method
+        :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
+        :param accept_header_override: Override the default accept header for this method
+        :param http_headers: Additional headers to set or replace on requests.
+        """
+        base_url = None
+        url_variables = None
+        if timeout_ms is None:
+            timeout_ms = self.sdk_configuration.timeout_ms
+
+        if server_url is not None:
+            base_url = server_url
+        else:
+            base_url = self._get_url(base_url, url_variables)
+
+        request = models.GetTripsRequest(
+            page=page,
+            limit=limit,
+            origin=origin,
+            destination=destination,
+            date_=date_,
+            bicycles=bicycles,
+            dogs=dogs,
+        )
+
+        req = self._build_request_async(
+            method="GET",
+            path="/trips",
+            base_url=base_url,
+            url_variables=url_variables,
+            request=request,
+            request_body_required=False,
+            request_has_path_params=False,
+            request_has_query_params=True,
+            user_agent_header="user-agent",
+            accept_header_value=accept_header_override.value
+            if accept_header_override is not None
+            else "application/json;q=1, application/xml;q=0",
+            http_headers=http_headers,
+            security=self.sdk_configuration.security,
+            allow_empty_value=None,
+            timeout_ms=timeout_ms,
+        )
+
+        if retries == UNSET:
+            if self.sdk_configuration.retry_config is not UNSET:
+                retries = self.sdk_configuration.retry_config
+            else:
+                retries = utils.RetryConfig(
+                    "backoff", utils.BackoffStrategy(500, 60000, 1.5, 3600000), True
+                )
+
+        retry_config = None
+        if isinstance(retries, utils.RetryConfig):
+            retry_config = (retries, ["5XX"])
+
+        http_res = await self.do_request_async(
+            hook_ctx=HookContext(
+                config=self.sdk_configuration,
+                base_url=base_url or "",
+                operation_id="get-trips",
+                oauth2_scopes=None,
+                security_source=get_security_from_env(
+                    self.sdk_configuration.security, models.Security
+                ),
+            ),
+            request=req,
+            error_status_codes=["400", "401", "403", "429", "4XX", "500", "5XX"],
+            retry_config=retry_config,
+        )
+
+        if utils.match_response(http_res, "200", "application/json"):
+            return models.GetTripsResponse(
+                result=unmarshal_json_response(models.GetTripsResponseBody, http_res),
+                headers=utils.get_response_headers(http_res.headers),
+            )
+        if utils.match_response(http_res, "200", "application/xml"):
+            http_res_bytes = await utils.stream_to_bytes_async(http_res)
+            return models.GetTripsResponse(
+                result=http_res_bytes,
+                headers=utils.get_response_headers(http_res.headers),
+            )
+        if utils.match_response(http_res, ["400", "401", "403", "429"], "*"):
+            http_res_text = await utils.stream_to_text_async(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "500", "*"):
+            http_res_text = await utils.stream_to_text_async(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "4XX", "*"):
+            http_res_text = await utils.stream_to_text_async(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+        if utils.match_response(http_res, "5XX", "*"):
+            http_res_text = await utils.stream_to_text_async(http_res)
+            raise errors.TrainTravelDefaultError(
+                "API error occurred", http_res, http_res_text
+            )
+
+        raise errors.TrainTravelDefaultError("Unexpected response received", http_res)

train_travel/types/__init__.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basemodel import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UnrecognizedInt,
+    UnrecognizedStr,
+    UNSET,
+    UNSET_SENTINEL,
+)
+
+__all__ = [
+    "BaseModel",
+    "Nullable",
+    "OptionalNullable",
+    "UnrecognizedInt",
+    "UnrecognizedStr",
+    "UNSET",
+    "UNSET_SENTINEL",
+]

train_travel/types/basemodel.py

@@ -0,0 +1,77 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from pydantic import ConfigDict, model_serializer
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic_core import core_schema
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union
+from typing_extensions import TypeAliasType, TypeAlias
+
+
+class BaseModel(PydanticBaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, protected_namespaces=()
+    )
+
+
+class Unset(BaseModel):
+    @model_serializer(mode="plain")
+    def serialize_model(self):
+        return UNSET_SENTINEL
+
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET = Unset()
+UNSET_SENTINEL = "~?~unset~?~sentinel~?~"
+
+
+T = TypeVar("T")
+if TYPE_CHECKING:
+    Nullable: TypeAlias = Union[T, None]
+    OptionalNullable: TypeAlias = Union[Optional[Nullable[T]], Unset]
+else:
+    Nullable = TypeAliasType("Nullable", Union[T, None], type_params=(T,))
+    OptionalNullable = TypeAliasType(
+        "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
+    )
+
+
+class UnrecognizedStr(str):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedStr only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedStr':
+            if isinstance(v, cls):
+                return v
+            return cls(str(v))
+
+        # Use lax_or_strict_schema where strict always fails
+        # This forces Pydantic to prefer other union members in strict mode
+        # and only fall back to UnrecognizedStr in lax mode
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )
+
+
+class UnrecognizedInt(int):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedInt only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedInt':
+            if isinstance(v, cls):
+                return v
+            return cls(int(v))
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.int_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )

train_travel/utils/__init__.py

@@ -0,0 +1,206 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import TYPE_CHECKING, Callable, TypeVar
+from importlib import import_module
+import asyncio
+import builtins
+import sys
+
+_T = TypeVar("_T")
+
+
+async def run_sync_in_thread(func: Callable[..., _T], *args) -> _T:
+    """Run a synchronous function in a thread pool to avoid blocking the event loop."""
+    return await asyncio.to_thread(func, *args)
+
+
+if TYPE_CHECKING:
+    from .annotations import get_discriminator
+    from .datetimes import parse_datetime
+    from .enums import OpenEnumMeta
+    from .headers import get_headers, get_response_headers
+    from .metadata import (
+        FieldMetadata,
+        find_metadata,
+        FormMetadata,
+        HeaderMetadata,
+        MultipartFormMetadata,
+        PathParamMetadata,
+        QueryParamMetadata,
+        RequestMetadata,
+        SecurityMetadata,
+    )
+    from .queryparams import get_query_params
+    from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
+    from .requestbodies import serialize_request_body, SerializedRequestBody
+    from .security import get_security, get_security_from_env
+
+    from .serializers import (
+        get_pydantic_model,
+        marshal_json,
+        unmarshal,
+        unmarshal_json,
+        serialize_decimal,
+        serialize_float,
+        serialize_int,
+        stream_to_text,
+        stream_to_text_async,
+        stream_to_bytes,
+        stream_to_bytes_async,
+        validate_const,
+        validate_decimal,
+        validate_float,
+        validate_int,
+    )
+    from .url import generate_url, template_url, remove_suffix
+    from .values import (
+        get_global_from_env,
+        match_content_type,
+        match_status_codes,
+        match_response,
+        cast_partial,
+    )
+    from .logger import Logger, get_body_content, get_default_logger
+
+__all__ = [
+    "BackoffStrategy",
+    "FieldMetadata",
+    "find_metadata",
+    "FormMetadata",
+    "generate_url",
+    "get_body_content",
+    "get_default_logger",
+    "get_discriminator",
+    "parse_datetime",
+    "get_global_from_env",
+    "get_headers",
+    "get_pydantic_model",
+    "get_query_params",
+    "get_response_headers",
+    "get_security",
+    "get_security_from_env",
+    "HeaderMetadata",
+    "Logger",
+    "marshal_json",
+    "match_content_type",
+    "match_status_codes",
+    "match_response",
+    "MultipartFormMetadata",
+    "OpenEnumMeta",
+    "PathParamMetadata",
+    "QueryParamMetadata",
+    "remove_suffix",
+    "Retries",
+    "retry",
+    "retry_async",
+    "RetryConfig",
+    "RequestMetadata",
+    "SecurityMetadata",
+    "serialize_decimal",
+    "serialize_float",
+    "serialize_int",
+    "serialize_request_body",
+    "SerializedRequestBody",
+    "stream_to_text",
+    "stream_to_text_async",
+    "stream_to_bytes",
+    "stream_to_bytes_async",
+    "template_url",
+    "unmarshal",
+    "unmarshal_json",
+    "validate_decimal",
+    "validate_const",
+    "validate_float",
+    "validate_int",
+    "cast_partial",
+]
+
+_dynamic_imports: dict[str, str] = {
+    "BackoffStrategy": ".retries",
+    "FieldMetadata": ".metadata",
+    "find_metadata": ".metadata",
+    "FormMetadata": ".metadata",
+    "generate_url": ".url",
+    "get_body_content": ".logger",
+    "get_default_logger": ".logger",
+    "get_discriminator": ".annotations",
+    "parse_datetime": ".datetimes",
+    "get_global_from_env": ".values",
+    "get_headers": ".headers",
+    "get_pydantic_model": ".serializers",
+    "get_query_params": ".queryparams",
+    "get_response_headers": ".headers",
+    "get_security": ".security",
+    "get_security_from_env": ".security",
+    "HeaderMetadata": ".metadata",
+    "Logger": ".logger",
+    "marshal_json": ".serializers",
+    "match_content_type": ".values",
+    "match_status_codes": ".values",
+    "match_response": ".values",
+    "MultipartFormMetadata": ".metadata",
+    "OpenEnumMeta": ".enums",
+    "PathParamMetadata": ".metadata",
+    "QueryParamMetadata": ".metadata",
+    "remove_suffix": ".url",
+    "Retries": ".retries",
+    "retry": ".retries",
+    "retry_async": ".retries",
+    "RetryConfig": ".retries",
+    "RequestMetadata": ".metadata",
+    "SecurityMetadata": ".metadata",
+    "serialize_decimal": ".serializers",
+    "serialize_float": ".serializers",
+    "serialize_int": ".serializers",
+    "serialize_request_body": ".requestbodies",
+    "SerializedRequestBody": ".requestbodies",
+    "stream_to_text": ".serializers",
+    "stream_to_text_async": ".serializers",
+    "stream_to_bytes": ".serializers",
+    "stream_to_bytes_async": ".serializers",
+    "template_url": ".url",
+    "unmarshal": ".serializers",
+    "unmarshal_json": ".serializers",
+    "validate_decimal": ".serializers",
+    "validate_const": ".serializers",
+    "validate_float": ".serializers",
+    "validate_int": ".serializers",
+    "cast_partial": ".values",
+}
+
+
+def dynamic_import(modname, retries=3):
+    for attempt in range(retries):
+        try:
+            return import_module(modname, __package__)
+        except KeyError:
+            # Clear any half-initialized module and retry
+            sys.modules.pop(modname, None)
+            if attempt == retries - 1:
+                break
+    raise KeyError(f"Failed to import module '{modname}' after {retries} attempts")
+
+
+def __getattr__(attr_name: str) -> object:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(
+            f"no {attr_name} found in _dynamic_imports, module name -> {__name__} "
+        )
+
+    try:
+        module = dynamic_import(module_name)
+        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 = builtins.list(_dynamic_imports.keys())
+    return builtins.sorted(lazy_attrs)

train_travel/utils/annotations.py

@@ -0,0 +1,79 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from enum import Enum
+from typing import Any, Optional
+
+
+def get_discriminator(model: Any, fieldname: str, key: str) -> str:
+    """
+    Recursively search for the discriminator attribute in a model.
+
+    Args:
+        model (Any): The model to search within.
+        fieldname (str): The name of the field to search for.
+        key (str): The key to search for in dictionaries.
+
+    Returns:
+        str: The name of the discriminator attribute.
+
+    Raises:
+        ValueError: If the discriminator attribute is not found.
+    """
+    upper_fieldname = fieldname.upper()
+
+    def get_field_discriminator(field: Any) -> Optional[str]:
+        """Search for the discriminator attribute in a given field."""
+
+        if isinstance(field, dict):
+            if key in field:
+                return f"{field[key]}"
+
+        if hasattr(field, fieldname):
+            attr = getattr(field, fieldname)
+            if isinstance(attr, Enum):
+                return f"{attr.value}"
+            return f"{attr}"
+
+        if hasattr(field, upper_fieldname):
+            attr = getattr(field, upper_fieldname)
+            if isinstance(attr, Enum):
+                return f"{attr.value}"
+            return f"{attr}"
+
+        return None
+
+    def search_nested_discriminator(obj: Any) -> Optional[str]:
+        """Recursively search for discriminator in nested structures."""
+        # First try direct field lookup
+        discriminator = get_field_discriminator(obj)
+        if discriminator is not None:
+            return discriminator
+
+        # If it's a dict, search in nested values
+        if isinstance(obj, dict):
+            for value in obj.values():
+                if isinstance(value, list):
+                    # Search in list items
+                    for item in value:
+                        nested_discriminator = search_nested_discriminator(item)
+                        if nested_discriminator is not None:
+                            return nested_discriminator
+                elif isinstance(value, dict):
+                    # Search in nested dict
+                    nested_discriminator = search_nested_discriminator(value)
+                    if nested_discriminator is not None:
+                        return nested_discriminator
+
+        return None
+
+    if isinstance(model, list):
+        for field in model:
+            discriminator = search_nested_discriminator(field)
+            if discriminator is not None:
+                return discriminator
+
+    discriminator = search_nested_discriminator(model)
+    if discriminator is not None:
+        return discriminator
+
+    raise ValueError(f"Could not find discriminator field {fieldname} in {model}")