augstash 0.2.0__py3-none-any.whl

augstash/generated/models/bot_menu_option.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotMenuOption(BaseModel):
+    """
+    BotMenuOption
+    """ # noqa: E501
+    id: Optional[StrictStr] = None
+    label: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "label", "description"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotMenuOption from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotMenuOption from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "label": obj.get("label"),
+            "description": obj.get("description")
+        })
+        return _obj
+
+

augstash/generated/models/bot_node_type_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotNodeTypeResponse(BaseModel):
+    """
+    BotNodeTypeResponse
+    """ # noqa: E501
+    type: Optional[StrictStr] = None
+    label: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["type", "label", "description"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotNodeTypeResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotNodeTypeResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "label": obj.get("label"),
+            "description": obj.get("description")
+        })
+        return _obj
+
+

augstash/generated/models/bot_response.py

@@ -0,0 +1,144 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from uuid import UUID
+from augstash.generated.models.flow_definition import FlowDefinition
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotResponse(BaseModel):
+    """
+    BotResponse
+    """ # noqa: E501
+    id: Optional[UUID] = None
+    name: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    status: Optional[StrictStr] = None
+    trigger_type: Optional[StrictStr] = Field(default=None, alias="triggerType")
+    trigger_keywords: Optional[List[StrictStr]] = Field(default=None, alias="triggerKeywords")
+    channels: Optional[List[StrictStr]] = None
+    published_version: Optional[StrictInt] = Field(default=None, alias="publishedVersion")
+    flow: Optional[FlowDefinition] = None
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["id", "name", "description", "status", "triggerType", "triggerKeywords", "channels", "publishedVersion", "flow", "createdAt", "updatedAt"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['DRAFT', 'ACTIVE', 'PAUSED', 'ARCHIVED']):
+            raise ValueError("must be one of enum values ('DRAFT', 'ACTIVE', 'PAUSED', 'ARCHIVED')")
+        return value
+
+    @field_validator('trigger_type')
+    def trigger_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['KEYWORD', 'DEFAULT', 'INTENT']):
+            raise ValueError("must be one of enum values ('KEYWORD', 'DEFAULT', 'INTENT')")
+        return value
+
+    @field_validator('channels')
+    def channels_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['WHATSAPP', 'SMS', 'EMAIL', 'RCS', 'VOICE', 'INSTAGRAM', 'MESSENGER', 'TELEGRAM']):
+                raise ValueError("each list item must be one of ('WHATSAPP', 'SMS', 'EMAIL', 'RCS', 'VOICE', 'INSTAGRAM', 'MESSENGER', 'TELEGRAM')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of flow
+        if self.flow:
+            _dict['flow'] = self.flow.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "status": obj.get("status"),
+            "triggerType": obj.get("triggerType"),
+            "triggerKeywords": obj.get("triggerKeywords"),
+            "channels": obj.get("channels"),
+            "publishedVersion": obj.get("publishedVersion"),
+            "flow": FlowDefinition.from_dict(obj["flow"]) if obj.get("flow") is not None else None,
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+

augstash/generated/models/bot_simulate_request.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotSimulateRequest(BaseModel):
+    """
+    BotSimulateRequest
+    """ # noqa: E501
+    session_id: Optional[StrictStr] = Field(default=None, alias="sessionId")
+    message: Annotated[str, Field(min_length=1, strict=True)]
+    mode: Optional[StrictStr] = None
+    selection_id: Optional[StrictStr] = Field(default=None, alias="selectionId")
+    __properties: ClassVar[List[str]] = ["sessionId", "message", "mode", "selectionId"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotSimulateRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotSimulateRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sessionId": obj.get("sessionId"),
+            "message": obj.get("message"),
+            "mode": obj.get("mode"),
+            "selectionId": obj.get("selectionId")
+        })
+        return _obj
+
+

