Superwise SDK

https://sdk.docs.superwise.ai
Admin
A Python SDK for integrating with the Superwise API, providing access to dashboards, policies,...
Tokens:90,879
Snippets:373
Trust Score:9.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### Create a General Widget with Python

Source: https://sdk.docs.superwise.ai/quickstart

Adds a new widget to an existing dashboard. This example demonstrates creating a table visualization based on dataset statistics, showing measures and dimensions. It requires specifying the dashboard, widget name, query type, visualization type, datasource, and data configuration.

```python
from superwise_api.models.dashboard_item.dashboard_item import VisualizationType
from superwise_api.models.dashboard_item.dashboard_item import Datasource
from superwise_api.models.dashboard_item.dashboard_item import Query as DashboardItemQuery
from superwise_api.models.dashboard_item.dashboard_item import QueryType
from superwise_api.models.dashboard_item.dashboard_item import DataConfigGeneral as DashboardItemDataConfigGeneral

widget = sw.dashboard_item.create(dashboard_id=dashboard.id,
                                  name="My API Created Widget",
                                  query_type=QueryType.STATISTICS.value,
                                  visualization_type=VisualizationType.TABLE.value,
                                  datasource=Datasource.DATASETS.value,
                                  data_config=DashboardItemDataConfigGeneral(
                                      query=DashboardItemQuery(measures=[f"{dataset.internal_id}.maxCarat"],
                                                               limit=1000,
                                                               dimensions=[f"{dataset.internal_id}.color"])),
                                  item_metadata={}
                                  )

```

--------------------------------

### Create a Destination with Python

Source: https://sdk.docs.superwise.ai/quickstart

Defines a destination for alerts and notifications. This requires an integration to be set up first. The example shows creating a Slack destination, specifying channel details.

```python
integrations = sw.integration.get()
integration = integrations.items[0]

destination = sw.destination.create(name="My Destination",
                                    integration_id=integration.id,
                                    params={"channel_id": "<SLACK CHANNEL ID>", "channel_name": "<SLACK CHANNEL NAME>"})

```

--------------------------------

### Policy Management

Source: https://sdk.docs.superwise.ai/quickstart

Define and create policies for monitoring and alerting.

```APIDOC
## Policy Management

### Create a Policy

#### Description
Creates a new policy for monitoring data and triggering alerts based on defined conditions.

#### Method
`sw.policy.create`

#### Parameters
- **name** (string) - Required - The name of the policy.
- **dataset_id** (string) - Required - The ID of the dataset to associate with the policy.
- **data_config** (object) - Required - Configuration for the data to be analyzed (e.g., measures, time range).
  - **query** (object) - Required - Defines the data measures to use (e.g., `{"measures": ["dataset.count"]}`).
  - **time_range_config** (object) - Required - Specifies the time range for data analysis.
    - **field_name** (string) - Required - The name of the time field.
    - **unit** (string) - Required - The unit of time (e.g., "HOUR").
    - **value** (integer) - Required - The duration value.
- **cron_expression** (string) - Required - A cron expression defining the schedule for policy evaluation.
- **threshold_settings** (object) - Required - Settings for alert thresholds.
  - **condition_above_value** (float) - Optional - Alert if the value is above this threshold.
  - **condition_below_value** (float) - Optional - Alert if the value is below this threshold.
- **alert_on_status** (string) - Required - When to trigger alerts (e.g., "HEALTHY_TO_UNHEALTHY").
- **alert_on_policy_level** (boolean) - Required - Whether to alert on the overall policy level.
- **destination_ids** (list) - Required - A list of destination IDs to send alerts to.
- **initialize_with_historic_data** (boolean) - Required - Whether to initialize the policy with historic data.

#### Request Example
```python
from superwise_api.models.policy.policy import StaticThresholdSettings
from superwise_api.models.policy.policy import DataConfigStatistics
from superwise_api.models.policy.policy import TimeRangeConfig

policy = sw.policy.create(
    name='my_policy',
    dataset_id=dataset.id,
    data_config=DataConfigStatistics(
        query={"measures": [f"{dataset.internal_id}.count"]},  ## you can use Query object for more complex queries
        time_range_config=TimeRangeConfig(
            field_name="ts",
            unit="HOUR",
            value=2
        )
    ),
    cron_expression="2 */1 * * *",
    threshold_settings=StaticThresholdSettings(
        condition_above_value=3.0,
        condition_below_value=None,
    ),
    alert_on_status="HEALTHY_TO_UNHEALTHY",
    alert_on_policy_level=True,
    destination_ids=[destination.id],
    initialize_with_historic_data=True
)
```
```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/dashboard/schemas/query

Demonstrates how to configure Pydantic models using `model_config`. This example shows setting `populate_by_name` and `validate_assignment` to True, enabling more flexible model usage.

```python
model_config = {'populate_by_name': True, 'validate_assignment': True}
Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].
```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/guardrails/schemas/guardrails

Demonstrates how to configure a Pydantic model using model_config. This example sets the 'extra' configuration to 'allow', enabling the model to accept additional fields not explicitly defined.

```python
model_config = {'extra': 'allow'}

```

--------------------------------

### Create Superwise Client with Python

Source: https://sdk.docs.superwise.ai/quickstart

Initializes the SuperwiseClient. Ensure that SUPERWISE_CLIENT_ID and SUPERWISE_CLIENT_SECRET environment variables are set before instantiation. This client is the entry point for interacting with the Superwise API.

```python
from superwise_api.superwise_client import SuperwiseClient

# assure that you have SUPERWISE_CLIENT_ID, SUPERWISE_CLIENT_SECRET in your env
sw = SuperwiseClient()

```

--------------------------------

### Dashboard Management

Source: https://sdk.docs.superwise.ai/quickstart

