Skip to content

Models

text2everything_sdk.models.base

Base models for the Text2Everything SDK.

AutoFeedbackConfig

Bases: BaseModel

Auto feedback configuration.

Source code in models/base.py 
53
54
55
56
57
class AutoFeedbackConfig(BaseModel):
    """Auto feedback configuration."""

    positive: bool = False
    negative: bool = False

BaseModel

Bases: BaseModel

Base model with common configuration.

Source code in models/base.py 
10
11
12
13
14
15
16
class BaseModel(PydanticBaseModel):
    """Base model with common configuration."""

    class Config:
        from_attributes = True
        use_enum_values = True
        validate_assignment = True

BaseResponse

Bases: BaseModel

Base response model with common fields.

Source code in models/base.py 
19
20
21
22
23
24
class BaseResponse(BaseModel):
    """Base response model with common fields."""

    id: str
    created_at: datetime
    updated_at: Optional[datetime] = None

ErrorResponse

Bases: BaseModel

Error response model.

Source code in models/base.py 
45
46
47
48
49
50
class ErrorResponse(BaseModel):
    """Error response model."""

    error: str
    detail: Optional[str] = None
    status_code: Optional[int] = None

MessageResponse

Bases: BaseModel

Generic message response.

Source code in models/base.py 
39
40
41
42
class MessageResponse(BaseModel):
    """Generic message response."""

    message: str

PaginatedResponse

Bases: BaseModel

Generic paginated response model.

Source code in models/base.py 
27
28
29
30
31
32
33
34
35
36
class PaginatedResponse(BaseModel):
    """Generic paginated response model."""

    items: List[Dict[str, Any]]
    total: int
    page: int = 1
    per_page: int = 50
    pages: int
    has_next: bool
    has_prev: bool

text2everything_sdk.models.projects

Project models for the Text2Everything SDK.

Project

Bases: ProjectBase, BaseResponse

Complete project model with all fields.

Source code in models/projects.py 
28
29
30
class Project(ProjectBase, BaseResponse):
    """Complete project model with all fields."""
    pass

ProjectBase

Bases: BaseModel

Base project model.

Source code in models/projects.py 
 9
10
11
12
13
class ProjectBase(BaseModel):
    """Base project model."""

    name: str
    description: Optional[str] = None

ProjectCreate

Bases: ProjectBase

Model for creating a new project.

Source code in models/projects.py 
16
17
18
class ProjectCreate(ProjectBase):
    """Model for creating a new project."""
    pass

ProjectUpdate

Bases: BaseModel

Model for updating a project.

Source code in models/projects.py 
21
22
23
24
25
class ProjectUpdate(BaseModel):
    """Model for updating a project."""

    name: Optional[str] = None
    description: Optional[str] = None

text2everything_sdk.models.contexts

Context models for the Text2Everything SDK.

Context

Bases: ContextBase, BaseResponse

Complete context model with all fields.

Source code in models/contexts.py 
32
33
34
35
36
class Context(ContextBase, BaseResponse):
    """Complete context model with all fields."""

    project_id: str
    h2ogpte_doc_id: Optional[str] = None

ContextBase

Bases: BaseModel

Base context model.

Source code in models/contexts.py 
 9
10
11
12
13
14
15
class ContextBase(BaseModel):
    """Base context model."""

    name: str
    description: Optional[str] = None
    content: str
    is_always_displayed: bool = False

ContextCreate

Bases: ContextBase

Model for creating a new context.

Source code in models/contexts.py 
18
19
20
class ContextCreate(ContextBase):
    """Model for creating a new context."""
    pass

ContextResponse

Bases: Context

Context response with collection ID.

Source code in models/contexts.py 
39
40
41
42
class ContextResponse(Context):
    """Context response with collection ID."""

    collection_id: Optional[str] = None

ContextUpdate

Bases: BaseModel

Model for updating a context.

