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

dasl_client-1.0.27/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: dasl_client
+Version: 1.0.27
+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.26
+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.27/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.27}/dasl_client/client.py

@@ -9,7 +9,7 @@ from dasl_api import (
     CoreV1Api,
     DbuiV1Api,
     DbuiV1QueryExtendRequest,
-    DbuiV1QueryExtendRequestTimeRange,
+    CoreV1QueryExtendRequestDateRange,
     DbuiV1QueryGenerateRequest,
     DbuiV1QueryGenerateRequestTimeRange,
     DbuiV1QueryGenerateStatus,
@@ -835,7 +835,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,
             )

{dasl_client-1.0.26 → dasl_client-1.0.27}/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.27/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.27}/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.27}/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.27/dasl_client.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: dasl_client
+Version: 1.0.27
+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.26
+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.27}/dasl_client.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE
+README.md
 pyproject.toml
-setup.py
 dasl_client/__init__.py
 dasl_client/client.py
 dasl_client/exec_rule.py

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dasl_client"
-version = "1.0.26"
+version = "1.0.27"
 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.26",
     "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",
-)