Create and manage dashboards for visualizing data.

```APIDOC
## Dashboard Management

### Create Dashboard

#### Description
Creates a new dashboard to organize and visualize metrics and insights.

#### Method
`sw.dashboard.create`

#### Parameters
- **name** (string) - Required - The name of the dashboard.

#### Request Example
```python
dashboard = sw.dashboard.create(name="My Dashboard")
```

### Create General Widget

#### Description
Creates a new widget within a dashboard to display specific data visualizations and insights.

#### Method
`sw.dashboard_item.create`

#### Parameters
- **dashboard_id** (string) - Required - The ID of the dashboard to which the widget will be added.
- **name** (string) - Required - The name of the widget.
- **query_type** (string) - Required - The type of query for the widget (e.g., `QueryType.STATISTICS.value`).
- **visualization_type** (string) - Required - The type of visualization (e.g., `VisualizationType.TABLE.value`).
- **datasource** (string) - Required - The data source for the widget (e.g., `Datasource.DATASETS.value`).
- **data_config** (object) - Required - Configuration for the widget's data.
  - **query** (object) - Required - Query definition for the data.
    - **measures** (list) - Required - List of measures to display.
    - **limit** (integer) - Optional - Limit for the number of results.
    - **dimensions** (list) - Optional - List of dimensions to group by.
- **item_metadata** (dict) - Optional - Metadata for the widget.

#### Request Example
```python
from superwise_api.models.dashboard_item.dashboard_item import VisualizationType
from superwise_api.models.dashboard_item.dashboard_item import Datasource
from superwise_api.models.dashboard_item.dashboard_item import Query as DashboardItemQuery
from superwise_api.models.dashboard_item.dashboard_item import QueryType
from superwise_api.models.dashboard_item.dashboard_item import DataConfigGeneral as DashboardItemDataConfigGeneral

widget = sw.dashboard_item.create(dashboard_id=dashboard.id,
                                  name="My API Created Widget",
                                  query_type=QueryType.STATISTICS.value,
                                  visualization_type=VisualizationType.TABLE.value,
                                  datasource=Datasource.DATASETS.value,
                                  data_config=DashboardItemDataConfigGeneral(
                                      query=DashboardItemQuery(measures=[f"{dataset.internal_id}.maxCarat"],
                                                               limit=1000,
                                                               dimensions=[f"{dataset.internal_id}.color"])),
                                  item_metadata={}
                                  )
```
```

--------------------------------

### Observability: Source Management

Source: https://sdk.docs.superwise.ai/quickstart

Configure data sources for Superwise, including S3 and GCS sources.

```APIDOC
## Observability: Source Management

### Create an S3 Source

#### Description
Creates a new S3 source configuration for ingesting data into Superwise.

#### Method
`sw.source.create_s3_source`

#### Parameters
- **name** (string) - Required - The name of the S3 source.
- **bucket_arn** (string) - Required - The ARN of the S3 bucket.
- **queue_arn** (string) - Required - The ARN of the SQS queue.
- **aws_access_key_id** (string) - Required - Your AWS access key ID.
- **aws_secret_access_key** (string) - Required - Your AWS secret access key.

#### Request Example
```python
s3_source = sw.source.create_s3_source(name="My S3 Source", bucket_arn="<S3 Bucket ARN>", queue_arn="<SQS ARN>", aws_access_key_id="<AWS ACCESS KEY ID>", aws_secret_access_key="<AWS SECRET ACCESS KEY>")
```

### Create GCS Source

#### Description
Creates a new Google Cloud Storage (GCS) source configuration for ingesting data into Superwise.

#### Method
`sw.source.create_gcs_source`

#### Parameters
- **name** (string) - Required - The name of the GCS source.
- **bucket_name** (string) - Required - The name of the GCS bucket.
- **pubsub_topic** (string) - Required - The Pub/Sub topic associated with the GCS bucket.
- **service_account** (string or dict) - Required - The path to the service account file or a service account dictionary.

#### Request Example
```python
gcs_source = sw.source.create_gcs_source(name="My GCS Source", bucket_name="<GCS BUCKET NAME>", pubsub_topic="<PUBSUB TOPIC>", service_account="<LOCAL PATH TO SERVICE ACCOUNT FILE OR SERVICE ACCOUNT DICTIONARY>")
```
```

--------------------------------

### Destination Management

Source: https://sdk.docs.superwise.ai/quickstart

Create destinations for alerts and notifications.

```APIDOC
## Destination Management

### Create Destination

#### Description
Creates a destination for receiving alerts and notifications. Ensure you have authenticated with the relevant integration first.

#### Method
`sw.destination.create`

#### Parameters
- **name** (string) - Required - The name of the destination.
- **integration_id** (string) - Required - The ID of the integration to use for the destination.
- **params** (dict) - Required - A dictionary of parameters specific to the integration (e.g., channel ID and name for Slack).

#### Request Example
```python
# First, retrieve available integrations
integrations = sw.integration.get()
integration = integrations.items[0] # Assuming the first integration is suitable

destination = sw.destination.create(name="My Destination",
                                    integration_id=integration.id,
                                    params={"channel_id": "<SLACK CHANNEL ID>", "channel_name": "<SLACK CHANNEL NAME>"})
```
```

--------------------------------

### Pydantic BaseModel Configuration Example

Source: https://sdk.docs.superwise.ai/guardrails/schemas/guardrails

Defines the configuration for a Pydantic model, specifying the type, threshold, validation method, and allowing extra configurations. This example demonstrates how to set up a model with specific validation rules and configuration options.

```python
type: Literal['toxicity']
threshold: float
validation_method: Union[Literal['sentence'], Literal['full']]
model_config = {'extra': 'allow'}
```

--------------------------------

### Superwise Client Initialization