Source code in models/contexts.py 
23
24
25
26
27
28
29
class ContextUpdate(BaseModel):
    """Model for updating a context."""

    name: Optional[str] = None
    description: Optional[str] = None
    content: Optional[str] = None
    is_always_displayed: Optional[bool] = None

text2everything_sdk.models.schema_metadata

Schema metadata models for the Text2Everything SDK.

SchemaMetadata

Bases: SchemaMetadataBase, BaseResponse

Complete schema metadata model with all fields.

Source code in models/schema_metadata.py 
32
33
34
35
36
class SchemaMetadata(SchemaMetadataBase, BaseResponse):
    """Complete schema metadata model with all fields."""

    project_id: str
    h2ogpte_doc_id: Optional[str] = None

SchemaMetadataBase

Bases: BaseModel

Base schema metadata model.

Source code in models/schema_metadata.py 
 9
10
11
12
13
14
15
class SchemaMetadataBase(BaseModel):
    """Base schema metadata model."""

    name: str
    description: Optional[str] = None
    schema_data: Dict[str, Any]
    is_always_displayed: bool = False

SchemaMetadataCreate

Bases: SchemaMetadataBase

Model for creating new schema metadata.

Source code in models/schema_metadata.py 
18
19
20
class SchemaMetadataCreate(SchemaMetadataBase):
    """Model for creating new schema metadata."""
    pass

SchemaMetadataResponse

Bases: SchemaMetadata

Schema metadata response with collection ID.

Source code in models/schema_metadata.py 
39
40
41
42
class SchemaMetadataResponse(SchemaMetadata):
    """Schema metadata response with collection ID."""

    collection_id: Optional[str] = None

SchemaMetadataUpdate

Bases: BaseModel

Model for updating schema metadata.

Source code in models/schema_metadata.py 
23
24
25
26
27
28
29
class SchemaMetadataUpdate(BaseModel):
    """Model for updating schema metadata."""

    name: Optional[str] = None
    description: Optional[str] = None
    schema_data: Optional[Dict[str, Any]] = None
    is_always_displayed: Optional[bool] = None

detect_schema_type(schema_data)

Detect the type of schema based on its structure.

Source code in models/schema_metadata.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
def detect_schema_type(schema_data: Dict[str, Any]) -> Optional[str]:
    """Detect the type of schema based on its structure."""
    if "table" in schema_data:
        table = schema_data["table"]
        if isinstance(table, dict):
            if "dimension" in table:
                return "dimension"
            elif "metric" in table:
                return "metric"
            elif "columns" in table:
                return "table"
    elif "relationship" in schema_data:
        return "relationship"

    return None

validate_dimension_schema(schema_data)

Validate dimension schema structure.

Requirements: - schema_data.table (object) - schema_data.table.dimension (object) - schema_data.table.dimension.content (object)

Source code in models/schema_metadata.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
def validate_dimension_schema(schema_data: Dict[str, Any]) -> list[str]:
    """Validate dimension schema structure.

    Requirements:
    - schema_data.table (object)
    - schema_data.table.dimension (object)
    - schema_data.table.dimension.content (object)
    """
    errors = []

    # Check schema_data.table
    if "table" not in schema_data:
        errors.append("Missing required field: schema_data.table")
        return errors

    table = schema_data["table"]
    if not isinstance(table, dict):
        errors.append("Field schema_data.table must be an object")
        return errors

    # Check schema_data.table.dimension
    if "dimension" not in table:
        errors.append("Missing required field: schema_data.table.dimension")
        return errors

    dimension = table["dimension"]
    if not isinstance(dimension, dict):
        errors.append("Field schema_data.table.dimension must be an object")
        return errors

    # Check schema_data.table.dimension.content
    if "content" not in dimension:
        errors.append("Missing required field: schema_data.table.dimension.content")
    elif not isinstance(dimension["content"], dict):
        errors.append("Field schema_data.table.dimension.content must be an object")

    return errors

validate_metric_schema(schema_data)

Validate metric schema structure.

