openlineage-python 1.14.0__tar.gz → 1.15.0__tar.gz

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openlineage-python
-Version: 1.14.0
+Version: 1.15.0
 Summary: OpenLineage Python Client
 Author-email: OpenLineage <info@openlineage.io>
 Keywords: openlineage

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/docs/release-api-reference.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# Copyright 2018-2023 contributors to the OpenLineage project
+# Copyright 2018-2024 contributors to the OpenLineage project
 # SPDX-License-Identifier: Apache-2.0
 #
 

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/docs/source/openlineage.client.rst

@@ -65,6 +65,14 @@ openlineage.client.utils module
    :undoc-members:
    :show-inheritance:
 
+openlineage.client.uuid module
+-------------------------------
+
+.. automodule:: openlineage.client.uuid
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 openlineage.client.generated.base module
 ----------------------------------------
 

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/__init__.py

@@ -2,7 +2,12 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+import warnings
+
 from openlineage.client.client import OpenLineageClient, OpenLineageClientOptions
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
 from openlineage.client.facet import set_producer as set_producer_v1
 from openlineage.client.facet_v2 import set_producer as set_producer_v2
 

openlineage_python-1.15.0/openlineage/client/client.py

@@ -0,0 +1,247 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import logging
+import os
+import warnings
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+import attr
+import yaml
+from openlineage.client.filter import Filter, create_filter
+from openlineage.client.serde import Serde
+
+if TYPE_CHECKING:
+    from requests import Session
+    from requests.adapters import HTTPAdapter
+
+from openlineage.client import event_v2
+from openlineage.client.run import DatasetEvent, JobEvent, RunEvent
+from openlineage.client.transport import Transport, TransportFactory, get_default_factory
+from openlineage.client.transport.http import HttpConfig, HttpTransport, create_token_provider
+from openlineage.client.transport.noop import NoopConfig, NoopTransport
+
+Event_v1 = Union[RunEvent, DatasetEvent, JobEvent]
+Event_v2 = Union[event_v2.RunEvent, event_v2.DatasetEvent, event_v2.JobEvent]
+Event = Union[Event_v1, Event_v2]
+
+
+@attr.s
+class OpenLineageClientOptions:
+    timeout: float = attr.ib(default=5.0)
+    verify: bool = attr.ib(default=True)
+    api_key: str = attr.ib(default=None)
+    adapter: HTTPAdapter = attr.ib(default=None)
+
+
+log = logging.getLogger(__name__)
+_T = TypeVar("_T", bound="OpenLineageClient")
+
+
+class OpenLineageClient:
+    def __init__(  # noqa: PLR0913
+        self,
+        url: str | None = None,
+        options: OpenLineageClientOptions | None = None,
+        session: Session | None = None,
+        transport: Transport | None = None,
+        factory: TransportFactory | None = None,
+    ) -> None:
+        # Set parent's logging level if environment variable is present
+        custom_logging_level = os.getenv("OPENLINEAGE_CLIENT_LOGGING", None)
+        if custom_logging_level:
+            logging.getLogger(__name__.rpartition(".")[0]).setLevel(custom_logging_level)
+
+        if url:
+            warnings.warn(
+                message="Initializing OpenLineageClient with url, options and session is deprecated.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+
+        # Make config ellipsis - as a guard value to not try to
+        # reload yaml each time config is referred to.
+        self._config: dict[str, dict[str, str]] | None = None
+
+        self.transport = self._resolve_transport(
+            url=url, options=options, session=session, transport=transport, factory=factory
+        )
+        log.info("OpenLineageClient will use `%s` transport", self.transport.kind)
+
+        self._filters: list[Filter] = []
+        for conf in self.config.get("filters", []):
+            _filter = create_filter(conf)
+            if _filter:
+                self._filters.append(_filter)
+
+    @classmethod
+    def from_environment(cls: type[_T]) -> _T:
+        warnings.warn(
+            message="`OpenLineageClient.from_environment()` is deprecated. Use `OpenLineageClient()`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls()
+
+    @classmethod
+    def from_dict(cls: type[_T], config: dict[str, str]) -> _T:
+        return cls(transport=get_default_factory().create(config=config))
+
+    def filter_event(
+        self,
+        event: Event,
+    ) -> Event | None:
+        """Filters jobs according to config-defined events"""
+        for _filter in self._filters:
+            if isinstance(event, RunEvent) and _filter.filter_event(event) is None:
+                return None
+        return event
+
+    def emit(self, event: Event) -> None:
+        from typing import get_args
+
+        if type(event) not in get_args(Event):
+            msg = "`emit` only accepts RunEvent, DatasetEvent, JobEvent classes"
+            raise ValueError(msg)
+        if not self.transport:
+            log.error("Tried to emit OpenLineage event, but transport is not configured.")
+            return
+        if self.transport.kind == NoopTransport.kind:
+            log.debug("OpenLineage is disabled. No events will be emitted.")
+            return
+        if self._filters and self.filter_event(event) is None:
+            log.debug("OpenLineage event has been filtered out and will not be emitted.")
+            return
+
+        if log.isEnabledFor(logging.DEBUG):
+            val = Serde.to_json(event).encode("utf-8")
+            log.debug("OpenLineageClient will emit event %s", val)
+        self.transport.emit(event)
+        log.debug("OpenLineage event successfully emitted.")
+
+    @property
+    def config(self) -> dict[str, Any]:
+        """Content of OpenLineage YAML config file."""
+        if self._config is None:
+            config_path = self._find_yaml_config_path()
+            if config_path:
+                self._config = self._get_config_file_content(config_path)
+            else:
+                self._config = {}
+        return self._config
+
+    def _resolve_transport(self, **kwargs: Any) -> Transport:
+        """
+        Resolves the transport mechanism based on the provided arguments or environment settings.
+
+        This method determines the appropriate transport by executing a sequence of checks:
+        1. Verifies if OpenLineage is disabled through environment variable.
+        2. Looks for a transport object provided in the arguments.
+        3. Attempts to configure the transport from a YAML config file.
+        4. Tries to initialize HTTP transport with an url argument (deprecated).
+        5. Tries to set up HTTP transport using environment variables.
+        6. If no configuration is found, defaults to a console transport and logs a warning message.
+
+        Returns:
+            The transport object that will be used to send lineage events.
+        """
+        # 1. Check if OpenLineage is disabled
+        if os.getenv("OPENLINEAGE_DISABLED", "").lower().strip() == "true":
+            log.info("OpenLineage is disabled. No events will be emitted.")
+            return NoopTransport(NoopConfig())
+
+        # 2. Check if transport is provided explicitly
+        if kwargs.get("transport"):
+            return cast(Transport, kwargs["transport"])
+
+        # 3. Check if transport configuration is provided in YAML config file
+        if self.config.get("transport"):
+            factory = kwargs.get("factory") or get_default_factory()
+            return factory.create(self.config["transport"])
+
+        # 4. Check legacy HTTP transport initialization with url and options
+        if kwargs.get("url"):
+            return self._http_transport_from_url(
+                url=kwargs["url"], options=kwargs.get("options"), session=kwargs.get("session")
+            )
+
+        # 5. Check HTTP transport initialization with env variables
+        if os.environ.get("OPENLINEAGE_URL"):
+            return self._http_transport_from_env_variables()
+
+        # 6. If all else fails, print events to console
+        from openlineage.client.transport.console import ConsoleConfig, ConsoleTransport
+
+        log.warning("Couldn't find any OpenLineage transport configuration; will print events to console.")
+        return ConsoleTransport(ConsoleConfig())
+
+    @staticmethod
+    def _get_config_file_content(config_path: str) -> dict[str, Any]:
+        try:
+            with open(config_path) as f:
+                config: dict[str, Any] | None = yaml.safe_load(f)
+                if not config:
+                    log.error("Empty OpenLineage config file: `%s`", config_path)
+                    return {}
+                log.debug("Using content of OpenLineage config file: `%s`", config_path)
+                return config
+        except Exception:
+            log.exception("Couldn't read content of the OpenLineage config file `%s`: ", config_path)
+        return {}
+
+    @staticmethod
+    def _find_yaml_config_path() -> str | None:
+        paths_to_check = (
+            # Check OPENLINEAGE_CONFIG env variable
+            (os.getenv("OPENLINEAGE_CONFIG", None), True),
+            # Check current working directory for `openlineage.yml` file
+            (os.path.join(os.getcwd(), "openlineage.yml"), False),
+            # Check $HOME/.openlineage dir for `openlineage.yml` file
+            (os.path.join(os.path.expanduser("~/.openlineage"), "openlineage.yml"), False),
+        )
+
+        for path, verbose in paths_to_check:
+            try:
+                if path and os.path.isfile(path) and os.access(path, os.R_OK):
+                    return path
+                if path and verbose:
+                    log.debug("OpenLineage config file is missing or not readable: `%s`.", path)
+            except Exception:  # noqa: BLE001
+                # We can get different errors depending on system
+                if verbose:
+                    log.exception("Couldn't check if OpenLineage config file is readable: `%s`", path)
+        return None
+
+    @staticmethod
+    def _http_transport_from_env_variables() -> HttpTransport:
+        config = HttpConfig(
+            url=os.environ["OPENLINEAGE_URL"],
+            auth=create_token_provider(
+                {
+                    "type": "api_key",
+                    "apiKey": os.environ.get("OPENLINEAGE_API_KEY", ""),
+                },
+            ),
+        )
+        endpoint = os.environ.get("OPENLINEAGE_ENDPOINT", None)
+        if endpoint is not None:
+            config.endpoint = endpoint
+
+        return HttpTransport(config)
+
+    @staticmethod
+    def _http_transport_from_url(
+        url: str,
+        options: OpenLineageClientOptions | None,
+        session: Session | None,
+    ) -> HttpTransport:
+        if not options:
+            options = OpenLineageClientOptions()
+        return HttpTransport(
+            HttpConfig.from_options(
+                url=url,
+                options=options,
+                session=session,
+            ),
+        )

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/constants.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-__version__ = "1.14.0"
+__version__ = "1.15.0"
 
 DEFAULT_TIMEOUT_MS = 5000
 DEFAULT_NAMESPACE_NAME = "default"

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/__init__.py

@@ -7,7 +7,7 @@ from openlineage.client.transport.factory import DefaultTransportFactory
 from openlineage.client.transport.file import FileTransport
 from openlineage.client.transport.http import HttpConfig, HttpTransport
 from openlineage.client.transport.kafka import KafkaConfig, KafkaTransport
-from openlineage.client.transport.msk_iam import MSKIAMTransport
+from openlineage.client.transport.msk_iam import MSKIAMConfig, MSKIAMTransport
 from openlineage.client.transport.noop import NoopTransport
 from openlineage.client.transport.transport import Config, Transport, TransportFactory
 

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/console.py

@@ -22,8 +22,9 @@ class ConsoleTransport(Transport):
 
     def __init__(self, config: ConsoleConfig) -> None:  # noqa: ARG002
         self.log = logging.getLogger(__name__)
-        self.log.debug("Constructing openlineage client to send events to console or logs")
+        self.log.debug("Constructing OpenLineage transport that will send events to console or logs")
 
     def emit(self, event: Event) -> None:
-        # If logging is set to DEBUG, this will also log event in client.py
+        # Note: When the logging level is set to DEBUG, the content of events is logged twice:
+        # here on the INFO level and in client.py on the DEBUG level for when different transport is used.
         self.log.info(Serde.to_json(event))

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/factory.py

@@ -21,20 +21,26 @@ class DefaultTransportFactory(TransportFactory):
         self.transports[of_type] = clazz
 
     def create(self, config: dict[str, str] | None = None) -> Transport:
-        if os.getenv("OPENLINEAGE_DISABLED", "").lower() == "true":
+        """
+        Initializes and returns a transport mechanism based on the provided configuration.
+
+        If 'OPENLINEAGE_DISABLED' is set to 'true', a NoopTransport instance is returned,
+        effectively disabling transport.
+        If a configuration dictionary is provided, transport specified by the config is initialized.
+        If no configuration is provided, the function defaults to a console-based transport, logging
+        a warning and printing events to the console.
+        """
+        if os.getenv("OPENLINEAGE_DISABLED", "").lower().strip() == "true":
+            log.info("OpenLineage is disabled. No events will be emitted.")
             return NoopTransport(NoopConfig())
 
         if config:
             return self._create_transport(config)
 
-        # Fallback to setting HTTP transport from env variables
-        http = self._try_http_from_env_config()
-        if http:
-            return http
-        # If there is no HTTP transport, log events to console
+        # If no config is passed, log events to console
         from openlineage.client.transport.console import ConsoleConfig, ConsoleTransport
 
-        log.warning("Couldn't initialize transport; will print events to console.")
+        log.warning("Couldn't initialize OpenLineage transport; will print events to console.")
         return ConsoleTransport(ConsoleConfig())
 
     def _create_transport(self, config: dict[str, str]) -> Transport:
@@ -63,31 +69,3 @@ class DefaultTransportFactory(TransportFactory):
             raise TypeError(msg)
 
         return transport_class(config_class.from_dict(config))  # type: ignore[call-arg]
-
-    @staticmethod
-    def _try_http_from_env_config() -> Transport | None:
-        from openlineage.client.transport.http import (
-            HttpConfig,
-            HttpTransport,
-            create_token_provider,
-        )
-
-        # backwards compatibility: create Transport from
-        # OPENLINEAGE_URL, OPENLINEAGE_ENDPOINT, and OPENLINEAGE_API_KEY
-        if "OPENLINEAGE_URL" not in os.environ:
-            log.error("Did not find openlineage.yml and OPENLINEAGE_URL is not set")
-            return None
-        config = HttpConfig(
-            url=os.environ["OPENLINEAGE_URL"],
-            auth=create_token_provider(
-                {
-                    "type": "api_key",
-                    "apiKey": os.environ.get("OPENLINEAGE_API_KEY", ""),
-                },
-            ),
-        )
-        endpoint = os.environ.get("OPENLINEAGE_ENDPOINT", None)
-        if endpoint is not None:
-            config.endpoint = endpoint
-
-        return HttpTransport(config)

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/file.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import io
+import logging
 from dataclasses import dataclass
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
@@ -14,6 +15,8 @@ if TYPE_CHECKING:
     from openlineage.client.client import Event
 from openlineage.client.serde import Serde
 
+log = logging.getLogger(__name__)
+
 
 @dataclass
 class FileConfig(Config):
@@ -35,6 +38,11 @@ class FileTransport(Transport):
 
     def __init__(self, config: FileConfig) -> None:
         self.config = config
+        log.debug(
+            "Constructing OpenLineage transport that will send events "
+            "to file(s) using the following config: %s",
+            self.config,
+        )
 
     def emit(self, event: Event) -> None:
         if self.config.append:
@@ -43,6 +51,7 @@ class FileTransport(Transport):
             time_str = datetime.now().strftime("%Y%m%d-%H%M%S.%f")
             log_file_path = f"{self.config.log_file_path}-{time_str}"
 
+        log.debug("Openlineage event will be emitted to file: `%s`", log_file_path)
         try:
             with open(log_file_path, "a" if self.config.append else "w") as log_file_handle:
                 log_file_handle.write(Serde.to_json(event) + "\n")

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/http.py

@@ -123,7 +123,12 @@ class HttpTransport(Transport):
         url = config.url.strip()
         self.config = config
 
-        log.debug("Constructing openlineage client to send events to %s - config %s", url, config)
+        log.debug(
+            "Constructing OpenLineage transport that will send events "
+            "to HTTP endpoint `%s` using the following config: %s",
+            urljoin(url, config.endpoint),
+            config,
+        )
         try:
             from urllib3.util import parse_url
 

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/kafka.py

@@ -70,7 +70,12 @@ class KafkaTransport(Transport):
         self.producer = None
         if not self._is_airflow_sqlalchemy:
             self._setup_producer(self.kafka_config.config)
-        log.debug("Constructing openlineage client to send events to topic %s", config.topic)
+        log.debug(
+            "Constructing OpenLineage transport that will send events "
+            "to kafka topic `%s` using the following config: %s",
+            self.topic,
+            self.kafka_config,
+        )
 
     def _get_message_key(self, event: Event) -> str:
         if isinstance(event, (DatasetEvent, event_v2.DatasetEvent)):

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/msk_iam.py

@@ -78,7 +78,7 @@ class MSKIAMTransport(KafkaTransport):
 
     def _setup_producer(self, config: dict) -> None:  # type: ignore[type-arg]
         try:
-            log.debug("Setup the MSK transport with this configuration: %s", self.msk_config)
+            log.debug("Use MSK producer with the following config: %s", self.msk_config)
 
             # https://github.com/confluentinc/librdkafka/blob/master/CONFIGURATION.md
             if self.msk_config.region is None:

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/openlineage/client/transport/noop.py

@@ -22,7 +22,7 @@ class NoopTransport(Transport):
     config_class = NoopConfig
 
     def __init__(self, config: NoopConfig) -> None:  # noqa: ARG002
-        log.info("OpenLineage client is disabled. NoopTransport.")
+        log.debug("Constructing OpenLineage transport that will NOT send any events.")
 
     def emit(self, event: Event) -> None:  # noqa: ARG002
         return None

openlineage_python-1.15.0/openlineage/client/utils.py

@@ -0,0 +1,44 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import importlib
+import logging
+from typing import Any, ClassVar, Type, cast
+
+import attr
+
+log = logging.getLogger(__name__)
+
+
+def import_from_string(path: str) -> type[Any]:
+    try:
+        module_path, target = path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        return cast(Type[Any], getattr(module, target))
+    except Exception as e:  # noqa: BLE001
+        log.warning(e)
+        msg = f"Failed to import {path}"
+        raise ImportError(msg) from e
+
+
+def try_import_from_string(path: str) -> type[Any] | None:
+    try:
+        return import_from_string(path)
+    except ImportError:
+        return None
+
+
+# Filter dictionary to get only those key: value pairs that have
+# key specified in passed attr class
+def get_only_specified_fields(clazz: type[Any], params: dict[str, Any]) -> dict[str, Any]:
+    field_keys = [item.name for item in attr.fields(clazz)]
+    return {key: value for key, value in params.items() if key in field_keys}
+
+
+class RedactMixin:
+    _skip_redact: ClassVar[list[str]] = []
+
+    @property
+    def skip_redact(self) -> list[str]:
+        return self._skip_redact

openlineage_python-1.15.0/openlineage/client/uuid.py

@@ -0,0 +1,89 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import secrets
+import time
+from datetime import timezone
+from hashlib import sha1
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+
+def generate_new_uuid(instant: datetime | None = None) -> UUID:
+    """Generate new UUID for an instant of time. Each function call returns a new UUID value.
+
+    UUID version is an implementation detail, and **should not** be relied on.
+    For now it is [UUIDv7](https://datatracker.ietf.org/doc/rfc9562/), so for increasing instant values,
+    returned UUID is always greater than previous one.
+
+    Using uuid6 lib implementation (MIT License), with few changes:
+    * https://github.com/oittaa/uuid6-python/blob/4f879849178b8a7a564f7cb76c3f7a6e5228d9ed/src/uuid6/__init__.py#L128-L147
+    * https://github.com/oittaa/uuid6-python/blob/4f879849178b8a7a564f7cb76c3f7a6e5228d9ed/src/uuid6/__init__.py#L46-L51
+
+    Added in v1.15.0
+
+    :param instant: instant of time used to generate UUID. If not provided, current time is used.
+    :return: UUID
+    """
+
+    timestamp_ms = int(instant.timestamp() * 1000) if instant else time.time_ns() // 10**6
+    node = secrets.randbits(76)
+    return _build_uuidv7(timestamp_ms, node)
+
+
+def generate_static_uuid(
+    instant: datetime,
+    data: bytes,
+) -> UUID:
+    """Generate UUID for instant of time and input data.
+    Calling function with same arguments always produces the same result.
+
+    UUID version is an implementation detail, and **should not* be relied on.
+    For now it is [UUIDv7](https://datatracker.ietf.org/doc/rfc9562/), so for increasing instant values,
+    returned UUID is always greater than previous one. The only difference from RFC 9562 is that
+    least significant bytes are not random, but instead a SHA-1 hash of input data.
+
+    Using uuid6 lib implementation (MIT License), with few changes:
+    * https://github.com/oittaa/uuid6-python/blob/4f879849178b8a7a564f7cb76c3f7a6e5228d9ed/src/uuid6/__init__.py#L128-L147
+    * https://github.com/oittaa/uuid6-python/blob/4f879849178b8a7a564f7cb76c3f7a6e5228d9ed/src/uuid6/__init__.py#L46-L51
+
+    Added in v1.15.0
+
+    :param instant: instant of time used to generate UUID. If not provided, current time is used.
+    :param data: input data to generate random part from.
+    :return: UUID
+    """
+
+    instant_utc = instant.astimezone(timezone.utc)
+    timestamp_ms = int(instant_utc.timestamp() * 1000)
+
+    # generate the rest of bytes using some hash.
+    # can be used to generate consistent UUIDs for some input, e.g. external runId.
+    # if data is some static value, e.g. job name, mix it with timestamp to make it more random
+    digest = sha1(instant_utc.isoformat().encode("utf-8") + data).digest()  # noqa: S324
+    # sha1 returns 160bit hash, we need only first 76 bits
+    node = int(digest.hex(), 16) >> 84
+
+    return _build_uuidv7(timestamp_ms, node)
+
+
+def _build_uuidv7(timestamp: int, node: int) -> UUID:
+    # merge timestamp and node into 128-bit UUID
+    # timestamp is first 48 bits, node is last 80 bits
+    uuid_int = (timestamp & 0xFFFFFFFFFFFF) << 80
+    uuid_int |= node & 0xFFFFFFFFFFFFFFFFFFFF
+
+    # Set the version number (4 bit).
+    version = 7
+    uuid_int &= ~(0xF000 << 64)
+    uuid_int |= version << 76
+
+    # Set the variant (2 bit) to RFC 4122.
+    uuid_int &= ~(0xC000 << 48)
+    uuid_int |= 0x8000 << 48
+
+    return UUID(int=uuid_int)

{openlineage_python-1.14.0 → openlineage_python-1.15.0}/pyproject.toml

@@ -6,7 +6,7 @@ requires = [
 
 [project]
 name = "openlineage-python"
-version = "1.14.0"
+version = "1.15.0"
 description = "OpenLineage Python Client"
 readme = "README.md"
 keywords = [