databricks-lakeflow-integrations 0.0.1__py3-none-any.whl

databricks/__init__.py

@@ -0,0 +1,7 @@
+# See: https://packaging.python.org/guides/packaging-namespace-packages/#pkgutil-style-namespace-packages
+#
+# This file must only contain the following line, or other packages in the databricks.* namespace
+# may not be importable. The contents of this file must be byte-for-byte equivalent across all packages.
+# If they are not, parallel package installation may lead to clobbered and invalid files.
+# Also see https://github.com/databricks/databricks-sdk-py/issues/343.
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

databricks/lakeflow/__init__.py

@@ -0,0 +1,6 @@
+# See: https://packaging.python.org/guides/packaging-namespace-packages/#pkgutil-style-namespace-packages
+#
+# This file must only contain the following line, or other packages in the databricks.lakeflow.* namespace
+# may not be importable. The contents of this file must be byte-for-byte equivalent across all packages.
+# If they are not, parallel package installation may lead to clobbered and invalid files.
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

databricks/lakeflow/integrations/__init__.py

@@ -0,0 +1,15 @@
+"""Databricks Lakeflow integrations."""
+
+from databricks.lakeflow.integrations._api import Context, Sensor, SensorResult
+from databricks.lakeflow.integrations._integration import integration
+from databricks.lakeflow.integrations._runtime import _entrypoint
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "Context",
+    "Sensor",
+    "SensorResult",
+    "integration",
+    "_entrypoint",
+]

databricks/lakeflow/integrations/_api.py

@@ -0,0 +1,73 @@
+"""Core API types for Databricks Lakeflow integrations."""
+
+import datetime
+from dataclasses import dataclass
+from typing import Literal, Protocol, runtime_checkable
+
+__all__ = [
+    "Context",
+    "Sensor",
+    "SensorResult",
+]
+
+
+@dataclass(frozen=True, kw_only=True)
+class Context:
+    """Carries the context of the job task run.
+
+    It is passed to :meth:`Sensor.poll` so sensor implementations can correlate
+    their polling with the run they belong to.
+
+    Attributes:
+        main: Fully qualified name of the task entry point.
+        task_key: Key of the task within the job.
+        job_run_id: Identifier of the job run.
+        task_run_id: Identifier of the task run.
+        job_id: Identifier of the job.
+    """
+
+    main: str
+    task_key: str
+    job_run_id: int
+    task_run_id: int
+    job_id: int
+
+
+@dataclass(frozen=True)
+class SensorResult:
+    """
+    SensorResult is returned by Sensor.poll method to indicate whether
+    the sensor has completed or should be deferred. When the sensor is
+    deferred, compute resources are released.
+    """
+
+    status: Literal["completed", "deferred"]
+    defer_for: datetime.timedelta | None = None
+
+    @classmethod
+    def completed(cls) -> "SensorResult":
+        return cls(status="completed")
+
+    @classmethod
+    def deferred(cls, duration: datetime.timedelta) -> "SensorResult":
+        return cls(status="deferred", defer_for=duration)
+
+
+@runtime_checkable
+class Sensor(Protocol):
+    """
+    Sensor is responsible for polling a condition and returning a SensorResult
+    indicating whether the condition has been met or if the sensor should be deferred.
+    """
+
+    def poll(self, ctx: "Context") -> SensorResult:
+        """Check the status of the condition being polled.
+
+        Args:
+            ctx: Context of the enclosing job task run.
+
+        Returns:
+            :meth:`SensorResult.completed` if the condition has been met, or
+            :meth:`SensorResult.deferred` if the sensor should be deferred.
+        """
+        ...

databricks/lakeflow/integrations/_integration.py