Requirements: - schema_data.table (object) - schema_data.table.metric (object) - schema_data.table.metric.content (object)

Source code in models/schema_metadata.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
def validate_metric_schema(schema_data: Dict[str, Any]) -> list[str]:
    """Validate metric schema structure.

    Requirements:
    - schema_data.table (object)
    - schema_data.table.metric (object)
    - schema_data.table.metric.content (object)
    """
    errors = []

    # Check schema_data.table
    if "table" not in schema_data:
        errors.append("Missing required field: schema_data.table")
        return errors

    table = schema_data["table"]
    if not isinstance(table, dict):
        errors.append("Field schema_data.table must be an object")
        return errors

    # Check schema_data.table.metric
    if "metric" not in table:
        errors.append("Missing required field: schema_data.table.metric")
        return errors

    metric = table["metric"]
    if not isinstance(metric, dict):
        errors.append("Field schema_data.table.metric must be an object")
        return errors

    # Check schema_data.table.metric.content
    if "content" not in metric:
        errors.append("Missing required field: schema_data.table.metric.content")
    elif not isinstance(metric["content"], dict):
        errors.append("Field schema_data.table.metric.content must be an object")

    return errors

validate_relationship_schema(schema_data)

Validate relationship schema structure.

Requirements: - schema_data.relationship (object)

Source code in models/schema_metadata.py 
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
def validate_relationship_schema(schema_data: Dict[str, Any]) -> list[str]:
    """Validate relationship schema structure.

    Requirements:
    - schema_data.relationship (object)
    """
    errors = []

    # Check schema_data.relationship
    if "relationship" not in schema_data:
        errors.append("Missing required field: schema_data.relationship")
        return errors

    relationship = schema_data["relationship"]
    if not isinstance(relationship, dict):
        errors.append("Field schema_data.relationship must be an object")

    return errors

validate_schema_metadata(schema_metadata, expected_type=None)

Validate schema metadata with nested required field checks.

Parameters:

Name Type Description Default
schema_metadata Dict[str, Any]

The schema metadata dictionary to validate

 required
expected_type Optional[str]

Optional expected type ('table', 'dimension', 'metric', 'relationship') If not provided, will auto-detect from schema_data structure

 None

Returns:

Type Description
list[str]

List of validation error messages. Empty list means validation passed.
Source code in models/schema_metadata.py 
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
def validate_schema_metadata(schema_metadata: Dict[str, Any], expected_type: Optional[str] = None) -> list[str]:
    """Validate schema metadata with nested required field checks.

    Args:
        schema_metadata: The schema metadata dictionary to validate
        expected_type: Optional expected type ('table', 'dimension', 'metric', 'relationship')
                      If not provided, will auto-detect from schema_data structure

    Returns:
        List of validation error messages. Empty list means validation passed.
    """
    errors = []

    # Basic structure validation
    if not isinstance(schema_metadata, dict):
        errors.append("Schema metadata must be an object")
        return errors

    # Check required top-level fields
    required_fields = ["name", "schema_data"]
    for field in required_fields:
        if field not in schema_metadata:
            errors.append(f"Missing required field: {field}")

    # Validate schema_data exists and is an object
    if "schema_data" not in schema_metadata:
        return errors  # Can't continue without schema_data

    schema_data = schema_metadata["schema_data"]
    if not isinstance(schema_data, dict):
        errors.append("Field schema_data must be an object")
        return errors

    # Detect or use provided schema type
    schema_type = expected_type or detect_schema_type(schema_data)

    if not schema_type:
        errors.append("Unable to determine schema type from schema_data structure")
        return errors

    # Apply type-specific validation with nested field checks
    if schema_type == "table":
        validation_errors = validate_table_schema(schema_data)
        errors.extend(validation_errors)
    elif schema_type == "dimension":
        validation_errors = validate_dimension_schema(schema_data)
        errors.extend(validation_errors)
    elif schema_type == "metric":
        validation_errors = validate_metric_schema(schema_data)
        errors.extend(validation_errors)
    elif schema_type == "relationship":
        validation_errors = validate_relationship_schema(schema_data)
        errors.extend(validation_errors)
    else:
        errors.append(f"Unknown schema type: {schema_type}")

    return errors