Source: https://sdk.docs.superwise.ai/quickstart

Initialize the SuperwiseClient to interact with the Superwise API. Ensure your environment variables SUPERWISE_CLIENT_ID and SUPERWISE_CLIENT_SECRET are set.

```APIDOC
## Initialize Superwise Client

### Description
Initialize the SuperwiseClient to start working with the Superwise API. Ensure that the `SUPERWISE_CLIENT_ID` and `SUPERWISE_CLIENT_SECRET` environment variables are set.

### Method
Instantiate `SuperwiseClient`

### Code Example
```python
from superwise_api.superwise_client import SuperwiseClient

# Assure that you have SUPERWISE_CLIENT_ID, SUPERWISE_CLIENT_SECRET in your env
sw = SuperwiseClient()
```
```

--------------------------------

### Observability: Dataset-Source Connection

Source: https://sdk.docs.superwise.ai/quickstart

Connect data sources to datasets for data ingestion.

```APIDOC
## Observability: Dataset-Source Connection

### Connect a Source to a Dataset

#### Description
Connects a configured data source to a dataset, specifying the ingestion folder and type.

#### Method
`sw.dataset.connect_to_source` or `sw.dataset_source.create`

#### Parameters
- **dataset_id** (string) - Required - The ID of the dataset to connect to.
- **source_id** (string) - Required - The ID of the source to connect.
- **folder** (string) - Required - The path within the source bucket/storage to ingest data from.
- **ingest_type** (IngestType enum) - Required - The type of ingestion (e.g., `IngestType.INSERT`).

#### Request Example
```python
from superwise_api.models.dataset_source.dataset_source import IngestType

# Using sw.dataset.connect_to_source
dataset_source = sw.dataset.connect_to_source(dataset_id=dataset.id,
                                              source_id=gcs_source.id,
                                              folder="path/to/my/data/within/the/bucket",
                                              ingest_type=IngestType.INSERT)

## Alternatively, using sw.dataset_source.create
dataset_source = sw.dataset_source.create(dataset_id=dataset.id,
                                          source_id=gcs_source.id,
                                          folder="path/to/my/data/within/the/bucket",
                                          ingest_type=IngestType.INSERT)
```
```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/agent/schemas/agent

This snippet demonstrates how to configure a Pydantic model using `model_config`. The example sets `populate_by_name` to True, allowing instantiation using field names, and `validate_assignment` to True, ensuring validation occurs when attributes are modified after instantiation.

```python
model_config = {"populate_by_name": True, "validate_assignment": True}
```

--------------------------------

### Observability: Dataset Management

Source: https://sdk.docs.superwise.ai/quickstart

Manage datasets within Superwise, including creating new datasets and logging data records.

```APIDOC
## Observability: Dataset Management

### Create a Dataset

#### Description
Creates a new dataset within the Superwise platform.

#### Method
`sw.dataset.create`

#### Parameters
- **name** (string) - Required - The name of the dataset.
- **id** (string) - Required - A unique identifier for the dataset.

#### Request Example
```python
dataset = sw.dataset.create(name="My Dataset", id="dataset_id")
```

### Write data record to a dataset

#### Description
Logs a single data record to a specified dataset.

#### Method
`dataset.log_record_to_dataset`

#### Parameters
- **dataset_id** (string) - Required - The ID of the dataset to which the record will be logged.
- **data** (dict) - Required - A dictionary containing the data record.

#### Request Example
```python
dataset.log_record_to_dataset(
    dataset_id="dataset_id",
    data={
        "some_data_key": "some_data_value",
        "another_data_key": "another_data_value"
        }
    )
```
```

--------------------------------

### Connect Source to Dataset with Python

Source: https://sdk.docs.superwise.ai/quickstart

Establishes a connection between a configured data source (S3 or GCS) and a dataset. This involves specifying the dataset, source, the folder within the source to ingest, and the ingestion type (e.g., INSERT).

```python
from superwise_api.models.dataset_source.dataset_source import IngestType

dataset_source = sw.dataset.connect_to_source(dataset_id=dataset.id,
                                              source_id=gcs_source.id,
                                              folder="path/to/my/data/within/the/bucket",
                                              ingest_type=IngestType.INSERT)
## or you can do it with DatasetSource meta entity
dataset_source = sw.dataset_source.create(dataset_id=dataset.id,
                                          source_id=gcs_source.id,
                                          folder="path/to/my/data/within/the/bucket",
                                          ingest_type=IngestType.INSERT)

```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/policy/schemas/policy

This example demonstrates a Pydantic model configuration using `model_config`. It shows how to set options like `populate_by_name` and `validate_assignment` for model behavior. This configuration is essential for customizing data validation and parsing.

```python
from typing import Literal
from pydantic import Field
from pydantic.config import ConfigDict

# Assuming TimeRangeConfig and Query are defined elsewhere
# from some_module import TimeRangeConfig, Query

# Placeholder types for demonstration
class TimeRangeConfig:
    pass
class Query:
    pass

type: Literal[<DataConfigType.STATISTICS: 'statistics'>]
query: Query
time_range_config: TimeRangeConfig

model_config = ConfigDict(populate_by_name=True, validate_assignment=True)

class DataConfigDistributionCompare(DataConfigBase): # Assuming DataConfigBase is a Pydantic BaseModel
    # ... other fields ...
    pass

# Usage docs: https://docs.pydantic.dev/2.10/concepts/models/
```

--------------------------------

### Create a Dataset with Python

Source: https://sdk.docs.superwise.ai/quickstart

Creates a new dataset within Superwise. A dataset is used to store and manage your data. The name and a unique ID are required parameters.

```python
dataset = sw.dataset.create(name="My Dataset", id="dataset_id")

```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/destination/schemas/destination