@@ -0,0 +1,50 @@
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Optional, TypeVar
+
+from databricks.lakeflow.integrations._api import Sensor
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+_INTEGRATION_METADATA_ATTR = "_lakeflow_integration_metadata"
+
+
+@dataclass(frozen=True, kw_only=True)
+class IntegrationMetadata:
+    display_name: str
+    description: Optional[str] = None
+
+
+def integration(*, display_name: str, description: Optional[str] = None) -> Callable[[F], F]:
+    """Mark a Sensor subclass or a function to appear as an integration.
+
+    Example::
+
+        @integration(display_name="Refresh view")
+        def refresh_mv(view: str): ...
+
+        @integration(display_name="Orders")
+        class OrdersSensor(Sensor): ...
+    """
+    metadata = IntegrationMetadata(display_name=display_name, description=description)
+
+    def decorate(target: F) -> F:
+        is_sensor = isinstance(target, type) and issubclass(target, Sensor)
+        if not (is_sensor or inspect.isfunction(target)):
+            raise TypeError("@integration can decorate only Sensor subclasses or functions")
+        setattr(target, _INTEGRATION_METADATA_ATTR, metadata)
+        return target
+
+    return decorate
+
+
+def get_integration_metadata(target: object) -> Optional[IntegrationMetadata]:
+    """Return the entry point's metadata, or None if it is not tagged."""
+    # __dict__ for a class, not getattr, so a subclass of a tagged Sensor does
+    # not inherit the tag.
+    if isinstance(target, type):
+        metadata = target.__dict__.get(_INTEGRATION_METADATA_ATTR)
+    else:
+        metadata = getattr(target, _INTEGRATION_METADATA_ATTR, None)
+    return metadata if isinstance(metadata, IntegrationMetadata) else None

databricks/lakeflow/integrations/_runtime.py