validate_schema_metadata_create(schema_metadata_create)

Validate a SchemaMetadataCreate object with nested field validation.

Source code in models/schema_metadata.py 
248
249
250
251
252
def validate_schema_metadata_create(schema_metadata_create: SchemaMetadataCreate) -> list[str]:
    """Validate a SchemaMetadataCreate object with nested field validation."""
    # Convert Pydantic model to dict for validation
    schema_dict = schema_metadata_create.model_dump()
    return validate_schema_metadata(schema_dict)

validate_schema_metadata_update(schema_metadata_update)

Validate a SchemaMetadataUpdate object with nested field validation.

Source code in models/schema_metadata.py 
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
def validate_schema_metadata_update(schema_metadata_update: SchemaMetadataUpdate) -> list[str]:
    """Validate a SchemaMetadataUpdate object with nested field validation."""
    errors = []

    # Convert Pydantic model to dict for validation
    schema_dict = schema_metadata_update.model_dump(exclude_unset=True)

    # If schema_data is being updated, validate it
    if "schema_data" in schema_dict and schema_dict["schema_data"] is not None:
        # For updates, we need to validate the schema_data structure
        schema_data = schema_dict["schema_data"]
        if not isinstance(schema_data, dict):
            errors.append("Field schema_data must be an object")
            return errors

        # Detect schema type and validate
        schema_type = detect_schema_type(schema_data)
        if schema_type:
            if schema_type == "table":
                validation_errors = validate_table_schema(schema_data)
                errors.extend(validation_errors)
            elif schema_type == "dimension":
                validation_errors = validate_dimension_schema(schema_data)
                errors.extend(validation_errors)
            elif schema_type == "metric":
                validation_errors = validate_metric_schema(schema_data)
                errors.extend(validation_errors)
            elif schema_type == "relationship":
                validation_errors = validate_relationship_schema(schema_data)
                errors.extend(validation_errors)
        else:
            errors.append("Unable to determine schema type from schema_data structure")

    return errors

validate_table_schema(schema_data)

Validate table schema structure.

Requirements: - schema_data.table (object) - schema_data.table.columns (array)

Source code in models/schema_metadata.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
def validate_table_schema(schema_data: Dict[str, Any]) -> list[str]:
    """Validate table schema structure.

    Requirements:
    - schema_data.table (object)
    - schema_data.table.columns (array)
    """
    errors = []

    # Check schema_data.table
    if "table" not in schema_data:
        errors.append("Missing required field: schema_data.table")
        return errors

    table = schema_data["table"]
    if not isinstance(table, dict):
        errors.append("Field schema_data.table must be an object")
        return errors

    # Check schema_data.table.columns
    if "columns" not in table:
        errors.append("Missing required field: schema_data.table.columns")
    elif not isinstance(table["columns"], list):
        errors.append("Field schema_data.table.columns must be an array")

    return errors

text2everything_sdk.models.golden_examples

Golden examples models for the Text2Everything SDK.

GoldenExample

Bases: GoldenExampleBase, BaseResponse

Complete golden example model with all fields.

Source code in models/golden_examples.py 
32
33
34
35
36
class GoldenExample(GoldenExampleBase, BaseResponse):
    """Complete golden example model with all fields."""

    project_id: str
    h2ogpte_doc_id: Optional[str] = None

GoldenExampleBase

Bases: BaseModel

Base golden example model.

Source code in models/golden_examples.py 
 9
10
11
12
13
14
15
class GoldenExampleBase(BaseModel):
    """Base golden example model."""

    user_query: str
    sql_query: str
    description: Optional[str] = None
    is_always_displayed: bool = False