Illustrates how to configure a Pydantic model using `model_config`. This example sets `populate_by_name` to `True`, allowing instantiation using field names or their aliases, and `validate_assignment` to `True`, enabling validation when model attributes are modified after instantiation. Configuration is provided as a dictionary conforming to `ConfigDict`.

```python
from pydantic import BaseModel, ConfigDict

class MyModel(BaseModel):
    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
    # ... fields ...

```

--------------------------------

### Create a Dashboard with Python

Source: https://sdk.docs.superwise.ai/quickstart

Creates a new dashboard within Superwise. Dashboards are used to visualize data and monitor metrics. A name is the primary parameter for creation.

```python
dashboard = sw.dashboard.create(name="My Dashboard")

```

--------------------------------

### Create a GCS Source with Python

Source: https://sdk.docs.superwise.ai/quickstart

Sets up a Google Cloud Storage (GCS) bucket as a data source. Requires the bucket name, a Pub/Sub topic for notifications, and service account credentials. This enables Superwise to ingest data from GCS.

```python
gcs_source = sw.source.create_gcs_source(name="My GCS Source", bucket_name="<GCS BUCKET NAME>", pubsub_topic="<PUBSUB TOPIC>",
                                         service_account="<LOCAL PATH TO SERVICE ACCOUNT FILE OR SERVICE ACCOUNT DICTIONARY>")

```

--------------------------------

### Create an S3 Source with Python

Source: https://sdk.docs.superwise.ai/quickstart

Configures an S3 bucket as a data source for Superwise. Requires the bucket ARN, SQS queue ARN for notifications, and AWS credentials. This allows Superwise to ingest data directly from S3.

```python
s3_source = sw.source.create_s3_source(name="My S3 Source", bucket_arn="<S3 Bucket ARN>",
                                       queue_arn="<SQS ARN>", aws_access_key_id="<AWS ACCESS KEY ID>",
                                       aws_secret_access_key="<AWS SECRET ACCESS KEY>")

```

--------------------------------

### Create a Policy with Python

Source: https://sdk.docs.superwise.ai/quickstart

Defines a monitoring policy to detect anomalies or specific conditions in your data. This includes specifying the dataset, data configuration, a cron schedule for evaluation, threshold settings, and connected destinations for alerts. It can also be initialized with historic data.

```python
from superwise_api.models.policy.policy import StaticThresholdSettings
from superwise_api.models.policy.policy import DataConfigStatistics
from superwise_api.models.policy.policy import TimeRangeConfig

policy = sw.policy.create(
    name='my_policy',
    dataset_id=dataset.id,
    data_config=DataConfigStatistics(
        query={"measures": [f"{dataset.internal_id}.count"]},  ## you can use Query object for more complex queries
        time_range_config=TimeRangeConfig(
            field_name="ts",
            unit="HOUR",
            value=2
        )
    ),
    cron_expression="2 */1 * * *",
    threshold_settings=StaticThresholdSettings(
        condition_above_value=3.0,
        condition_below_value=None,
    ),
    alert_on_status="HEALTHY_TO_UNHEALTHY",
    alert_on_policy_level=True,
    destination_ids=[destination.id],
    initialize_with_historic_data=True
)

```

--------------------------------

### Log Data Record to Dataset with Python

Source: https://sdk.docs.superwise.ai/quickstart

Appends a single data record to an existing dataset. The record is provided as a dictionary. This is useful for logging individual events or data points.

```python
dataset.log_record_to_dataset(
    dataset_id="dataset_id",
    data={
        "some_data_key": "some_data_value",
        "another_data_key": "another_data_value"
        }
    )

```

--------------------------------

### Create Agent using Python

Source: https://sdk.docs.superwise.ai/quickstart

This Python code snippet illustrates how to create an agent using the Superwise AI SDK. It takes a name for the agent and an optional list of tools, and it requires a configured LLM model (like the one defined previously).

```python
app = sw.agent.create(name="My Agent", tools=[], llm_model=model)


```

--------------------------------

### Pydantic BaseModel Inheritance Example

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Illustrates how to create a new Pydantic model by inheriting from `ToolConfigBase`. It also shows the usage documentation link for Pydantic models.

```python
class ToolConfigOpenAPI(ToolConfigBase):
    # Usage docs: https://docs.pydantic.dev/2.10/concepts/models/
    pass
```

--------------------------------

### Pydantic BaseModel Configuration Example

Source: https://sdk.docs.superwise.ai/guardrails/schemas/guardrails

Demonstrates setting model configuration, including 'extra' behavior, using a dictionary that conforms to Pydantic's ConfigDict. This allows for flexible handling of undefined fields.

```python
model_config = {'extra': 'allow'}
```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Demonstrates how to define configuration for a Pydantic model using `model_config`. This allows customization of model behavior, such as setting a type for a specific tool configuration.

```python
import pydantic
from typing import Literal, ClassVar

class ToolConfigSQLBase:
    type: Literal[<ToolType.SQL_DATABASE_BIGQUERY: 'BigQuery'>]
    project_id: str
    dataset_id: str
    service_account: dict[str, str]
    model_config: ClassVar[pydantic.config.ConfigDict] = {}

class ToolConfigPGVector(ToolConfigSQLBase):
    pass

```

--------------------------------

### Create OpenAI Model for Agent using Python

Source: https://sdk.docs.superwise.ai/quickstart

This Python snippet shows how to define an LLM model configuration for an agent using the Superwise AI SDK. It specifically configures an OpenAI model, specifying the provider, version (GPT-3.5-turbo), and requiring an API token.

```python
from superwise_api.models.agent.agent import ModelLLM
from superwise_api.models.agent.agent import ModelProvider
from superwise_api.models.agent.agent import OpenAIModelVersion

model = ModelLLM(provider=ModelProvider.OPENAI, version=OpenAIModelVersion.GPT_3_5_TURBO,
                 api_token="your-openai-api-key")


```

