qanswer_sdk 3.1508.0__py3-none-any.whl → 3.1510.0__py3-none-any.whl

qanswer_sdk/models/user.py

@@ -62,6 +62,7 @@ class User(BaseModel):
     user_chatbot_setting: Optional[UserChatbotSetting] = Field(default=None, alias="userChatbotSetting")
     user_llm_features: Optional[UserLlmFeatures] = Field(default=None, alias="userLlmFeatures")
     logo: Optional[Logo] = None
+    selected_org: Optional[Organization] = Field(default=None, alias="selectedOrg")
     user_dataset: Optional[List[UserDataset]] = Field(default=None, alias="userDataset")
     user_dataset_shared: Optional[List[UserDatasetShared]] = Field(default=None, alias="userDatasetShared")
     favorite_dataset: Optional[List[UserDataset]] = Field(default=None, alias="favoriteDataset")
@@ -79,8 +80,8 @@ class User(BaseModel):
     administered_organizations: Optional[List[Organization]] = Field(default=None, alias="administeredOrganizations")
     user_logs: Optional[List[UserLog]] = Field(default=None, alias="userLogs")
     user_info: Optional[UserInfo] = Field(default=None, alias="userInfo")
-    credit_quota_exceeded: Optional[StrictBool] = Field(default=None, alias="creditQuotaExceeded")
-    __properties: ClassVar[List[str]] = ["id", "name", "username", "email", "password", "origin", "enabled", "blocked", "created", "updated", "lastLogin", "stripeCustomerId", "pricingPlan", "dataPackage", "pricingPlanSubscription", "questionCreditsStart", "questionCreditsUsed", "quotaQuestionCredits", "quotaDatasetNumber", "quotaDatasetSpaceMb", "creditCapacity", "creditUsage", "language", "runningOutOfQuotaWarned", "runOutOfQuotaWarned", "removeBranding", "roles", "userChatbotSetting", "userLlmFeatures", "logo", "userDataset", "userDatasetShared", "favoriteDataset", "llmConsumptions", "embedderConsumptions", "authorizedTeamAccesses", "requestedTeamAccesses", "authorizedOrganizationAccesses", "requestedOrganizationAccesses", "verificationTokens", "refreshToken", "teams", "administeredTeams", "organizations", "administeredOrganizations", "userLogs", "userInfo", "creditQuotaExceeded"]
+    selected_org_id: Optional[StrictInt] = Field(default=None, alias="selectedOrgId")
+    __properties: ClassVar[List[str]] = ["id", "name", "username", "email", "password", "origin", "enabled", "blocked", "created", "updated", "lastLogin", "stripeCustomerId", "pricingPlan", "dataPackage", "pricingPlanSubscription", "questionCreditsStart", "questionCreditsUsed", "quotaQuestionCredits", "quotaDatasetNumber", "quotaDatasetSpaceMb", "creditCapacity", "creditUsage", "language", "runningOutOfQuotaWarned", "runOutOfQuotaWarned", "removeBranding", "roles", "userChatbotSetting", "userLlmFeatures", "logo", "selectedOrg", "userDataset", "userDatasetShared", "favoriteDataset", "llmConsumptions", "embedderConsumptions", "authorizedTeamAccesses", "requestedTeamAccesses", "authorizedOrganizationAccesses", "requestedOrganizationAccesses", "verificationTokens", "refreshToken", "teams", "administeredTeams", "organizations", "administeredOrganizations", "userLogs", "userInfo", "selectedOrgId"]
 
     @field_validator('pricing_plan')
     def pricing_plan_validate_enum(cls, value):