GoldenExampleCreate

Bases: GoldenExampleBase

Model for creating a new golden example.

Source code in models/golden_examples.py 
18
19
20
class GoldenExampleCreate(GoldenExampleBase):
    """Model for creating a new golden example."""
    pass

GoldenExampleResponse

Bases: GoldenExample

Golden example response with collection ID.

Source code in models/golden_examples.py 
39
40
41
42
class GoldenExampleResponse(GoldenExample):
    """Golden example response with collection ID."""

    collection_id: Optional[str] = None

GoldenExampleUpdate

Bases: BaseModel

Model for updating a golden example.

Source code in models/golden_examples.py 
23
24
25
26
27
28
29
class GoldenExampleUpdate(BaseModel):
    """Model for updating a golden example."""

    user_query: Optional[str] = None
    sql_query: Optional[str] = None
    description: Optional[str] = None
    is_always_displayed: Optional[bool] = None

text2everything_sdk.models.connectors

Connectors models for the Text2Everything SDK.

Connector

Bases: ConnectorBase, BaseResponse

Complete connector model with all fields.

Source code in models/connectors.py 
51
52
53
class Connector(ConnectorBase, BaseResponse):
    """Complete connector model with all fields."""
    pass

ConnectorBase

Bases: BaseModel

Base connector model.

Source code in models/connectors.py 
18
19
20
21
22
23
24
25
26
27
28
29
class ConnectorBase(BaseModel):
    """Base connector model."""

    name: str
    description: Optional[str] = None
    db_type: str
    host: str
    port: Optional[int] = None
    username: str
    password: str
    database: str
    config: Optional[Dict[str, Any]] = None

ConnectorCreate

Bases: ConnectorBase

Model for creating a new connector.

Source code in models/connectors.py 
32
33
34
class ConnectorCreate(ConnectorBase):
    """Model for creating a new connector."""
    pass

ConnectorType

Bases: str, Enum

Supported database connector types.

Source code in models/connectors.py 
10
11
12
13
14
15
class ConnectorType(str, Enum):
    """Supported database connector types."""
    SNOWFLAKE = "snowflake"
    SQLSERVER = "sqlserver"
    POSTGRES = "postgres"
    MYSQL = "mysql"

ConnectorUpdate

Bases: BaseModel

Model for updating a connector.

Source code in models/connectors.py 
37
38
39
40
41
42
43
44
45
46
47
48
class ConnectorUpdate(BaseModel):
    """Model for updating a connector."""

    name: Optional[str] = None
    description: Optional[str] = None
    db_type: Optional[str] = None
    host: Optional[str] = None
    port: Optional[int] = None
    username: Optional[str] = None
    password: Optional[str] = None
    database: Optional[str] = None
    config: Optional[Dict[str, Any]] = None

text2everything_sdk.models.chat_sessions

Chat sessions models for the Text2Everything SDK.

ChatSessionCreate

Bases: BaseModel

Model for creating a new chat session.

Source code in models/chat_sessions.py 
10
11
12
13
14
class ChatSessionCreate(BaseModel):
    """Model for creating a new chat session."""

    name: Optional[str] = None
    custom_tool_id: Optional[str] = None

ChatSessionQuestion

Bases: BaseModel

Model for chat session question.

Source code in models/chat_sessions.py 
32
33
34
35
class ChatSessionQuestion(BaseModel):
    """Model for chat session question."""

    question: str

ChatSessionQuestionsResponse

Bases: BaseModel

Model for chat session questions response.

Source code in models/chat_sessions.py 
38
39
40
41
42
class ChatSessionQuestionsResponse(BaseModel):
    """Model for chat session questions response."""

    session_id: str
    questions: List[ChatSessionQuestion]

ChatSessionResponse

Bases: BaseModel

Model for chat session response.

Source code in models/chat_sessions.py 
17
18
19
20
21
22
23
class ChatSessionResponse(BaseModel):
    """Model for chat session response."""

    id: str
    name: Optional[str] = None
    created_at: datetime
    custom_tool_id: Optional[str] = None