@@ -0,0 +1,196 @@
+"""Runtime entry point for executing Lakeflow Python operator tasks."""
+
+import inspect
+import importlib
+import json
+from enum import Enum
+from typing import Optional, get_type_hints
+
+from databricks.lakeflow.integrations._api import Context, Sensor, SensorResult
+
+__all__ = [
+    "Context",
+    "Sensor",
+    "SensorResult",
+    "_entrypoint",
+    "_run_function",
+]
+
+
+def _entrypoint(ctx: dict):
+    # `databricks.sdk.runtime` is only available inside the user's cluster
+    # Python environment. Import lazily so this module can be imported (and
+    # unit-tested) without the SDK present.
+    from databricks.sdk.runtime import dbutils
+
+    bindings = dbutils.widgets.getAll()
+    return _run_function(bindings=bindings, ctx=ctx)
+
+
+class _Outcome(Enum):
+    COMPLETED = "COMPLETED"
+    DEFERRED = "DEFERRED"
+
+
+class _PythonOperatorClientMessage:
+    MIME_TYPE = "application/vnd.databricks.pythonoperatortask+json"
+
+    def __init__(self, outcome: _Outcome, deferred_duration_millis: Optional[int]):
+        self.payload: dict = {"outcome": outcome.name}
+        if deferred_duration_millis is not None:
+            self.payload["deferred_duration_millis"] = deferred_duration_millis
+
+    def _repr_mimebundle_(self, **kwargs):
+        return {self.MIME_TYPE: json.dumps(self.payload)}, {}
+
+    def __repr__(self):
+        return f"PythonOperatorClientMessage({self.payload})"
+
+
+def _run_function(bindings: dict[str, str], ctx: dict):
+    context = _parse_context(ctx)
+    main = context.main
+
+    parameters = {k: v for k, v in bindings.items() if not k.startswith("__databricks")}
+
+    # main is a string like "a.b.c.function". `rsplit` on a bare name (no dot)
+    # would raise an unfriendly unpacking error, so reject that up front.
+    if "." not in main:
+        raise ValueError("main is not a valid qualified name")
+
+    module_name, func_name = main.rsplit(".", 1)
+
+    if not module_name or not func_name:
+        raise ValueError("main is not a valid qualified name")
+
+    module = importlib.import_module(module_name)
+    obj = getattr(module, func_name, None)
+
+    if obj is None:
+        raise ValueError(f"Function {func_name} not found in module {module_name}")
+
+    if inspect.isfunction(obj):
+        _run_callable(obj, parameters)
+
+        return _PythonOperatorClientMessage(
+            outcome=_Outcome.COMPLETED,
+            deferred_duration_millis=None,
+        )
+    elif _is_sensor_class(obj):
+        instance = _run_callable(obj, parameters)
+
+        if not isinstance(instance, Sensor):
+            raise ValueError(f"{func_name} is not a Sensor")
+
+        result = instance.poll(context)
+
+        return _client_message_from_result(result)
+    else:
+        raise ValueError(f"{func_name} is not a function or Sensor")
+
+
+def _parse_context(ctx: dict) -> Context:
+    return Context(
+        main=ctx["main"],
+        task_key=ctx["task_key"],
+        job_run_id=ctx["job_run_id"],
+        task_run_id=ctx["task_run_id"],
+        job_id=ctx["job_id"],
+    )
+
+
+def _client_message_from_result(result: SensorResult) -> _PythonOperatorClientMessage:
+    if result.status == "completed":
+        return _PythonOperatorClientMessage(
+            outcome=_Outcome.COMPLETED,
+            deferred_duration_millis=None,
+        )
+    else:
+        deferred_duration_millis = None
+        if result.defer_for:
+            deferred_duration_millis = int(result.defer_for.total_seconds() * 1000)
+
+        return _PythonOperatorClientMessage(
+            outcome=_Outcome.DEFERRED,
+            deferred_duration_millis=deferred_duration_millis,
+        )
+
+
+def _is_sensor_class(obj: object) -> bool:
+    return inspect.isclass(obj) and issubclass(obj, Sensor)
+
+
+def _run_callable(obj, parameters: dict[str, str]):
+    signature = inspect.signature(obj)
+    converted_kwargs: dict[str, object] = {}
+
+    # `inspect.signature(...).parameters[i].annotation` returns the raw
+    # `__annotations__` entry, which is a literal string under PEP 563
+    # (`from __future__ import annotations`) or PEP 484 explicit forward
+    # references. `typing.get_type_hints` evaluates those strings against
+    # the callable's module globals to produce the actual type objects.
+    # For classes, annotations live on `__init__`.
+    hints_target = obj.__init__ if inspect.isclass(obj) else obj
+    type_hints = get_type_hints(hints_target)
+
+    has_kwargs = any(param.kind == inspect.Parameter.VAR_KEYWORD for param in signature.parameters.values())
+    if has_kwargs:
+        # capture all parameters as kwargs if signature has kwargs
+        converted_kwargs = {**parameters}
+
+    # inspect func signature and validate parameters
+    for param in signature.parameters.values():
+        if param.kind in [
+            inspect.Parameter.VAR_POSITIONAL,  # non-deterministic, don't pass anything
+            inspect.Parameter.VAR_KEYWORD,  # already captured as kwargs
+            inspect.Parameter.POSITIONAL_ONLY,  # this will result in error when we call the function
+        ]:
+            continue
+
+        if param.kind in [
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            inspect.Parameter.KEYWORD_ONLY,
+        ]:
+            if param.name in parameters:
+                annotation = type_hints.get(param.name, param.annotation)
+                converted_kwargs[param.name] = _convert_parameter(param.name, annotation, parameters[param.name])
+
+    return obj(**converted_kwargs)
+
+
+def _convert_parameter(name: str, annotation, value: str):
+    # No annotation: pass the raw widget string through unchanged. Otherwise a
+    # plain `def fn(x, **kwargs)` would error before the user code ever runs.
+    if annotation is inspect.Parameter.empty or annotation is str:
+        return value
+    if annotation is int:
+        try:
+            return int(value)
+        except ValueError as e:
+            raise ValueError(f"Parameter {name}: invalid int value '{value}'") from e
+    if annotation is float:
+        try:
+            return float(value)
+        except ValueError as e:
+            raise ValueError(f"Parameter {name}: invalid float value '{value}'") from e
+    if annotation is bool:
+        if value not in ["true", "false"]:
+            raise ValueError(f"Parameter {name}: invalid boolean value '{value}'")
+        return value == "true"
+    if annotation is list:
+        result = json.loads(value)
+        if not isinstance(result, list):
+            raise ValueError(f"Parameter {name}: invalid list value '{value}'")
+        return result
+    if annotation is dict:
+        result = json.loads(value)
+        if not isinstance(result, dict):
+            raise ValueError(f"Parameter {name}: invalid dict value '{value}'")
+        return result
+
+    # TODO: support more types, including generics
+
+    raise ValueError(
+        f"Parameter {name}: unsupported type '{annotation}',"
+        f"only str, int, float, bool, list, and dict are supported."
+    )