--------------------------------

### Pydantic BaseModel Configuration Example

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Demonstrates how to configure a Pydantic BaseModel using the `model_config` attribute. This allows for customization of model behavior, such as handling extra fields. It uses a `ClassVar` for type hinting.

```python
from typing import ClassVar
import pydantic

class MyModel(pydantic.BaseModel):
    table_name: str
    model_config: ClassVar[pydantic.config.ConfigDict] = {
        "extra": "allow"
    }

```

--------------------------------

### Pydantic Model Configuration Example

Source: https://sdk.docs.superwise.ai/guardrails/schemas/guardrails

Defines a Pydantic model with type hints for detection, a threshold, categories, and model configuration allowing extra fields. This sets up a basic structure for data validation and processing.

```python
type: Literal['pii_detection']
threshold: float
categories: set[str]
model_config = {'extra': 'allow'}
```

--------------------------------

### Data Configuration Model Example

Source: https://sdk.docs.superwise.ai/dashboard_item/schemas/dashboard_item

Demonstrates the configuration for a data model, including type literals for data configuration, query objects, and optional distance functions. It also shows Pydantic's model configuration for validation.

```python
type: Literal[<DataConfigType.DISTRIBUTION_COMPARE: 'distribution_compare'>]
query_a: superwise_api.models.dashboard.query.Query
query_b: superwise_api.models.dashboard.query.Query
distance_function: Optional[DistanceFunction]
model_config = {'populate_by_name': True, 'validate_assignment': True}
Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].
```

--------------------------------

### Pydantic Model Configuration and Validation Example

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Demonstrates a Pydantic model `FileKnowledgeMetadata` that inherits from `BaseModel`. It includes configuration settings and a custom validator for the 'url' field to ensure a valid URL scheme.

```python
class FileKnowledgeMetadata(pydantic.main.BaseModel):
  type: Literal[<KnowledgeType.URL: 'url'>]
  url: str
  max_depth: int

  @field_validator('url')
  def validate_url_scheme(cls, value):
    # Custom validation logic for URL scheme would go here
    return value

model_config: ClassVar[pydantic.config.ConfigDict] = {}
# Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].
```

--------------------------------

### Get Sources - Python

Source: https://sdk.docs.superwise.ai/source/source_api

Retrieves a paginated list of sources based on optional filters such as name, creator, creation/update timestamps, and source type. Allows specifying page number and size.

```python
def get( self, name: Optional[str] = None, created_by: Optional[str] = None, created_at: Optional[datetime.datetime] = None, updated_at: Optional[datetime.datetime] = None, type: Optional[superwise_api.models.source.source.SourceType] = None, page: Optional[Annotated[int, Strict(strict=True), Interval(gt=None, ge=1, lt=None, le=None), None]] = None, size: Optional[Annotated[int, Strict(strict=True), Interval(gt=None, ge=1, lt=None, le=500), None]] = None, **kwargs) -> superwise_api.client.models.page.Page:
Retrieves sources based on the provided filters.
###### Arguments:
  * **name (Optional[str], optional):** The name of the source.
  * **created_by (Optional[str], optional):** The creator of the source.
  * **created_at (Optional[datetime], optional):** When the source was created.
  * **updated_at (Optional[datetime], optional):** When the source was last updated.
  * **type (Optional[SourceType], optional):** The type of the source.
  * **page (Optional[conint(strict=True, ge=1)], optional):** The page number to retrieve.
  * **size (Optional[conint(strict=True, le=500, ge=1)], optional):** The number of sources to retrieve per page.
  * ****kwargs:** Arbitrary keyword arguments.


###### Returns:
> Page: A page of sources.
```

--------------------------------

### Pydantic BaseModel Inheritance and Type Aliases

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Demonstrates type aliases and discriminators used with Pydantic models, facilitating the creation of complex and flexible data structures. These examples showcase how to create union types with specific discriminators for runtime type checking.

```python
ToolConfig =  typing.Annotated[ToolConfigPGVector | ToolConfigPineconeVectorDB | ToolConfigSQLDatabasePostgres | ToolConfigSQLDatabaseMySQL | ToolConfigSQLDatabaseMSSQL | ToolConfigSQLDatabaseOracle | ToolConfigBigQuery | ToolConfigOpenAPI | ToolConfigKnowledge | ToolConfigMCP, Discriminator(discriminator='type', custom_error_type=None, custom_error_message=None, custom_error_context=None)]
SQL_TOOLS =  typing.Annotated[ToolConfigSQLDatabasePostgres | ToolConfigSQLDatabaseMySQL | ToolConfigSQLDatabaseMSSQL | ToolConfigSQLDatabaseOracle | ToolConfigBigQuery, Discriminator(discriminator='type', custom_error_type=None, custom_error_message=None, custom_error_context=None)]
ContextConfig =  typing.Annotated[ToolConfigKnowledge | ToolConfigPGVector | ToolConfigPineconeVectorDB | ToolConfigSQLDatabasePostgres | ToolConfigSQLDatabaseMySQL | ToolConfigSQLDatabaseMSSQL | ToolConfigSQLDatabaseOracle | ToolConfigBigQuery, Discriminator(discriminator='type', custom_error_type=None, custom_error_message=None, custom_error_context=None)]
```

--------------------------------

### Pydantic BaseModel Inherited Members and Version Class Example

Source: https://sdk.docs.superwise.ai/agent/schemas/agent

This snippet illustrates the common members inherited from Pydantic's `BaseModel` and presents a concrete example of a `Version` class. The `Version` class inherits from `SuperwiseEntity` and utilizes Pydantic's features for data modeling, including methods like `to_str`, `to_json`, and `from_json`.