ChatSessionUpdateRequest

Bases: BaseModel

Model for updating a chat session.

Source code in models/chat_sessions.py 
26
27
28
29
class ChatSessionUpdateRequest(BaseModel):
    """Model for updating a chat session."""

    custom_tool_id: Optional[str] = None

text2everything_sdk.models.chat

Chat models for the Text2Everything SDK.

AutoFeedbackConfig

Bases: BaseModel

Configuration for automatic feedback submission.

Source code in models/chat.py 
10
11
12
13
14
class AutoFeedbackConfig(BaseModel):
    """Configuration for automatic feedback submission."""

    positive: bool = False
    negative: bool = False

ChatRequest

Bases: BaseModel

Model for chat request.

Source code in models/chat.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class ChatRequest(BaseModel):
    """Model for chat request."""

    query: str
    llm: Optional[str] = None
    context_id: Optional[str] = None
    schema_metadata_id: Optional[str] = None
    connector_id: Optional[str] = None
    example_id: Optional[str] = None
    # RAG retrieval limits
    contexts_limit: Optional[int] = None
    schema_limit: Optional[int] = None
    feedback_limit: Optional[int] = None
    examples_limit: Optional[int] = None
    # LLM agent parameters
    use_agent: Optional[bool] = None
    agent_accuracy: Optional[str] = None

ChatResponse

Bases: ChatResponseBase

Complete chat response model.

Source code in models/chat.py 
52
53
54
class ChatResponse(ChatResponseBase):
    """Complete chat response model."""
    pass

ChatResponseBase

Bases: BaseModel

Base chat response model.

Source code in models/chat.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class ChatResponseBase(BaseModel):
    """Base chat response model."""

    id: str
    project_id: str
    chat_session_id: Optional[str] = None
    user_query: str
    sql_query: Optional[str] = None
    explanation: Optional[str] = None
    agent_tool_response: Optional[str] = None
    context_id: Optional[str] = None
    schema_metadata_id: Optional[str] = None
    connector_id: Optional[str] = None
    example_id: Optional[str] = None

ChatToAnswerRequest

Bases: ChatRequest

Model for chat-to-answer request.

Source code in models/chat.py 
57
58
59
60
61
class ChatToAnswerRequest(ChatRequest):
    """Model for chat-to-answer request."""

    auto_add_feedback: AutoFeedbackConfig = AutoFeedbackConfig()
    custom_tool_id: Optional[str] = None

ChatToAnswerResponse

Bases: ChatResponseBase

Model for chat-to-answer response.

Source code in models/chat.py 
64
65
66
67
68
class ChatToAnswerResponse(ChatResponseBase):
    """Model for chat-to-answer response."""

    execution_result: Optional[SQLExecuteResponse] = None
    feedback: Optional[Dict[str, Any]] = None

text2everything_sdk.models.executions

Executions models for the Text2Everything SDK.

Execution

Bases: ExecutionBase, BaseResponse

Complete execution model with all fields.

Source code in models/executions.py 
43
44
45
class Execution(ExecutionBase, BaseResponse):
    """Complete execution model with all fields."""
    pass

ExecutionBase

Bases: BaseModel

Base execution model.

Source code in models/executions.py 
33
34
35
36
37
38
39
40
class ExecutionBase(BaseModel):
    """Base execution model."""

    result: Dict[str, Any]
    execution_time_ms: int
    chat_message_id: Optional[str] = None
    sql_query: Optional[str] = None
    connector_id: str

SQLExecuteRequest

Bases: BaseModel

Model for SQL execution request.

Source code in models/executions.py 
10
11
12
13
14
15
16
17
18
19
class SQLExecuteRequest(BaseModel):
    """Model for SQL execution request."""

    class Config:
        populate_by_name = True

    connector_id: str
    chat_message_id: Optional[str] = None
    sql_query: Optional[str] = None
    chat_session_id: Optional[str] = Field(None, alias="h2ogpte_session_id")

