databricks-sdk 0.44.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

databricks/sdk/_property.py

@@ -16,8 +16,9 @@ class _cached_property:
         if self.attrname is None:
             self.attrname = name
         elif name != self.attrname:
-            raise TypeError("Cannot assign the same cached_property to two different names "
-                            f"({self.attrname!r} and {name!r}).")
+            raise TypeError(
+                "Cannot assign the same cached_property to two different names " f"({self.attrname!r} and {name!r})."
+            )
 
     def __get__(self, instance, owner=None):
         if instance is None:
@@ -26,9 +27,11 @@ class _cached_property:
             raise TypeError("Cannot use cached_property instance without calling __set_name__ on it.")
         try:
             cache = instance.__dict__
-        except AttributeError: # not all objects have __dict__ (e.g. class defines slots)
-            msg = (f"No '__dict__' attribute on {type(instance).__name__!r} "
-                   f"instance to cache {self.attrname!r} property.")
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            msg = (
+                f"No '__dict__' attribute on {type(instance).__name__!r} "
+                f"instance to cache {self.attrname!r} property."
+            )
             raise TypeError(msg) from None
         val = cache.get(self.attrname, _NOT_FOUND)
         if val is _NOT_FOUND:
@@ -36,7 +39,9 @@ class _cached_property:
             try:
                 cache[self.attrname] = val
             except TypeError:
-                msg = (f"The '__dict__' attribute on {type(instance).__name__!r} instance "
-                       f"does not support item assignment for caching {self.attrname!r} property.")
+                msg = (
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance "
+                    f"does not support item assignment for caching {self.attrname!r} property."
+                )
                 raise TypeError(msg) from None
         return val

databricks/sdk/_widgets/__init__.py

@@ -43,7 +43,17 @@ try:
     # Detect if we are in an interactive notebook by iterating over the mro of the current ipython instance,
     # to find ZMQInteractiveShell (jupyter). When used from REPL or file, this check will fail, since the
     # mro only contains TerminalInteractiveShell.
-    if len(list(filter(lambda i: i.__name__ == 'ZMQInteractiveShell', get_ipython().__class__.__mro__))) == 0:
+    if (
+        len(
+            list(
+                filter(
+                    lambda i: i.__name__ == "ZMQInteractiveShell",
+                    get_ipython().__class__.__mro__,
+                )
+            )
+        )
+        == 0
+    ):
         logging.debug("Not in an interactive notebook. Skipping ipywidgets implementation for dbutils.")
         raise EnvironmentError("Not in an interactive notebook.")
 
@@ -61,7 +71,8 @@ try:
         warnings.warn(
             "\nTo use databricks widgets interactively in your notebook, please install databricks sdk using:\n"
             "\tpip install 'databricks-sdk[notebook]'\n"
-            "Falling back to default_value_only implementation for databricks widgets.")
+            "Falling back to default_value_only implementation for databricks widgets."
+        )
         logging.debug(f"{e.msg}. Skipping ipywidgets implementation for dbutils.")
         raise e
 

databricks/sdk/_widgets/default_widgets_utils.py

@@ -11,25 +11,31 @@ class DefaultValueOnlyWidgetUtils(WidgetUtils):
     def text(self, name: str, defaultValue: str, label: typing.Optional[str] = None):
         self._widgets[name] = defaultValue
 