```python
Usage docs: https://docs.pydantic.dev/2.10/concepts/models/
A base class for creating Pydantic models.

##### Inherited Members pydantic.main.BaseModel
    BaseModel     model_extra     model_fields_set     model_construct     model_copy     model_dump     model_dump_json     model_json_schema     model_parametrized_name     model_post_init     model_rebuild     model_validate     model_validate_json     model_validate_strings     dict     json     parse_obj     parse_raw     parse_file     from_orm     construct     copy     schema     schema_json     validate     update_forward_refs     model_fields     model_computed_fields

superwise_api.models.SuperwiseEntity
    to_str     to_json     to_dict     from_json

class Version(superwise_api.models.SuperwiseEntity):
    ...

```

--------------------------------

### Agent API - Get Agents

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a list of agents, with optional filtering.

```APIDOC
## GET /api/agents

### Description
Gets agents. Filter if any of the parameters are provided.

### Method
GET

### Endpoint
/api/agents

#### Query Parameters
- **name** (str) - Optional - The name of the agent.
- **created_by** (str) - Optional - The creator of the agent.
- **prompt** (str) - Optional - The prompt of the agent.
- **dataset_id** (str) - Optional - The id of the dataset.
- **page** (int) - Optional - The page number. Must be greater than or equal to 1.
- **size** (int) - Optional - The size of the page. Must be between 1 and 500 (inclusive).

### Response
#### Success Response (200)
- **page** (Page) - A page object containing a list of agents.

#### Response Example
```json
{
  "items": [
    {
      "id": "agent_123",
      "name": "My new agent",
      "description": "This is a test agent",
      "authentication_enabled": true,
      "observability_enabled": false,
      "block_guardrails_violations": false,
      "guardrails_violation_message": "Please try again later."
    }
  ],
  "total_items": 10,
  "page": 1,
  "size": 10
}
```
```

--------------------------------

### Agent API - Get Agent Versions

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a list of all versions for a given agent.

```APIDOC
## GET /api/agents/{agent_id}/versions

### Description
Retrieves all versions for a given agent.

### Method
GET

### Endpoint
/api/agents/{agent_id}/versions

#### Path Parameters
- **agent_id** (str) - Required - The id of the agent.

#### Query Parameters
- **name** (str) - Optional - Filter by version name.
- **created_by** (str) - Optional - Filter by the creator of the version.

### Response
#### Success Response (200)
- **versions** (list[Version]) - A list of agent version objects.

#### Response Example
```json
[
  {
    "id": "version_xyz",
    "agent_id": "agent_123",
    "name": "v1.0",
    "description": "Initial version",
    "agent_config": {
      "type": "BasicLLMConfig",
      "llm_model_id": "gpt-4"
    },
    "guardrails": ["guardrail_abc"]
  }
]
```
```

--------------------------------

### Get Dashboards

Source: https://sdk.docs.superwise.ai/dashboard/dashboard_api

Retrieves a paginated list of dashboards, optionally filtered by name.

```APIDOC
## GET /dashboards

### Description
Gets all dashboards.

### Method
GET

### Endpoint
/dashboards

### Parameters
#### Query Parameters
- **name** (str, optional) - The name of the dashboard to filter by.
- **page** (int, optional) - The page number for pagination. Must be greater than or equal to 1.
- **size** (int, optional) - The number of items per page. Must be between 1 and 500.

### Request Example
```json
{
  "name": "My Dashboard",
  "page": 1,
  "size": 50
}
```

### Response
#### Success Response (200)
- **items** (array) - A list of dashboard objects.
- **total** (int) - The total number of dashboards available.
- **page** (int) - The current page number.
- **size** (int) - The number of items per page.

#### Response Example
```json
{
  "items": [
    {
      "id": "dsh_12345",
      "name": "My Dashboard",
      "created_at": "2023-10-27T10:00:00Z",
      "updated_at": "2023-10-27T10:00:00Z"
    }
  ],
  "total": 1,
  "page": 1,
  "size": 50
}
```
```

--------------------------------

### Agent API - Get Agent Version by ID

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a specific agent version by its ID.

```APIDOC
## GET /api/agents/{agent_id}/versions/{version_id}

### Description
Retrieves a specific agent version by its ID.

### Method
GET

### Endpoint
/api/agents/{agent_id}/versions/{version_id}

#### Path Parameters
- **agent_id** (str) - Required - The id of the agent.
- **version_id** (str) - Required - The id of the version to retrieve.

### Response
#### Success Response (200)
- **version** (Version) - The retrieved agent version object.

#### Response Example
```json
{
  "id": "version_xyz",
  "agent_id": "agent_123",
  "name": "v1.0",
  "description": "Initial version",
  "agent_config": {
    "type": "BasicLLMConfig",
    "llm_model_id": "gpt-4"
  },
  "guardrails": ["guardrail_abc"]
}
```
```

--------------------------------

### Integration API

Source: https://sdk.docs.superwise.ai/integration/integration_api

Provides methods to interact with the Integration API, including getting, deleting, and listing integrations.

