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

qanswer_sdk/models/user_profile_dto.py

@@ -0,0 +1,199 @@
+# 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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from qanswer_sdk.models.pricing_plan import PricingPlan
+from qanswer_sdk.models.role import Role
+from qanswer_sdk.models.user_credits_dto import UserCreditsDto
+from qanswer_sdk.models.user_team_dto import UserTeamDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserProfileDto(BaseModel):
+    """
+    UserProfileDto
+    """ # noqa: E501
+    id: StrictInt
+    username: StrictStr
+    name: StrictStr
+    email: StrictStr
+    created: Optional[datetime] = None
+    last_login: Optional[datetime] = Field(default=None, alias="lastLogin")
+    selected_org: Optional[StrictInt] = Field(default=None, alias="selectedOrg")
+    can_unselect_org: Optional[StrictBool] = Field(default=None, alias="canUnselectOrg")
+    quota_dataset_number: Optional[StrictInt] = Field(default=None, alias="quotaDatasetNumber")
+    quota_dataset_number_used: Optional[StrictInt] = Field(default=None, alias="quotaDatasetNumberUsed")
+    quota_dataset_space_mb: Optional[StrictInt] = Field(default=None, alias="quotaDatasetSpaceMb")
+    quota_dataset_space_mb_used: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="quotaDatasetSpaceMbUsed")
+    quota_external_resources: Optional[StrictInt] = Field(default=None, alias="quotaExternalResources")
+    rate_limit_bucket: Optional[StrictInt] = Field(default=None, alias="rateLimitBucket")
+    question_credits_start: Optional[datetime] = Field(default=None, alias="questionCreditsStart")
+    quota_question_credits: Optional[StrictInt] = Field(default=None, alias="quotaQuestionCredits")
+    quota_question_credits_used: Optional[StrictInt] = Field(default=None, alias="quotaQuestionCreditsUsed")
+    credit_capacity: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="creditCapacity")
+    credit_usage: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="creditUsage")
+    role: Optional[List[Role]] = None
+    pricing_plan: Optional[PricingPlan] = Field(default=None, alias="pricingPlan")
+    data_package: Optional[StrictInt] = Field(default=0, alias="dataPackage")
+    pricing_plan_subscription: Optional[datetime] = Field(default=None, alias="pricingPlanSubscription")
+    external_resources_used: Optional[StrictInt] = Field(default=0, alias="externalResourcesUsed")
+    activated: Optional[StrictBool] = False
+    blocked: Optional[StrictBool] = False
+    language: Optional[StrictStr] = None
+    teams: Optional[List[UserTeamDto]] = None
+    organizations: Optional[List[Any]] = None
+    origin: Optional[StrictStr] = None
+    enable_enhanced_context_length: Optional[StrictBool] = Field(default=False, alias="enableEnhancedContextLength")
+    enable_llm_file_parsing: Optional[StrictBool] = Field(default=False, alias="enableLLMFileParsing")
+    user_credits: Optional[UserCreditsDto] = Field(default=None, alias="userCredits")
+    user_profile_completed: Optional[StrictBool] = Field(default=False, alias="userProfileCompleted")
+    has_customer_id: Optional[StrictBool] = Field(default=False, alias="hasCustomerId")
+    can_remove_branding: Optional[StrictBool] = Field(default=False, alias="canRemoveBranding")
+    company: Optional[StrictStr] = None
+    position: Optional[StrictStr] = None
+    country: Optional[StrictStr] = None
+    phone: Optional[StrictStr] = None
+    oauth_logged: Optional[StrictBool] = Field(default=False, alias="oauthLogged")
+    __properties: ClassVar[List[str]] = ["id", "username", "name", "email", "created", "lastLogin", "selectedOrg", "canUnselectOrg", "quotaDatasetNumber", "quotaDatasetNumberUsed", "quotaDatasetSpaceMb", "quotaDatasetSpaceMbUsed", "quotaExternalResources", "rateLimitBucket", "questionCreditsStart", "quotaQuestionCredits", "quotaQuestionCreditsUsed", "creditCapacity", "creditUsage", "role", "pricingPlan", "dataPackage", "pricingPlanSubscription", "externalResourcesUsed", "activated", "blocked", "language", "teams", "organizations", "origin", "enableEnhancedContextLength", "enableLLMFileParsing", "userCredits", "userProfileCompleted", "hasCustomerId", "canRemoveBranding", "company", "position", "country", "phone", "oauthLogged"]
+
+    @field_validator('language')
+    def language_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['en', 'fr', 'de']):
+            raise ValueError("must be one of enum values ('en', 'fr', 'de')")
+        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 UserProfileDto 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 role (list)
+        _items = []
+        if self.role:
+            for _item_role in self.role:
+                if _item_role:
+                    _items.append(_item_role.to_dict())
+            _dict['role'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in teams (list)
+        _items = []
+        if self.teams:
+            for _item_teams in self.teams:
+                if _item_teams:
+                    _items.append(_item_teams.to_dict())
+            _dict['teams'] = _items
+        # override the default output from pydantic by calling `to_dict()` of user_credits
+        if self.user_credits:
+            _dict['userCredits'] = self.user_credits.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserProfileDto 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"),
+            "username": obj.get("username"),
+            "name": obj.get("name"),
+            "email": obj.get("email"),
+            "created": obj.get("created"),
+            "lastLogin": obj.get("lastLogin"),
+            "selectedOrg": obj.get("selectedOrg"),
+            "canUnselectOrg": obj.get("canUnselectOrg"),
+            "quotaDatasetNumber": obj.get("quotaDatasetNumber"),
+            "quotaDatasetNumberUsed": obj.get("quotaDatasetNumberUsed"),
+            "quotaDatasetSpaceMb": obj.get("quotaDatasetSpaceMb"),
+            "quotaDatasetSpaceMbUsed": obj.get("quotaDatasetSpaceMbUsed"),
+            "quotaExternalResources": obj.get("quotaExternalResources"),
+            "rateLimitBucket": obj.get("rateLimitBucket"),
+            "questionCreditsStart": obj.get("questionCreditsStart"),
+            "quotaQuestionCredits": obj.get("quotaQuestionCredits"),
+            "quotaQuestionCreditsUsed": obj.get("quotaQuestionCreditsUsed"),
+            "creditCapacity": obj.get("creditCapacity"),
+            "creditUsage": obj.get("creditUsage"),
+            "role": [Role.from_dict(_item) for _item in obj["role"]] if obj.get("role") is not None else None,
+            "pricingPlan": obj.get("pricingPlan"),
+            "dataPackage": obj.get("dataPackage") if obj.get("dataPackage") is not None else 0,
+            "pricingPlanSubscription": obj.get("pricingPlanSubscription"),
+            "externalResourcesUsed": obj.get("externalResourcesUsed") if obj.get("externalResourcesUsed") is not None else 0,
+            "activated": obj.get("activated") if obj.get("activated") is not None else False,
+            "blocked": obj.get("blocked") if obj.get("blocked") is not None else False,
+            "language": obj.get("language"),
+            "teams": [UserTeamDto.from_dict(_item) for _item in obj["teams"]] if obj.get("teams") is not None else None,
+            "organizations": obj.get("organizations"),
+            "origin": obj.get("origin"),
+            "enableEnhancedContextLength": obj.get("enableEnhancedContextLength") if obj.get("enableEnhancedContextLength") is not None else False,
+            "enableLLMFileParsing": obj.get("enableLLMFileParsing") if obj.get("enableLLMFileParsing") is not None else False,
+            "userCredits": UserCreditsDto.from_dict(obj["userCredits"]) if obj.get("userCredits") is not None else None,
+            "userProfileCompleted": obj.get("userProfileCompleted") if obj.get("userProfileCompleted") is not None else False,
+            "hasCustomerId": obj.get("hasCustomerId") if obj.get("hasCustomerId") is not None else False,
+            "canRemoveBranding": obj.get("canRemoveBranding") if obj.get("canRemoveBranding") is not None else False,
+            "company": obj.get("company"),
+            "position": obj.get("position"),
+            "country": obj.get("country"),
+            "phone": obj.get("phone"),
+            "oauthLogged": obj.get("oauthLogged") if obj.get("oauthLogged") is not None else False
+        })
+        return _obj
+
+

