dasl-client 1.0.26__tar.gz → 1.0.28__tar.gz

dasl_client-1.0.28/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: dasl_client
+Version: 1.0.28
+Summary: The DASL client library used for interacting with the DASL workspace
+Author-email: Antimatter Team <support@antimatter.io>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dasl_api==0.1.27
+Requires-Dist: databricks-sdk>=0.41.0
+Requires-Dist: pydantic>=2
+Requires-Dist: typing_extensions>=4.10.0
+Requires-Dist: pyyaml==6.0.2
+Dynamic: license-file
+
+# DASL Client Library
+
+The DASL (Databricks Antimatter Security Lakehouse) Client Library is a Python SDK for interacting with DASL services.
+This library provides an interface for interacting with DASL services, allowing you to manage
+datasources, rules, workspace configurations, and more from Databricks notebooks.
+
+## Features
+
+* **Simple Authentication**: Automatic workspace detection in Databricks notebooks
+* **Datasource Management**: Create, update, list, and delete datasources
+* **Rule Management**: Define and manage security detection rules to identify threats
+* **Workspace Configuration**: Update and retrieve DASL's workspace-level settings
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install dasl-client
+```
+
+## Quick Start
+
+### Databricks Notebook Environment (Recommended)
+
+The DASL client works best in Databricks notebooks with automatic authentication:
+
+```python
+from dasl_client import Client
+
+# Automatically detects Databricks context and authenticates
+client = Client.for_workspace()
+print("Connected to DASL!")
+
+# List existing datasources
+print("Existing datasources:")
+for datasource in client.list_datasources():
+    print(f"  - {datasource.metadata.name}")
+
+# List detection rules
+print("Existing detection rules:")
+for rule in client.list_rules():
+    print(f"  - {rule.metadata.name}")
+```
+
+### Creating a Datasource
+
+```python
+from dasl_client import DataSource, Schedule, BronzeSpec, SilverSpec
+
+# Create a new datasource
+datasource = Datasource(
+    source="aws",
+    source_type="cloudtrail",
+    autoloader=Autoloader(
+        enabled=True,
+        schedule=Schedule(
+            at_least_every="1h",
+            enabled=True
+        )
+    ),
+    bronze=BronzeSpec(
+        bronze_table="security_logs_bronze",
+        skip_bronze_loading=False
+    ),
+    silver=SilverSpec(
+        # Configure silver layer here, see the API reference for more details
+    ),
+    gold=GoldSpec(
+        # Configure gold layer here, see the API reference for more details
+    )
+)
+
+# Create the datasource
+created_datasource = client.create_datasource(datasource)
+print(f"Created datasource: {created.metadata.name}")
+```
+
+### Creating a Detection Rule
+
+```python
+from dasl_client.types import Rule, Schedule
+
+# Create a new detection rule to detect failed logins
+rule = Rule(
+    schedule=Schedule(
+        at_least_every="2h",
+        enabled=True,
+    ),
+    input=Rule.Input(
+        stream=Rule.Input.Stream(
+            tables=[
+                Rule.Input.Stream.Table(name="http_activity"),
+            ],
+            filter="disposition = 'Blocked'",
+            starting_timestamp=datetime(2025, 7, 8, 16, 47, 30),
+        ),
+    ),
+    output=Rule.Output(
+        summary="record was blocked",
+    ),
+)
+
+try:
+    created_rule = client.create_rule("Detect Blocked HTTP Activity", rule)
+    print(f"Successfully created rule: {created_rule.metadata.name}")
+except Exception as e:
+    print(f"Error creating rule: {e}")
+```
+
+## Requirements
+
+- Python 3.8+
+- Access to a Databricks workspace with DASL enabled
+- `databricks-sdk>=0.41.0`
+- `pydantic>=2`
+
+## Documentation
+
+For complete DASL Client documentation, examples, and API reference:
+
+- [DASL Client Documentation](https://antimatter-dasl-client.readthedocs-hosted.com/)
+- [API Reference](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/api-reference/)
+- [Quickstart Guide](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/quickstart.html)
+
+## Support
+
+- **Email**: support@antimatter.io
+- **Documentation**: [DASL Documentation](https://docs.sl.antimatter.io)

dasl_client-1.0.28/README.md

@@ -0,0 +1,129 @@
+# DASL Client Library
+
+The DASL (Databricks Antimatter Security Lakehouse) Client Library is a Python SDK for interacting with DASL services.
+This library provides an interface for interacting with DASL services, allowing you to manage
+datasources, rules, workspace configurations, and more from Databricks notebooks.
+
+## Features
+
+* **Simple Authentication**: Automatic workspace detection in Databricks notebooks
+* **Datasource Management**: Create, update, list, and delete datasources
+* **Rule Management**: Define and manage security detection rules to identify threats
+* **Workspace Configuration**: Update and retrieve DASL's workspace-level settings
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install dasl-client
+```
+
+## Quick Start
+
+### Databricks Notebook Environment (Recommended)
+
+The DASL client works best in Databricks notebooks with automatic authentication:
+
+```python
+from dasl_client import Client
+
+# Automatically detects Databricks context and authenticates
+client = Client.for_workspace()
+print("Connected to DASL!")
+
+# List existing datasources
+print("Existing datasources:")
+for datasource in client.list_datasources():
+    print(f"  - {datasource.metadata.name}")
+
+# List detection rules
+print("Existing detection rules:")
+for rule in client.list_rules():
+    print(f"  - {rule.metadata.name}")
+```
+
+### Creating a Datasource
+
+```python
+from dasl_client import DataSource, Schedule, BronzeSpec, SilverSpec
+
+# Create a new datasource
+datasource = Datasource(
+    source="aws",
+    source_type="cloudtrail",
+    autoloader=Autoloader(
+        enabled=True,
+        schedule=Schedule(
+            at_least_every="1h",
+            enabled=True
+        )
+    ),
+    bronze=BronzeSpec(
+        bronze_table="security_logs_bronze",
+        skip_bronze_loading=False
+    ),
+    silver=SilverSpec(
+        # Configure silver layer here, see the API reference for more details
+    ),
+    gold=GoldSpec(
+        # Configure gold layer here, see the API reference for more details
+    )
+)
+
+# Create the datasource
+created_datasource = client.create_datasource(datasource)
+print(f"Created datasource: {created.metadata.name}")
+```
+
+### Creating a Detection Rule
+
+```python
+from dasl_client.types import Rule, Schedule
+
+# Create a new detection rule to detect failed logins
+rule = Rule(
+    schedule=Schedule(
+        at_least_every="2h",
+        enabled=True,
+    ),
+    input=Rule.Input(
+        stream=Rule.Input.Stream(
+            tables=[
+                Rule.Input.Stream.Table(name="http_activity"),
+            ],
+            filter="disposition = 'Blocked'",
+            starting_timestamp=datetime(2025, 7, 8, 16, 47, 30),
+        ),
+    ),
+    output=Rule.Output(
+        summary="record was blocked",
+    ),
+)
+
+try:
+    created_rule = client.create_rule("Detect Blocked HTTP Activity", rule)
+    print(f"Successfully created rule: {created_rule.metadata.name}")
+except Exception as e:
+    print(f"Error creating rule: {e}")
+```
+
+## Requirements
+
+- Python 3.8+
+- Access to a Databricks workspace with DASL enabled
+- `databricks-sdk>=0.41.0`
+- `pydantic>=2`
+
+## Documentation
+
+For complete DASL Client documentation, examples, and API reference:
+
+- [DASL Client Documentation](https://antimatter-dasl-client.readthedocs-hosted.com/)
+- [API Reference](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/api-reference/)
+- [Quickstart Guide](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/quickstart.html)
+
+## Support
+
+- **Email**: support@antimatter.io
+- **Documentation**: [DASL Documentation](https://docs.sl.antimatter.io)

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client/client.py

@@ -9,7 +9,7 @@ from dasl_api import (
     CoreV1Api,
     DbuiV1Api,
     DbuiV1QueryExtendRequest,
-    DbuiV1QueryExtendRequestTimeRange,
+    CoreV1QueryExtendRequestDateRange,
     DbuiV1QueryGenerateRequest,
     DbuiV1QueryGenerateRequestTimeRange,
     DbuiV1QueryGenerateStatus,
@@ -29,6 +29,7 @@ from dasl_client.auth.auth import (
     DatabricksTokenAuth,
     ServiceAccountKeyAuth,
 )
+from dasl_client.metadata import WorkspaceMetadata
 from dasl_client.conn.conn import get_base_conn
 from dasl_client.errors.errors import ConflictError, error_handler
 from .helpers import Helpers
@@ -79,7 +80,7 @@ class Client:
         service_principal_id: str,
         service_principal_secret: str,
         workspace_url: Optional[str] = None,
-        region: str = Helpers.default_region,
+        region: Optional[str] = None,
         dasl_host: Optional[str] = None,
     ) -> "Client":
         """
@@ -98,18 +99,24 @@ class Client:
             being registered. If you omit this value, it will be inferred
             if you are running within a Databricks notebook. Otherwise, an
             exception will be raised.
-        :param region: The name of the DASL region.
+        :param region: The name of the DASL region. If not specified,
+            the client will auto-detect the region from the workspace
+            URL. For a DASL region, this includes the cloud host, e.g.
+            aws-us-east-1.
         :param dasl_host: The URL of the DASL server. This value should
             not generally be specified. When specified, this value
-            overrides region.
+            overrides both region and auto-detection.
         :returns: Client for the newly created workspace.
         """
-        if dasl_host is None:
-            dasl_host = Regions.lookup(region)
-
         with error_handler():
             if workspace_url is None:
                 workspace_url = Helpers.current_workspace_url()
+
+            # Determine the DASL host to use
+            dasl_host = Client._dasl_host_from_workspace_metadata(
+                workspace_url, dasl_host, region
+            )
+
             admin_config = AdminConfig(
                 workspace_url=workspace_url,
                 app_client_id=app_client_id,
@@ -137,7 +144,7 @@ class Client:
     def for_workspace(
         workspace_url: Optional[str] = None,
         service_account_token: Optional[str] = None,
-        region: str = Helpers.default_region,
+        region: Optional[str] = None,
         dasl_host: Optional[str] = None,
     ) -> "Client":
         """
@@ -151,19 +158,24 @@ class Client:
         :param service_account_token: Antimatter service account token.
             If provided, the client will use this token for auth instead
             of (automatic) secret-based auth.
-        :param region: The name of the DASL region.
+        :param region: The name of the DASL region. If not specified,
+            the client will auto-detect the region from the workspace
+            URL. For a DASL region, this includes the cloud host, e.g.
+            aws-us-east-1.
         :param dasl_host: The URL of the DASL server. This value should
             not generally be specified. When specified, this value
-            overrides region.
+            overrides both region and auto-detection.
         :returns: Client for the existing workspace.
         """
-        if dasl_host is None:
-            dasl_host = Regions.lookup(region)
-
         with error_handler():
             if workspace_url is None:
                 workspace_url = Helpers.current_workspace_url()
 
+            # Determine the DASL host to use
+            dasl_host = Client._dasl_host_from_workspace_metadata(
+                workspace_url, dasl_host, region
+            )
+
             if service_account_token is None:
                 return Client(
                     DatabricksSecretAuth(
@@ -188,7 +200,7 @@ class Client:
         service_principal_secret: str,
         workspace_url: Optional[str] = None,
         service_account_token: Optional[str] = None,
-        region: str = Helpers.default_region,
+        region: Optional[str] = None,
         dasl_host: Optional[str] = None,
     ) -> "Client":
         """
@@ -220,10 +232,13 @@ class Client:
             If provided, the client will use this token for auth instead
             of (automatic) secret-based auth. Ignored if the workspace
             doesn't exist.
-        :param region: The name of the DASL region.
+        :param region: The name of the DASL region. If not specified,
+            the client will auto-detect the region from the workspace
+            URL. For a DASL region, this includes the cloud host, e.g.
+            aws-us-east-1.
         :param dasl_host: The URL of the DASL server. This value should
             not generally be specified. When specified, this value
-            overrides region.
+            overrides both region and auto-detection.
         :returns: Client for the newly created or existing workspace.
         """
         try:
@@ -835,7 +850,7 @@ class Client:
         """
         time_range = None
         if start_date is not None or end_date is not None:
-            time_range = DbuiV1QueryExtendRequestTimeRange(
+            time_range = CoreV1QueryExtendRequestDateRange(
                 startDate=start_date,
                 endDate=end_date,
             )
@@ -990,3 +1005,52 @@ class Client:
         """
         with error_handler():
             return self._dbui_client().dbui_v1_query_cancel(self._workspace(), id)
+
+    @staticmethod
+    def _dasl_host_from_workspace_metadata(
+        workspace_url: str, dasl_host: Optional[str], region: Optional[str]
+    ) -> str:
+        """
+        If the dasl_host is already set, it will be returned as-is. If a region
+        is set, this will return the host that region maps to. If neither are
+        set, this gets the DASL host from the workspace URL with a workspace
+        metadata lookup.
+
+        :param workspace_url: The full base URL of the Databricks workspace
+            being registered. If you omit this value, it will be inferred
+            if you are running within a Databricks notebook. Otherwise, an
+            exception will be raised.
+        :param dasl_host: The URL of the DASL server. This value should
+            not generally be specified. When specified, this value
+            overrides both region and auto-detection.
+        :param region: The name of the DASL region. If not specified,
+            the client will auto-detect the region from the workspace
+            URL. For a DASL region, this includes the cloud host, e.g.
+            aws-us-east-1.
+        :return: The DASL host to use.
+        """
+        if dasl_host is None:
+            if region is not None:
+                # Use explicit region
+                dasl_host = Regions.lookup(region)
+            else:
+                # Attempt auto-detection from workspace URL
+                try:
+                    metadata = WorkspaceMetadata.get_workspace_metadata(workspace_url)
+                    if metadata is not None:
+                        dasl_host = metadata.api_url
+                    else:
+                        raise Exception(
+                            f"Could not determine API endpoint for workspace '{workspace_url}'. "
+                            f"The workspace may not be in a supported region. "
+                            f"Please specify 'region' or 'dasl_host' explicitly."
+                        )
+                except Exception as e:
+                    if "Could not determine API endpoint" in str(e):
+                        raise
+                    else:
+                        raise Exception(
+                            f"Failed to auto-detect API endpoint for workspace '{workspace_url}': {e}. "
+                            f"Please specify 'region' or 'dasl_host' explicitly."
+                        )
+        return dasl_host

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client/helpers.py

@@ -3,7 +3,7 @@ import os
 
 
 class Helpers:
-    default_region = "us-east-1"
+    default_region = "aws-us-east-1"
 
     @staticmethod
     def ensure_databricks():

dasl_client-1.0.28/dasl_client/metadata.py

@@ -0,0 +1,74 @@
+import base64
+from typing import Optional
+
+from dasl_api import ApiClient, Configuration, WorkspaceV1Api
+from dasl_api.models import WorkspaceV1WorkspaceMetadata
+from dasl_api.exceptions import ApiException
+
+
+class WorkspaceMetadata:
+    """Workspace metadata lookup functionality for auto-detecting API endpoints."""
+
+    @staticmethod
+    def get_workspace_metadata(
+        workspace_url: str, dasl_host: Optional[str] = None
+    ) -> Optional[WorkspaceV1WorkspaceMetadata]:
+        """
+        Query the workspace metadata endpoint to auto-detect the correct region
+        and API endpoint for a given Databricks workspace.
+
+        :param workspace_url: The Databricks workspace URL to lookup
+        :param dasl_host: Optional DASL host to use for the lookup. If None, uses default region.
+        :returns: WorkspaceV1WorkspaceMetadata if successful, None if workspace not found
+        """
+        if dasl_host is None:
+            # Use default region for metadata lookup
+            from .regions import Regions
+            from .helpers import Helpers
+
+            dasl_host = Regions.lookup(Helpers.default_region)
+
+        try:
+            # Create an unauthenticated client for the public metadata endpoint
+            configuration = Configuration(host=dasl_host)
+            api_client = ApiClient(configuration)
+            workspace_api = WorkspaceV1Api(api_client)
+
+            # Base64 encode the workspace URL
+            encoded_workspace = base64.urlsafe_b64encode(
+                workspace_url.encode()
+            ).decode()
+
+            # Call the metadata endpoint
+            metadata = workspace_api.workspace_v1_get_workspace_metadata(
+                databricks_workspace=encoded_workspace
+            )
+
+            return metadata
+
+        except ApiException as e:
+            if e.status == 404:
+                # Workspace not found or not in supported region
+                return None
+            elif e.status == 400:
+                # Invalid workspace URL
+                raise ValueError(f"Invalid workspace URL: {workspace_url}")
+            else:
+                # Other API errors
+                raise Exception(f"Failed to get workspace metadata: {e}")
+        except Exception as e:
+            # Network errors, encoding errors, etc.
+            raise Exception(f"Failed to lookup workspace metadata: {e}")
+
+    @staticmethod
+    def get_endpoint_for_workspace(workspace_url: str) -> Optional[str]:
+        """
+        Get the API endpoint URL for a workspace.
+
+        :param workspace_url: The Databricks workspace URL
+        :returns: API endpoint URL if successful, None if workspace not found
+        """
+        metadata = WorkspaceMetadata.get_workspace_metadata(workspace_url)
+        if metadata is not None:
+            return metadata.api_url
+        return None

dasl_client-1.0.28/dasl_client/regions.json

@@ -0,0 +1,4 @@
+{
+	"aws-us-east-1": "https://api.sl.us-east-1.cloud.databricks.com",
+	"aws-us-west-2": "https://api.sl.us-west-2.cloud.databricks.com"
+}

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client/types/datasource.py

@@ -610,6 +610,7 @@ class SilverSpec(BaseModel):
         post_filter: Optional[str] = None
         preset_overrides: Optional["SilverSpec.PreTransform.PresetOverrides"] = None
         add_fields: Optional[List[FieldSpec]] = None
+        utils: Optional[FieldUtils] = None
 
         @staticmethod
         def from_api_obj(
@@ -630,6 +631,7 @@ class SilverSpec(BaseModel):
                     obj.preset_overrides
                 ),
                 add_fields=add_fields,
+                utils=FieldUtils.from_api_obj(obj.utils),
             )
 
         def to_api_obj(self) -> CoreV1DataSourceSpecSilverPreTransform:
@@ -645,6 +647,7 @@ class SilverSpec(BaseModel):
                 post_filter=self.post_filter,
                 preset_overrides=Helpers.maybe(to_api_obj, self.preset_overrides),
                 add_fields=add_fields,
+                utils=Helpers.maybe(to_api_obj, self.utils),
             )
 
     class Transform(BaseModel):

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client/types/dbui.py

@@ -6,14 +6,16 @@ from dasl_api import (
     DbuiV1ObservableEventsListItemsInnerNotable,
     DbuiV1ObservableEventsListItemsInner,
     DbuiV1TransformRequest,
-    DbuiV1TransformRequestInput,
+    DbuiV1TransformRequestIngestion,
+    DbuiV1TransformRequestIngestionInput,
+    DbuiV1TransformRequestIngestionAutoloaderInput,
+    DbuiV1TransformRequestIngestionAdditionalInputTablesInner,
     DbuiV1TableColumnDetails,
     DbuiV1TransformRequestTransformsInner,
     DbuiV1TransformRequestTransformsInnerPresetOverrides,
     DbuiV1TransformResponse,
     DbuiV1TransformResponseStagesInner,
     ContentV1DatasourcePresetAutoloaderCloudFiles,
-    DbuiV1TransformRequestAutoloaderInput,
 )
 
 from .datasource import DataSource, FieldSpec, FieldUtils
@@ -124,18 +126,16 @@ class Dbui(BaseModel):
 
 class TransformRequest(BaseModel):
     """
-    The transform request identifies the starting data (either with an
-    autoloader spec or an input block) and then specifies a chain of
-    transforms to be performed on the data. The response includes the data
-    at each intermediate stage (e.g. input/autoloaded data, pre-transform,
-    silver).
+    The transform request identifies the starting data through an ingestion
+    configuration and then specifies a chain of transforms to be performed
+    on the data. The response includes the data at each intermediate stage
+    (e.g. input/autoloaded data, pre-transform, silver).
 
     Attributes:
-        input (TransformRequest.Input):
-            The input block containing the columns metadata and data.
-        autoloader_input (Autoloader):
-            The autoloader input configuration.
-        use_preset (str):
+        ingestion (Optional[TransformRequest.Ingestion]):
+            Ingestion (bronze) layer configuration for acquiring and wrangling
+            data before silver and gold transformations.
+        use_preset (Optional[str]):
             Indicates which preset to use for the transforms.
         transforms (List[TransformRequest.Transform]):
             A list of transform configurations.
@@ -157,7 +157,7 @@ class TransformRequest(BaseModel):
 
         @staticmethod
         def from_api_obj(
-            obj: Optional[DbuiV1TransformRequestInput],
+            obj: Optional[DbuiV1TransformRequestIngestionInput],
         ) -> Optional["TransformRequest.Input"]:
             if obj is None:
                 return None
@@ -168,8 +168,8 @@ class TransformRequest(BaseModel):
                 data=obj.data,
             )
 
-        def to_api_obj(self) -> DbuiV1TransformRequestInput:
-            return DbuiV1TransformRequestInput(
+        def to_api_obj(self) -> DbuiV1TransformRequestIngestionInput:
+            return DbuiV1TransformRequestIngestionInput(
                 columns=[item.to_api_obj() for item in self.columns],
                 data=self.data,
             )
@@ -204,7 +204,7 @@ class TransformRequest(BaseModel):
             @staticmethod
             def from_api_obj(
                 obj: Optional[ContentV1DatasourcePresetAutoloaderCloudFiles],
-            ) -> "TransformRequest.Autoloader.CloudFiles":
+            ) -> Optional["TransformRequest.Autoloader.CloudFiles"]:
                 if obj is None:
                     return None
                 return TransformRequest.Autoloader.CloudFiles(
@@ -228,7 +228,7 @@ class TransformRequest(BaseModel):
 
         @staticmethod
         def from_api_obj(
-            obj: Optional[DbuiV1TransformRequestAutoloaderInput],
+            obj: Optional[DbuiV1TransformRequestIngestionAutoloaderInput],
         ) -> "Optional[TransformRequest.Autoloader]":
             if obj is None:
                 return None
@@ -244,15 +244,124 @@ class TransformRequest(BaseModel):
                 row_offset=obj.row_offset,
             )
 
-        def to_api_obj(self) -> DbuiV1TransformRequestAutoloaderInput:
-            return DbuiV1TransformRequestAutoloaderInput(
+        def to_api_obj(self) -> DbuiV1TransformRequestIngestionAutoloaderInput:
+            return DbuiV1TransformRequestIngestionAutoloaderInput(
                 format=self.format,
                 location=self.location,
-                schemaFile=self.schema_file,
-                schema=self.var_schema,
-                cloudFiles=Helpers.maybe(lambda o: o.to_api_obj(), self.cloud_files),
-                rowCount=self.row_count,
-                rowOffset=self.row_offset,
+                schema_file=self.schema_file,
+                var_schema=self.var_schema,
+                cloud_files=Helpers.maybe(lambda o: o.to_api_obj(), self.cloud_files),
+                row_count=self.row_count,
+                row_offset=self.row_offset,
+            )
+
+    class AdditionalInputTable(BaseModel):
+        """
+        Configuration for additional input tables used for lookup or enrichment.
+
+        Attributes:
+            name (str):
+                The name of the table.
+            alias (str):
+                Alias name for the table.
+            join_type (str):
+                How to join to the preceding table.
+            join_expr (str):
+                The join condition expression to join with the preceding table.
+        """
+
+        name: str
+        alias: str
+        join_type: str
+        join_expr: str
+
+        @staticmethod
+        def from_api_obj(
+            obj: Optional[DbuiV1TransformRequestIngestionAdditionalInputTablesInner],
+        ) -> Optional["TransformRequest.AdditionalInputTable"]:
+            if obj is None:
+                return None
+            return TransformRequest.AdditionalInputTable(
+                name=obj.name,
+                alias=obj.alias,
+                join_type=obj.join_type,
+                join_expr=obj.join_expr,
+            )
+
+        def to_api_obj(
+            self,
+        ) -> DbuiV1TransformRequestIngestionAdditionalInputTablesInner:
+            return DbuiV1TransformRequestIngestionAdditionalInputTablesInner(
+                name=self.name,
+                alias=self.alias,
+                join_type=self.join_type,
+                join_expr=self.join_expr,
+            )
+
+    class Ingestion(BaseModel):
+        """
+        Ingestion (bronze) layer configuration for acquiring and wrangling data
+        before silver and gold transformations.
+
+        Attributes:
+            input (Optional[TransformRequest.Input]):
+                Provides static data for adhoc transform processing.
+            autoloader_input (Optional[TransformRequest.Autoloader]):
+                Configures ingestion from an external data source using Databricks Auto Loader.
+            load_as_single_variant (Optional[bool]):
+                Whether to ingest the data as a single variant column called data.
+            additional_input_tables (Optional[List[TransformRequest.AdditionalInputTable]]):
+                A list of existing tables that are joined with the input data.
+            pre_transform (Optional[List[List[str]]]):
+                A set of SQL expressions to apply before writing the Auto Loader data to bronze.
+        """
+
+        input: Optional["TransformRequest.Input"] = None
+        autoloader_input: Optional["TransformRequest.Autoloader"] = None
+        load_as_single_variant: Optional[bool] = None
+        additional_input_tables: Optional[
+            List["TransformRequest.AdditionalInputTable"]
+        ] = None
+        pre_transform: Optional[List[List[str]]] = None
+
+        @staticmethod
+        def from_api_obj(
+            obj: Optional[DbuiV1TransformRequestIngestion],
+        ) -> Optional["TransformRequest.Ingestion"]:
+            if obj is None:
+                return None
+
+            additional_input_tables = None
+            if obj.additional_input_tables is not None:
+                additional_input_tables = [
+                    TransformRequest.AdditionalInputTable.from_api_obj(item)
+                    for item in obj.additional_input_tables
+                ]
+
+            return TransformRequest.Ingestion(
+                input=TransformRequest.Input.from_api_obj(obj.input),
+                autoloader_input=TransformRequest.Autoloader.from_api_obj(
+                    obj.autoloader_input
+                ),
+                load_as_single_variant=obj.load_as_single_variant,
+                additional_input_tables=additional_input_tables,
+                pre_transform=obj.pre_transform,
+            )
+
+        def to_api_obj(self) -> DbuiV1TransformRequestIngestion:
+            to_api_obj = lambda o: o.to_api_obj()
+            additional_input_tables = None
+            if self.additional_input_tables is not None:
+                additional_input_tables = [
+                    item.to_api_obj() for item in self.additional_input_tables
+                ]
+
+            return DbuiV1TransformRequestIngestion(
+                input=Helpers.maybe(to_api_obj, self.input),
+                autoloader_input=Helpers.maybe(to_api_obj, self.autoloader_input),
+                load_as_single_variant=self.load_as_single_variant,
+                additional_input_tables=additional_input_tables,
+                pre_transform=self.pre_transform,
             )
 
     class Transform(BaseModel):
@@ -350,18 +459,14 @@ class TransformRequest(BaseModel):
                 utils=Helpers.maybe(to_api_obj, self.utils),
             )
 
-    input: Optional["TransformRequest.Input"] = None
-    autoloader_input: Optional["TransformRequest.Autoloader"] = None
+    ingestion: Optional["TransformRequest.Ingestion"] = None
     use_preset: Optional[str] = None
     transforms: List["TransformRequest.Transform"]
 
     @staticmethod
     def from_api_obj(obj: DbuiV1TransformRequest) -> "TransformRequest":
         return TransformRequest(
-            input=TransformRequest.Input.from_api_obj(obj.input),
-            autoloader_input=TransformRequest.Autoloader.from_api_obj(
-                obj.autoloader_input
-            ),
+            ingestion=TransformRequest.Ingestion.from_api_obj(obj.ingestion),
             use_preset=obj.use_preset,
             transforms=[
                 TransformRequest.Transform.from_api_obj(item) for item in obj.transforms
@@ -369,10 +474,10 @@ class TransformRequest(BaseModel):
         )
 
     def to_api_obj(self) -> DbuiV1TransformRequest:
-        to_api_obj = lambda o: o.to_api_obj()
         return DbuiV1TransformRequest(
-            input=Helpers.maybe(to_api_obj, self.input),
-            autoloader_input=Helpers.maybe(to_api_obj, self.autoloader_input),
+            ingestion=(
+                self.ingestion.to_api_obj() if self.ingestion is not None else None
+            ),
             use_preset=self.use_preset,
             transforms=[item.to_api_obj() for item in self.transforms],
         )

dasl_client-1.0.28/dasl_client.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: dasl_client
+Version: 1.0.28
+Summary: The DASL client library used for interacting with the DASL workspace
+Author-email: Antimatter Team <support@antimatter.io>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dasl_api==0.1.27
+Requires-Dist: databricks-sdk>=0.41.0
+Requires-Dist: pydantic>=2
+Requires-Dist: typing_extensions>=4.10.0
+Requires-Dist: pyyaml==6.0.2
+Dynamic: license-file
+
+# DASL Client Library
+
+The DASL (Databricks Antimatter Security Lakehouse) Client Library is a Python SDK for interacting with DASL services.
+This library provides an interface for interacting with DASL services, allowing you to manage
+datasources, rules, workspace configurations, and more from Databricks notebooks.
+
+## Features
+
+* **Simple Authentication**: Automatic workspace detection in Databricks notebooks
+* **Datasource Management**: Create, update, list, and delete datasources
+* **Rule Management**: Define and manage security detection rules to identify threats
+* **Workspace Configuration**: Update and retrieve DASL's workspace-level settings
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install dasl-client
+```
+
+## Quick Start
+
+### Databricks Notebook Environment (Recommended)
+
+The DASL client works best in Databricks notebooks with automatic authentication:
+
+```python
+from dasl_client import Client
+
+# Automatically detects Databricks context and authenticates
+client = Client.for_workspace()
+print("Connected to DASL!")
+
+# List existing datasources
+print("Existing datasources:")
+for datasource in client.list_datasources():
+    print(f"  - {datasource.metadata.name}")
+
+# List detection rules
+print("Existing detection rules:")
+for rule in client.list_rules():
+    print(f"  - {rule.metadata.name}")
+```
+
+### Creating a Datasource
+
+```python
+from dasl_client import DataSource, Schedule, BronzeSpec, SilverSpec
+
+# Create a new datasource
+datasource = Datasource(
+    source="aws",
+    source_type="cloudtrail",
+    autoloader=Autoloader(
+        enabled=True,
+        schedule=Schedule(
+            at_least_every="1h",
+            enabled=True
+        )
+    ),
+    bronze=BronzeSpec(
+        bronze_table="security_logs_bronze",
+        skip_bronze_loading=False
+    ),
+    silver=SilverSpec(
+        # Configure silver layer here, see the API reference for more details
+    ),
+    gold=GoldSpec(
+        # Configure gold layer here, see the API reference for more details
+    )
+)
+
+# Create the datasource
+created_datasource = client.create_datasource(datasource)
+print(f"Created datasource: {created.metadata.name}")
+```
+
+### Creating a Detection Rule
+
+```python
+from dasl_client.types import Rule, Schedule
+
+# Create a new detection rule to detect failed logins
+rule = Rule(
+    schedule=Schedule(
+        at_least_every="2h",
+        enabled=True,
+    ),
+    input=Rule.Input(
+        stream=Rule.Input.Stream(
+            tables=[
+                Rule.Input.Stream.Table(name="http_activity"),
+            ],
+            filter="disposition = 'Blocked'",
+            starting_timestamp=datetime(2025, 7, 8, 16, 47, 30),
+        ),
+    ),
+    output=Rule.Output(
+        summary="record was blocked",
+    ),
+)
+
+try:
+    created_rule = client.create_rule("Detect Blocked HTTP Activity", rule)
+    print(f"Successfully created rule: {created_rule.metadata.name}")
+except Exception as e:
+    print(f"Error creating rule: {e}")
+```
+
+## Requirements
+
+- Python 3.8+
+- Access to a Databricks workspace with DASL enabled
+- `databricks-sdk>=0.41.0`
+- `pydantic>=2`
+
+## Documentation
+
+For complete DASL Client documentation, examples, and API reference:
+
+- [DASL Client Documentation](https://antimatter-dasl-client.readthedocs-hosted.com/)
+- [API Reference](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/api-reference/)
+- [Quickstart Guide](https://antimatter-dasl-client.readthedocs-hosted.com/en/latest/quickstart.html)
+
+## Support
+
+- **Email**: support@antimatter.io
+- **Documentation**: [DASL Documentation](https://docs.sl.antimatter.io)

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client.egg-info/SOURCES.txt

@@ -1,10 +1,11 @@
 LICENSE
+README.md
 pyproject.toml
-setup.py
 dasl_client/__init__.py
 dasl_client/client.py
 dasl_client/exec_rule.py
 dasl_client/helpers.py
+dasl_client/metadata.py
 dasl_client/regions.json
 dasl_client/regions.py
 dasl_client.egg-info/PKG-INFO

{dasl_client-1.0.26 → dasl_client-1.0.28}/dasl_client.egg-info/requires.txt

@@ -1,4 +1,4 @@
-dasl_api==0.1.25
+dasl_api==0.1.27
 databricks-sdk>=0.41.0
 pydantic>=2
 typing_extensions>=4.10.0

{dasl_client-1.0.26 → dasl_client-1.0.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dasl_client"
-version = "1.0.26"
+version = "1.0.28"
 description = "The DASL client library used for interacting with the DASL workspace"
 readme = "README.md"
 authors = [
@@ -13,7 +13,7 @@ authors = [
 requires-python = ">=3.8"
 
 dependencies = [
-    "dasl_api==0.1.25",
+    "dasl_api==0.1.27",
     "databricks-sdk>=0.41.0",
     "pydantic>=2",
     "typing_extensions>=4.10.0",

dasl_client-1.0.26/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: dasl_client
-Version: 1.0.26
-Summary: The DASL client library used for interacting with the DASL workspace
-Home-page: https://github.com/antimatter/asl
-Author: Antimatter Team
-Author-email: Antimatter Team <support@antimatter.io>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: dasl_api==0.1.25
-Requires-Dist: databricks-sdk>=0.41.0
-Requires-Dist: pydantic>=2
-Requires-Dist: typing_extensions>=4.10.0
-Requires-Dist: pyyaml==6.0.2
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python

dasl_client-1.0.26/dasl_client/regions.json

@@ -1,3 +0,0 @@
-{
-	"us-east-1": "https://api.sl.us-east-1.cloud.databricks.com"
-}

dasl_client-1.0.26/dasl_client.egg-info/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.4
-Name: dasl_client
-Version: 1.0.26
-Summary: The DASL client library used for interacting with the DASL workspace
-Home-page: https://github.com/antimatter/asl
-Author: Antimatter Team
-Author-email: Antimatter Team <support@antimatter.io>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: dasl_api==0.1.25
-Requires-Dist: databricks-sdk>=0.41.0
-Requires-Dist: pydantic>=2
-Requires-Dist: typing_extensions>=4.10.0
-Requires-Dist: pyyaml==6.0.2
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python

dasl_client-1.0.26/setup.py

@@ -1,16 +0,0 @@
-# setup.py
-
-from setuptools import setup, find_packages
-
-setup(
-    name="dasl-client",
-    version="0.0.0",
-    author="Antimatter Team",
-    author_email="support@antimatter.io",
-    description="The DASL client library used for interacting with the DASL client.",
-    long_description="TODO: Link to docs page or README.md.",
-    long_description_content_type="text/markdown",
-    url="https://github.com/antimatter/asl",
-    packages=find_packages(),
-    python_requires=">=3.8",
-)