```APIDOC
## GET /integrations

### Description
Retrieves a list of integrations, with optional filtering by name, type, creator, and pagination.

### Method
GET

### Endpoint
/integrations

### Parameters
#### Query Parameters
- **name** (str, optional) - The name of the integration.
- **integration_type** (IntegrationType, optional) - The type of the integration.
- **created_by** (str, optional) - The user who created the integration.
- **page** (int, optional) - The page number.
- **size** (int, optional) - The number of integrations per page.

### Response
#### Success Response (200)
- **Page** (Page) - A page object containing a list of integrations.

#### Response Example
```json
{
  "items": [
    {
      "id": "integration_id_1",
      "name": "Example Integration 1",
      "type": "WEBHOOK",
      "created_by": "user_id_1",
      "created_at": "2023-10-27T10:00:00Z"
    },
    {
      "id": "integration_id_2",
      "name": "Example Integration 2",
      "type": "API",
      "created_by": "user_id_2",
      "created_at": "2023-10-27T11:00:00Z"
    }
  ],
  "total_items": 2,
  "page": 0,
  "size": 10
}
```

## GET /integrations/{integration_id}

### Description
Retrieves a specific integration by its unique identifier.

### Method
GET

### Endpoint
/integrations/{integration_id}

### Parameters
#### Path Parameters
- **integration_id** (str) - Required - The unique identifier of the integration to retrieve.

### Response
#### Success Response (200)
- **Integration** (Integration) - The requested integration object.

#### Response Example
```json
{
  "id": "integration_id_1",
  "name": "Example Integration 1",
  "type": "WEBHOOK",
  "created_by": "user_id_1",
  "created_at": "2023-10-27T10:00:00Z"
}
```

## DELETE /integrations/{integration_id}

### Description
Deletes an integration by its unique identifier. Optionally, it can also delete associated destinations.

### Method
DELETE

### Endpoint
/integrations/{integration_id}

### Parameters
#### Path Parameters
- **integration_id** (str) - Required - The unique identifier of the integration to delete.

#### Query Parameters
- **delete_destinations** (bool, optional) - If true, deletes associated destinations. Defaults to false.

### Response
#### Success Response (204)
No content is returned upon successful deletion.

#### Response Example
(No content)

```

--------------------------------

### Get Agent Versions

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a list of all versions for a given agent ID. Can be filtered by version name or creator.

```python
from superwise_api.client.api_client import ApiClient
from superwise_api.entities.agent import AgentApi

# Assuming agent_api is an initialized AgentApi instance
agent_id = "your_agent_id"
versions = agent_api.get_versions(agent_id=agent_id, name="v1.0")
```

--------------------------------

### Get Agents

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a paginated list of agents. Supports filtering by name, creator, prompt, dataset ID, and pagination parameters.

```python
from superwise_api.client.api_client import ApiClient
from superwise_api.entities.agent import AgentApi

# Assuming agent_api is an initialized AgentApi instance
agent_page = agent_api.get(
    name="My Agent",
    page=1,
    size=10
)
```

--------------------------------

### Get Agent Version by ID

Source: https://sdk.docs.superwise.ai/agent/agent_api

Retrieves a specific agent version using its unique version ID and the agent's ID.

```python
from superwise_api.client.api_client import ApiClient
from superwise_api.entities.agent import AgentApi

# Assuming agent_api is an initialized AgentApi instance
agent_id = "your_agent_id"
version_id = "your_version_id"
version = agent_api.get_version_by_id(agent_id=agent_id, version_id=version_id)
```

--------------------------------

### Initialize AgentApi

Source: https://sdk.docs.superwise.ai/agent/agent_api

Initializes the AgentApi class with an ApiClient instance. This is the entry point for interacting with the Agent API.

```python
from superwise_api.client.api_client import ApiClient
from superwise_api.entities.agent import AgentApi

# Assuming api_client is an initialized ApiClient instance
agent_api = AgentApi(api_client=api_client)
```

--------------------------------

### Get Dashboards - Python

Source: https://sdk.docs.superwise.ai/dashboard/dashboard_api

Retrieves a paginated list of dashboards. Supports filtering by name and specifying page number and size. Requires an initialized SuperwiseClient.

```python
from superwise_api.entities.dashboard import DashboardApi
from superwise_api.client import SuperwiseClient

# Assuming api_client is an initialized SuperwiseClient instance
# api_client = SuperwiseClient(...)

dashboard_api = DashboardApi(api_client)

# Get all dashboards with default pagination
all_dashboards_page = dashboard_api.get()
print(f"Total dashboards: {all_dashboards_page.total}")

# Get dashboards with specific pagination and filtering
filtered_dashboards = dashboard_api.get(name="Specific Dashboard Name", page=1, size=10)
for dashboard in filtered_dashboards.items:
    print(f"- {dashboard.name}")
```

--------------------------------

### Create Distribution Compare Widget using Python

Source: https://sdk.docs.superwise.ai/quickstart

This snippet demonstrates how to create a distribution compare widget using the Superwise AI Python SDK. It defines two queries (query_a and query_b) to compare distributions of a measure across different filter values. The widget is configured with a table visualization and uses the 'wasserstein_distance' as the distance function.

```python
from superwise_api.models.dashboard_item.dashboard_item import VisualizationType
from superwise_api.models.dashboard_item.dashboard_item import Datasource
from superwise_api.models.dashboard_item.dashboard_item import Query as DashboardItemQuery
from superwise_api.models.dashboard_item.dashboard_item import QueryType
from superwise_api.models.dashboard_item.dashboard_item import

DataConfigDistributionCompare as DashboardItemDataConfigDistributionCompare

# Get distribution of X for color D
query_a = DashboardItemQuery(measures=[f"{dataset.internal_id}.count", f"{dataset.internal_id}.__quantilesX"],
                             limit=1000,
                             dimensions=[f"{dataset.internal_id}.__x_bucket"],
                             filters=[
                                 {"member": f"{dataset.internal_id}.color", "operator": "equals", "values": ["D"]}],)

                             # Get distribution of X for color F
                             query_b=DashboardItemQuery(
                                 measures=[f"{dataset.internal_id}.count", f"{dataset.internal_id}.__quantilesX"],
                                 limit=1000,
                                 dimensions=[f"{dataset.internal_id}.__x_bucket"],
                                 filters=[{"member": f"{dataset.internal_id}.color", "operator": "equals",
                                           "values": ["F"]}])

                             widget=sw.dashboard_item.create(dashboard_id=dashboard.id,
                                                             name="My API Created Widget",
                                                             query_type=QueryType.STATISTICS.value,
                                                             visualization_type=VisualizationType.TABLE.value,
                                                             datasource=Datasource.DATASETS.value,
                                                             data_config=DashboardItemDataConfigDistributionCompare(
                                                                 query_a=query_a,
                                                                 query_b=query_b,
                                                                 distance_function="wasserstein_distance"),
                                                             item_metadata={})


```