qanswer_sdk/models/user_profile_list_dto.py

@@ -0,0 +1,101 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from qanswer_sdk.models.user_profile_dto import UserProfileDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserProfileListDto(BaseModel):
+    """
+    UserProfileListDto
+    """ # noqa: E501
+    users: Optional[List[UserProfileDto]] = None
+    page: Optional[StrictInt] = None
+    page_size: Optional[StrictInt] = Field(default=None, alias="pageSize")
+    total: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = ["users", "page", "pageSize", "total"]
+
+    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 UserProfileListDto 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 users (list)
+        _items = []
+        if self.users:
+            for _item_users in self.users:
+                if _item_users:
+                    _items.append(_item_users.to_dict())
+            _dict['users'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UserProfileListDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "users": [UserProfileDto.from_dict(_item) for _item in obj["users"]] if obj.get("users") is not None else None,
+            "page": obj.get("page"),
+            "pageSize": obj.get("pageSize"),
+            "total": obj.get("total")
+        })
+        return _obj
+
+

qanswer_sdk/models/user_team_dto.py

@@ -0,0 +1,94 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from qanswer_sdk.models.team_role import TeamRole
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserTeamDto(BaseModel):
+    """
+    UserTeamDto
+    """ # noqa: E501
+    id: StrictInt
+    name: StrictStr
+    team_role: TeamRole = Field(alias="teamRole")
+    organization_id: Optional[StrictInt] = Field(default=None, alias="organizationId")
+    __properties: ClassVar[List[str]] = ["id", "name", "teamRole", "organizationId"]
+
+    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 UserTeamDto 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 UserTeamDto 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"),
+            "teamRole": obj.get("teamRole"),
+            "organizationId": obj.get("organizationId")
+        })
+        return _obj
+
+

