qanswer-sdk 0.46.0.dev0__py3-none-any.whl

qanswer_sdk/models/document_file_delete_by_id_model.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    free-text-client
+
+    QAnswer 2.0 API
+
+    The version of the OpenAPI document: 2.0.0
+    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
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DocumentFileDeleteByIdModel(BaseModel):
+    """
+    DocumentFileDeleteByIdModel
+    """ # noqa: E501
+    username: StrictStr
+    dataset: StrictStr
+    file_ids: List[StrictStr]
+    __properties: ClassVar[List[str]] = ["username", "dataset", "file_ids"]
+
+    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 DocumentFileDeleteByIdModel 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 DocumentFileDeleteByIdModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "username": obj.get("username"),
+            "dataset": obj.get("dataset"),
+            "file_ids": obj.get("file_ids")
+        })
+        return _obj
+
+

qanswer_sdk/models/document_metadata.py

@@ -0,0 +1,173 @@
+# coding: utf-8
+
+"""
+    free-text-client
+
+    QAnswer 2.0 API
+
+    The version of the OpenAPI document: 2.0.0
+    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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DocumentMetadata(BaseModel):
+    """
+    DocumentMetadata
+    """ # noqa: E501
+    file_name: Optional[StrictStr] = Field(default=None, alias="fileName")
+    original_file_name: Optional[StrictStr] = Field(default=None, alias="originalFileName")
+    file_extension: Optional[StrictStr] = Field(default=None, alias="fileExtension")
+    file_id: Optional[StrictStr] = Field(default=None, alias="fileId")
+    connector_type: Optional[StrictStr] = Field(default=None, alias="connectorType")
+    connector_id: Optional[StrictInt] = Field(default=None, alias="connectorId")
+    source: Optional[StrictStr] = None
+    display_name: Optional[StrictStr] = Field(default=None, alias="displayName")
+    title: Optional[StrictStr] = None
+    additional_fields: Optional[Dict[str, StrictStr]] = Field(default=None, alias="additionalFields")
+    do_ocr: Optional[StrictBool] = Field(default=False, alias="doOCR")
+    do_llm: Optional[StrictBool] = Field(default=False, alias="doLLM")
+    tabular_parse_method: Optional[StrictStr] = Field(default=None, alias="tabularParseMethod")
+    transcription_mode: Optional[StrictStr] = Field(default=None, alias="transcriptionMode")
+    __properties: ClassVar[List[str]] = ["fileName", "originalFileName", "fileExtension", "fileId", "connectorType", "connectorId", "source", "displayName", "title", "additionalFields", "doOCR", "doLLM", "tabularParseMethod", "transcriptionMode"]
+
+    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 DocumentMetadata 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,
+        )
+        # set to None if file_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.file_name is None and "file_name" in self.model_fields_set:
+            _dict['fileName'] = None
+
+        # set to None if original_file_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.original_file_name is None and "original_file_name" in self.model_fields_set:
+            _dict['originalFileName'] = None
+
+        # set to None if file_extension (nullable) is None
+        # and model_fields_set contains the field
+        if self.file_extension is None and "file_extension" in self.model_fields_set:
+            _dict['fileExtension'] = None
+
+        # set to None if file_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.file_id is None and "file_id" in self.model_fields_set:
+            _dict['fileId'] = None
+
+        # set to None if connector_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.connector_type is None and "connector_type" in self.model_fields_set:
+            _dict['connectorType'] = None
+
+        # set to None if connector_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.connector_id is None and "connector_id" in self.model_fields_set:
+            _dict['connectorId'] = None
+
+        # set to None if source (nullable) is None
+        # and model_fields_set contains the field
+        if self.source is None and "source" in self.model_fields_set:
+            _dict['source'] = None
+
+        # set to None if display_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.display_name is None and "display_name" in self.model_fields_set:
+            _dict['displayName'] = None
+
+        # set to None if title (nullable) is None
+        # and model_fields_set contains the field
+        if self.title is None and "title" in self.model_fields_set:
+            _dict['title'] = None
+
+        # set to None if additional_fields (nullable) is None
+        # and model_fields_set contains the field
+        if self.additional_fields is None and "additional_fields" in self.model_fields_set:
+            _dict['additionalFields'] = None
+
+        # set to None if tabular_parse_method (nullable) is None
+        # and model_fields_set contains the field
+        if self.tabular_parse_method is None and "tabular_parse_method" in self.model_fields_set:
+            _dict['tabularParseMethod'] = None
+
+        # set to None if transcription_mode (nullable) is None
+        # and model_fields_set contains the field
+        if self.transcription_mode is None and "transcription_mode" in self.model_fields_set:
+            _dict['transcriptionMode'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DocumentMetadata from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fileName": obj.get("fileName"),
+            "originalFileName": obj.get("originalFileName"),
+            "fileExtension": obj.get("fileExtension"),
+            "fileId": obj.get("fileId"),
+            "connectorType": obj.get("connectorType"),
+            "connectorId": obj.get("connectorId"),
+            "source": obj.get("source"),
+            "displayName": obj.get("displayName"),
+            "title": obj.get("title"),
+            "additionalFields": obj.get("additionalFields"),
+            "doOCR": obj.get("doOCR") if obj.get("doOCR") is not None else False,
+            "doLLM": obj.get("doLLM") if obj.get("doLLM") is not None else False,
+            "tabularParseMethod": obj.get("tabularParseMethod"),
+            "transcriptionMode": obj.get("transcriptionMode")
+        })
+        return _obj
+
+

qanswer_sdk/models/document_metadata_list_wrapper.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+    free-text-client
+
+    QAnswer 2.0 API
+
+    The version of the OpenAPI document: 2.0.0
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from qanswer_sdk.models.document_metadata import DocumentMetadata
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DocumentMetadataListWrapper(BaseModel):
+    """
+    DocumentMetadataListWrapper
+    """ # noqa: E501
+    metadata: Optional[List[DocumentMetadata]] = None
+    __properties: ClassVar[List[str]] = ["metadata"]
+
+    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 DocumentMetadataListWrapper 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 metadata (list)
+        _items = []
+        if self.metadata:
+            for _item_metadata in self.metadata:
+                if _item_metadata:
+                    _items.append(_item_metadata.to_dict())
+            _dict['metadata'] = _items
+        # set to None if metadata (nullable) is None
+        # and model_fields_set contains the field
+        if self.metadata is None and "metadata" in self.model_fields_set:
+            _dict['metadata'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DocumentMetadataListWrapper from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "metadata": [DocumentMetadata.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None
+        })
+        return _obj
+
+

qanswer_sdk/models/document_parsing_task_settings.py

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+    free-text-client
+
+    QAnswer 2.0 API
+
+    The version of the OpenAPI document: 2.0.0
+    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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from qanswer_sdk.models.llm_endpoint_read_output import LLMEndpointReadOutput
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DocumentParsingTaskSettings(BaseModel):
+    """
+    DocumentParsingTaskSettings
+    """ # noqa: E501
+    prompt: Optional[StrictStr] = None
+    bot_seed: Optional[StrictInt] = None
+    bot_temperature: Optional[Union[StrictFloat, StrictInt]] = None
+    bot_answer_length: Optional[StrictStr] = 'brief'
+    number_of_references: Optional[StrictInt] = None
+    stream_speed: Optional[Union[StrictFloat, StrictInt]] = None
+    context_window: Optional[StrictInt] = None
+    max_tokens: Optional[StrictInt] = None
+    slots_values: Optional[Dict[str, StrictStr]] = None
+    bot_name: Optional[StrictStr] = None
+    bot_description: Optional[StrictStr] = None
+    llm_id: Optional[StrictInt] = Field(default=None, description="The LLM ID. This field is populated based on the llm_choice.")
+    llm_endpoint: Optional[LLMEndpointReadOutput] = Field(default=None, description="The LLM endpoint details. This field is populated based on the llm_choice.")
+    max_images_per_request: Optional[Annotated[int, Field(strict=True, ge=1)]] = 1
+    max_images_per_request_override: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["prompt", "bot_seed", "bot_temperature", "bot_answer_length", "number_of_references", "stream_speed", "context_window", "max_tokens", "slots_values", "bot_name", "bot_description", "llm_id", "llm_endpoint", "max_images_per_request", "max_images_per_request_override"]
+
+    @field_validator('bot_answer_length')
+    def bot_answer_length_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['short', 'brief', 'long']):
+            raise ValueError("must be one of enum values ('short', 'brief', 'long')")
+        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 DocumentParsingTaskSettings 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 llm_endpoint
+        if self.llm_endpoint:
+            _dict['llm_endpoint'] = self.llm_endpoint.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DocumentParsingTaskSettings from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "prompt": obj.get("prompt"),
+            "bot_seed": obj.get("bot_seed"),
+            "bot_temperature": obj.get("bot_temperature"),
+            "bot_answer_length": obj.get("bot_answer_length") if obj.get("bot_answer_length") is not None else 'brief',
+            "number_of_references": obj.get("number_of_references"),
+            "stream_speed": obj.get("stream_speed"),
+            "context_window": obj.get("context_window"),
+            "max_tokens": obj.get("max_tokens"),
+            "slots_values": obj.get("slots_values"),
+            "bot_name": obj.get("bot_name"),
+            "bot_description": obj.get("bot_description"),
+            "llm_id": obj.get("llm_id"),
+            "llm_endpoint": LLMEndpointReadOutput.from_dict(obj["llm_endpoint"]) if obj.get("llm_endpoint") is not None else None,
+            "max_images_per_request": obj.get("max_images_per_request") if obj.get("max_images_per_request") is not None else 1,
+            "max_images_per_request_override": obj.get("max_images_per_request_override")
+        })
+        return _obj
+
+

qanswer_sdk/models/document_parsing_task_settings_update_payload.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    free-text-client
+
+    QAnswer 2.0 API
+
+    The version of the OpenAPI document: 2.0.0
+    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
+from qanswer_sdk.models.document_parsing_task_update import DocumentParsingTaskUpdate
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DocumentParsingTaskSettingsUpdatePayload(BaseModel):
+    """
+    DocumentParsingTaskSettingsUpdatePayload
+    """ # noqa: E501
+    username: StrictStr
+    dataset: StrictStr
+    configs: DocumentParsingTaskUpdate
+    __properties: ClassVar[List[str]] = ["username", "dataset", "configs"]
+
+    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 DocumentParsingTaskSettingsUpdatePayload 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 configs
+        if self.configs:
+            _dict['configs'] = self.configs.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DocumentParsingTaskSettingsUpdatePayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "username": obj.get("username"),
+            "dataset": obj.get("dataset"),
+            "configs": DocumentParsingTaskUpdate.from_dict(obj["configs"]) if obj.get("configs") is not None else None
+        })
+        return _obj
+
+