Create Superwise Client

from superwise_api.superwise_client import SuperwiseClient

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

with SuperwiseClient you can start to work with Superwise API !!!

---

Observability

Create a Dataset

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

Write data record to a dataset

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

Create an S3 Source

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

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>")

Connect a Source to a Dataset

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)

Create Destination

make sure to authenticate with the integration first - see Destinations

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>"})

Create a Policy

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
)

Create Dashboard

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

Create General Widget

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 Distribution Compare Widget

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={}
                                                             )

Application Deployment

Create Model

from superwise_api.models.application.application import ModelLLM
from superwise_api.models.application.application import ModelProvider
from superwise_api.models.application.application import OpenAIModelVersion

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

Create Application

app = sw.application.create(name="My Application", tools=[], llm_model=model)