SQLExecuteResponse

Bases: BaseModel

Model for SQL execution response.

Source code in models/executions.py 
22
23
24
25
26
27
28
29
30
class SQLExecuteResponse(BaseModel):
    """Model for SQL execution response."""

    execution_id: str
    connector_id: str
    sql_query: str
    result: Dict[str, Any]
    execution_time_ms: int
    chat_message_id: Optional[str] = None

text2everything_sdk.models.feedback

Feedback models for the Text2Everything SDK.

Feedback

Bases: FeedbackBase, BaseResponse

Complete feedback model with all fields.

Source code in models/feedback.py 
35
36
37
38
class Feedback(FeedbackBase, BaseResponse):
    """Complete feedback model with all fields."""

    project_id: str

FeedbackBase

Bases: BaseModel

Base feedback model.

Source code in models/feedback.py 
 9
10
11
12
13
14
15
16
class FeedbackBase(BaseModel):
    """Base feedback model."""

    chat_message_id: str
    feedback: str
    is_positive: bool = True
    execution_id: Optional[str] = None
    h2ogpte_doc_id: Optional[str] = None

FeedbackCreate

Bases: BaseModel

Model for creating feedback.

Source code in models/feedback.py 
19
20
21
22
23
24
25
class FeedbackCreate(BaseModel):
    """Model for creating feedback."""

    chat_message_id: str
    feedback: str
    is_positive: bool = True
    execution_id: Optional[str] = None

FeedbackResponse

Bases: Feedback

Feedback response with collection ID.

Source code in models/feedback.py 
41
42
43
44
class FeedbackResponse(Feedback):
    """Feedback response with collection ID."""

    collection_id: Optional[str] = None

FeedbackUpdate

Bases: BaseModel

Model for updating feedback.

Source code in models/feedback.py 
28
29
30
31
32
class FeedbackUpdate(BaseModel):
    """Model for updating feedback."""

    feedback: Optional[str] = None
    is_positive: Optional[bool] = None

text2everything_sdk.models.custom_tools

Custom tools models for the Text2Everything SDK.

CustomTool

Bases: CustomToolBase, BaseResponse

Complete custom tool model with all fields.

Source code in models/custom_tools.py 
44
45
46
47
48
class CustomTool(CustomToolBase, BaseResponse):
    """Complete custom tool model with all fields."""

    project_id: str
    documents: List[CustomToolDocument] = []

CustomToolBase

Bases: BaseModel

Base custom tool model.

Source code in models/custom_tools.py 
22
23
24
25
26
27
class CustomToolBase(BaseModel):
    """Base custom tool model."""

    name: str
    description: str
    h2ogpte_collection_id: Optional[str] = None

CustomToolCreate

Bases: BaseModel

Model for creating a new custom tool.

Source code in models/custom_tools.py 
30
31
32
33
34
class CustomToolCreate(BaseModel):
    """Model for creating a new custom tool."""

    name: str
    description: str

CustomToolDocument

Bases: CustomToolDocumentBase, BaseResponse

Complete custom tool document model.

Source code in models/custom_tools.py 
16
17
18
19
class CustomToolDocument(CustomToolDocumentBase, BaseResponse):
    """Complete custom tool document model."""

    custom_tool_id: str

CustomToolDocumentBase

Bases: BaseModel

Base custom tool document model.

Source code in models/custom_tools.py 
 9
10
11
12
13
class CustomToolDocumentBase(BaseModel):
    """Base custom tool document model."""

    filename: str
    h2ogpte_doc_id: str

CustomToolUpdate

Bases: BaseModel

Model for updating a custom tool.

Source code in models/custom_tools.py 
37
38
39
40
41
class CustomToolUpdate(BaseModel):
    """Model for updating a custom tool."""

    name: Optional[str] = None
    description: Optional[str] = None