-    def dropdown(self,
-                 name: str,
-                 defaultValue: str,
-                 choices: typing.List[str],
-                 label: typing.Optional[str] = None):
+    def dropdown(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
         self._widgets[name] = defaultValue
 
-    def combobox(self,
-                 name: str,
-                 defaultValue: str,
-                 choices: typing.List[str],
-                 label: typing.Optional[str] = None):
+    def combobox(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
         self._widgets[name] = defaultValue
 
-    def multiselect(self,
-                    name: str,
-                    defaultValue: str,
-                    choices: typing.List[str],
-                    label: typing.Optional[str] = None):
+    def multiselect(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
         self._widgets[name] = defaultValue
 
     def _get(self, name: str) -> str:

databricks/sdk/_widgets/ipywidgets_utils.py

@@ -28,9 +28,9 @@ class DbUtilsWidget:
         if type(value) == str or value is None:
             return value
         if type(value) == list or type(value) == tuple:
-            return ','.join(value)
+            return ",".join(value)
 
-        raise ValueError("The returned value has invalid type (" + type(value) + ").")
+        raise ValueError(f"The returned value has invalid type ({type(value)}).")
 
 
 class IPyWidgetUtil(WidgetUtils):
@@ -38,7 +38,12 @@ class IPyWidgetUtil(WidgetUtils):
     def __init__(self) -> None:
         self._widgets: typing.Dict[str, DbUtilsWidget] = {}
 
-    def _register(self, name: str, widget: ValueWidget, label: typing.Optional[str] = None):
+    def _register(
+        self,
+        name: str,
+        widget: ValueWidget,
+        label: typing.Optional[str] = None,
+    ):
         label = label if label is not None else name
         w = DbUtilsWidget(label, widget)
 
@@ -51,29 +56,47 @@ class IPyWidgetUtil(WidgetUtils):
     def text(self, name: str, defaultValue: str, label: typing.Optional[str] = None):
         self._register(name, widget_string.Text(defaultValue), label)
 
-    def dropdown(self,
-                 name: str,
-                 defaultValue: str,
-                 choices: typing.List[str],
-                 label: typing.Optional[str] = None):
-        self._register(name, widget_selection.Dropdown(value=defaultValue, options=choices), label)
-
-    def combobox(self,
-                 name: str,
-                 defaultValue: str,
-                 choices: typing.List[str],
-                 label: typing.Optional[str] = None):
-        self._register(name, widget_string.Combobox(value=defaultValue, options=choices), label)
-
-    def multiselect(self,
-                    name: str,
-                    defaultValue: str,
-                    choices: typing.List[str],
-                    label: typing.Optional[str] = None):
+    def dropdown(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
         self._register(
             name,
-            widget_selection.SelectMultiple(value=(defaultValue, ),
-                                            options=[("__EMPTY__", ""), *list(zip(choices, choices))]), label)
+            widget_selection.Dropdown(value=defaultValue, options=choices),
+            label,
+        )
+
+    def combobox(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
+        self._register(
+            name,
+            widget_string.Combobox(value=defaultValue, options=choices),
+            label,
+        )
+
+    def multiselect(
+        self,
+        name: str,
+        defaultValue: str,
+        choices: typing.List[str],
+        label: typing.Optional[str] = None,
+    ):
+        self._register(
+            name,
+            widget_selection.SelectMultiple(
+                value=(defaultValue,),
+                options=[("__EMPTY__", ""), *list(zip(choices, choices))],
+            ),
+            label,
+        )
 
     def _get(self, name: str) -> str:
         return self._widgets[name].value

databricks/sdk/azure.py

@@ -4,14 +4,14 @@ from .oauth import TokenSource
 from .service.provisioning import Workspace
 
 
-def add_workspace_id_header(cfg: 'Config', headers: Dict[str, str]):
+def add_workspace_id_header(cfg: "Config", headers: Dict[str, str]):
     if cfg.azure_workspace_resource_id:
         headers["X-Databricks-Azure-Workspace-Resource-Id"] = cfg.azure_workspace_resource_id
 
 
-def add_sp_management_token(token_source: 'TokenSource', headers: Dict[str, str]):
+def add_sp_management_token(token_source: "TokenSource", headers: Dict[str, str]):
     mgmt_token = token_source.token()
-    headers['X-Databricks-Azure-SP-Management-Token'] = mgmt_token.access_token
+    headers["X-Databricks-Azure-SP-Management-Token"] = mgmt_token.access_token
 
 
 def get_azure_resource_id(workspace: Workspace):
@@ -22,6 +22,8 @@ def get_azure_resource_id(workspace: Workspace):
     """
     if workspace.azure_workspace_info is None:
         return None
-    return (f'/subscriptions/{workspace.azure_workspace_info.subscription_id}'
-            f'/resourceGroups/{workspace.azure_workspace_info.resource_group}'
-            f'/providers/Microsoft.Databricks/workspaces/{workspace.workspace_name}')
+    return (
+        f"/subscriptions/{workspace.azure_workspace_info.subscription_id}"
+        f"/resourceGroups/{workspace.azure_workspace_info.resource_group}"
+        f"/providers/Microsoft.Databricks/workspaces/{workspace.workspace_name}"
+    )

databricks/sdk/casing.py

@@ -8,22 +8,22 @@ class _Name(object):
         for ch in raw_name:
             if ch.isupper():
                 if segment:
-                    self._segments.append(''.join(segment))
+                    self._segments.append("".join(segment))
                 segment = [ch.lower()]
             elif ch.islower():
                 segment.append(ch)
             else:
                 if segment:
-                    self._segments.append(''.join(segment))
+                    self._segments.append("".join(segment))
                 segment = []
         if segment:
-            self._segments.append(''.join(segment))
+            self._segments.append("".join(segment))
 
     def to_snake_case(self) -> str:
-        return '_'.join(self._segments)
+        return "_".join(self._segments)
 
     def to_header_case(self) -> str:
-        return '-'.join([s.capitalize() for s in self._segments])
+        return "-".join([s.capitalize() for s in self._segments])
 
 
 class Casing(object):