databricks/lakeflow/integrations/generate.py

@@ -0,0 +1,282 @@
+"""Generate Lakeflow integration definitions from Python Operator entry points."""
+
+import argparse
+import importlib
+import inspect
+import json
+import pkgutil
+from collections.abc import Callable
+from pathlib import Path
+from types import ModuleType
+from typing import Optional, Union, get_args, get_origin, get_type_hints
+
+from databricks.lakeflow.integrations._integration import get_integration_metadata
+
+_SCHEMA_VERSION = "lakeflow-integration-v0.1.0"
+
+_EntryPoint = Union[type, Callable]
+
+# Parameter kinds that cannot be surfaced as named config fields: *args and
+# **kwargs have no stable name to bind a widget to, and positional-only params
+# cannot be passed by keyword (which is how the operator injects values).
+_UNSUPPORTED_PARAMETER_KINDS = frozenset(
+    {
+        inspect.Parameter.VAR_POSITIONAL,
+        inspect.Parameter.VAR_KEYWORD,
+        inspect.Parameter.POSITIONAL_ONLY,
+    }
+)
+
+
+def _generate(package_module_name: str, environment: Optional[dict] = None) -> list[dict]:
+    """Return an integration definition for every entry point in the package.
+
+    Definitions are ordered by their ``main`` entry point for deterministic
+    output. ``environment`` is copied into every definition (omitted when None).
+    """
+    return [_build_definition(obj, environment) for obj in _discover_entry_points(package_module_name)]
+
+
+def _discover_entry_points(package_module_name: str) -> list[_EntryPoint]:
+    """Import the package recursively and collect its ``@integration`` entry points.
+
+    Results are deduplicated by entry point name and sorted by it.
+    """
+    package = importlib.import_module(package_module_name)
+
+    entry_points: dict[str, _EntryPoint] = {}
+    for module in _load_modules(package):
+        for _name, member in inspect.getmembers(module):
+            if _is_entry_point(member, module.__name__):
+                entry_points[f"{member.__module__}.{member.__qualname__}"] = member
+
+    return [entry_points[main] for main in sorted(entry_points)]
+
+
+def _load_modules(package_module: ModuleType) -> list[ModuleType]:
+    """Import ``package_module`` and all of its submodules recursively.
+
+    Simplified from the reference loader: import errors propagate rather than
+    being collected, since this is a build-time tool where failing loudly is
+    preferable to silently emitting a partial definition set.
+    """
+    spec = package_module.__spec__
+    if spec is None:
+        raise ValueError(f"Module '{package_module.__name__}' has no __spec__")
+
+    module_names = []
+    # A package with an __init__.py has an origin; a namespace package does not.
+    if spec.origin:
+        module_names.append(spec.name)
+
+    if spec.submodule_search_locations:
+        prefix = spec.name + "."
+        for _finder, name, _is_pkg in pkgutil.walk_packages(spec.submodule_search_locations, prefix):
+            module_names.append(name)
+
+    # Sort for a deterministic import order.
+    return [importlib.import_module(name) for name in sorted(set(module_names))]
+
+
+def _is_entry_point(obj: object, module_name: str) -> bool:
+    # Restrict to entry points physically defined in this module so one
+    # imported into another module is not reported twice.
+    if getattr(obj, "__module__", None) != module_name:
+        return False
+    return get_integration_metadata(obj) is not None
+
+
+def _build_definition(obj: _EntryPoint, environment: Optional[dict] = None) -> dict:
+    """Build a single ``lakeflow-integration-v0.1.0`` definition for ``obj``.
+
+    ``environment`` is copied in verbatim when provided, otherwise omitted.
+    """
+    metadata = get_integration_metadata(obj)
+    assert metadata is not None  # discovery only yields tagged objects
+
+    definition = {
+        "schema": _SCHEMA_VERSION,
+        "name": metadata.display_name,
+        "description": metadata.description or _docstring(obj) or metadata.display_name,
+        "main": f"{obj.__module__}.{obj.__qualname__}",
+        "config": _build_config(obj),
+    }
+    if environment is not None:
+        definition["environment"] = environment
+    return definition
+
+
+def _build_environment(
+    dependencies: list[str],
+    environment_version: Optional[str],
+    environment_key: Optional[str],
+) -> Optional[dict]:
+    """Build the shared ``environment`` block from CLI inputs.
+
+    Key order matches the schema: ``environment_key``, ``environment_version``,
+    ``dependencies``. Returns None when no environment inputs were supplied, so
+    the block is omitted rather than emitted empty.
+    """
+    if not dependencies and environment_version is None and environment_key is None:
+        return None
+
+    environment: dict = {}
+    if environment_key is not None:
+        environment["environment_key"] = environment_key
+    if environment_version is not None:
+        environment["environment_version"] = environment_version
+    environment["dependencies"] = dependencies
+    return environment
+
+
+def _build_config(obj: _EntryPoint) -> dict:
+    """Build the ``config`` JSON Schema from the entry point's signature.
+
+    Parameters without a default are listed under ``required``; scalar defaults
+    are carried through.
+    """
+    properties: dict[str, dict] = {}
+    required: list[str] = []
+
+    annotations = _annotations(obj)
+    for param in _config_parameters(obj):
+        annotation = annotations.get(param.name, param.annotation)
+        prop = _config_property(annotation)
+
+        if param.default is inspect.Parameter.empty:
+            required.append(param.name)
+        elif _is_scalar(param.default):
+            prop["default"] = param.default
+
+        properties[param.name] = prop
+
+    config: dict = {"type": "object", "properties": properties}
+    if required:
+        config["required"] = required
+    return config
+
+
+def _config_parameters(obj: _EntryPoint) -> list[inspect.Parameter]:
+    try:
+        signature = inspect.signature(obj)
+    except (ValueError, TypeError):
+        # Builtins and some C-level types have no introspectable signature.
+        return []
+
+    return [param for param in signature.parameters.values() if param.kind not in _UNSUPPORTED_PARAMETER_KINDS]
+
+
+def _annotations(obj: _EntryPoint) -> dict:
+    # get_type_hints resolves deferred (PEP 563) / forward-reference annotations
+    # against the module globals. For a class they live on __init__.
+    target = obj.__init__ if inspect.isclass(obj) else obj
+    try:
+        return get_type_hints(target)
+    except (NameError, TypeError):
+        # Unresolvable forward reference: fall back to raw annotations rather
+        # than aborting the run.
+        return {}
+
+
+def _config_property(annotation: object) -> dict:
+    # int gets the number widget; every other type is emitted with only its JSON
+    # Schema type, letting the UI pick its default control.
+    annotation = _unwrap_optional(annotation)
+
+    if annotation is int:
+        return {"type": "integer", "x-ui": {"widget": "number"}}
+    if annotation is float:
+        return {"type": "number"}
+    if annotation is bool:
+        return {"type": "boolean"}
+    return {"type": "string"}
+
+
+def _unwrap_optional(annotation: object) -> object:
+    # Optional[T] is Union[T, None]; unwrap the single non-None arm.
+    if get_origin(annotation) is Union:
+        args = [arg for arg in get_args(annotation) if arg is not type(None)]
+        if len(args) == 1:
+            return args[0]
+    return annotation
+
+
+def _docstring(obj: _EntryPoint) -> Optional[str]:
+    # __doc__ directly, not inspect.getdoc, which would inherit the Sensor
+    # protocol's docstring for an undocumented sensor.
+    doc = obj.__doc__
+    if doc:
+        for line in inspect.cleandoc(doc).splitlines():
+            stripped = line.strip()
+            if stripped:
+                return stripped
+    return None
+
+
+def _is_scalar(value: object) -> bool:
+    # bool is a subclass of int; all four are JSON scalars the schema allows.
+    return isinstance(value, (str, int, float, bool))
+
+
+def _write_definitions(
+    package_module_name: str,
+    output_dir: Path,
+    environment: Optional[dict] = None,
+) -> list[Path]:
+    """Write one ``<main>.yml`` file per entry point into ``output_dir``.
+
+    ``main`` is the entry point's unique dotted path, so it is a collision-free
+    file name. The body is formatted JSON, a valid YAML subset. Returns the
+    written paths, sorted.
+    """
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    written = []
+    for definition in _generate(package_module_name, environment):
+        path = output_dir / f"{definition['main']}.yml"
+        path.write_text(json.dumps(definition, indent=2) + "\n")
+        written.append(path)
+    return written
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--package-module",
+        required=True,
+        help="Dotted name of the package to load recursively, e.g. 'my_pkg'.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        required=True,
+        help="Directory to write the '<main>.yml' files into.",
+    )
+    parser.add_argument(
+        "--dependency",
+        action="append",
+        default=[],
+        dest="dependencies",
+        metavar="SPEC",
+        help="pip-style dependency or workspace .whl path for the environment "
+        "block. Repeatable; must include the wheel that provides the entry points.",
+    )
+    parser.add_argument(
+        "--environment-version",
+        help="environment_version for the environment block, e.g. '5'.",
+    )
+    parser.add_argument(
+        "--environment-key",
+        help="environment_key for the environment block.",
+    )
+    args = parser.parse_args(argv)
+
+    environment = _build_environment(
+        dependencies=args.dependencies,
+        environment_version=args.environment_version,
+        environment_key=args.environment_key,
+    )
+    _write_definitions(args.package_module, Path(args.output_dir), environment)
+
+
+if __name__ == "__main__":
+    main()