@@ -88,8 +89,8 @@ class User(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['NOT_LOGGED', 'FREE', 'BASIC', 'BASIC_DOLLAR', 'BASIC_ANNUAL', 'BASIC_ANNUAL_DOLLAR', 'PROFESSIONAL', 'PROFESSIONAL_DOLLAR', 'PROFESSIONAL_ANNUAL', 'PROFESSIONAL_ANNUAL_DOLLAR', 'CUSTOM', 'UNLIMITED']):
-            raise ValueError("must be one of enum values ('NOT_LOGGED', 'FREE', 'BASIC', 'BASIC_DOLLAR', 'BASIC_ANNUAL', 'BASIC_ANNUAL_DOLLAR', 'PROFESSIONAL', 'PROFESSIONAL_DOLLAR', 'PROFESSIONAL_ANNUAL', 'PROFESSIONAL_ANNUAL_DOLLAR', 'CUSTOM', 'UNLIMITED')")
+        if value not in set(['NOT_LOGGED', 'FREE', 'WORK', 'WORK_DOLLAR', 'WORK_ANNUAL', 'WORK_ANNUAL_DOLLAR', 'BASIC', 'BASIC_DOLLAR', 'BASIC_ANNUAL', 'BASIC_ANNUAL_DOLLAR', 'PROFESSIONAL', 'PROFESSIONAL_DOLLAR', 'PROFESSIONAL_ANNUAL', 'PROFESSIONAL_ANNUAL_DOLLAR', 'CUSTOM', 'UNLIMITED']):
+            raise ValueError("must be one of enum values ('NOT_LOGGED', 'FREE', 'WORK', 'WORK_DOLLAR', 'WORK_ANNUAL', 'WORK_ANNUAL_DOLLAR', 'BASIC', 'BASIC_DOLLAR', 'BASIC_ANNUAL', 'BASIC_ANNUAL_DOLLAR', 'PROFESSIONAL', 'PROFESSIONAL_DOLLAR', 'PROFESSIONAL_ANNUAL', 'PROFESSIONAL_ANNUAL_DOLLAR', 'CUSTOM', 'UNLIMITED')")
         return value
 
     @field_validator('language')
@@ -157,6 +158,9 @@ class User(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of logo
         if self.logo:
             _dict['logo'] = self.logo.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of selected_org
+        if self.selected_org:
+            _dict['selectedOrg'] = self.selected_org.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each item in user_dataset (list)
         _items = []
         if self.user_dataset:
@@ -310,6 +314,7 @@ class User(BaseModel):
             "userChatbotSetting": UserChatbotSetting.from_dict(obj["userChatbotSetting"]) if obj.get("userChatbotSetting") is not None else None,
             "userLlmFeatures": UserLlmFeatures.from_dict(obj["userLlmFeatures"]) if obj.get("userLlmFeatures") is not None else None,
             "logo": Logo.from_dict(obj["logo"]) if obj.get("logo") is not None else None,
+            "selectedOrg": Organization.from_dict(obj["selectedOrg"]) if obj.get("selectedOrg") is not None else None,
             "userDataset": [UserDataset.from_dict(_item) for _item in obj["userDataset"]] if obj.get("userDataset") is not None else None,
             "userDatasetShared": [UserDatasetShared.from_dict(_item) for _item in obj["userDatasetShared"]] if obj.get("userDatasetShared") is not None else None,
             "favoriteDataset": [UserDataset.from_dict(_item) for _item in obj["favoriteDataset"]] if obj.get("favoriteDataset") is not None else None,
@@ -327,7 +332,7 @@ class User(BaseModel):
             "administeredOrganizations": [Organization.from_dict(_item) for _item in obj["administeredOrganizations"]] if obj.get("administeredOrganizations") is not None else None,
             "userLogs": [UserLog.from_dict(_item) for _item in obj["userLogs"]] if obj.get("userLogs") is not None else None,
             "userInfo": UserInfo.from_dict(obj["userInfo"]) if obj.get("userInfo") is not None else None,
-            "creditQuotaExceeded": obj.get("creditQuotaExceeded")
+            "selectedOrgId": obj.get("selectedOrgId")
         })
         return _obj
 

