From 5189d8228fc1b411c3c966fa8b0655ab2e70006a Mon Sep 17 00:00:00 2001 From: Rudolf the Rabbit Date: Mon, 25 May 2026 08:07:03 +0000 Subject: [PATCH] chore: update OpenAPI client to 2026.05.25.0755-691cc5e --- openapi/schemas/audience.openapi.json | 29 + openapi/schemas/order.openapi.json | 5 + openapi/schemas/rapid.openapi.json | 250 ++++ .../schemas/rapidata.filtered.openapi.json | 440 ++++++- openapi/schemas/rapidata.openapi.json | 440 ++++++- openapi/schemas/workflow.openapi.json | 106 +- src/rapidata/api_client/__init__.py | 1 + src/rapidata/api_client/api/__init__.py | 1 + src/rapidata/api_client/api/audience_api.py | 252 ++++ .../api_client/api/global_text_api.py | 1135 +++++++++++++++++ .../create_global_text_endpoint_input.py | 91 ++ .../create_global_text_endpoint_output.py | 89 ++ .../create_job_revision_endpoint_input.py | 11 +- .../get_all_global_texts_endpoint_output.py | 97 ++ ...t_all_global_texts_endpoint_output_item.py | 93 ++ ...simple_workflow_results_endpoint_output.py | 12 +- .../get_workflow_results_endpoint_output.py | 12 +- .../models/i_response_aggregation.py | 138 ++ ...sponse_aggregation_classify_aggregation.py | 111 ++ ...esponse_aggregation_compare_aggregation.py | 111 ++ .../api_client/models/response_tally.py | 91 ++ .../update_global_text_endpoint_input.py | 91 ++ src/rapidata/api_client_README.md | 14 + 23 files changed, 3608 insertions(+), 12 deletions(-) create mode 100644 src/rapidata/api_client/api/global_text_api.py create mode 100644 src/rapidata/api_client/models/create_global_text_endpoint_input.py create mode 100644 src/rapidata/api_client/models/create_global_text_endpoint_output.py create mode 100644 src/rapidata/api_client/models/get_all_global_texts_endpoint_output.py create mode 100644 src/rapidata/api_client/models/get_all_global_texts_endpoint_output_item.py create mode 100644 src/rapidata/api_client/models/i_response_aggregation.py create mode 100644 src/rapidata/api_client/models/i_response_aggregation_classify_aggregation.py create mode 100644 src/rapidata/api_client/models/i_response_aggregation_compare_aggregation.py create mode 100644 src/rapidata/api_client/models/response_tally.py create mode 100644 src/rapidata/api_client/models/update_global_text_endpoint_input.py diff --git a/openapi/schemas/audience.openapi.json b/openapi/schemas/audience.openapi.json index 7a1c34a7c..5ef33a378 100644 --- a/openapi/schemas/audience.openapi.json +++ b/openapi/schemas/audience.openapi.json @@ -1444,6 +1444,35 @@ } } }, + "/audience/reconcile-user-counts": { + "post": { + "tags": [ + "Audience" + ], + "summary": "Enqueues a background job that reconciles audience-row state derived\n from audience_state_counts.", + "responses": { + "202": { + "description": "Accepted" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + } + }, "/audience/{audienceId}/recreate-external-audiences": { "post": { "tags": [ diff --git a/openapi/schemas/order.openapi.json b/openapi/schemas/order.openapi.json index e5ab9977e..4c66ab4d1 100644 --- a/openapi/schemas/order.openapi.json +++ b/openapi/schemas/order.openapi.json @@ -3357,6 +3357,11 @@ } ], "description": "The aggregator type. If not provided, inherits from the previous revision." + }, + "validationSetId": { + "type": "string", + "description": "A validation set id to pin on this revision. When set, every job run from this\n revision uses the specified validation set as the source of validation rapids\n instead of audience-derived examples. If not provided, inherits from the previous\n revision. Provide a wrapped null value to clear a previously pinned set.", + "nullable": true } }, "description": "The input for the create job revision endpoint." diff --git a/openapi/schemas/rapid.openapi.json b/openapi/schemas/rapid.openapi.json index 2eb2861d4..0c5ebbe62 100644 --- a/openapi/schemas/rapid.openapi.json +++ b/openapi/schemas/rapid.openapi.json @@ -806,6 +806,176 @@ } } }, + "/global-text": { + "post": { + "tags": [ + "GlobalText" + ], + "summary": "Creates a new global text entry.", + "requestBody": { + "description": "The payload describing the entry to create.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + }, + "get": { + "tags": [ + "GlobalText" + ], + "summary": "Returns every global text entry.", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + } + }, + "/global-text/{globalTextId}": { + "delete": { + "tags": [ + "GlobalText" + ], + "summary": "Deletes a global text entry.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to delete.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + }, + "patch": { + "tags": [ + "GlobalText" + ], + "summary": "Updates a global text entry using patch semantics.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to update.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "description": "The patch payload describing which fields should change.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UpdateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + } + }, "/rapid/{rapidId}/reject": { "post": { "tags": [ @@ -1526,6 +1696,35 @@ } } }, + "CreateGlobalTextEndpoint_Input": { + "required": [ + "key", + "englishText" + ], + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The human-readable key used to look up the text from translations." + }, + "englishText": { + "type": "string", + "description": "The English source text that all translations derive from." + } + } + }, + "CreateGlobalTextEndpoint_Output": { + "required": [ + "globalTextId" + ], + "type": "object", + "properties": { + "globalTextId": { + "type": "string", + "description": "The unique identifier of the created global text entry." + } + } + }, "CreateValidationFeedbackEndpoint_Input": { "required": [ "feedback" @@ -1561,6 +1760,44 @@ "Audio" ] }, + "GetAllGlobalTextsEndpoint_Output": { + "required": [ + "globalTexts" + ], + "type": "object", + "properties": { + "globalTexts": { + "allOf": [ + { + "type": "array", + "items": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output_Item" + } + } + ], + "description": "The list of global text entries." + } + } + }, + "GetAllGlobalTextsEndpoint_Output_Item": { + "required": [ + "id", + "key", + "englishText" + ], + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "key": { + "type": "string" + }, + "englishText": { + "type": "string" + } + } + }, "GetGlobalResponsesEndpoint_Output": { "required": [ "responses" @@ -3905,6 +4142,19 @@ } } }, + "UpdateGlobalTextEndpoint_Input": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The new key for the global text entry." + }, + "englishText": { + "type": "string", + "description": "The new English source text for the global text entry." + } + } + }, "UpdateValidationRapidEndpoint_Input": { "type": "object", "properties": { diff --git a/openapi/schemas/rapidata.filtered.openapi.json b/openapi/schemas/rapidata.filtered.openapi.json index a121b42f7..c7ea24f90 100644 --- a/openapi/schemas/rapidata.filtered.openapi.json +++ b/openapi/schemas/rapidata.filtered.openapi.json @@ -135,6 +135,10 @@ "name": "CustomerRapid", "x-displayName": "CustomerRapid" }, + { + "name": "GlobalText", + "x-displayName": "GlobalText" + }, { "name": "Rapid", "x-displayName": "Rapid" @@ -2264,6 +2268,44 @@ ] } }, + "/audience/reconcile-user-counts": { + "post": { + "tags": [ + "Audience" + ], + "summary": "Enqueues a background job that reconciles audience-row state derived\n from audience_state_counts.", + "responses": { + "202": { + "description": "Accepted" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/audience/{audienceId}/recreate-external-audiences": { "post": { "tags": [ @@ -16314,6 +16356,212 @@ ] } }, + "/global-text": { + "post": { + "tags": [ + "GlobalText" + ], + "summary": "Creates a new global text entry.", + "requestBody": { + "description": "The payload describing the entry to create.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + }, + "get": { + "tags": [ + "GlobalText" + ], + "summary": "Returns every global text entry.", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, + "/global-text/{globalTextId}": { + "delete": { + "tags": [ + "GlobalText" + ], + "summary": "Deletes a global text entry.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to delete.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + }, + "patch": { + "tags": [ + "GlobalText" + ], + "summary": "Updates a global text entry using patch semantics.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to update.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "description": "The patch payload describing which fields should change.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UpdateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/rapid/{rapidId}/reject": { "post": { "tags": [ @@ -29014,6 +29262,11 @@ } ], "description": "The aggregator type. If not provided, inherits from the previous revision." + }, + "validationSetId": { + "type": "string", + "description": "A validation set id to pin on this revision. When set, every job run from this\n revision uses the specified validation set as the source of validation rapids\n instead of audience-derived examples. If not provided, inherits from the previous\n revision. Provide a wrapped null value to clear a previously pinned set.", + "nullable": true } }, "description": "The input for the create job revision endpoint." @@ -32935,6 +33188,35 @@ } } }, + "CreateGlobalTextEndpoint_Input": { + "required": [ + "key", + "englishText" + ], + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The human-readable key used to look up the text from translations." + }, + "englishText": { + "type": "string", + "description": "The English source text that all translations derive from." + } + } + }, + "CreateGlobalTextEndpoint_Output": { + "required": [ + "globalTextId" + ], + "type": "object", + "properties": { + "globalTextId": { + "type": "string", + "description": "The unique identifier of the created global text entry." + } + } + }, "CreateValidationFeedbackEndpoint_Input": { "required": [ "feedback" @@ -32947,6 +33229,44 @@ } } }, + "GetAllGlobalTextsEndpoint_Output": { + "required": [ + "globalTexts" + ], + "type": "object", + "properties": { + "globalTexts": { + "allOf": [ + { + "type": "array", + "items": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output_Item" + } + } + ], + "description": "The list of global text entries." + } + } + }, + "GetAllGlobalTextsEndpoint_Output_Item": { + "required": [ + "id", + "key", + "englishText" + ], + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "key": { + "type": "string" + }, + "englishText": { + "type": "string" + } + } + }, "GetGlobalResponsesEndpoint_Output": { "required": [ "responses" @@ -34733,6 +35053,19 @@ } } }, + "UpdateGlobalTextEndpoint_Input": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The new key for the global text entry." + }, + "englishText": { + "type": "string", + "description": "The new English source text for the global text entry." + } + } + }, "UpdateValidationRapidEndpoint_Input": { "type": "object", "properties": { @@ -35674,6 +36007,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -35707,7 +36041,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -35735,6 +36074,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -35893,6 +36240,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -35926,7 +36274,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -35954,6 +36307,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -36851,6 +37212,67 @@ } } }, + "IResponseAggregation": { + "required": [ + "_t" + ], + "type": "object", + "oneOf": [ + { + "$ref": "#/components/schemas/IResponseAggregationClassifyAggregation" + }, + { + "$ref": "#/components/schemas/IResponseAggregationCompareAggregation" + } + ], + "discriminator": { + "propertyName": "_t", + "mapping": { + "ClassifyAggregation": "#/components/schemas/IResponseAggregationClassifyAggregation", + "CompareAggregation": "#/components/schemas/IResponseAggregationCompareAggregation" + } + } + }, + "IResponseAggregationClassifyAggregation": { + "required": [ + "categoryTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "ClassifyAggregation" + ], + "type": "string" + }, + "categoryTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, + "IResponseAggregationCompareAggregation": { + "required": [ + "winnerTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "CompareAggregation" + ], + "type": "string" + }, + "winnerTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, "IWorkflowModel": { "required": [ "_t" @@ -37476,6 +37898,19 @@ "Rejected" ] }, + "ResponseTally": { + "type": "object", + "properties": { + "count": { + "type": "integer", + "format": "int64" + }, + "userScoreSum": { + "type": "number", + "format": "double" + } + } + }, "SortDirection": { "enum": [ "Asc", @@ -37606,6 +38041,7 @@ "name": "Rapidata Rapid API", "tags": [ "CustomerRapid", + "GlobalText", "Rapid", "UserRapid", "ValidationFeedback" diff --git a/openapi/schemas/rapidata.openapi.json b/openapi/schemas/rapidata.openapi.json index 527de7035..f1e5220ce 100644 --- a/openapi/schemas/rapidata.openapi.json +++ b/openapi/schemas/rapidata.openapi.json @@ -135,6 +135,10 @@ "name": "CustomerRapid", "x-displayName": "CustomerRapid" }, + { + "name": "GlobalText", + "x-displayName": "GlobalText" + }, { "name": "Rapid", "x-displayName": "Rapid" @@ -2264,6 +2268,44 @@ ] } }, + "/audience/reconcile-user-counts": { + "post": { + "tags": [ + "Audience" + ], + "summary": "Enqueues a background job that reconciles audience-row state derived\n from audience_state_counts.", + "responses": { + "202": { + "description": "Accepted" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/audience/{audienceId}/recreate-external-audiences": { "post": { "tags": [ @@ -16363,6 +16405,212 @@ ] } }, + "/global-text": { + "post": { + "tags": [ + "GlobalText" + ], + "summary": "Creates a new global text entry.", + "requestBody": { + "description": "The payload describing the entry to create.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateGlobalTextEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + }, + "get": { + "tags": [ + "GlobalText" + ], + "summary": "Returns every global text entry.", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, + "/global-text/{globalTextId}": { + "delete": { + "tags": [ + "GlobalText" + ], + "summary": "Deletes a global text entry.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to delete.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + }, + "patch": { + "tags": [ + "GlobalText" + ], + "summary": "Updates a global text entry using patch semantics.", + "parameters": [ + { + "name": "globalTextId", + "in": "path", + "description": "The id of the global text entry to update.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "description": "The patch payload describing which fields should change.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UpdateGlobalTextEndpoint_Input" + } + } + }, + "required": true + }, + "responses": { + "204": { + "description": "No Content" + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ValidationProblemDetails" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "OpenIdConnect": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/rapid/{rapidId}/reject": { "post": { "tags": [ @@ -29063,6 +29311,11 @@ } ], "description": "The aggregator type. If not provided, inherits from the previous revision." + }, + "validationSetId": { + "type": "string", + "description": "A validation set id to pin on this revision. When set, every job run from this\n revision uses the specified validation set as the source of validation rapids\n instead of audience-derived examples. If not provided, inherits from the previous\n revision. Provide a wrapped null value to clear a previously pinned set.", + "nullable": true } }, "description": "The input for the create job revision endpoint." @@ -32984,6 +33237,35 @@ } } }, + "CreateGlobalTextEndpoint_Input": { + "required": [ + "key", + "englishText" + ], + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The human-readable key used to look up the text from translations." + }, + "englishText": { + "type": "string", + "description": "The English source text that all translations derive from." + } + } + }, + "CreateGlobalTextEndpoint_Output": { + "required": [ + "globalTextId" + ], + "type": "object", + "properties": { + "globalTextId": { + "type": "string", + "description": "The unique identifier of the created global text entry." + } + } + }, "CreateValidationFeedbackEndpoint_Input": { "required": [ "feedback" @@ -32996,6 +33278,44 @@ } } }, + "GetAllGlobalTextsEndpoint_Output": { + "required": [ + "globalTexts" + ], + "type": "object", + "properties": { + "globalTexts": { + "allOf": [ + { + "type": "array", + "items": { + "$ref": "#/components/schemas/GetAllGlobalTextsEndpoint_Output_Item" + } + } + ], + "description": "The list of global text entries." + } + } + }, + "GetAllGlobalTextsEndpoint_Output_Item": { + "required": [ + "id", + "key", + "englishText" + ], + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "key": { + "type": "string" + }, + "englishText": { + "type": "string" + } + } + }, "GetGlobalResponsesEndpoint_Output": { "required": [ "responses" @@ -34782,6 +35102,19 @@ } } }, + "UpdateGlobalTextEndpoint_Input": { + "type": "object", + "properties": { + "key": { + "type": "string", + "description": "The new key for the global text entry." + }, + "englishText": { + "type": "string", + "description": "The new English source text for the global text entry." + } + } + }, "UpdateValidationRapidEndpoint_Input": { "type": "object", "properties": { @@ -35723,6 +36056,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -35756,7 +36090,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -35784,6 +36123,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -35942,6 +36289,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -35975,7 +36323,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -36003,6 +36356,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -36900,6 +37261,67 @@ } } }, + "IResponseAggregation": { + "required": [ + "_t" + ], + "type": "object", + "oneOf": [ + { + "$ref": "#/components/schemas/IResponseAggregationClassifyAggregation" + }, + { + "$ref": "#/components/schemas/IResponseAggregationCompareAggregation" + } + ], + "discriminator": { + "propertyName": "_t", + "mapping": { + "ClassifyAggregation": "#/components/schemas/IResponseAggregationClassifyAggregation", + "CompareAggregation": "#/components/schemas/IResponseAggregationCompareAggregation" + } + } + }, + "IResponseAggregationClassifyAggregation": { + "required": [ + "categoryTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "ClassifyAggregation" + ], + "type": "string" + }, + "categoryTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, + "IResponseAggregationCompareAggregation": { + "required": [ + "winnerTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "CompareAggregation" + ], + "type": "string" + }, + "winnerTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, "IWorkflowModel": { "required": [ "_t" @@ -37525,6 +37947,19 @@ "Rejected" ] }, + "ResponseTally": { + "type": "object", + "properties": { + "count": { + "type": "integer", + "format": "int64" + }, + "userScoreSum": { + "type": "number", + "format": "double" + } + } + }, "SortDirection": { "enum": [ "Asc", @@ -37655,6 +38090,7 @@ "name": "Rapidata Rapid API", "tags": [ "CustomerRapid", + "GlobalText", "Rapid", "UserRapid", "ValidationFeedback" diff --git a/openapi/schemas/workflow.openapi.json b/openapi/schemas/workflow.openapi.json index 6abad3853..2c598b235 100644 --- a/openapi/schemas/workflow.openapi.json +++ b/openapi/schemas/workflow.openapi.json @@ -1242,6 +1242,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -1275,7 +1276,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -1303,6 +1309,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -1461,6 +1475,7 @@ "payload", "asset", "responses", + "totalResponseCount", "state" ], "type": "object", @@ -1494,7 +1509,12 @@ } } ], - "description": "The list of responses for the rapid." + "description": "The (possibly capped) list of responses for the rapid." + }, + "totalResponseCount": { + "type": "integer", + "description": "The true number of matching responses for this rapid, regardless of whether the\n returned list was capped.", + "format": "int64" }, "state": { "allOf": [ @@ -1522,6 +1542,14 @@ "description": "The decisiveness of the rapid.", "format": "double", "nullable": true + }, + "aggregation": { + "allOf": [ + { + "$ref": "#/components/schemas/IResponseAggregation" + } + ], + "description": "Per-payload-type aggregation over all matching responses (computed before sampling).\n Populated for Compare and Classify rapids; null otherwise." } } }, @@ -2858,6 +2886,67 @@ } } }, + "IResponseAggregation": { + "required": [ + "_t" + ], + "type": "object", + "oneOf": [ + { + "$ref": "#/components/schemas/IResponseAggregationClassifyAggregation" + }, + { + "$ref": "#/components/schemas/IResponseAggregationCompareAggregation" + } + ], + "discriminator": { + "propertyName": "_t", + "mapping": { + "ClassifyAggregation": "#/components/schemas/IResponseAggregationClassifyAggregation", + "CompareAggregation": "#/components/schemas/IResponseAggregationCompareAggregation" + } + } + }, + "IResponseAggregationClassifyAggregation": { + "required": [ + "categoryTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "ClassifyAggregation" + ], + "type": "string" + }, + "categoryTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, + "IResponseAggregationCompareAggregation": { + "required": [ + "winnerTallies", + "_t" + ], + "properties": { + "_t": { + "enum": [ + "CompareAggregation" + ], + "type": "string" + }, + "winnerTallies": { + "type": "object", + "additionalProperties": { + "$ref": "#/components/schemas/ResponseTally" + } + } + } + }, "IWorkflowModel": { "required": [ "_t" @@ -3489,6 +3578,19 @@ "Rejected" ] }, + "ResponseTally": { + "type": "object", + "properties": { + "count": { + "type": "integer", + "format": "int64" + }, + "userScoreSum": { + "type": "number", + "format": "double" + } + } + }, "SortDirection": { "enum": [ "Asc", diff --git a/src/rapidata/api_client/__init__.py b/src/rapidata/api_client/__init__.py index bf2c4ed61..7b6482c5e 100644 --- a/src/rapidata/api_client/__init__.py +++ b/src/rapidata/api_client/__init__.py @@ -47,6 +47,7 @@ "FeedbackApi": "rapidata.api_client.api.feedback_api", "FlowApi": "rapidata.api_client.api.flow_api", "FlowItemApi": "rapidata.api_client.api.flow_item_api", + "GlobalTextApi": "rapidata.api_client.api.global_text_api", "GroupedRankingApi": "rapidata.api_client.api.grouped_ranking_api", "IdentityApi": "rapidata.api_client.api.identity_api", "JobApi": "rapidata.api_client.api.job_api", diff --git a/src/rapidata/api_client/api/__init__.py b/src/rapidata/api_client/api/__init__.py index eb78f6edd..06b9369bd 100644 --- a/src/rapidata/api_client/api/__init__.py +++ b/src/rapidata/api_client/api/__init__.py @@ -19,6 +19,7 @@ from rapidata.api_client.api.feedback_api import FeedbackApi from rapidata.api_client.api.flow_api import FlowApi from rapidata.api_client.api.flow_item_api import FlowItemApi +from rapidata.api_client.api.global_text_api import GlobalTextApi from rapidata.api_client.api.grouped_ranking_api import GroupedRankingApi from rapidata.api_client.api.identity_api import IdentityApi from rapidata.api_client.api.job_api import JobApi diff --git a/src/rapidata/api_client/api/audience_api.py b/src/rapidata/api_client/api/audience_api.py index 623e10e37..f4ef7929f 100644 --- a/src/rapidata/api_client/api/audience_api.py +++ b/src/rapidata/api_client/api/audience_api.py @@ -5746,6 +5746,258 @@ def _audience_post_serialize( + @validate_call + def audience_reconcile_user_counts_post( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """Enqueues a background job that reconciles audience-row state derived from audience_state_counts. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._audience_reconcile_user_counts_post_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '202': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def audience_reconcile_user_counts_post_with_http_info( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """Enqueues a background job that reconciles audience-row state derived from audience_state_counts. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._audience_reconcile_user_counts_post_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '202': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def audience_reconcile_user_counts_post_without_preload_content( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Enqueues a background job that reconciles audience-row state derived from audience_state_counts. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._audience_reconcile_user_counts_post_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '202': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _audience_reconcile_user_counts_post_serialize( + self, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + 'OpenIdConnect' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/audience/reconcile-user-counts', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + @validate_call def audience_state_recalculation_recalculation_id_get( self, diff --git a/src/rapidata/api_client/api/global_text_api.py b/src/rapidata/api_client/api/global_text_api.py new file mode 100644 index 000000000..c24373803 --- /dev/null +++ b/src/rapidata/api_client/api/global_text_api.py @@ -0,0 +1,1135 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +import warnings +from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt +from typing import Any, Dict, List, Optional, Tuple, Union +from typing_extensions import Annotated + +from pydantic import Field, StrictStr +from typing_extensions import Annotated +from rapidata.api_client.models.create_global_text_endpoint_input import CreateGlobalTextEndpointInput +from rapidata.api_client.models.create_global_text_endpoint_output import CreateGlobalTextEndpointOutput +from rapidata.api_client.models.get_all_global_texts_endpoint_output import GetAllGlobalTextsEndpointOutput +from rapidata.api_client.models.update_global_text_endpoint_input import UpdateGlobalTextEndpointInput + +from rapidata.api_client.api_client import ApiClient, RequestSerialized +from rapidata.api_client.api_response import ApiResponse +from rapidata.api_client.rest import RESTResponseType + + +class GlobalTextApi: + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient.get_default() + self.api_client = api_client + + + @validate_call + def global_text_get( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> GetAllGlobalTextsEndpointOutput: + """Returns every global text entry. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "GetAllGlobalTextsEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def global_text_get_with_http_info( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[GetAllGlobalTextsEndpointOutput]: + """Returns every global text entry. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "GetAllGlobalTextsEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def global_text_get_without_preload_content( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Returns every global text entry. + + + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "GetAllGlobalTextsEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _global_text_get_serialize( + self, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + 'OpenIdConnect' + ] + + return self.api_client.param_serialize( + method='GET', + resource_path='/global-text', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def global_text_global_text_id_delete( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to delete.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """Deletes a global text entry. + + + :param global_text_id: The id of the global text entry to delete. (required) + :type global_text_id: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_delete_serialize( + global_text_id=global_text_id, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def global_text_global_text_id_delete_with_http_info( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to delete.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """Deletes a global text entry. + + + :param global_text_id: The id of the global text entry to delete. (required) + :type global_text_id: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_delete_serialize( + global_text_id=global_text_id, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def global_text_global_text_id_delete_without_preload_content( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to delete.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Deletes a global text entry. + + + :param global_text_id: The id of the global text entry to delete. (required) + :type global_text_id: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_delete_serialize( + global_text_id=global_text_id, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _global_text_global_text_id_delete_serialize( + self, + global_text_id, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + if global_text_id is not None: + _path_params['globalTextId'] = global_text_id + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + + # authentication setting + _auth_settings: List[str] = [ + 'OpenIdConnect' + ] + + return self.api_client.param_serialize( + method='DELETE', + resource_path='/global-text/{globalTextId}', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def global_text_global_text_id_patch( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to update.")], + update_global_text_endpoint_input: Annotated[UpdateGlobalTextEndpointInput, Field(description="The patch payload describing which fields should change.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """Updates a global text entry using patch semantics. + + + :param global_text_id: The id of the global text entry to update. (required) + :type global_text_id: str + :param update_global_text_endpoint_input: The patch payload describing which fields should change. (required) + :type update_global_text_endpoint_input: UpdateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_patch_serialize( + global_text_id=global_text_id, + update_global_text_endpoint_input=update_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def global_text_global_text_id_patch_with_http_info( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to update.")], + update_global_text_endpoint_input: Annotated[UpdateGlobalTextEndpointInput, Field(description="The patch payload describing which fields should change.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """Updates a global text entry using patch semantics. + + + :param global_text_id: The id of the global text entry to update. (required) + :type global_text_id: str + :param update_global_text_endpoint_input: The patch payload describing which fields should change. (required) + :type update_global_text_endpoint_input: UpdateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_patch_serialize( + global_text_id=global_text_id, + update_global_text_endpoint_input=update_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def global_text_global_text_id_patch_without_preload_content( + self, + global_text_id: Annotated[StrictStr, Field(description="The id of the global text entry to update.")], + update_global_text_endpoint_input: Annotated[UpdateGlobalTextEndpointInput, Field(description="The patch payload describing which fields should change.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Updates a global text entry using patch semantics. + + + :param global_text_id: The id of the global text entry to update. (required) + :type global_text_id: str + :param update_global_text_endpoint_input: The patch payload describing which fields should change. (required) + :type update_global_text_endpoint_input: UpdateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_global_text_id_patch_serialize( + global_text_id=global_text_id, + update_global_text_endpoint_input=update_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '204': None, + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _global_text_global_text_id_patch_serialize( + self, + global_text_id, + update_global_text_endpoint_input, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + if global_text_id is not None: + _path_params['globalTextId'] = global_text_id + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if update_global_text_endpoint_input is not None: + _body_params = update_global_text_endpoint_input + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'OpenIdConnect' + ] + + return self.api_client.param_serialize( + method='PATCH', + resource_path='/global-text/{globalTextId}', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def global_text_post( + self, + create_global_text_endpoint_input: Annotated[CreateGlobalTextEndpointInput, Field(description="The payload describing the entry to create.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> CreateGlobalTextEndpointOutput: + """Creates a new global text entry. + + + :param create_global_text_endpoint_input: The payload describing the entry to create. (required) + :type create_global_text_endpoint_input: CreateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_post_serialize( + create_global_text_endpoint_input=create_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "CreateGlobalTextEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def global_text_post_with_http_info( + self, + create_global_text_endpoint_input: Annotated[CreateGlobalTextEndpointInput, Field(description="The payload describing the entry to create.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[CreateGlobalTextEndpointOutput]: + """Creates a new global text entry. + + + :param create_global_text_endpoint_input: The payload describing the entry to create. (required) + :type create_global_text_endpoint_input: CreateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_post_serialize( + create_global_text_endpoint_input=create_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "CreateGlobalTextEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def global_text_post_without_preload_content( + self, + create_global_text_endpoint_input: Annotated[CreateGlobalTextEndpointInput, Field(description="The payload describing the entry to create.")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Creates a new global text entry. + + + :param create_global_text_endpoint_input: The payload describing the entry to create. (required) + :type create_global_text_endpoint_input: CreateGlobalTextEndpointInput + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._global_text_post_serialize( + create_global_text_endpoint_input=create_global_text_endpoint_input, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "CreateGlobalTextEndpointOutput", + '400': "ValidationProblemDetails", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _global_text_post_serialize( + self, + create_global_text_endpoint_input, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if create_global_text_endpoint_input is not None: + _body_params = create_global_text_endpoint_input + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'OpenIdConnect' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/global-text', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + diff --git a/src/rapidata/api_client/models/create_global_text_endpoint_input.py b/src/rapidata/api_client/models/create_global_text_endpoint_input.py new file mode 100644 index 000000000..d566de7b3 --- /dev/null +++ b/src/rapidata/api_client/models/create_global_text_endpoint_input.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr +from typing import Any, ClassVar, Dict, List +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class CreateGlobalTextEndpointInput(LazyValidatedModel): + """ + CreateGlobalTextEndpointInput + """ # noqa: E501 + key: StrictStr = Field(description="The human-readable key used to look up the text from translations.") + english_text: StrictStr = Field(description="The English source text that all translations derive from.", alias="englishText") + __properties: ClassVar[List[str]] = ["key", "englishText"] + + # model_config is inherited from LazyValidatedModel + + + 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 CreateGlobalTextEndpointInput 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 CreateGlobalTextEndpointInput from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "key": obj.get("key"), + "englishText": obj.get("englishText") + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/create_global_text_endpoint_output.py b/src/rapidata/api_client/models/create_global_text_endpoint_output.py new file mode 100644 index 000000000..3b8c054fc --- /dev/null +++ b/src/rapidata/api_client/models/create_global_text_endpoint_output.py @@ -0,0 +1,89 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr +from typing import Any, ClassVar, Dict, List +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class CreateGlobalTextEndpointOutput(LazyValidatedModel): + """ + CreateGlobalTextEndpointOutput + """ # noqa: E501 + global_text_id: StrictStr = Field(description="The unique identifier of the created global text entry.", alias="globalTextId") + __properties: ClassVar[List[str]] = ["globalTextId"] + + # model_config is inherited from LazyValidatedModel + + + 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 CreateGlobalTextEndpointOutput 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 CreateGlobalTextEndpointOutput from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "globalTextId": obj.get("globalTextId") + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/create_job_revision_endpoint_input.py b/src/rapidata/api_client/models/create_job_revision_endpoint_input.py index 21167ef3f..766ba523d 100644 --- a/src/rapidata/api_client/models/create_job_revision_endpoint_input.py +++ b/src/rapidata/api_client/models/create_job_revision_endpoint_input.py @@ -39,7 +39,8 @@ class CreateJobRevisionEndpointInput(LazyValidatedModel): rapid_feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="rapidFeatureFlags") campaign_feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="campaignFeatureFlags") aggregator_type: Optional[AggregatorType] = Field(default=None, alias="aggregatorType") - __properties: ClassVar[List[str]] = ["workflow", "referee", "datasetId", "featureFlags", "rapidFeatureFlags", "campaignFeatureFlags", "aggregatorType"] + validation_set_id: Optional[StrictStr] = Field(default=None, description="A validation set id to pin on this revision. When set, every job run from this revision uses the specified validation set as the source of validation rapids instead of audience-derived examples. If not provided, inherits from the previous revision. Provide a wrapped null value to clear a previously pinned set.", alias="validationSetId") + __properties: ClassVar[List[str]] = ["workflow", "referee", "datasetId", "featureFlags", "rapidFeatureFlags", "campaignFeatureFlags", "aggregatorType", "validationSetId"] # model_config is inherited from LazyValidatedModel @@ -108,6 +109,11 @@ def to_dict(self) -> Dict[str, Any]: if self.aggregator_type is None and "aggregator_type" in self.model_fields_set: _dict['aggregatorType'] = None + # set to None if validation_set_id (nullable) is None + # and model_fields_set contains the field + if self.validation_set_id is None and "validation_set_id" in self.model_fields_set: + _dict['validationSetId'] = None + return _dict @classmethod @@ -126,7 +132,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None, "rapidFeatureFlags": [FeatureFlag.from_dict(_item) for _item in obj["rapidFeatureFlags"]] if obj.get("rapidFeatureFlags") is not None else None, "campaignFeatureFlags": [FeatureFlag.from_dict(_item) for _item in obj["campaignFeatureFlags"]] if obj.get("campaignFeatureFlags") is not None else None, - "aggregatorType": obj.get("aggregatorType") + "aggregatorType": obj.get("aggregatorType"), + "validationSetId": obj.get("validationSetId") } try: _obj = cls.model_validate(_data) diff --git a/src/rapidata/api_client/models/get_all_global_texts_endpoint_output.py b/src/rapidata/api_client/models/get_all_global_texts_endpoint_output.py new file mode 100644 index 000000000..42e80df03 --- /dev/null +++ b/src/rapidata/api_client/models/get_all_global_texts_endpoint_output.py @@ -0,0 +1,97 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field +from typing import Any, ClassVar, Dict, List +from rapidata.api_client.models.get_all_global_texts_endpoint_output_item import GetAllGlobalTextsEndpointOutputItem +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class GetAllGlobalTextsEndpointOutput(LazyValidatedModel): + """ + GetAllGlobalTextsEndpointOutput + """ # noqa: E501 + global_texts: List[GetAllGlobalTextsEndpointOutputItem] = Field(alias="globalTexts") + __properties: ClassVar[List[str]] = ["globalTexts"] + + # model_config is inherited from LazyValidatedModel + + + 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 GetAllGlobalTextsEndpointOutput 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 global_texts (list) + _items = [] + if self.global_texts: + for _item_global_texts in self.global_texts: + if _item_global_texts: + _items.append(_item_global_texts.to_dict()) + _dict['globalTexts'] = _items + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of GetAllGlobalTextsEndpointOutput from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "globalTexts": [GetAllGlobalTextsEndpointOutputItem.from_dict(_item) for _item in obj["globalTexts"]] if obj.get("globalTexts") is not None else None + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/get_all_global_texts_endpoint_output_item.py b/src/rapidata/api_client/models/get_all_global_texts_endpoint_output_item.py new file mode 100644 index 000000000..57bc981bf --- /dev/null +++ b/src/rapidata/api_client/models/get_all_global_texts_endpoint_output_item.py @@ -0,0 +1,93 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr +from typing import Any, ClassVar, Dict, List +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class GetAllGlobalTextsEndpointOutputItem(LazyValidatedModel): + """ + GetAllGlobalTextsEndpointOutputItem + """ # noqa: E501 + id: StrictStr + key: StrictStr + english_text: StrictStr = Field(alias="englishText") + __properties: ClassVar[List[str]] = ["id", "key", "englishText"] + + # model_config is inherited from LazyValidatedModel + + + 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 GetAllGlobalTextsEndpointOutputItem 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 GetAllGlobalTextsEndpointOutputItem from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "id": obj.get("id"), + "key": obj.get("key"), + "englishText": obj.get("englishText") + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/get_simple_workflow_results_endpoint_output.py b/src/rapidata/api_client/models/get_simple_workflow_results_endpoint_output.py index af4adac64..00cf0f201 100644 --- a/src/rapidata/api_client/models/get_simple_workflow_results_endpoint_output.py +++ b/src/rapidata/api_client/models/get_simple_workflow_results_endpoint_output.py @@ -22,6 +22,7 @@ from rapidata.api_client.models.get_workflow_results_result_response import GetWorkflowResultsResultResponse from rapidata.api_client.models.i_asset_model import IAssetModel from rapidata.api_client.models.i_rapid_payload import IRapidPayload +from rapidata.api_client.models.i_response_aggregation import IResponseAggregation from rapidata.api_client.models.rapid_state import RapidState from pydantic import ValidationError from rapidata.api_client.lazy_model import LazyValidatedModel @@ -36,11 +37,13 @@ class GetSimpleWorkflowResultsEndpointOutput(LazyValidatedModel): payload: IRapidPayload = Field(description="The payload of the rapid.") asset: IAssetModel = Field(description="The asset of the rapid.") responses: List[GetWorkflowResultsResultResponse] + total_response_count: StrictInt = Field(description="The true number of matching responses for this rapid, regardless of whether the returned list was capped.", alias="totalResponseCount") state: RapidState = Field(description="The state of the rapid.") context: Optional[StrictStr] = Field(default=None, description="The optional textual context of the rapid.") context_asset: Optional[IAssetModel] = Field(default=None, description="The optional asset shown as context to the user.", alias="contextAsset") decisiveness: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The decisiveness of the rapid.") - __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "state", "context", "contextAsset", "decisiveness"] + aggregation: Optional[IResponseAggregation] = Field(default=None, description="Per-payload-type aggregation over all matching responses (computed before sampling). Populated for Compare and Classify rapids; null otherwise.") + __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "totalResponseCount", "state", "context", "contextAsset", "decisiveness", "aggregation"] # model_config is inherited from LazyValidatedModel @@ -93,6 +96,9 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of context_asset if self.context_asset: _dict['contextAsset'] = self.context_asset.to_dict() + # override the default output from pydantic by calling `to_dict()` of aggregation + if self.aggregation: + _dict['aggregation'] = self.aggregation.to_dict() # set to None if context (nullable) is None # and model_fields_set contains the field if self.context is None and "context" in self.model_fields_set: @@ -119,10 +125,12 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "payload": IRapidPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None, "asset": IAssetModel.from_dict(obj["asset"]) if obj.get("asset") is not None else None, "responses": [GetWorkflowResultsResultResponse.from_dict(_item) for _item in obj["responses"]] if obj.get("responses") is not None else None, + "totalResponseCount": obj.get("totalResponseCount"), "state": obj.get("state"), "context": obj.get("context"), "contextAsset": IAssetModel.from_dict(obj["contextAsset"]) if obj.get("contextAsset") is not None else None, - "decisiveness": obj.get("decisiveness") + "decisiveness": obj.get("decisiveness"), + "aggregation": IResponseAggregation.from_dict(obj["aggregation"]) if obj.get("aggregation") is not None else None } try: _obj = cls.model_validate(_data) diff --git a/src/rapidata/api_client/models/get_workflow_results_endpoint_output.py b/src/rapidata/api_client/models/get_workflow_results_endpoint_output.py index 3948c2209..4472d9f66 100644 --- a/src/rapidata/api_client/models/get_workflow_results_endpoint_output.py +++ b/src/rapidata/api_client/models/get_workflow_results_endpoint_output.py @@ -22,6 +22,7 @@ from rapidata.api_client.models.get_workflow_results_result_response import GetWorkflowResultsResultResponse from rapidata.api_client.models.i_asset_model import IAssetModel from rapidata.api_client.models.i_rapid_payload import IRapidPayload +from rapidata.api_client.models.i_response_aggregation import IResponseAggregation from rapidata.api_client.models.rapid_state import RapidState from pydantic import ValidationError from rapidata.api_client.lazy_model import LazyValidatedModel @@ -36,11 +37,13 @@ class GetWorkflowResultsEndpointOutput(LazyValidatedModel): payload: IRapidPayload = Field(description="The payload of the rapid.") asset: IAssetModel = Field(description="The asset of the rapid.") responses: List[GetWorkflowResultsResultResponse] + total_response_count: StrictInt = Field(description="The true number of matching responses for this rapid, regardless of whether the returned list was capped.", alias="totalResponseCount") state: RapidState = Field(description="The state of the rapid.") context: Optional[StrictStr] = Field(default=None, description="The optional textual context of the rapid.") context_asset: Optional[IAssetModel] = Field(default=None, description="The optional asset shown as context to the user.", alias="contextAsset") decisiveness: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The decisiveness of the rapid.") - __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "state", "context", "contextAsset", "decisiveness"] + aggregation: Optional[IResponseAggregation] = Field(default=None, description="Per-payload-type aggregation over all matching responses (computed before sampling). Populated for Compare and Classify rapids; null otherwise.") + __properties: ClassVar[List[str]] = ["rapidId", "payload", "asset", "responses", "totalResponseCount", "state", "context", "contextAsset", "decisiveness", "aggregation"] # model_config is inherited from LazyValidatedModel @@ -93,6 +96,9 @@ def to_dict(self) -> Dict[str, Any]: # override the default output from pydantic by calling `to_dict()` of context_asset if self.context_asset: _dict['contextAsset'] = self.context_asset.to_dict() + # override the default output from pydantic by calling `to_dict()` of aggregation + if self.aggregation: + _dict['aggregation'] = self.aggregation.to_dict() # set to None if context (nullable) is None # and model_fields_set contains the field if self.context is None and "context" in self.model_fields_set: @@ -119,10 +125,12 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "payload": IRapidPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None, "asset": IAssetModel.from_dict(obj["asset"]) if obj.get("asset") is not None else None, "responses": [GetWorkflowResultsResultResponse.from_dict(_item) for _item in obj["responses"]] if obj.get("responses") is not None else None, + "totalResponseCount": obj.get("totalResponseCount"), "state": obj.get("state"), "context": obj.get("context"), "contextAsset": IAssetModel.from_dict(obj["contextAsset"]) if obj.get("contextAsset") is not None else None, - "decisiveness": obj.get("decisiveness") + "decisiveness": obj.get("decisiveness"), + "aggregation": IResponseAggregation.from_dict(obj["aggregation"]) if obj.get("aggregation") is not None else None } try: _obj = cls.model_validate(_data) diff --git a/src/rapidata/api_client/models/i_response_aggregation.py b/src/rapidata/api_client/models/i_response_aggregation.py new file mode 100644 index 000000000..a3968c2c1 --- /dev/null +++ b/src/rapidata/api_client/models/i_response_aggregation.py @@ -0,0 +1,138 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +import pprint +from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator +from typing import Any, List, Optional +from rapidata.api_client.models.i_response_aggregation_classify_aggregation import IResponseAggregationClassifyAggregation +from rapidata.api_client.models.i_response_aggregation_compare_aggregation import IResponseAggregationCompareAggregation +from pydantic import StrictStr, Field +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Union, List, Set, Optional, Dict +from typing_extensions import Literal, Self + +IRESPONSEAGGREGATION_ONE_OF_SCHEMAS = ["IResponseAggregationClassifyAggregation", "IResponseAggregationCompareAggregation"] + +class IResponseAggregation(LazyValidatedModel): + """ + IResponseAggregation + """ + # data type: IResponseAggregationClassifyAggregation + oneof_schema_1_validator: Optional[IResponseAggregationClassifyAggregation] = None + # data type: IResponseAggregationCompareAggregation + oneof_schema_2_validator: Optional[IResponseAggregationCompareAggregation] = None + actual_instance: Optional[Union[IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation]] = None + one_of_schemas: Set[str] = { "IResponseAggregationClassifyAggregation", "IResponseAggregationCompareAggregation" } + + # model_config is inherited from LazyValidatedModel + + + discriminator_value_class_map: Dict[str, str] = { + } + + 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_oneof(cls, v): + instance = IResponseAggregation.model_construct() + error_messages = [] + match = 0 + # validate data type: IResponseAggregationClassifyAggregation + if not isinstance(v, IResponseAggregationClassifyAggregation): + error_messages.append(f"Error! Input type `{type(v)}` is not `IResponseAggregationClassifyAggregation`") + else: + match += 1 + # validate data type: IResponseAggregationCompareAggregation + if not isinstance(v, IResponseAggregationCompareAggregation): + error_messages.append(f"Error! Input type `{type(v)}` is not `IResponseAggregationCompareAggregation`") + else: + match += 1 + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when setting `actual_instance` in IResponseAggregation with oneOf schemas: IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when setting `actual_instance` in IResponseAggregation with oneOf schemas: IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation. Details: " + ", ".join(error_messages)) + else: + return v + + @classmethod + def from_dict(cls, obj: Union[str, 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 = [] + match = 0 + + # deserialize data into IResponseAggregationClassifyAggregation + try: + instance.actual_instance = IResponseAggregationClassifyAggregation.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + # deserialize data into IResponseAggregationCompareAggregation + try: + instance.actual_instance = IResponseAggregationCompareAggregation.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when deserializing the JSON string into IResponseAggregation with oneOf schemas: IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when deserializing the JSON string into IResponseAggregation with oneOf schemas: IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation. 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], IResponseAggregationClassifyAggregation, IResponseAggregationCompareAggregation]]: + """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: + # primitive type + return self.actual_instance + + def to_str(self) -> str: + """Returns the string representation of the actual instance""" + return pprint.pformat(self.model_dump()) + + diff --git a/src/rapidata/api_client/models/i_response_aggregation_classify_aggregation.py b/src/rapidata/api_client/models/i_response_aggregation_classify_aggregation.py new file mode 100644 index 000000000..a62680c35 --- /dev/null +++ b/src/rapidata/api_client/models/i_response_aggregation_classify_aggregation.py @@ -0,0 +1,111 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List +from rapidata.api_client.models.response_tally import ResponseTally +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class IResponseAggregationClassifyAggregation(LazyValidatedModel): + """ + IResponseAggregationClassifyAggregation + """ # noqa: E501 + t: StrictStr = Field(alias="_t") + category_tallies: Dict[str, ResponseTally] = Field(alias="categoryTallies") + __properties: ClassVar[List[str]] = ["_t", "categoryTallies"] + + @field_validator('t') + def t_validate_enum(cls, value): + """Validates the enum""" + if value not in set(['ClassifyAggregation']): + raise ValueError("must be one of enum values ('ClassifyAggregation')") + return value + + # model_config is inherited from LazyValidatedModel + + + 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 IResponseAggregationClassifyAggregation 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 value in category_tallies (dict) + _field_dict = {} + if self.category_tallies: + for _key_category_tallies in self.category_tallies: + if self.category_tallies[_key_category_tallies]: + _field_dict[_key_category_tallies] = self.category_tallies[_key_category_tallies].to_dict() + _dict['categoryTallies'] = _field_dict + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of IResponseAggregationClassifyAggregation from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "_t": obj.get("_t"), + "categoryTallies": dict( + (_k, ResponseTally.from_dict(_v)) + for _k, _v in obj["categoryTallies"].items() + ) + if obj.get("categoryTallies") is not None + else None + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/i_response_aggregation_compare_aggregation.py b/src/rapidata/api_client/models/i_response_aggregation_compare_aggregation.py new file mode 100644 index 000000000..b5f79b1b3 --- /dev/null +++ b/src/rapidata/api_client/models/i_response_aggregation_compare_aggregation.py @@ -0,0 +1,111 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List +from rapidata.api_client.models.response_tally import ResponseTally +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class IResponseAggregationCompareAggregation(LazyValidatedModel): + """ + IResponseAggregationCompareAggregation + """ # noqa: E501 + t: StrictStr = Field(alias="_t") + winner_tallies: Dict[str, ResponseTally] = Field(alias="winnerTallies") + __properties: ClassVar[List[str]] = ["_t", "winnerTallies"] + + @field_validator('t') + def t_validate_enum(cls, value): + """Validates the enum""" + if value not in set(['CompareAggregation']): + raise ValueError("must be one of enum values ('CompareAggregation')") + return value + + # model_config is inherited from LazyValidatedModel + + + 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 IResponseAggregationCompareAggregation 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 value in winner_tallies (dict) + _field_dict = {} + if self.winner_tallies: + for _key_winner_tallies in self.winner_tallies: + if self.winner_tallies[_key_winner_tallies]: + _field_dict[_key_winner_tallies] = self.winner_tallies[_key_winner_tallies].to_dict() + _dict['winnerTallies'] = _field_dict + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of IResponseAggregationCompareAggregation from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "_t": obj.get("_t"), + "winnerTallies": dict( + (_k, ResponseTally.from_dict(_v)) + for _k, _v in obj["winnerTallies"].items() + ) + if obj.get("winnerTallies") is not None + else None + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/response_tally.py b/src/rapidata/api_client/models/response_tally.py new file mode 100644 index 000000000..263f9679e --- /dev/null +++ b/src/rapidata/api_client/models/response_tally.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt +from typing import Any, ClassVar, Dict, List, Optional, Union +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class ResponseTally(LazyValidatedModel): + """ + ResponseTally + """ # noqa: E501 + count: Optional[StrictInt] = None + user_score_sum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="userScoreSum") + __properties: ClassVar[List[str]] = ["count", "userScoreSum"] + + # model_config is inherited from LazyValidatedModel + + + 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 ResponseTally 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 ResponseTally from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "count": obj.get("count"), + "userScoreSum": obj.get("userScoreSum") + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client/models/update_global_text_endpoint_input.py b/src/rapidata/api_client/models/update_global_text_endpoint_input.py new file mode 100644 index 000000000..4b1c3107e --- /dev/null +++ b/src/rapidata/api_client/models/update_global_text_endpoint_input.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from pydantic import ValidationError +from rapidata.api_client.lazy_model import LazyValidatedModel +from typing import Optional, Set +from typing_extensions import Self + +class UpdateGlobalTextEndpointInput(LazyValidatedModel): + """ + UpdateGlobalTextEndpointInput + """ # noqa: E501 + key: Optional[StrictStr] = Field(default=None, description="The new key for the global text entry.") + english_text: Optional[StrictStr] = Field(default=None, description="The new English source text for the global text entry.", alias="englishText") + __properties: ClassVar[List[str]] = ["key", "englishText"] + + # model_config is inherited from LazyValidatedModel + + + 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 UpdateGlobalTextEndpointInput 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 UpdateGlobalTextEndpointInput from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _data = { + "key": obj.get("key"), + "englishText": obj.get("englishText") + } + try: + _obj = cls.model_validate(_data) + except ValidationError as _val_error: + _obj = cls._lazy_construct(_data, _val_error) + return _obj + + diff --git a/src/rapidata/api_client_README.md b/src/rapidata/api_client_README.md index 0337a50d4..62ce8ff08 100644 --- a/src/rapidata/api_client_README.md +++ b/src/rapidata/api_client_README.md @@ -93,6 +93,7 @@ Class | Method | HTTP request | Description *AudienceApi* | [**audience_base_audience_id_filter_post**](rapidata/api_client/docs/AudienceApi.md#audience_base_audience_id_filter_post) | **POST** /audience/{baseAudienceId}/filter | Creates a filtered view on the given base audience by applying a filter on top of its graduates. Returns an audience id that can be used in job creation just like a regular audience id; no new onboarding is required. *AudienceApi* | [**audience_inactivity_sync_sync_id_get**](rapidata/api_client/docs/AudienceApi.md#audience_inactivity_sync_sync_id_get) | **GET** /audience/inactivity-sync/{syncId} | Returns the audience inactivity sync with the given id. *AudienceApi* | [**audience_post**](rapidata/api_client/docs/AudienceApi.md#audience_post) | **POST** /audience | Creates a new empty audience. +*AudienceApi* | [**audience_reconcile_user_counts_post**](rapidata/api_client/docs/AudienceApi.md#audience_reconcile_user_counts_post) | **POST** /audience/reconcile-user-counts | Enqueues a background job that reconciles audience-row state derived from audience_state_counts. *AudienceApi* | [**audience_state_recalculation_recalculation_id_get**](rapidata/api_client/docs/AudienceApi.md#audience_state_recalculation_recalculation_id_get) | **GET** /audience/state-recalculation/{recalculationId} | Returns the audience state recalculation with the given id. *AudienceApi* | [**audiences_get**](rapidata/api_client/docs/AudienceApi.md#audiences_get) | **GET** /audiences | Queries all audiences visible to the caller. *BatchUploadApi* | [**asset_batch_upload_batch_upload_id_abort_post**](rapidata/api_client/docs/BatchUploadApi.md#asset_batch_upload_batch_upload_id_abort_post) | **POST** /asset/batch-upload/{batchUploadId}/abort | Aborts the specified batch upload. @@ -172,6 +173,10 @@ Class | Method | HTTP request | Description *FlowApi* | [**flow_ranking_flow_id_response_count_histogram_get**](rapidata/api_client/docs/FlowApi.md#flow_ranking_flow_id_response_count_histogram_get) | **GET** /flow/ranking/{flowId}/response-count-histogram | Returns the distribution of total votes per completed flow item. *FlowApi* | [**flow_ranking_flow_id_response_count_timeseries_get**](rapidata/api_client/docs/FlowApi.md#flow_ranking_flow_id_response_count_timeseries_get) | **GET** /flow/ranking/{flowId}/response-count-timeseries | Returns average response counts bucketed over time for completed flow items. *FlowItemApi* | [**flow_item_flow_item_id_stop_post**](rapidata/api_client/docs/FlowItemApi.md#flow_item_flow_item_id_stop_post) | **POST** /flow/item/{flowItemId}/stop | Stops the specified flow item and triggers partial result processing. +*GlobalTextApi* | [**global_text_get**](rapidata/api_client/docs/GlobalTextApi.md#global_text_get) | **GET** /global-text | Returns every global text entry. +*GlobalTextApi* | [**global_text_global_text_id_delete**](rapidata/api_client/docs/GlobalTextApi.md#global_text_global_text_id_delete) | **DELETE** /global-text/{globalTextId} | Deletes a global text entry. +*GlobalTextApi* | [**global_text_global_text_id_patch**](rapidata/api_client/docs/GlobalTextApi.md#global_text_global_text_id_patch) | **PATCH** /global-text/{globalTextId} | Updates a global text entry using patch semantics. +*GlobalTextApi* | [**global_text_post**](rapidata/api_client/docs/GlobalTextApi.md#global_text_post) | **POST** /global-text | Creates a new global text entry. *GroupedRankingApi* | [**workflow_grouped_ranking_workflow_id_results_get**](rapidata/api_client/docs/GroupedRankingApi.md#workflow_grouped_ranking_workflow_id_results_get) | **GET** /workflow/grouped-ranking/{workflowId}/results | Gets the result overview for a grouped ranking workflow. *IdentityApi* | [**identity_bridge_token_get**](rapidata/api_client/docs/IdentityApi.md#identity_bridge_token_get) | **GET** /identity/bridge-token | Reads the bridge token keys for a given read key. *IdentityApi* | [**identity_bridge_token_post**](rapidata/api_client/docs/IdentityApi.md#identity_bridge_token_post) | **POST** /identity/bridge-token | Creates a pair of read and write bridge token keys for a client. @@ -366,6 +371,8 @@ Class | Method | HTTP request | Description - [CreateFlowEndpointOutput](rapidata/api_client/docs/CreateFlowEndpointOutput.md) - [CreateFlowItemEndpointInput](rapidata/api_client/docs/CreateFlowItemEndpointInput.md) - [CreateFlowItemEndpointOutput](rapidata/api_client/docs/CreateFlowItemEndpointOutput.md) + - [CreateGlobalTextEndpointInput](rapidata/api_client/docs/CreateGlobalTextEndpointInput.md) + - [CreateGlobalTextEndpointOutput](rapidata/api_client/docs/CreateGlobalTextEndpointOutput.md) - [CreateJobDefinitionEndpointInput](rapidata/api_client/docs/CreateJobDefinitionEndpointInput.md) - [CreateJobDefinitionEndpointOutput](rapidata/api_client/docs/CreateJobDefinitionEndpointOutput.md) - [CreateJobEndpointInput](rapidata/api_client/docs/CreateJobEndpointInput.md) @@ -410,6 +417,8 @@ Class | Method | HTTP request | Description - [FlowType](rapidata/api_client/docs/FlowType.md) - [ForkBenchmarkEndpointOutput](rapidata/api_client/docs/ForkBenchmarkEndpointOutput.md) - [GenderUserFilterModelGender](rapidata/api_client/docs/GenderUserFilterModelGender.md) + - [GetAllGlobalTextsEndpointOutput](rapidata/api_client/docs/GetAllGlobalTextsEndpointOutput.md) + - [GetAllGlobalTextsEndpointOutputItem](rapidata/api_client/docs/GetAllGlobalTextsEndpointOutputItem.md) - [GetAudienceByIdEndpointOutput](rapidata/api_client/docs/GetAudienceByIdEndpointOutput.md) - [GetAudienceInactivitySyncByIdEndpointOutput](rapidata/api_client/docs/GetAudienceInactivitySyncByIdEndpointOutput.md) - [GetAudienceStateRecalculationByIdEndpointOutput](rapidata/api_client/docs/GetAudienceStateRecalculationByIdEndpointOutput.md) @@ -710,6 +719,9 @@ Class | Method | HTTP request | Description - [IRefereeModelEarlyStoppingRefereeModel](rapidata/api_client/docs/IRefereeModelEarlyStoppingRefereeModel.md) - [IRefereeModelNaiveRefereeModel](rapidata/api_client/docs/IRefereeModelNaiveRefereeModel.md) - [IRefereeModelQuorumRefereeModel](rapidata/api_client/docs/IRefereeModelQuorumRefereeModel.md) + - [IResponseAggregation](rapidata/api_client/docs/IResponseAggregation.md) + - [IResponseAggregationClassifyAggregation](rapidata/api_client/docs/IResponseAggregationClassifyAggregation.md) + - [IResponseAggregationCompareAggregation](rapidata/api_client/docs/IResponseAggregationCompareAggregation.md) - [ISelection](rapidata/api_client/docs/ISelection.md) - [ISelectionAbTestSelection](rapidata/api_client/docs/ISelectionAbTestSelection.md) - [ISelectionCappedSelection](rapidata/api_client/docs/ISelectionCappedSelection.md) @@ -859,6 +871,7 @@ Class | Method | HTTP request | Description - [ReadBridgeTokenEndpointNotAvailableOutput](rapidata/api_client/docs/ReadBridgeTokenEndpointNotAvailableOutput.md) - [RecreateExternalAudiencesEndpointInput](rapidata/api_client/docs/RecreateExternalAudiencesEndpointInput.md) - [ReportRapidEndpointInput](rapidata/api_client/docs/ReportRapidEndpointInput.md) + - [ResponseTally](rapidata/api_client/docs/ResponseTally.md) - [RetrievalMode](rapidata/api_client/docs/RetrievalMode.md) - [RunStatus](rapidata/api_client/docs/RunStatus.md) - [ScrubTruthModelScrubRange](rapidata/api_client/docs/ScrubTruthModelScrubRange.md) @@ -903,6 +916,7 @@ Class | Method | HTTP request | Description - [UpdateCampaignEndpointInput](rapidata/api_client/docs/UpdateCampaignEndpointInput.md) - [UpdateConfigEndpointInput](rapidata/api_client/docs/UpdateConfigEndpointInput.md) - [UpdateDatasetNameEndpointInput](rapidata/api_client/docs/UpdateDatasetNameEndpointInput.md) + - [UpdateGlobalTextEndpointInput](rapidata/api_client/docs/UpdateGlobalTextEndpointInput.md) - [UpdateJobDefinitionEndpointInput](rapidata/api_client/docs/UpdateJobDefinitionEndpointInput.md) - [UpdateJobEndpointInput](rapidata/api_client/docs/UpdateJobEndpointInput.md) - [UpdateLeaderboardEndpointInput](rapidata/api_client/docs/UpdateLeaderboardEndpointInput.md)