qanswer_sdk/models/validation_error.py

@@ -0,0 +1,108 @@
+# 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, Optional
+from qanswer_sdk.models.validation_error_loc_inner import ValidationErrorLocInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ValidationError(BaseModel):
+    """
+    ValidationError
+    """ # noqa: E501
+    loc: List[ValidationErrorLocInner]
+    msg: StrictStr
+    type: StrictStr
+    input: Optional[Any] = None
+    ctx: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[List[str]] = ["loc", "msg", "type", "input", "ctx"]
+
+    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 ValidationError 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 loc (list)
+        _items = []
+        if self.loc:
+            for _item_loc in self.loc:
+                if _item_loc:
+                    _items.append(_item_loc.to_dict())
+            _dict['loc'] = _items
+        # set to None if input (nullable) is None
+        # and model_fields_set contains the field
+        if self.input is None and "input" in self.model_fields_set:
+            _dict['input'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ValidationError from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "loc": [ValidationErrorLocInner.from_dict(_item) for _item in obj["loc"]] if obj.get("loc") is not None else None,
+            "msg": obj.get("msg"),
+            "type": obj.get("type"),
+            "input": obj.get("input"),
+            "ctx": obj.get("ctx")
+        })
+        return _obj
+
+

qanswer_sdk/models/validation_error_loc_inner.py

@@ -0,0 +1,138 @@
+# 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
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, ValidationError, field_validator
+from typing import Optional
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+VALIDATIONERRORLOCINNER_ANY_OF_SCHEMAS = ["int", "str"]
+
+class ValidationErrorLocInner(BaseModel):
+    """
+    ValidationErrorLocInner
+    """
+
+    # data type: str
+    anyof_schema_1_validator: Optional[StrictStr] = None
+    # data type: int
+    anyof_schema_2_validator: Optional[StrictInt] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[Union[int, str]] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = { "int", "str" }
+
+    model_config = {
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_anyof(cls, v):
+        instance = ValidationErrorLocInner.model_construct()
+        error_messages = []
+        # validate data type: str
+        try:
+            instance.anyof_schema_1_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: int
+        try:
+            instance.anyof_schema_2_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        if error_messages:
+            # no match
+            raise ValueError("No match found when setting the actual_instance in ValidationErrorLocInner with anyOf schemas: int, str. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Dict[str, Any]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        # deserialize data into str
+        try:
+            # validation
+            instance.anyof_schema_1_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_1_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into int
+        try:
+            # validation
+            instance.anyof_schema_2_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_2_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if error_messages:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into ValidationErrorLocInner with anyOf schemas: int, str. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], int, str]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

qanswer_sdk/models/warn_visibility.py

@@ -0,0 +1,40 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class WarnVisibility(str, Enum):
+    """
+    Privacy warning signal attached to every conversation response.  Computed from the interaction of a dataset's DataStoragePreference and LogsVisibilityPolicy. When multiple datasets apply, the highest- precedence value wins:     shared > shared_anonymized > incognito > not_shared > none
+    """
+
+    """
+    allowed enum values
+    """
+    SHARED = 'shared'
+    SHARED_ANONYMIZED = 'shared_anonymized'
+    INCOGNITO = 'incognito'
+    NOT_SHARED = 'not_shared'
+    NONE = 'none'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of WarnVisibility from a JSON string"""
+        return cls(json.loads(json_str))
+
+