qanswer_sdk/models/user_credits_config_dto.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    QAnswer: Api Documentation
+
+    APIs provided by QAnswer
+
+    The version of the OpenAPI document: 1.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
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserCreditsConfigDto(BaseModel):
+    """
+    UserCreditsConfigDto
+    """ # noqa: E501
+    username: Optional[StrictStr] = None
+    quota_question_credits: Optional[StrictInt] = Field(default=None, alias="quotaQuestionCredits")
+    quota_dataset_number: Optional[StrictInt] = Field(default=None, alias="quotaDatasetNumber")
+    quota_dataset_space_mb: Optional[StrictInt] = Field(default=None, alias="quotaDatasetSpaceMb")
+    credit_capacity: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="creditCapacity")
+    __properties: ClassVar[List[str]] = ["username", "quotaQuestionCredits", "quotaDatasetNumber", "quotaDatasetSpaceMb", "creditCapacity"]
+
+    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 UserCreditsConfigDto 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 UserCreditsConfigDto 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"),
+            "quotaQuestionCredits": obj.get("quotaQuestionCredits"),
+            "quotaDatasetNumber": obj.get("quotaDatasetNumber"),
+            "quotaDatasetSpaceMb": obj.get("quotaDatasetSpaceMb"),
+            "creditCapacity": obj.get("creditCapacity")
+        })
+        return _obj
+
+

qanswer_sdk/models/user_credits_dto.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    QAnswer: Api Documentation
+
+    APIs provided by QAnswer
+
+    The version of the OpenAPI document: 1.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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UserCreditsDto(BaseModel):
+    """
+    UserCreditsDto
+    """ # noqa: E501
+    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")
+    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")
+    __properties: ClassVar[List[str]] = ["quotaDatasetNumber", "quotaDatasetNumberUsed", "quotaDatasetSpaceMb", "quotaDatasetSpaceMbUsed", "questionCreditsStart", "quotaQuestionCredits", "quotaQuestionCreditsUsed", "creditCapacity", "creditUsage"]
+
+    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 UserCreditsDto 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 UserCreditsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "quotaDatasetNumber": obj.get("quotaDatasetNumber"),
+            "quotaDatasetNumberUsed": obj.get("quotaDatasetNumberUsed"),
+            "quotaDatasetSpaceMb": obj.get("quotaDatasetSpaceMb"),
+            "quotaDatasetSpaceMbUsed": obj.get("quotaDatasetSpaceMbUsed"),
+            "questionCreditsStart": obj.get("questionCreditsStart"),
+            "quotaQuestionCredits": obj.get("quotaQuestionCredits"),
+            "quotaQuestionCreditsUsed": obj.get("quotaQuestionCreditsUsed"),
+            "creditCapacity": obj.get("creditCapacity"),
+            "creditUsage": obj.get("creditUsage")
+        })
+        return _obj
+
+

qanswer_sdk/models/user_dataset.py

@@ -46,11 +46,13 @@ class UserDataset(BaseModel):
     shared_users: Optional[List[UserDatasetShared]] = Field(default=None, alias="sharedUsers")
     shared_team_accesses: Optional[List[SharedTeamAccess]] = Field(default=None, alias="sharedTeamAccesses")
     shared_organization_accesses: Optional[List[SharedOrganizationAccess]] = Field(default=None, alias="sharedOrganizationAccesses")
-    access_control_origin_headers: Optional[List[UserDatasetAccessControlOriginHeader]] = Field(default=None, alias="accessControlOriginHeaders")
+    mcp_tool_selections: Optional[List[UserDatasetMcpToolSelection]] = Field(default=None, alias="mcpToolSelections")
+    ai_assistant_restricted_domains: Optional[List[AiAssistantRestrictedDomain]] = Field(default=None, alias="aiAssistantRestrictedDomains")
     entity_description: Optional[EntityDescription] = Field(default=None, alias="entityDescription")
     logo: Optional[Logo] = None
     llm_consumptions: Optional[List[LlmConsumption]] = Field(default=None, alias="llmConsumptions")