databricks_lakeflow_integrations-0.0.1.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: databricks-lakeflow-integrations
+Version: 0.0.1
+Summary: Extend Lakeflow with custom integrations using Python.
+Author: Gleb Kanterov
+Author-email: Gleb Kanterov <gleb.kanterov@databricks.com>
+License-Expression: LicenseRef-Databricks
+License-File: LICENSE.md
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# databricks-lakeflow-integrations
+
+Extend Lakeflow with custom integrations using Python.
+
+## Usage
+
+Follow instructions received by email from the Databricks representative.

databricks_lakeflow_integrations-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+databricks/__init__.py,sha256=CF2MJcZFwbpn9TwQER8qnCDhkPooBGQNVkX4v7g6p3g,537
+databricks/lakeflow/__init__.py,sha256=iZWKnlKLkb1JhqJHYHyEK2BUo2AbMRoc-jEA_aisfVI,475
+databricks/lakeflow/integrations/__init__.py,sha256=fFqHzRYix2wGKLuDIeO5nDMhYcagXsdW5SqkPXlJLVE,382
+databricks/lakeflow/integrations/_api.py,sha256=FkKwrn0VdUlvOBN19TqFpE890JLeU2kEC6_fLuLGuS8,2016
+databricks/lakeflow/integrations/_integration.py,sha256=7T4yXlQhCZ42CxZIjnXVd7APM_XGwdk6lrq4lF0jzIo,1756
+databricks/lakeflow/integrations/_runtime.py,sha256=iab-GQz_pZHwf2zQ6L0B3YEupFLfNDihLTdDYHMJ-m0,6900
+databricks/lakeflow/integrations/generate.py,sha256=79uh6ibOs6yeB6N9uibiPJLHZDvUE-1EJSV_dpImWsk,9978
+databricks_lakeflow_integrations-0.0.1.dist-info/licenses/LICENSE.md,sha256=TTZEJNJMEwwTNZdZXD4V3iPuUjU10jBJwoSzRCc4J34,3442
+databricks_lakeflow_integrations-0.0.1.dist-info/WHEEL,sha256=CoDSoyhtC_eO_tlxRYzsTraPv1fPJRXFx91k6ISeAvA,81
+databricks_lakeflow_integrations-0.0.1.dist-info/METADATA,sha256=E8a49UNg4disllmUS_ONyDWM6CMEFoFFxKH8ILLvVO0,529
+databricks_lakeflow_integrations-0.0.1.dist-info/RECORD,,