--------------------------------

### Model Field Definitions

Source: https://sdk.docs.superwise.ai/agent/schemas/agent

Example of field definitions within a Pydantic model, showcasing type annotations, including `typing.Annotated` for custom validation and metadata, and union types for flexibility.

```python
id: typing.Annotated[uuid.UUID, UuidVersion(uuid_version=4)]
agent_id: typing.Annotated[uuid.UUID, UuidVersion(uuid_version=4)]
created_by: str
created_at: datetime.datetime | None
updated_at: datetime.datetime | None
name: str
description: str | None
agent_config: typing.Annotated[ReactAgentConfig | ContextChainConfig | BasicLLMConfig | FlowiseAppConfig, Discriminator(discriminator='type', custom_error_type=None, custom_error_message=None, custom_error_context=None)]
guardrails: list[typing.Annotated[uuid.UUID, UuidVersion(uuid_version=4)]]
```

--------------------------------

### Python: Get Guardrule Schema

Source: https://sdk.docs.superwise.ai/guardrails/guardrails_api

Fetches the schema definitions for the available guardrules. This provides details on the expected parameters and structure for each type of guardrule, aiding in their correct configuration.

```python
import superwise_api

api = superwise_api.GuardrailsApi()

# Example: Get guardrule schema
guardrule_schemas = api.gardrules_schema()
print("Guardrule schemas:")
for schema in guardrule_schemas:
    print(f"- Type: {schema['type']}, Schema: {schema['schema']}")
```

--------------------------------

### Create Policy - Python

Source: https://sdk.docs.superwise.ai/policy/policy_api

Creates a new policy with specified configurations. Requires detailed arguments like name, data configuration, cron schedule, threshold settings, dataset IDs, and destination IDs. Supports optional initialization with historic data and a secondary dataset.

```python
def create(
    self,
    name: str,
    data_config: Union[superwise_api.models.policy.policy.DataConfigStatistics, superwise_api.models.policy.policy.DataConfigDistributionCompare],
    cron_expression: str,
    threshold_settings: Union[superwise_api.models.policy.policy.StaticThresholdSettings, superwise_api.models.policy.policy.MovingAverageThresholdSettings],
    alert_on_status: superwise_api.models.policy.policy.AlertOnStatusDirection,
    alert_on_policy_level: bool,
    dataset_id: str,
    destination_ids: list[str],
    initialize_with_historic_data: bool = False,
    dataset_b_id: str = None,
    **kwargs
) -> superwise_api.models.policy.policy.Policy:
    """Create a new policy."""
    pass
```

--------------------------------

### SQL Database Configuration (PostgreSQL)

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Defines the configuration for a PostgreSQL database connection within the SDK. It specifies the type of tool and the connection string required.

```python
type: Literal[<ToolType.SQL_DATABASE_POSTGRES: 'PostgreSQL'>]
connection_string: str
model_config: ClassVar[pydantic.config.ConfigDict] = {}
Configuration for the model, should be a dictionary conforming to [`ConfigDict`][pydantic.config.ConfigDict].
```

--------------------------------

### Get Policies with Filters - Python

Source: https://sdk.docs.superwise.ai/policy/policy_api

Fetches a paginated list of policies, allowing filtering by name, status, creator, or dataset ID. Optional page and size parameters control pagination.

```python
def get(self, name: Optional[str] = None, status: Optional[str] = None, created_by: Optional[str] = None, dataset_id: Optional[str] = None, page: Optional[int] = None, size: Optional[int] = None, **kwargs) -> superwise_api.client.models.page.Page:
    """Gets policies. Filter if any of the parameters are provided."""
    pass
```

--------------------------------

### Pydantic BaseModel Configuration and Inherited Methods

Source: https://sdk.docs.superwise.ai/tool/schemas/tool

Demonstrates the configuration dictionary `model_config` and highlights inherited methods from `pydantic.main.BaseModel`. These methods are essential for model instantiation, validation, serialization, and schema generation.

```python
import pydantic
from typing import ClassVar, Optional

class UploadResponse:
    files: list[FileUploadResponse]
    total_files: int
    total_size: int

    @classmethod
    def from_dict(cls, obj: dict) -> Optional['UploadResponse']:
        # Implementation details...
        pass

    model_config: ClassVar[pydantic.config.ConfigDict] = {}

    # Inherited members from pydantic.main.BaseModel
    # ... model_extra, model_fields_set, model_construct, model_copy, model_dump, etc.
```

--------------------------------

### Get All Dashboard Items

Source: https://sdk.docs.superwise.ai/dashboard_item/dashboard_item_api

Retrieves a paginated list of all dashboard items. This method supports filtering by name and dashboard ID, and allows for pagination using page number and size parameters.

```python
all_dashboard_items = dashboard_item_api.get(
    name="Example Item",
    dashboard_id="some_dashboard_id",
    page=1,
    size=10
)
```

--------------------------------

### Get Dashboard Item by ID

Source: https://sdk.docs.superwise.ai/dashboard_item/dashboard_item_api

Retrieves a specific dashboard item using its unique identifier. This method takes the dashboard item's ID as input and returns the corresponding DashboardItem object.

```python
dashboard_item_id = "some_item_id"
dashboard_item = dashboard_item_api.get_by_id(dashboard_item_id=dashboard_item_id)
```
Tokens:
Raw