augstash/generated/models/bot_simulate_response.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from augstash.generated.models.bot_menu_option import BotMenuOption
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotSimulateResponse(BaseModel):
+    """
+    BotSimulateResponse
+    """ # noqa: E501
+    session_id: Optional[StrictStr] = Field(default=None, alias="sessionId")
+    replies: Optional[List[StrictStr]] = None
+    variables: Optional[Dict[str, StrictStr]] = None
+    status: Optional[StrictStr] = None
+    awaiting_input: Optional[StrictBool] = Field(default=None, alias="awaitingInput")
+    handoff: Optional[StrictBool] = None
+    handoff_reason: Optional[StrictStr] = Field(default=None, alias="handoffReason")
+    current_node_id: Optional[StrictStr] = Field(default=None, alias="currentNodeId")
+    menu_options: Optional[List[BotMenuOption]] = Field(default=None, alias="menuOptions")
+    __properties: ClassVar[List[str]] = ["sessionId", "replies", "variables", "status", "awaitingInput", "handoff", "handoffReason", "currentNodeId", "menuOptions"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotSimulateResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in menu_options (list)
+        _items = []
+        if self.menu_options:
+            for _item_menu_options in self.menu_options:
+                if _item_menu_options:
+                    _items.append(_item_menu_options.to_dict())
+            _dict['menuOptions'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotSimulateResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sessionId": obj.get("sessionId"),
+            "replies": obj.get("replies"),
+            "variables": obj.get("variables"),
+            "status": obj.get("status"),
+            "awaitingInput": obj.get("awaitingInput"),
+            "handoff": obj.get("handoff"),
+            "handoffReason": obj.get("handoffReason"),
+            "currentNodeId": obj.get("currentNodeId"),
+            "menuOptions": [BotMenuOption.from_dict(_item) for _item in obj["menuOptions"]] if obj.get("menuOptions") is not None else None
+        })
+        return _obj
+
+

augstash/generated/models/bot_summary_response.py

@@ -0,0 +1,136 @@
+# coding: utf-8
+
+"""
+    Augstash Public API
+
+    Every /api/** response is wrapped in {success, code, data, message, traceId, timestamp}; the schema shown for an operation is what arrives in `data`, and the SDKs unwrap it. Errors carry a stable `code` - branch on that, never on `message`. Authentication is an ask_live_* key on X-Api-Key, or a bearer token. Operations marked 'Not reachable with an ask_live_* API key' need a user token.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from uuid import UUID
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BotSummaryResponse(BaseModel):
+    """
+    BotSummaryResponse
+    """ # noqa: E501
+    id: Optional[UUID] = None
+    name: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    status: Optional[StrictStr] = None
+    trigger_type: Optional[StrictStr] = Field(default=None, alias="triggerType")
+    channels: Optional[List[StrictStr]] = None
+    published_version: Optional[StrictInt] = Field(default=None, alias="publishedVersion")
+    created_at: Optional[datetime] = Field(default=None, alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, alias="updatedAt")
+    __properties: ClassVar[List[str]] = ["id", "name", "description", "status", "triggerType", "channels", "publishedVersion", "createdAt", "updatedAt"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['DRAFT', 'ACTIVE', 'PAUSED', 'ARCHIVED']):
+            raise ValueError("must be one of enum values ('DRAFT', 'ACTIVE', 'PAUSED', 'ARCHIVED')")
+        return value
+
+    @field_validator('trigger_type')
+    def trigger_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['KEYWORD', 'DEFAULT', 'INTENT']):
+            raise ValueError("must be one of enum values ('KEYWORD', 'DEFAULT', 'INTENT')")
+        return value
+
+    @field_validator('channels')
+    def channels_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['WHATSAPP', 'SMS', 'EMAIL', 'RCS', 'VOICE', 'INSTAGRAM', 'MESSENGER', 'TELEGRAM']):
+                raise ValueError("each list item must be one of ('WHATSAPP', 'SMS', 'EMAIL', 'RCS', 'VOICE', 'INSTAGRAM', 'MESSENGER', 'TELEGRAM')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of BotSummaryResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BotSummaryResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "description": obj.get("description"),
+            "status": obj.get("status"),
+            "triggerType": obj.get("triggerType"),
+            "channels": obj.get("channels"),
+            "publishedVersion": obj.get("publishedVersion"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+