databricks_lakeflow_integrations-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.28
+Root-Is-Purelib: true
+Tag: py3-none-any

databricks_lakeflow_integrations-0.0.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,30 @@
+# Databricks License
+
+## Definitions
+
+**Agreement:** The agreement between Databricks, Inc., and you governing the use of the Databricks Services, as that term is defined in the Master Cloud Services Agreement (MCSA) located at [www.databricks.com/legal/mcsa](https://www.databricks.com/legal/mcsa).
+
+**Licensed Materials:** The source code, object code, data, and/or other works to which this license applies.
+
+## Scope of Use
+
+You may not use the Licensed Materials except in connection with your use of the Databricks Services pursuant to the Agreement. Your use of the Licensed Materials must comply at all times with any restrictions applicable to the Databricks Services, generally, and must be used in accordance with any applicable documentation. You may view, use, copy, modify, publish, and/or distribute the Licensed Materials solely for the purposes of using the Licensed Materials within or connecting to the Databricks Services. If you do not agree to these terms, you may not view, use, copy, modify, publish, and/or distribute the Licensed Materials.
+
+## Redistribution
+
+You may redistribute and sublicense the Licensed Materials so long as all use is in compliance with these terms. In addition:
+
+- You must give any other recipients a copy of this License;
+- You must cause any modified files to carry prominent notices stating that you changed the files;
+- You must retain, in any derivative works that you distribute, all copyright, patent, trademark, and attribution notices, excluding those notices that do not pertain to any part of the derivative works; and
+- If a "NOTICE" text file is provided as part of its distribution, then any derivative works that you distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the derivative works.
+
+You may add your own copyright statement to your modifications and may provide additional license terms and conditions for use, reproduction, or distribution of your modifications, or for any such derivative works as a whole, provided your use, reproduction, and distribution of the Licensed Materials otherwise complies with the conditions stated in this License.
+
+## Termination
+
+This license terminates automatically upon your breach of these terms or upon the termination of your Agreement. Additionally, Databricks may terminate this license at any time on notice. Upon termination, you must permanently delete the Licensed Materials and all copies thereof.
+
+## Disclaimer; Limitation of Liability
+
+THE LICENSED MATERIALS ARE PROVIDED "AS-IS" AND WITH ALL FAULTS. DATABRICKS, ON BEHALF OF ITSELF AND ITS LICENSORS, SPECIFICALLY DISCLAIMS ALL WARRANTIES RELATING TO THE LICENSED MATERIALS, EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, IMPLIED WARRANTIES, CONDITIONS AND OTHER TERMS OF MERCHANTABILITY, SATISFACTORY QUALITY OR FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. DATABRICKS AND ITS LICENSORS TOTAL AGGREGATE LIABILITY RELATING TO OR ARISING OUT OF YOUR USE OF OR DATABRICKS' PROVISIONING OF THE LICENSED MATERIALS SHALL BE LIMITED TO ONE THOUSAND ($1,000) DOLLARS. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE LICENSED MATERIALS OR THE USE OR OTHER DEALINGS IN THE LICENSED MATERIALS.