dasl-client 1.0.14__py3-none-any.whl → 1.0.17__py3-none-any.whl

dasl_client/client.py

@@ -1,4 +1,6 @@
 from copy import deepcopy
+from datetime import datetime, timedelta
+from time import sleep
 from typing import Any, Callable, Iterator, List, Optional, Tuple, TypeVar
 from pydantic import Field
 from pyspark.sql import DataFrame
@@ -608,6 +610,7 @@ class Client:
         self,
         warehouse: str,
         request: TransformRequest,
+        timeout: timedelta = timedelta(minutes=5),
     ) -> TransformResponse:
         """
         Run a sequence of ADHOC transforms against a SQL warehouse to
@@ -618,16 +621,29 @@ class Client:
         :return: a TransformResponse object containing the results
             after running the transforms.
         :raises: NotFoundError if the rule does not exist
+        :raises: Exception for a server-side error or timeout
         """
         with error_handler():
-            return TransformResponse.from_api_obj(
-                self._dbui_client().dbui_v1_transform(
-                    self._workspace(),
-                    warehouse,
-                    request.to_api_obj(),
-                )
+            status = self._dbui_client().dbui_v1_transform(
+                self._workspace(),
+                warehouse,
+                request.to_api_obj(),
             )
 
+            begin = datetime.now()
+            while datetime.now() - begin < timeout:
+                sleep(5)
+                status = self._dbui_client().dbui_v1_transform_status(
+                    self._workspace(), status.id
+                )
+
+                if status.status == "failure":
+                    raise Exception(f"adhoc transform failed with {status.error}")
+                elif status.status == "success":
+                    return TransformResponse.from_api_obj(status.result)
+
+            raise Exception("timed out waiting for adhoc transform result")
+
     def get_observable_events(
         self,
         warehouse: str,
@@ -687,3 +703,11 @@ class Client:
                     self._workspace(), name
                 )
             )
+
+    def purge_preset_cache(self)-> None:
+        """
+        Purge the datasource cache presets. This will cause the DASL workspace
+        to fetch presets from provided sources.
+        """
+        with error_handler():
+            self._content_client().content_v1_preset_purge_cache(self._workspace())

dasl_client/preset_development/errors.py

@@ -149,7 +149,10 @@ class AssertionFailedError(PresetError):
     def __init__(self, expr: str, assertion_message: str, df: DataFrame):
         # Get the Databricks built-in functions out the namespace.
         ipython = get_ipython()
-        display = ipython.user_ns["display"]
+        if ipython is not None:
+            display = ipython.user_ns["display"]
+        else:
+            display = lambda x: x.show()
 
         self.expr = expr
         self.assertion_message = assertion_message

dasl_client/preset_development/preview_engine.py

@@ -54,10 +54,13 @@ class PreviewEngine:
                 self._preset.get("silver", None), self._pretransform_name
             )
 
+        self._bronze = None
         self._pre = None
         self._silver = []
         self._gold = []