-    __properties: ClassVar[List[str]] = ["id", "dataset", "name", "description", "user", "uploaded", "indexed", "access", "accessType", "size", "created", "indexType", "languages", "assistantTemplatePublished", "sharedUsers", "sharedTeamAccesses", "sharedOrganizationAccesses", "accessControlOriginHeaders", "entityDescription", "logo", "llmConsumptions"]
+    embedder_consumptions: Optional[List[EmbedderConsumption]] = Field(default=None, alias="embedderConsumptions")
+    __properties: ClassVar[List[str]] = ["id", "dataset", "name", "description", "user", "uploaded", "indexed", "access", "accessType", "size", "created", "indexType", "languages", "assistantTemplatePublished", "sharedUsers", "sharedTeamAccesses", "sharedOrganizationAccesses", "mcpToolSelections", "aiAssistantRestrictedDomains", "entityDescription", "logo", "llmConsumptions", "embedderConsumptions"]
 
     @field_validator('access_type')
     def access_type_validate_enum(cls, value):
@@ -125,13 +127,20 @@ class UserDataset(BaseModel):
                 if _item_shared_organization_accesses:
                     _items.append(_item_shared_organization_accesses.to_dict())
             _dict['sharedOrganizationAccesses'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in access_control_origin_headers (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in mcp_tool_selections (list)
         _items = []
-        if self.access_control_origin_headers:
-            for _item_access_control_origin_headers in self.access_control_origin_headers:
-                if _item_access_control_origin_headers:
-                    _items.append(_item_access_control_origin_headers.to_dict())
-            _dict['accessControlOriginHeaders'] = _items
+        if self.mcp_tool_selections:
+            for _item_mcp_tool_selections in self.mcp_tool_selections:
+                if _item_mcp_tool_selections:
+                    _items.append(_item_mcp_tool_selections.to_dict())
+            _dict['mcpToolSelections'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in ai_assistant_restricted_domains (list)
+        _items = []
+        if self.ai_assistant_restricted_domains:
+            for _item_ai_assistant_restricted_domains in self.ai_assistant_restricted_domains:
+                if _item_ai_assistant_restricted_domains:
+                    _items.append(_item_ai_assistant_restricted_domains.to_dict())
+            _dict['aiAssistantRestrictedDomains'] = _items
         # override the default output from pydantic by calling `to_dict()` of entity_description
         if self.entity_description:
             _dict['entityDescription'] = self.entity_description.to_dict()
@@ -145,6 +154,13 @@ class UserDataset(BaseModel):
                 if _item_llm_consumptions:
                     _items.append(_item_llm_consumptions.to_dict())
             _dict['llmConsumptions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in embedder_consumptions (list)
+        _items = []
+        if self.embedder_consumptions:
+            for _item_embedder_consumptions in self.embedder_consumptions:
+                if _item_embedder_consumptions:
+                    _items.append(_item_embedder_consumptions.to_dict())
+            _dict['embedderConsumptions'] = _items
         return _dict
 
     @classmethod
@@ -174,18 +190,22 @@ class UserDataset(BaseModel):
             "sharedUsers": [UserDatasetShared.from_dict(_item) for _item in obj["sharedUsers"]] if obj.get("sharedUsers") is not None else None,
             "sharedTeamAccesses": [SharedTeamAccess.from_dict(_item) for _item in obj["sharedTeamAccesses"]] if obj.get("sharedTeamAccesses") is not None else None,
             "sharedOrganizationAccesses": [SharedOrganizationAccess.from_dict(_item) for _item in obj["sharedOrganizationAccesses"]] if obj.get("sharedOrganizationAccesses") is not None else None,
-            "accessControlOriginHeaders": [UserDatasetAccessControlOriginHeader.from_dict(_item) for _item in obj["accessControlOriginHeaders"]] if obj.get("accessControlOriginHeaders") is not None else None,
+            "mcpToolSelections": [UserDatasetMcpToolSelection.from_dict(_item) for _item in obj["mcpToolSelections"]] if obj.get("mcpToolSelections") is not None else None,
+            "aiAssistantRestrictedDomains": [AiAssistantRestrictedDomain.from_dict(_item) for _item in obj["aiAssistantRestrictedDomains"]] if obj.get("aiAssistantRestrictedDomains") is not None else None,
             "entityDescription": EntityDescription.from_dict(obj["entityDescription"]) if obj.get("entityDescription") is not None else None,
             "logo": Logo.from_dict(obj["logo"]) if obj.get("logo") is not None else None,
-            "llmConsumptions": [LlmConsumption.from_dict(_item) for _item in obj["llmConsumptions"]] if obj.get("llmConsumptions") is not None else None
+            "llmConsumptions": [LlmConsumption.from_dict(_item) for _item in obj["llmConsumptions"]] if obj.get("llmConsumptions") is not None else None,
+            "embedderConsumptions": [EmbedderConsumption.from_dict(_item) for _item in obj["embedderConsumptions"]] if obj.get("embedderConsumptions") is not None else None
         })
         return _obj
 
+from qanswer_sdk.models.ai_assistant_restricted_domain import AiAssistantRestrictedDomain
+from qanswer_sdk.models.embedder_consumption import EmbedderConsumption
 from qanswer_sdk.models.llm_consumption import LlmConsumption
 from qanswer_sdk.models.shared_organization_access import SharedOrganizationAccess
 from qanswer_sdk.models.shared_team_access import SharedTeamAccess
 from qanswer_sdk.models.user import User
-from qanswer_sdk.models.user_dataset_access_control_origin_header import UserDatasetAccessControlOriginHeader
+from qanswer_sdk.models.user_dataset_mcp_tool_selection import UserDatasetMcpToolSelection
 from qanswer_sdk.models.user_dataset_shared import UserDatasetShared
 # TODO: Rewrite to not use raise_errors
 UserDataset.model_rebuild(raise_errors=False)

qanswer_sdk/models/{relation_extraction_row_output.py → user_dataset_mcp_tool_selection.py}

@@ -17,22 +17,25 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictInt
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from qanswer_sdk.models.relation_value_output import RelationValueOutput
-from qanswer_sdk.models.subject_model import SubjectModel
 from typing import Optional, Set
 from typing_extensions import Self
 
-class RelationExtractionRowOutput(BaseModel):
+class UserDatasetMcpToolSelection(BaseModel):
     """
-    RelationExtractionRowOutput
+    UserDatasetMcpToolSelection
     """ # noqa: E501
-    subject: Optional[SubjectModel] = None
-    relations: Optional[List[RelationValueOutput]] = None
-    index: Optional[StrictInt] = None
-    row_id: Optional[StrictInt] = None
-    __properties: ClassVar[List[str]] = ["subject", "relations", "index", "row_id"]
+    id: Optional[StrictInt] = None
+    user_dataset: Optional[UserDataset] = Field(default=None, alias="userDataset")
+    mcp_tool: Optional[McpTool] = Field(default=None, alias="mcpTool")
+    enabled: Optional[StrictBool] = None
+    ask_for_confirmation: Optional[StrictBool] = Field(default=None, alias="askForConfirmation")
+    created: Optional[datetime] = None
+    updated: Optional[datetime] = None
+    server_uid: Optional[StrictStr] = Field(default=None, alias="serverUid")
+    __properties: ClassVar[List[str]] = ["id", "userDataset", "mcpTool", "enabled", "askForConfirmation", "created", "updated", "serverUid"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -52,7 +55,7 @@ class RelationExtractionRowOutput(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RelationExtractionRowOutput from a JSON string"""
+        """Create an instance of UserDatasetMcpToolSelection from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,21 +76,17 @@ class RelationExtractionRowOutput(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of subject
-        if self.subject:
-            _dict['subject'] = self.subject.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in relations (list)
-        _items = []
-        if self.relations:
-            for _item_relations in self.relations:
-                if _item_relations:
-                    _items.append(_item_relations.to_dict())
-            _dict['relations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of user_dataset
+        if self.user_dataset:
+            _dict['userDataset'] = self.user_dataset.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of mcp_tool
+        if self.mcp_tool:
+            _dict['mcpTool'] = self.mcp_tool.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RelationExtractionRowOutput from a dict"""
+        """Create an instance of UserDatasetMcpToolSelection from a dict"""
         if obj is None:
             return None
 
@@ -95,11 +94,19 @@ class RelationExtractionRowOutput(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "subject": SubjectModel.from_dict(obj["subject"]) if obj.get("subject") is not None else None,
-            "relations": [RelationValueOutput.from_dict(_item) for _item in obj["relations"]] if obj.get("relations") is not None else None,
-            "index": obj.get("index"),
-            "row_id": obj.get("row_id")
+            "id": obj.get("id"),
+            "userDataset": UserDataset.from_dict(obj["userDataset"]) if obj.get("userDataset") is not None else None,
+            "mcpTool": McpTool.from_dict(obj["mcpTool"]) if obj.get("mcpTool") is not None else None,
+            "enabled": obj.get("enabled"),
+            "askForConfirmation": obj.get("askForConfirmation"),
+            "created": obj.get("created"),
+            "updated": obj.get("updated"),
+            "serverUid": obj.get("serverUid")
         })
         return _obj
 
+from qanswer_sdk.models.mcp_tool import McpTool
+from qanswer_sdk.models.user_dataset import UserDataset
+# TODO: Rewrite to not use raise_errors
+UserDatasetMcpToolSelection.model_rebuild(raise_errors=False)
 

qanswer_sdk/models/user_dataset_mcp_tool_selection_dto.py

@@ -30,11 +30,12 @@ class UserDatasetMcpToolSelectionDto(BaseModel):
     id: Optional[StrictInt] = None
     assistant_id: Optional[StrictInt] = Field(default=None, alias="assistantId")
     tool_uid: Optional[StrictStr] = Field(default=None, alias="toolUid")
+    server_uid: Optional[StrictStr] = Field(default=None, alias="serverUid")
     enabled: Optional[StrictBool] = None
     ask_for_confirmation: Optional[StrictBool] = Field(default=None, alias="askForConfirmation")
     created: Optional[datetime] = None
     updated: Optional[datetime] = None
-    __properties: ClassVar[List[str]] = ["id", "assistantId", "toolUid", "enabled", "askForConfirmation", "created", "updated"]
+    __properties: ClassVar[List[str]] = ["id", "assistantId", "toolUid", "serverUid", "enabled", "askForConfirmation", "created", "updated"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -90,6 +91,7 @@ class UserDatasetMcpToolSelectionDto(BaseModel):
             "id": obj.get("id"),
             "assistantId": obj.get("assistantId"),
             "toolUid": obj.get("toolUid"),
+            "serverUid": obj.get("serverUid"),
             "enabled": obj.get("enabled"),
             "askForConfirmation": obj.get("askForConfirmation"),
             "created": obj.get("created"),

qanswer_sdk/models/user_filter_dto.py

@@ -34,7 +34,8 @@ class UserFilterDto(BaseModel):
     size: Optional[StrictInt] = None
     sort_by: Optional[StrictStr] = Field(default=None, alias="sortBy")
     sort_dir: Optional[StrictStr] = Field(default=None, alias="sortDir")
-    __properties: ClassVar[List[str]] = ["search", "userId", "organizationId", "teamId", "page", "size", "sortBy", "sortDir"]
+    only_org_id: Optional[StrictInt] = Field(default=None, alias="onlyOrgId")
+    __properties: ClassVar[List[str]] = ["search", "userId", "organizationId", "teamId", "page", "size", "sortBy", "sortDir", "onlyOrgId"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -94,7 +95,8 @@ class UserFilterDto(BaseModel):
             "page": obj.get("page"),
             "size": obj.get("size"),
             "sortBy": obj.get("sortBy"),
-            "sortDir": obj.get("sortDir")
+            "sortDir": obj.get("sortDir"),
+            "onlyOrgId": obj.get("onlyOrgId")
         })
         return _obj
 

qanswer_sdk/models/{relation_extraction_row_input.py → user_mcp_tool_selection.py}

@@ -17,22 +17,24 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictInt
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt
 from typing import Any, ClassVar, Dict, List, Optional
-from qanswer_sdk.models.relation_value_input import RelationValueInput
-from qanswer_sdk.models.subject_model import SubjectModel
 from typing import Optional, Set
 from typing_extensions import Self
 
-class RelationExtractionRowInput(BaseModel):
+class UserMcpToolSelection(BaseModel):
     """
-    RelationExtractionRowInput
+    UserMcpToolSelection
     """ # noqa: E501
-    subject: Optional[SubjectModel] = None
-    relations: Optional[List[RelationValueInput]] = None
-    index: Optional[StrictInt] = None
-    row_id: Optional[StrictInt] = None
-    __properties: ClassVar[List[str]] = ["subject", "relations", "index", "row_id"]
+    id: Optional[StrictInt] = None
+    user: Optional[User] = None
+    mcp_tool: Optional[McpTool] = Field(default=None, alias="mcpTool")
+    enabled: Optional[StrictBool] = None
+    ask_for_confirmation: Optional[StrictBool] = Field(default=None, alias="askForConfirmation")
+    created: Optional[datetime] = None
+    updated: Optional[datetime] = None
+    __properties: ClassVar[List[str]] = ["id", "user", "mcpTool", "enabled", "askForConfirmation", "created", "updated"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -52,7 +54,7 @@ class RelationExtractionRowInput(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RelationExtractionRowInput from a JSON string"""
+        """Create an instance of UserMcpToolSelection from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,21 +75,17 @@ class RelationExtractionRowInput(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of subject
-        if self.subject:
-            _dict['subject'] = self.subject.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in relations (list)
-        _items = []
-        if self.relations:
-            for _item_relations in self.relations:
-                if _item_relations:
-                    _items.append(_item_relations.to_dict())
-            _dict['relations'] = _items
+        # override the default output from pydantic by calling `to_dict()` of user
+        if self.user:
+            _dict['user'] = self.user.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of mcp_tool
+        if self.mcp_tool:
+            _dict['mcpTool'] = self.mcp_tool.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RelationExtractionRowInput from a dict"""
+        """Create an instance of UserMcpToolSelection from a dict"""
         if obj is None:
             return None
 
@@ -95,11 +93,18 @@ class RelationExtractionRowInput(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "subject": SubjectModel.from_dict(obj["subject"]) if obj.get("subject") is not None else None,
-            "relations": [RelationValueInput.from_dict(_item) for _item in obj["relations"]] if obj.get("relations") is not None else None,
-            "index": obj.get("index"),
-            "row_id": obj.get("row_id")
+            "id": obj.get("id"),
+            "user": User.from_dict(obj["user"]) if obj.get("user") is not None else None,
+            "mcpTool": McpTool.from_dict(obj["mcpTool"]) if obj.get("mcpTool") is not None else None,
+            "enabled": obj.get("enabled"),
+            "askForConfirmation": obj.get("askForConfirmation"),
+            "created": obj.get("created"),
+            "updated": obj.get("updated")
         })
         return _obj
 
+from qanswer_sdk.models.mcp_tool import McpTool
+from qanswer_sdk.models.user import User
+# TODO: Rewrite to not use raise_errors
+UserMcpToolSelection.model_rebuild(raise_errors=False)
 

qanswer_sdk/models/user_mcp_tool_selection_dto.py

@@ -29,11 +29,12 @@ class UserMcpToolSelectionDto(BaseModel):
     """ # noqa: E501
     id: Optional[StrictInt] = None
     tool_uid: Optional[StrictStr] = Field(default=None, alias="toolUid")
+    server_uid: Optional[StrictStr] = Field(default=None, alias="serverUid")
     enabled: Optional[StrictBool] = None
     ask_for_confirmation: Optional[StrictBool] = Field(default=None, alias="askForConfirmation")
     created: Optional[datetime] = None
     updated: Optional[datetime] = None
-    __properties: ClassVar[List[str]] = ["id", "toolUid", "enabled", "askForConfirmation", "created", "updated"]
+    __properties: ClassVar[List[str]] = ["id", "toolUid", "serverUid", "enabled", "askForConfirmation", "created", "updated"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,6 +89,7 @@ class UserMcpToolSelectionDto(BaseModel):
         _obj = cls.model_validate({
             "id": obj.get("id"),
             "toolUid": obj.get("toolUid"),
+            "serverUid": obj.get("serverUid"),
             "enabled": obj.get("enabled"),
             "askForConfirmation": obj.get("askForConfirmation"),
             "created": obj.get("created"),