syllable-sdk 0.44.4__py3-none-any.whl → 0.44.17__py3-none-any.whl

syllable_sdk/models/getvalueaction.py

@@ -0,0 +1,151 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .caseexpression import CaseExpression, CaseExpressionTypedDict
+from .celexpression import CelExpression, CelExpressionTypedDict
+from .jmespathexpression import JMESPathExpression, JMESPathExpressionTypedDict
+from enum import Enum
+import pydantic
+from pydantic import Discriminator, Tag, model_serializer
+from syllable_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from syllable_sdk.utils import get_discriminator
+from typing import Any, List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+GetValueActionValueFrom1TypedDict = TypeAliasType(
+    "GetValueActionValueFrom1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+GetValueActionValueFrom1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetValueActionValueFrom2TypedDict = TypeAliasType(
+    "GetValueActionValueFrom2TypedDict",
+    Union[CaseExpressionTypedDict, GetValueActionValueFrom1TypedDict, str],
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+GetValueActionValueFrom2 = TypeAliasType(
+    "GetValueActionValueFrom2", Union[CaseExpression, GetValueActionValueFrom1, str]
+)
+r"""Expression to compute initial value (mutually exclusive with value)."""
+
+
+GetValueActionIf1TypedDict = TypeAliasType(
+    "GetValueActionIf1TypedDict",
+    Union[CelExpressionTypedDict, JMESPathExpressionTypedDict],
+)
+
+
+GetValueActionIf1 = Annotated[
+    Union[
+        Annotated[CelExpression, Tag("cel")],
+        Annotated[JMESPathExpression, Tag("jmespath")],
+        Annotated[JMESPathExpression, Tag("jp")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+GetValueActionIf2TypedDict = TypeAliasType(
+    "GetValueActionIf2TypedDict",
+    Union[CaseExpressionTypedDict, GetValueActionIf1TypedDict, str],
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+GetValueActionIf2 = TypeAliasType(
+    "GetValueActionIf2", Union[CaseExpression, GetValueActionIf1, str]
+)
+r"""An expression that must evaluate to true for the action to be applied."""
+
+
+class GetValueActionAction(str, Enum):
+    r"""Populate default input values."""
+
+    GET = "get"
+    LOAD = "load"
+
+
+class GetValueActionTypedDict(TypedDict):
+    value: NotRequired[Nullable[Any]]
+    r"""Initial value of the variable."""
+    value_from: NotRequired[Nullable[GetValueActionValueFrom2TypedDict]]
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+    if_: NotRequired[Nullable[GetValueActionIf2TypedDict]]
+    r"""An expression that must evaluate to true for the action to be applied."""
+    action: NotRequired[GetValueActionAction]
+    r"""Populate default input values."""
+    inputs: NotRequired[Nullable[List[str]]]
+    r"""Input field names to populate; None populates all step inputs."""
+    overwrite: NotRequired[bool]
+    r"""If False (default), only populate empty inputs. If True, always overwrite."""
+
+
+class GetValueAction(BaseModel):
+    value: OptionalNullable[Any] = UNSET
+    r"""Initial value of the variable."""
+
+    value_from: OptionalNullable[GetValueActionValueFrom2] = UNSET
+    r"""Expression to compute initial value (mutually exclusive with value)."""
+
+    if_: Annotated[OptionalNullable[GetValueActionIf2], pydantic.Field(alias="if")] = (
+        UNSET
+    )
+    r"""An expression that must evaluate to true for the action to be applied."""
+
+    action: Optional[GetValueActionAction] = GetValueActionAction.GET
+    r"""Populate default input values."""
+
+    inputs: OptionalNullable[List[str]] = UNSET
+    r"""Input field names to populate; None populates all step inputs."""
+
+    overwrite: Optional[bool] = False
+    r"""If False (default), only populate empty inputs. If True, always overwrite."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["value", "value_from", "if", "action", "inputs", "overwrite"]
+        nullable_fields = ["value", "value_from", "if", "inputs"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

syllable_sdk/models/pronunciationoverridesdictionary.py

@@ -1,11 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .dictionarymetadata import DictionaryMetadata, DictionaryMetadataTypedDict
 from .pronunciationoverride import PronunciationOverride, PronunciationOverrideTypedDict
-from .schemas_tts_v1_pronunciations_dictionarymetadata import (
-    SchemasTtsV1PronunciationsDictionaryMetadata,
-    SchemasTtsV1PronunciationsDictionaryMetadataTypedDict,
-)
 from .voicedisplayinfo import VoiceDisplayInfo, VoiceDisplayInfoTypedDict
 from syllable_sdk.types import BaseModel
 from typing import Dict, List, Optional
@@ -35,7 +32,7 @@ class PronunciationOverridesDictionaryTypedDict(TypedDict):
     """
 
     pronunciations: List[PronunciationOverrideTypedDict]
-    metadata: SchemasTtsV1PronunciationsDictionaryMetadataTypedDict
+    metadata: DictionaryMetadataTypedDict
     r"""Audit metadata associated with a dictionary."""
     type: NotRequired[str]
     voices: NotRequired[Dict[str, VoiceDisplayInfoTypedDict]]
@@ -65,7 +62,7 @@ class PronunciationOverridesDictionary(BaseModel):
 
     pronunciations: List[PronunciationOverride]
 
-    metadata: SchemasTtsV1PronunciationsDictionaryMetadata
+    metadata: DictionaryMetadata
     r"""Audit metadata associated with a dictionary."""
 
     type: Optional[str] = "pronunciations_v1"

syllable_sdk/models/stepeventactions.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .callaction import CallAction, CallActionTypedDict
+from .getvalueaction import GetValueAction, GetValueActionTypedDict
 from .incrementaction import IncrementAction, IncrementActionTypedDict
 from .saveaction import SaveAction, SaveActionTypedDict
 from .sayaction import SayAction, SayActionTypedDict
@@ -22,9 +23,8 @@ from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 StepEventActionsStartTypedDict = TypeAliasType(
     "StepEventActionsStartTypedDict",
     Union[
-        SayActionTypedDict,
-        SaveActionTypedDict,
         IncrementActionTypedDict,
+        SayActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
     ],
@@ -35,7 +35,6 @@ StepEventActionsStart = Annotated[
     Union[
         Annotated[CallAction, Tag("call")],
         Annotated[IncrementAction, Tag("inc")],
-        Annotated[SaveAction, Tag("save")],
         Annotated[SayAction, Tag("say")],
         Annotated[SetValueAction, Tag("set")],
     ],
@@ -48,9 +47,9 @@ EnterTypedDict = TypeAliasType(
     Union[
         IncrementActionTypedDict,
         SayActionTypedDict,
-        SaveActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
+        GetValueActionTypedDict,
     ],
 )
 
@@ -58,8 +57,9 @@ EnterTypedDict = TypeAliasType(
 Enter = Annotated[
     Union[
         Annotated[CallAction, Tag("call")],
+        Annotated[GetValueAction, Tag("get")],
         Annotated[IncrementAction, Tag("inc")],
-        Annotated[SaveAction, Tag("save")],
+        Annotated[GetValueAction, Tag("load")],
         Annotated[SayAction, Tag("say")],
         Annotated[SetValueAction, Tag("set")],
     ],
@@ -69,13 +69,20 @@ Enter = Annotated[
 
 PresubmitTypedDict = TypeAliasType(
     "PresubmitTypedDict",
-    Union[IncrementActionTypedDict, SaveActionTypedDict, SetValueActionTypedDict],
+    Union[
+        IncrementActionTypedDict,
+        SaveActionTypedDict,
+        SetValueActionTypedDict,
+        GetValueActionTypedDict,
+    ],
 )
 
 
 Presubmit = Annotated[
     Union[
+        Annotated[GetValueAction, Tag("get")],
         Annotated[IncrementAction, Tag("inc")],
+        Annotated[GetValueAction, Tag("load")],
         Annotated[SaveAction, Tag("save")],
         Annotated[SetValueAction, Tag("set")],
     ],
@@ -87,8 +94,8 @@ StepEventActionsSubmitTypedDict = TypeAliasType(
     "StepEventActionsSubmitTypedDict",
     Union[
         IncrementActionTypedDict,
-        SayActionTypedDict,
         SaveActionTypedDict,
+        SayActionTypedDict,
         SetValueActionTypedDict,
         CallActionTypedDict,
     ],

syllable_sdk/models/toolparametertransform.py

@@ -19,7 +19,7 @@ from typing import Any, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class Action(str, Enum):
+class ToolParameterTransformAction(str, Enum):
     r"""The action to perform on the tool parameter value: `default` means only set the value (using the `format` field) if the parameter doesn't exist or is empty, `override` means always set the value,\" and `remove` means \"remove the parameter value.\" """
 
     DEFAULT = "default"
@@ -35,7 +35,7 @@ class ToolParameterTransformTypedDict(TypedDict):
     - `format` is a string composed of other parameters or context variables.
     """
 
-    action: NotRequired[Action]
+    action: NotRequired[ToolParameterTransformAction]
     r"""The action to perform on the tool parameter value: `default` means only set the value (using the `format` field) if the parameter doesn't exist or is empty, `override` means always set the value,\" and `remove` means \"remove the parameter value.\" """
     when: NotRequired[Nullable[ToolParameterTransformConditionTypedDict]]
     r"""Only apply the transform if the condition is met."""
@@ -53,7 +53,9 @@ class ToolParameterTransform(BaseModel):
     - `format` is a string composed of other parameters or context variables.
     """
 
-    action: Optional[Action] = Action.DEFAULT
+    action: Optional[ToolParameterTransformAction] = (
+        ToolParameterTransformAction.DEFAULT
+    )
     r"""The action to perform on the tool parameter value: `default` means only set the value (using the `format` field) if the parameter doesn't exist or is empty, `override` means always set the value,\" and `remove` means \"remove the parameter value.\" """
 
     when: OptionalNullable[ToolParameterTransformCondition] = UNSET

syllable_sdk/pronunciations.py

@@ -172,7 +172,7 @@ class Pronunciations(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> models.SchemasTtsV1PronunciationsDictionaryMetadata:
+    ) -> models.DictionaryMetadata:
         r"""Get Pronunciations Metadata
 
         :param retries: Override the default retry configuration for this method
@@ -230,9 +230,7 @@ class Pronunciations(BaseSDK):
         )
 
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                models.SchemasTtsV1PronunciationsDictionaryMetadata, http_res
-            )
+            return unmarshal_json_response(models.DictionaryMetadata, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = utils.stream_to_text(http_res)
             raise errors.APIError("API error occurred", http_res, http_res_text)
@@ -249,7 +247,7 @@ class Pronunciations(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> models.SchemasTtsV1PronunciationsDictionaryMetadata:
+    ) -> models.DictionaryMetadata:
         r"""Get Pronunciations Metadata
 
         :param retries: Override the default retry configuration for this method
@@ -307,9 +305,7 @@ class Pronunciations(BaseSDK):
         )
 
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                models.SchemasTtsV1PronunciationsDictionaryMetadata, http_res
-            )
+            return unmarshal_json_response(models.DictionaryMetadata, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = await utils.stream_to_text_async(http_res)
             raise errors.APIError("API error occurred", http_res, http_res_text)

syllable_sdk/types/basemodel.py

@@ -2,7 +2,8 @@
 
 from pydantic import ConfigDict, model_serializer
 from pydantic import BaseModel as PydanticBaseModel
-from typing import TYPE_CHECKING, Literal, Optional, TypeVar, Union
+from pydantic_core import core_schema
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union
 from typing_extensions import TypeAliasType, TypeAlias
 
 
@@ -35,5 +36,42 @@ else:
         "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
     )
 
-UnrecognizedInt: TypeAlias = int
-UnrecognizedStr: TypeAlias = str
+
+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
+        )