-        self._result_df_map = {}
+        self._result_df_map: Tuple[
+            DataFrame, Dict[str, DataFrame], Dict[str, DataFrame]
+        ] = (None, {}, {})
 
     def _validate_pretransform_name(
         self, silver: Dict[str, str], pretransform_name: str
@@ -181,8 +184,12 @@ class PreviewEngine:
 
         # Get the Databricks built-in functions out the namespace.
         ipython = get_ipython()
-        displayHTML = ipython.user_ns["displayHTML"]
-        display = ipython.user_ns["display"]
+        if ipython is not None:
+            displayHTML = ipython.user_ns["displayHTML"]
+            display = ipython.user_ns["display"]
+        else:
+            displayHTML = lambda x: print(x)
+            display = lambda x: x.show()
 
         def d(txt, lvl) -> None:
             displayHTML(
@@ -245,7 +252,7 @@ class PreviewEngine:
                 raise UnknownGoldTableError(name, gold_table_schema)
 
             # Performs the type check.
-            delta_df = self._spark.table(f"{gold_table_schema}.{name}").limit(0)
+            delta_df = self._spark.table(f"`{gold_table_schema}`.`{name}`").limit(0)
             unioned_df = delta_df.unionByName(df, allowMissingColumns=True)
 
             # Now we check no new columns.
@@ -286,7 +293,7 @@ class PreviewEngine:
             d("Resultant gold table preview", 3)
             display(unioned_df)
 
-    def evaluate(self, gold_table_schema: str) -> None:
+    def evaluate(self, gold_table_schema: str, display: bool = True) -> None:
         """
         Evaluates the loaded preset YAML using the input datasource configuration to load
         records. Finally, checks that the output from the Gold stages is compatible with
@@ -303,7 +310,9 @@ class PreviewEngine:
         ):
             if not any(
                 row.databaseName == schema_name
-                for row in self._spark.sql(f"SHOW SCHEMAS IN {catalog_name}").collect()
+                for row in self._spark.sql(
+                    f"SHOW SCHEMAS IN `{catalog_name}`"
+                ).collect()
             ):
                 raise InvalidGoldTableSchemaError(
                     gold_table_schema,
@@ -340,5 +349,12 @@ class PreviewEngine:
         self._compile_stages()
 
         with self._ds_params as df:
+            self._bronze = df
             self._result_df_map = self._run(df)
-            self._render_output(df, self._result_df_map, gold_table_schema)
+            if display:
+                self._render_output(df, self._result_df_map, gold_table_schema)
+
+    def results(
+        self,
+    ) -> Tuple[DataFrame, DataFrame, Dict[str, DataFrame], Dict[str, DataFrame]]:
+        return self._bronze, *self._result_df_map

dasl_client/preset_development/preview_parameters.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from pyspark.sql import DataFrame, SparkSession
 from pyspark.sql.types import *
 from pyspark.sql.dataframe import DataFrame
@@ -115,6 +117,7 @@ class PreviewParameters:
         self._table = None
 
         self._pretransform_name = None
+        self._bronze_pre_transform: Optional[List[str]] = None
 
         self._df = None
 
@@ -166,10 +169,13 @@ class PreviewParameters:
                 self._record_limit
             )
 
+            if self._bronze_pre_transform is not None:
+                stream_df = stream_df.selectExpr(*self._bronze_pre_transform)
+
             query = (
                 stream_df.writeStream.format("memory")
                 .queryName("batch_data")
-                .trigger(once=True)
+                .trigger(availableNow=True)
                 .start()
             )
 
@@ -193,12 +199,17 @@ class PreviewParameters:
 
         # Get the Databricks built-in functions out the namespace.
         ipython = get_ipython()
-        dbutils = ipython.user_ns["dbutils"]
+        if ipython is not None:
+            dbutils = ipython.user_ns["dbutils"]
 
-        dbutils.fs.rm(
-            f"{self._autoloader_temp_schema_location}/{self._schema_uuid_str}",
-            recurse=True,
-        )
+            dbutils.fs.rm(
+                f"{self._autoloader_temp_schema_location}/{self._schema_uuid_str}",
+                recurse=True,
+            )
+        else:
+            print(
+                f"FYI, we are leaking temp data {self._autoloader_temp_schema_location}/{self._schema_uuid_str}"
+            )
 
     def from_input(self):
         """
@@ -286,6 +297,10 @@ class PreviewParameters:
         Returns:
             PreviewParameters: The current instance with updated configuration.
         """
+        if file_format.lower() == "jsonl":
+            self._autoloader_format = "json"
+            self.set_autoloader_multiline(False)
+            return self
         self._autoloader_format = file_format
         return self
 
@@ -350,6 +365,16 @@ class PreviewParameters:
         self._pretransform_name = pretransform_name
         return self
 
+    def set_bronze_pre_transform(self, expr: List[str]):
+        """
+        Sets a pre-transform expression that will run before data is written to bronze
+
+        Returns:
+            PreviewParameters: The current instance with updated configuration.
+        """
+        self._bronze_pre_transform = expr
+        return self
+
     def set_date_range(self, column: str, start_time: str, end_time: str):
         """
         Set the TIMESTAMP column and date range to use as the input data filter to

dasl_client/preset_development/stage.py

@@ -150,17 +150,19 @@ class Stage:
         if target_col not in existing_columns:
             raise ReferencedColumnMissingError("jsonExtract", target_col)
         schema = self._spark.sql(
-            f"SELECT schema_of_json_agg({target_col}) AS sc FROM {{df}}", df=df
+            f"SELECT schema_of_json_agg({self.auto_backtick(target_col)}) AS sc FROM {{df}}",
+            df=df,
         ).collect()[0][0]
         extract_df = self._spark.createDataFrame(data=[], schema=schema)
         columns = extract_df.columns
         columns = [
-            f"extract.{col} AS {col}"
+            self.auto_backtick(f"extract.{col}") + f" AS {self.auto_backtick(col)}"
             for col in columns
             if col not in omit_fields and col not in existing_columns
         ]
         columns += [
-            f"extract.{col} AS {duplicate_prefix}{col}"
+            self.auto_backtick(f"extract.{col}")
+            + f" AS {self.auto_backtick(duplicate_prefix + col)}"
             for col in columns
             if col not in omit_fields and col in existing_columns
         ]
@@ -176,7 +178,10 @@ class Stage:
             A DataFrame with the resultant operation's records.
         """
         return (
-            df.selectExpr("*", f"from_json({target_col}, '{schema}') AS extract")
+            df.selectExpr(
+                "*",
+                f"from_json({self.auto_backtick(target_col)}, '{schema}') AS extract",
+            )
             .selectExpr("*", *columns)
             .drop("extract")
         )
@@ -198,7 +203,10 @@ class Stage:
         """
         extract_df = self._spark.createDataFrame(data=[], schema=schema)
         schema = extract_df.drop(omit_fields).schema.simpleString()
-        return df.selectExpr("*", f"from_json({target_col}, '{schema}') AS {name}")
+        return df.selectExpr(
+            "*",
+            f"from_json({self.auto_backtick(target_col)}, '{schema}') AS {self.auto_backtick(name)}",
+        )
 
     def preserved_columns(
         self, df: DataFrame
@@ -224,7 +232,7 @@ class Stage:
         duplicate_prefix = self._duplicate_prefix()
         column_names = self._column_names()
         duplicate_renames = [
-            f"{col} AS {duplicate_prefix}{col}"
+            f"{self.auto_backtick(col)} AS {self.auto_backtick(duplicate_prefix + col)}"
             for col in preserved_columns
             if col in column_names
         ]
@@ -296,14 +304,46 @@ class Stage:
         """
         if field.get("from", None):
             # check that the from column exists in the df?
-            return f"{field['from']} AS {name}"
+            return f"{self.auto_backtick(field['from'])} AS {self.auto_backtick(name)}"
         elif field.get("literal", None):
-            return f"'{field['literal']}' AS {name}"
-        elif field.get("expr", None):
-            return f"{field['expr']} AS {name}"
+            return f"'{field['literal']}' AS {self.auto_backtick(name)}"
+        elif field.get("expr", None) is not None:
+            return f"{field['expr']} AS {self.auto_backtick(name)}"
         else:
             return ""
 
+    def is_backtick_escaped(self, name: str) -> bool:
+        """
+        check if a given (column) name is backtick escaped or not
+        :param name: column name
+        :return: bool
+        """
+        return name.startswith("`") and name.endswith("`")
+
+    def auto_backtick(self, name: str) -> str:
+        """
+        auto-backtick given name in case it isn't already backtick escaped.
+        if the name contains dots it will get split and each component backticked individually.
+        Returns the name wrapped in backticks or the passed name if it already had backticks.
+        :param name: column name
+        :return: str
+        """
+        if self.is_backtick_escaped(name):
+            return name
+        parts = name.split(".")
+        return ".".join(list(map(lambda s: f"`{s}`", parts)))
+
+    def force_apply_backticks(self, name: str) -> str:
+        """
+        forces application of backticks to the given (column) name as a single unit
+        if it already has backticks this is a noop
+        :param name: column name
+        :return: str
+        """
+        if self.is_backtick_escaped(name):
+            return name
+        return f"`{name}`"
+
     def process_node(self, name: str, node: Node) -> str:
         """
         Processes a single node in a tree of nodes.
@@ -319,7 +359,7 @@ class Stage:
                 child_expr = self.process_node(child_name, child_node)
                 fields_list.append(f"{child_expr}")
             joined_fields = ",\n".join(fields_list)
-            return f"struct(\n{joined_fields}\n) AS {name}"
+            return f"struct(\n{joined_fields}\n) AS {self.auto_backtick(name)}"
         else:
             return ""
 
@@ -341,12 +381,22 @@ class Stage:
         """
         Renders a list of field specifications containing both simple and
         STRUCT references into valid, STRUCT cognicient, SELECT expressions.
+        if a nested field is wrapped in backticks it will be treated as a simple field
+        for example field of name `col.with.dots` will NOT be treated as nested field.
 
         Returns:
             The SQL expression.
         """
-        simple_fields = [f for f in fields if "." not in f["name"]]
-        nested_fields = [f for f in fields if "." in f["name"]]
+        simple_fields = [
+            f
+            for f in fields
+            if "." not in f["name"] or self.is_backtick_escaped(f["name"])
+        ]
+        nested_fields = [
+            f
+            for f in fields
+            if "." in f["name"] and not self.is_backtick_escaped(f["name"])
+        ]
 
         result_parts = []
         for field in simple_fields:
@@ -358,7 +408,7 @@ class Stage:
             nested_str = self.parse_to_string(tree)
             result_parts.append(nested_str)
 
-        return [p for p in result_parts if p]
+        return [p for p in result_parts if p is not None and len(p) > 0]
 
     def select_expr(self, df: DataFrame) -> str:
         """
@@ -379,8 +429,12 @@ class Stage:
             if should_preserve:
                 if embed_col := preserve.get("embedColumn", None):
                     preserved_columns = self.preserved_columns_embed_column(df)
+                    # preserved_columns is obtained from df.columns
+                    # applying backticks to all of them is OK here
+                    # since they will never use "obj.key" to reference nested fields of structs
+                    # so we just go ahead and apply backticks to all across the board
                     select_fields += [
-                        f"struct({', '.join(preserved_columns)}) AS {embed_col}"
+                        f"struct({', '.join(list(map(lambda x: self.force_apply_backticks(x), preserved_columns)))}) AS {self.auto_backtick(embed_col)}"
                     ]
                 else:
                     (
@@ -388,8 +442,13 @@ class Stage:
                         duplicate_renames,
                         column_names,
                     ) = self.preserved_columns(df)
-                    select_fields += preserved_columns
-                    select_fields += duplicate_renames
+                    # see note above: same here - apply backticks to all columns across the board
+                    select_fields += list(
+                        map(lambda x: self.force_apply_backticks(x), preserved_columns)
+                    )
+                    select_fields += list(
+                        map(lambda x: self.force_apply_backticks(x), duplicate_renames)
+                    )
 
         return ["*"] + select_fields if self._stage == "temp_fields" else select_fields
 
@@ -475,7 +534,9 @@ class Stage:
                 df = (
                     df.alias("tmp")
                     .join(df_joined, on=[df[lhs] == df_joined[rhs]], how="left")
-                    .selectExpr("tmp.*", f"{select} AS {field.get('name')}")
+                    .selectExpr(
+                        "tmp.*", f"{select} AS {self.auto_backtick(field.get('name'))}"
+                    )
                 )
             elif csv := join.get("withCSV", None):
                 if path := csv.get("path", None):
@@ -485,7 +546,10 @@ class Stage:
                     df = (
                         df.alias("tmp")
                         .join(df_joined, on=[df[lhs] == df_joined[rhs]], how="left")
-                        .selectExpr("tmp.*", f"{select} AS {field.get('name')}")
+                        .selectExpr(
+                            "tmp.*",
+                            f"{select} AS {self.auto_backtick(field.get('name'))}",
+                        )
                     )
             else:
                 raise MissingJoinFieldError("withTable or withCSV (please supply 1)")
@@ -500,7 +564,10 @@ class Stage:
         """
         for field in self._fields:
             if field.get("alias", None):
-                df = df.selectExpr("*", f"{field.get('alias')} AS {field.get('name')}")
+                df = df.selectExpr(
+                    "*",
+                    f"{self.auto_backtick(field.get('alias'))} AS {self.auto_backtick(field.get('name'))}",
+                )
         return df
 
     def run_assertions(self, df: DataFrame) -> DataFrame:

dasl_client/types/dbui.py

@@ -11,7 +11,8 @@ from dasl_api import (
     DbuiV1TransformRequestTransformsInner,
     DbuiV1TransformRequestTransformsInnerPresetOverrides,
     DbuiV1TransformResponse,
-    DbuiV1TransformResponseStagesInner, ContentV1DatasourcePresetAutoloaderCloudFiles,
+    DbuiV1TransformResponseStagesInner,
+    ContentV1DatasourcePresetAutoloaderCloudFiles,
     DbuiV1TransformRequestAutoloaderInput,
 )
 
@@ -202,7 +203,7 @@ class TransformRequest(BaseModel):
 
             @staticmethod
             def from_api_obj(
-                    obj: Optional[ContentV1DatasourcePresetAutoloaderCloudFiles],
+                obj: Optional[ContentV1DatasourcePresetAutoloaderCloudFiles],
             ) -> "TransformRequest.Autoloader.CloudFiles":
                 if obj is None:
                     return None
@@ -220,14 +221,14 @@ class TransformRequest(BaseModel):
         format: Optional[str] = None
         location: str
         schema_file: Optional[str] = None
-        schema: Optional[str] = None
+        var_schema: Optional[str] = None
         cloud_files: Optional["TransformRequest.Autoloader.CloudFiles"] = None
         row_count: Optional[int] = None
         row_offset: Optional[int] = None
 
         @staticmethod
         def from_api_obj(
-                obj: Optional[DbuiV1TransformRequestAutoloaderInput],
+            obj: Optional[DbuiV1TransformRequestAutoloaderInput],
         ) -> "Optional[TransformRequest.Autoloader]":
             if obj is None:
                 return None
@@ -235,22 +236,25 @@ class TransformRequest(BaseModel):
                 format=obj.format,
                 location=obj.location,
                 schema_file=obj.schema_file,
-                cloud_files=TransformRequest.Autoloader.CloudFiles.from_api_obj(obj.cloud_files),
+                var_schema=obj.var_schema,
+                cloud_files=TransformRequest.Autoloader.CloudFiles.from_api_obj(
+                    obj.cloud_files
+                ),
                 row_count=obj.row_count,
                 row_offset=obj.row_offset,
             )
+
         def to_api_obj(self) -> DbuiV1TransformRequestAutoloaderInput:
             return DbuiV1TransformRequestAutoloaderInput(
                 format=self.format,
                 location=self.location,
                 schemaFile=self.schema_file,
-                schema=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
+                rowOffset=self.row_offset,
             )
 
-
     class Transform(BaseModel):
         """
         A transform configuration to apply to the data.
@@ -360,7 +364,9 @@ class TransformRequest(BaseModel):
     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),
+            autoloader_input=TransformRequest.Autoloader.from_api_obj(
+                obj.autoloader_input
+            ),
             use_preset=obj.use_preset,
             transforms=[
                 TransformRequest.Transform.from_api_obj(item) for item in obj.transforms

{dasl_client-1.0.14.dist-info → dasl_client-1.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dasl_client
-Version: 1.0.14
+Version: 1.0.17
 Summary: The DASL client library used for interacting with the DASL workspace
 Home-page: https://github.com/antimatter/asl
 Author: Antimatter Team
@@ -11,8 +11,7 @@ License-File: LICENSE
 Requires-Dist: dasl-api ==0.1.17
 Requires-Dist: databricks-sdk >=0.41.0
 Requires-Dist: pydantic >=2
-Requires-Dist: pyspark >=3.5.5
-Requires-Dist: typing-extensions ==4.10.0
+Requires-Dist: typing-extensions >=4.10.0
 
 # DASL Client Library
 

{dasl_client-1.0.14.dist-info → dasl_client-1.0.17.dist-info}/RECORD

@@ -1,5 +1,5 @@
 dasl_client/__init__.py,sha256=E6gOgO8qg96Y38JKA-4LyNBvc2ytQPEfhdniYsCWBxA,127
-dasl_client/client.py,sha256=Eb_A7UKjRaTqmD0Q5Keq-JMA4MGGtKFv1Oft9vXE4Yo,26831
+dasl_client/client.py,sha256=vt2qY0BkhE-hbbntfg6FmyC7c-HJkHGzni8zbSD6aXQ,27819
 dasl_client/helpers.py,sha256=L7ycxrqyG28glRRGZgsrVBdCJzXYCW7DB0hAvupGMuA,1118
 dasl_client/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dasl_client/auth/auth.py,sha256=yTeijYYpfJVJ_wYyq0U6kAntg4xz5MzIR37_CpVR57k,7277
@@ -9,21 +9,28 @@ dasl_client/conn/conn.py,sha256=7o-2qeoVhzULQGW5l6OLYE5dZ60_8OU080ebV_-AW9Q,1433
 dasl_client/errors/__init__.py,sha256=lpH2HGF5kCRTk6MxpPEyY9ulTvsLBFKb4NnLuFFLZZA,40
 dasl_client/errors/errors.py,sha256=u-B8dR8zlxdNVeEdHi6UozX178jwJJ5ZJOGl9YjONRc,4008
 dasl_client/preset_development/__init__.py,sha256=9yC4gmQfombvYLThzo0pSfT5JMolfNVWFVQIuIg_XUA,131
-dasl_client/preset_development/errors.py,sha256=soLSaaWu97vo6LCTUgQw2MZNV06zXsaHoswmzB2I0Mk,5391
-dasl_client/preset_development/preview_engine.py,sha256=JH-iqtACBf8tYIDuQ7gNHeFSobANKU-qSklrYf8G5sg,14162
-dasl_client/preset_development/preview_parameters.py,sha256=KRk3lTImyvJTeEcepwOSokwa4dIQPEgLpQaodHRCEZk,13704
-dasl_client/preset_development/stage.py,sha256=NiDuFiKvoXgqVPPjzB3TZQN1dQeVff6he6oaSVGwkCs,20154
+dasl_client/preset_development/errors.py,sha256=jsqBFMZtl7uHi6O9bBHnOt0UQ4WM9KN9x0uYtf5c268,5482
+dasl_client/preset_development/preview_engine.py,sha256=eMt-Uu3_ocLMuEsZAoCdQfzDI_YvM5gUfiPFfRzpyvU,14714
+dasl_client/preset_development/preview_parameters.py,sha256=YjSJ00mEUcqF5KkJEPW6Wif8I4iaMIMxJeUSuyIS4x0,14640
+dasl_client/preset_development/stage.py,sha256=b4AE7aOocVG1WLKJLb69efNn1qwHulophBa_i58wMog,23089
 dasl_client/types/__init__.py,sha256=GsXC3eWuv21VTLPLPH9pzM95JByaKnKrPjJkh2rlZfQ,170
 dasl_client/types/admin_config.py,sha256=Kmx3Kuai9_LWMeO2NpWasRUgLihYSEXGtuYVfG0FkjU,2200
 dasl_client/types/content.py,sha256=uZAO-Vm_orvqsH2CkiwBUHgn6fWGXR90hOGKc256lcA,7442
 dasl_client/types/datasource.py,sha256=-ABmBh5yZwHeY-PKQMnNCNa9FSzod5n1O817m8ZCL6o,52519
-dasl_client/types/dbui.py,sha256=CLGEaBudddi7AmXoykHw3Mxv8wU2cWm20DZuM-bAjQA,16302
+dasl_client/types/dbui.py,sha256=VYRcxwVgoAfcuY7IlPdgfQ-R21Xmz-QWa3DdJgXIHM4,16413
 dasl_client/types/helpers.py,sha256=gLGTvrssAKrdkQT9h80twEosld2egwhvj-zAudxWFPs,109
 dasl_client/types/rule.py,sha256=BqhWhT8Eh95UXNytd0PxVcjqYuWQcdN1tfKjUB4Tk74,25781
 dasl_client/types/types.py,sha256=DeUOfdYGOhUGEy7yKOfo0OYTXYRrs57yYgNLUbu7Tlc,8806
 dasl_client/types/workspace_config.py,sha256=RThg_THS_4leITWdzBPTWdR2ytq5Uk36m6nIOUMzFCM,24878
-dasl_client-1.0.14.dist-info/LICENSE,sha256=M35UepUPyKmFkvENlkweeaMElheQqNoM5Emh8ADO-rs,4
-dasl_client-1.0.14.dist-info/METADATA,sha256=G12U4jgWU43fwrPGNh392IArKnjuAO33s8Wvb9nPTvQ,772
-dasl_client-1.0.14.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dasl_client-1.0.14.dist-info/top_level.txt,sha256=kIv8ox_2oJPjGB8_yuey5vvuPCyfY8kywG138f9oSOY,12
-dasl_client-1.0.14.dist-info/RECORD,,
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/conftest.py,sha256=ZfNULJxVQ609GHxw9UsreTcbQMl3gbcTP_DKT1oySwQ,440
+test/constants.py,sha256=ed3xiemWDJVBlHDwn-iQToCbcaXD3AN-5r8HkURCqBs,438
+test/test_api_changes.py,sha256=-SjOG5wKPD_cpTukkfNkALebph06_yxBYsqxtQVnedc,3466
+test/test_api_surface.py,sha256=XXAfJxYddRpYV1cmmVH2dI5LS9NLzd-sp-6jOnOgBTs,10613
+test/test_databricks_secret_auth.py,sha256=P1seBBHOLcCzJPLdRZlJZxeG62GUFKFbjsY8c7gTT_8,3613
+test/test_marshaling.py,sha256=WrouTCgcye_ytVOBMMseeEvUGZjbwibPJmEvGSK2LL4,37928
+dasl_client-1.0.17.dist-info/LICENSE,sha256=M35UepUPyKmFkvENlkweeaMElheQqNoM5Emh8ADO-rs,4
+dasl_client-1.0.17.dist-info/METADATA,sha256=T7ngJt7bv-rI9M9Y9hyIfq2wTPkMbtKcK0vVWNH1Ew8,741
+dasl_client-1.0.17.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dasl_client-1.0.17.dist-info/top_level.txt,sha256=943P5S_qILHKZYxAvxPUeqOzM2yV18d5SBVKxzPw2OE,17
+dasl_client-1.0.17.dist-info/RECORD,,

{dasl_client-1.0.14.dist-info → dasl_client-1.0.17.dist-info}/top_level.txt

@@ -1 +1,2 @@
 dasl_client
+test

test/conftest.py

@@ -0,0 +1,18 @@
+import pytest
+
+from dasl_client import Client
+
+from .constants import *
+
+
+@pytest.fixture(scope="session")
+def api_client():
+    client = Client.new_workspace(
+        admin_email="test@antimatter.io",
+        app_client_id=app_client_id,
+        service_principal_id=databricks_client_id,
+        service_principal_secret=databricks_client_secret,
+        workspace_url=databricks_host,
+        dasl_host=dasl_host,
+    )
+    yield client

test/constants.py

@@ -0,0 +1,10 @@
+import os
+from urllib.parse import urlparse
+
+dasl_host = os.environ["DASL_API_URL"]
+databricks_host = os.environ["DASL_DATABRICKS_HOST"]
+databricks_client_id = os.environ["DASL_DATABRICKS_CLIENT_ID"]
+databricks_client_secret = os.environ["DASL_DATABRICKS_CLIENT_SECRET"]
+workspace = urlparse(databricks_host).hostname
+app_client_id = "22853b93-68ba-4ae2-8e41-976417f501dd"
+alternate_app_client_id = "335ac0d3-e0ea-4732-ba93-0277423b5029"