openlineage-python 1.23.0__tar.gz → 1.24.0__tar.gz

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/PKG-INFO

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

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/client.py

@@ -10,8 +10,9 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 import attr
 import yaml
-from openlineage.client.filter import Filter, create_filter
+from openlineage.client.filter import Filter, FilterConfig, create_filter
 from openlineage.client.serde import Serde
+from openlineage.client.utils import deep_merge_dicts
 
 if TYPE_CHECKING:
     from requests import Session
@@ -20,8 +21,17 @@ if TYPE_CHECKING:
 import contextlib
 
 from openlineage.client import event_v2
+from openlineage.client.facets import FacetsConfig
+from openlineage.client.generated.environment_variables_run import (
+    EnvironmentVariable,
+    EnvironmentVariablesRunFacet,
+)
 from openlineage.client.run import DatasetEvent, JobEvent, RunEvent
-from openlineage.client.transport import Transport, TransportFactory, get_default_factory
+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
 
@@ -38,6 +48,24 @@ class OpenLineageClientOptions:
     adapter: HTTPAdapter = attr.ib(default=None)
 
 
+@attr.s
+class OpenLineageConfig:
+    transport: dict[str, Any] | None = attr.ib(factory=dict)
+    facets: FacetsConfig = attr.ib(factory=FacetsConfig)
+    filters: list[FilterConfig] = attr.ib(factory=list)
+
+    @classmethod
+    def from_dict(cls, params: dict[str, Any]) -> OpenLineageConfig:
+        config = cls()
+        if "transport" in params:
+            config.transport = params["transport"]
+        if "facets" in params:
+            config.facets = FacetsConfig(**params["facets"])
+        if "filters" in params:
+            config.filters = [FilterConfig(**filter_config) for filter_config in params["filters"]]
+        return config
+
+
 log = logging.getLogger(__name__)
 _T = TypeVar("_T", bound="OpenLineageClient")
 
@@ -53,6 +81,8 @@ class OpenLineageClient:
         session: Session | None = None,
         transport: Transport | None = None,
         factory: TransportFactory | None = None,
+        *,
+        config: dict[str, str] | None = None,
     ) -> None:
         # Set parent's logging level if environment variable is present
         custom_logging_level = os.getenv("OPENLINEAGE_CLIENT_LOGGING", None)
@@ -68,7 +98,9 @@ class OpenLineageClient:
 
         # 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._config: OpenLineageConfig | None = None
+
+        self.user_defined_config: dict[str, str] | None = config
 
         self._alias_env_vars()
 
@@ -78,7 +110,7 @@ class OpenLineageClient:
         log.info("OpenLineageClient will use `%s` transport", self.transport.kind)
 
         self._filters: list[Filter] = []
-        for conf in self.config.get("filters", []):
+        for conf in self.config.filters:
             _filter = create_filter(conf)
             if _filter:
                 self._filters.append(_filter)
@@ -94,7 +126,7 @@ class OpenLineageClient:
 
     @classmethod
     def from_dict(cls: type[_T], config: dict[str, str]) -> _T:
-        return cls(transport=get_default_factory().create(config=config))
+        return cls(config=config)
 
     def filter_event(
         self,
@@ -122,6 +154,8 @@ class OpenLineageClient:
             log.debug("OpenLineage event has been filtered out and will not be emitted.")
             return
 
+        event = self.add_environment_facets(event)
+
         if log.isEnabledFor(logging.DEBUG):
             val = Serde.to_json(event).encode("utf-8")
             log.debug("OpenLineageClient will emit event %s", val)
@@ -129,17 +163,39 @@ class OpenLineageClient:
         log.debug("OpenLineage event successfully emitted.")
 
     @property
-    def config(self) -> dict[str, Any]:
-        """Content of OpenLineage YAML config file."""
+    def config(self) -> OpenLineageConfig:
+        """
+        Retrieves the OpenLineage configuration.
+
+        This property method returns the content of the OpenLineage YAML config file.
+        The configuration is determined by merging sources in the following order of precedence:
+        1. User-defined configuration passed to the client constructor.
+        2. YAML config file located in one of the following paths:
+        - Path specified by the `OPENLINEAGE_CONFIG` environment variable.
+        - Current working directory.
+        - `$HOME/.openlineage`.
+        3. Environment variables with the `OPENLINEAGE__` prefix.
+        If the configuration is not already loaded, it will be constructed by merging the above sources.
+        In case of a TypeError during the parsing of the configuration, a ValueError will be raised indicating
+        that the structure of the config does not match the expected format.
+        """
         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 = {}
+            config_dict: dict[str, Any] = {}
+            if self.user_defined_config:
+                config_dict = self.user_defined_config
+            if config_path := self._find_yaml_config_path():
+                config_dict = deep_merge_dicts(self._get_config_file_content(config_path), config_dict)
+            if config_from_env_vars := self._load_config_from_env_variables():
+                config_dict = deep_merge_dicts(config_from_env_vars, config_dict)
+            try:
+                self._config = OpenLineageConfig.from_dict(config_dict)
+            except TypeError as e:
+                # raise exception that structure of the config does not match
+                msg = "Failed to parse OpenLineage config."
+                raise ValueError(msg) from e
         return self._config
 
-    def _resolve_transport(self, **kwargs: Any) -> Transport:  # noqa: PLR0911
+    def _resolve_transport(self, **kwargs: Any) -> Transport:
         """
         Resolves the transport mechanism based on the provided arguments or environment settings.
 
@@ -164,9 +220,9 @@ class OpenLineageClient:
             return cast(Transport, kwargs["transport"])
 
         # 3. Check if transport configuration is provided in YAML config file
-        if self.config.get("transport"):
+        if self.config.transport and self.config.transport.get("type"):
             factory = kwargs.get("factory") or get_default_factory()
-            return factory.create(self.config["transport"])
+            return factory.create(self.config.transport)
 
         # 4. Check legacy HTTP transport initialization with url and options
         if kwargs.get("url"):
@@ -174,16 +230,11 @@ class OpenLineageClient:
                 url=kwargs["url"], options=kwargs.get("options"), session=kwargs.get("session")
             )
 
-        # 5. Check transport initialization with env variables
-        if config := self._load_config_from_env_variables():
-            factory = kwargs.get("factory") or get_default_factory()
-            return factory.create(config["transport"])
-
-        # 6. Check HTTP transport initialization with env variables
+        # 5. Check HTTP transport initialization with env variables
         if os.environ.get("OPENLINEAGE_URL"):
             return self._http_transport_from_env_variables()
 
-        # 7. If all else fails, print events to console
+        # 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.")
@@ -306,9 +357,6 @@ class OpenLineageClient:
 
             cls._insert_into_config(config, keys, env_value)
 
-        if (transport_config := config.get("transport")) is None or transport_config.get("type") is None:
-            return None
-
         return config
 
     @staticmethod
@@ -323,3 +371,28 @@ class OpenLineageClient:
 
         # Overwrite if key already exists
         current[keys[-1]] = value
+
+    def add_environment_facets(self, event: Event) -> Event:
+        """
+        Adds environment variables as facets to the event object.
+        """
+        if isinstance(event, RunEvent) and (env_vars := self._collect_environment_variables()):
+            event.run.facets["environmentVariables"] = EnvironmentVariablesRunFacet(
+                environmentVariables=[
+                    EnvironmentVariable(name=name, value=value) for name, value in env_vars.items()
+                ]
+            )
+        return event
+
+    def _collect_environment_variables(self) -> dict[str, str]:
+        """
+        Collects and returns a dictionary of relevant environment variables.
+        """
+        filtered_vars = {k: v for k, v in os.environ.items() if k in self.config.facets.environment_variables}
+        missing_vars = set(self.config.facets.environment_variables) - set(filtered_vars)
+        if missing_vars:
+            log.warning(
+                "The following environment variables are missing: %s when adding to OpenLineage event",
+                missing_vars,
+            )
+        return filtered_vars

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/constants.py

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

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/facet_v2.py

@@ -9,6 +9,7 @@ from openlineage.client.generated import (
     datasource_dataset,
     documentation_dataset,
     documentation_job,
+    environment_variables_run,
     error_message_run,
     external_query_run,
     extraction_error_run,
@@ -54,6 +55,7 @@ __all__ = [
     "datasource_dataset",
     "documentation_dataset",
     "documentation_job",
+    "environment_variables_run",
     "error_message_run",
     "external_query_run",
     "extraction_error_run",

openlineage_python-1.24.0/openlineage/client/facets.py

@@ -0,0 +1,10 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import attr
+
+
+@attr.s
+class FacetsConfig:
+    environment_variables: list[str] = attr.ib(factory=list)

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/filter.py

@@ -5,12 +5,20 @@ from __future__ import annotations
 import re
 import typing
 
+import attr
 from openlineage.client.event_v2 import RunEvent as RunEvent_v2
 from openlineage.client.run import RunEvent
 
 RunEventType = typing.Union[RunEvent, RunEvent_v2]
 
 
+@attr.s
+class FilterConfig:
+    type: str | None = attr.ib(default=None)
+    match: str | None = attr.ib(default=None)
+    regex: str | None = attr.ib(default=None)
+
+
 class Filter:
     def filter_event(self, event: RunEventType) -> RunEventType | None:
         ...
@@ -36,12 +44,12 @@ class RegexFilter(Filter):
         return event
 
 
-def create_filter(conf: dict[str, str]) -> Filter | None:
-    if "type" not in conf:
+def create_filter(conf: FilterConfig) -> Filter | None:
+    if not conf.type:
         return None
     # Switch in 3.10 🙂
-    if conf["type"] == "exact":
-        return ExactMatchFilter(match=conf["match"])
-    if conf["type"] == "regex":
-        return RegexFilter(regex=conf["regex"])
+    if conf.type == "exact" and conf.match:
+        return ExactMatchFilter(match=conf.match)
+    if conf.type == "regex" and conf.regex:
+        return RegexFilter(regex=conf.regex)
     return None

openlineage_python-1.24.0/openlineage/client/generated/environment_variables_run.py

@@ -0,0 +1,35 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+import attr
+from openlineage.client.generated.base import RunFacet
+from openlineage.client.utils import RedactMixin
+
+
+@attr.define
+class EnvironmentVariable(RedactMixin):
+    name: str
+    """The name of the environment variable."""
+
+    value: str
+    """The value of the environment variable."""
+
+    _skip_redact: ClassVar[list[str]] = ["name"]
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/EnvironmentVariablesRunFacet.json#/$defs/EnvironmentVariable"
+
+
+@attr.define
+class EnvironmentVariablesRunFacet(RunFacet):
+    environmentVariables: list[EnvironmentVariable]  # noqa: N815
+    """The environment variables for the run."""
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/EnvironmentVariablesRunFacet.json#/$defs/EnvironmentVariablesRunFacet"

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/transport/transport.py

@@ -20,6 +20,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, TypeVar
 
+import attr
+
 if TYPE_CHECKING:
     from openlineage.client.client import Event
 
@@ -27,6 +29,7 @@ if TYPE_CHECKING:
 _T = TypeVar("_T", bound="Config")
 
 
+@attr.s
 class Config:
     @classmethod
     def from_dict(cls: type[_T], params: dict[str, Any]) -> _T:  # noqa: ARG003

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/openlineage/client/utils.py

@@ -36,6 +36,25 @@ def get_only_specified_fields(clazz: type[Any], params: dict[str, Any]) -> dict[
     return {key: value for key, value in params.items() if key in field_keys}
 
 
+def deep_merge_dicts(dict1: dict[Any, Any], dict2: dict[Any, Any]) -> dict[Any, Any]:
+    """Deep merges two dictionaries.
+
+    This function merges two dictionaries while handling nested dictionaries.
+    For keys that exist in both dictionaries, the values from dict2 take precedence.
+    If a key exists in both dictionaries and the values are dictionaries themselves,
+    they are merged recursively.
+    This function merges only dictionaries. If key is of different type, e.g. list
+    it does not work properly.
+    """
+    merged = dict1.copy()
+    for k, v in dict2.items():
+        if k in merged and isinstance(v, dict):
+            merged[k] = deep_merge_dicts(merged.get(k, {}), v)
+        else:
+            merged[k] = v
+    return merged
+
+
 class RedactMixin:
     _skip_redact: ClassVar[list[str]] = []
 

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/pyproject.toml

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

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/redact_fields.yml

@@ -92,6 +92,13 @@
   classes:
     - class_name: DocumentationJobFacet
       redact_fields: []
+- module: environment_variables_run
+  classes:
+    - class_name: EnvironmentVariable
+      redact_fields:
+        - name
+    - class_name: EnvironmentVariablesRunFacet
+      redact_fields: []
 - module: error_message_run
   classes:
     - class_name: ErrorMessageRunFacet

{openlineage_python-1.23.0 → openlineage_python-1.24.0}/tests/test_client.py

@@ -9,7 +9,12 @@ from typing import TYPE_CHECKING
 from unittest.mock import MagicMock, patch
 
 import pytest
-from openlineage.client.client import OpenLineageClient, OpenLineageClientOptions
+from openlineage.client.client import OpenLineageClient, OpenLineageClientOptions, OpenLineageConfig
+from openlineage.client.facets import FacetsConfig
+from openlineage.client.generated.environment_variables_run import (
+    EnvironmentVariable,
+    EnvironmentVariablesRunFacet,
+)
 from openlineage.client.run import (
     SCHEMA_URL,
     Dataset,
@@ -351,22 +356,137 @@ def test_find_yaml_config_path_checks_all_paths(mock_is_file, mocker: MockerFixt
     assert result is None
 
 
+def test_ol_config_from_dict():
+    # Test with complete config
+    config_dict = {
+        "transport": {"url": "http://localhost:5050"},
+        "facets": {"environment_variables": ["VAR1", "VAR2"]},
+        "filters": [{"type": "exact", "match": "job_name"}],
+    }
+    config = OpenLineageConfig.from_dict(config_dict)
+    assert config.transport["url"] == "http://localhost:5050"
+    assert config.facets.environment_variables == ["VAR1", "VAR2"]
+    assert config.filters[0].type == "exact"
+    assert config.filters[0].match == "job_name"
+
+    # Test with missing keys
+    config_dict = {}
+    config = OpenLineageConfig.from_dict(config_dict)
+    assert config.transport == {}
+    assert config.facets == FacetsConfig()
+    assert config.filters == []
+
+    # Test with invalid data type
+    with pytest.raises(TypeError):
+        OpenLineageConfig.from_dict({"facets": "invalid_data"})
+
+
 @patch("yaml.safe_load", return_value=None)
 def test_config_file_content_empty_file(mock_yaml) -> None:  # noqa: ARG001
-    assert OpenLineageClient().config == {}
+    assert OpenLineageClient().config == OpenLineageConfig()
 
 
 def test_config(mocker: MockerFixture, root: Path) -> None:
     mocker.patch.dict(os.environ, {"OPENLINEAGE_CONFIG": str(root / "config" / "http.yml")})
-    assert OpenLineageClient().config == {
+    assert OpenLineageClient().config == OpenLineageConfig.from_dict(
+        {
+            "transport": {
+                "auth": {"apiKey": "random_token", "type": "api_key"},
+                "compression": "gzip",
+                "endpoint": "api/v1/lineage",
+                "type": "http",
+                "url": "http://localhost:5050",
+            }
+        }
+    )
+
+
+def test_openlineage_client_from_dict() -> None:
+    config_dict = {"transport": {"type": "http", "url": "http://localhost:5050"}}
+    client = OpenLineageClient.from_dict(config_dict)
+    assert client.transport.url == "http://localhost:5050"
+
+
+def test_openlineage_client_from_empty_dict() -> None:
+    client = OpenLineageClient.from_dict({})
+    assert isinstance(client.transport, ConsoleTransport)
+
+
+def test_openlineage_config_from_dict() -> None:
+    config_dict = {
         "transport": {
-            "auth": {"apiKey": "random_token", "type": "api_key"},
-            "compression": "gzip",
-            "endpoint": "api/v1/lineage",
             "type": "http",
             "url": "http://localhost:5050",
-        }
+            "auth": {"api_key": "random_token"},
+        },
+        "facets": {
+            "environment_variables": ["VAR1", "VAR2"],
+        },
+        "filters": [
+            {"type": "regex", "match": ".*"},
+        ],
     }
+    config = OpenLineageConfig.from_dict(config_dict)
+
+    assert config.transport == config_dict["transport"]
+    assert config.facets.environment_variables == config_dict["facets"]["environment_variables"]
+    assert len(config.filters) == 1
+    assert config.filters[0].type == "regex"
+    assert config.filters[0].match == ".*"
+
+
+def test_openlineage_config_default_values() -> None:
+    config = OpenLineageConfig()
+
+    assert config.transport == {}
+    assert isinstance(config.facets, FacetsConfig)
+    assert config.filters == []
+
+
+@patch.dict(os.environ, {"ENV_VAR_1": "value1", "ENV_VAR_2": "value2"})
+def test_collect_environment_variables():
+    client = OpenLineageClient()
+    client._config = OpenLineageConfig(  # noqa: SLF001
+        facets=FacetsConfig(environment_variables=["ENV_VAR_1", "ENV_VAR_2", "MISSING_VAR"])
+    )
+    env_vars = client._collect_environment_variables()  # noqa: SLF001
+    assert env_vars == {"ENV_VAR_1": "value1", "ENV_VAR_2": "value2"}
+
+
+@patch.dict(os.environ, {"ENV_VAR_1": "value1", "SENSITIVE_VAR": "PII"})
+def test_add_environment_facets():
+    client = OpenLineageClient()
+    client._config = OpenLineageConfig(  # noqa: SLF001
+        facets=FacetsConfig(environment_variables=["ENV_VAR_1"])
+    )
+    run = Run(runId=str(generate_new_uuid()))
+    event = RunEvent(
+        eventType=RunState.START,
+        eventTime="2021-11-03T10:53:52.427343",
+        run=run,
+        job=Job(name="name", namespace=""),
+        producer="",
+        schemaURL="",
+    )
+    event.run.facets = {}
+
+    modified_event = client.add_environment_facets(event)
+
+    assert "environmentVariables" in modified_event.run.facets
+    assert modified_event.run.facets["environmentVariables"] == EnvironmentVariablesRunFacet(
+        [EnvironmentVariable(name="ENV_VAR_1", value="value1")]
+    )
+
+
+@patch("openlineage.client.client.OpenLineageClient._find_yaml_config_path")
+@patch("openlineage.client.client.OpenLineageClient._get_config_file_content")
+def test_config_property_loads_yaml(mock_get_config_content, mock_find_yaml):
+    mock_find_yaml.return_value = "config.yml"
+    mock_get_config_content.return_value = {"transport": {"type": "http", "url": "http://localhost:5050"}}
+
+    config = OpenLineageClient().config
+    assert config.transport["type"] == "http"
+    assert config.transport["url"] == "http://localhost:5050"
 
 
 @patch.dict(
@@ -490,6 +610,155 @@ def test_kafka_transport_configured_with_aliased_message_key() -> None:
     }
 
 
+@patch.dict(
+    os.environ,
+    {
+        "CUSTOM_ENV_VAR": "custom_value",
+        "OPENLINEAGE__TRANSPORT__TYPE": "console",
+        "OPENLINEAGE__FACETS__ENVIRONMENT_VARIABLES": '["CUSTOM_ENV_VAR"]',
+    },
+)
+@patch("openlineage.client.client.OpenLineageClient._resolve_transport")
+def test_add_environment_facets_with_custom_env_var(mock_resolve_transport) -> None:
+    mock_resolve_transport.return_value = mock_transport = MagicMock()
+    client = OpenLineageClient()
+    run = Run(runId=str(generate_new_uuid()))
+    event = RunEvent(
+        eventType=RunState.START,
+        eventTime="2021-11-03T10:53:52.427343",
+        run=run,
+        job=Job(name="name", namespace=""),
+        producer="",
+        schemaURL="",
+    )
+
+    client.emit(event)
+    assert mock_transport.emit.call_args[0][0].run.facets[
+        "environmentVariables"
+    ] == EnvironmentVariablesRunFacet([EnvironmentVariable(name="CUSTOM_ENV_VAR", value="custom_value")])
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE__TRANSPORT__TYPE": "http",
+        "OPENLINEAGE__TRANSPORT__URL": "http://localhost:5050",
+        "OPENLINEAGE__TRANSPORT__AUTH__API_KEY": "random_token",
+    },
+)
+@patch("openlineage.client.client.OpenLineageClient._find_yaml_config_path")
+def test_config_property_loads_env_vars(mock_find_yaml) -> None:
+    mock_find_yaml.return_value = None
+    client = OpenLineageClient()
+    config = client.config
+    assert config.transport["type"] == "http"
+    assert config.transport["url"] == "http://localhost:5050"
+    assert config.transport["auth"]["api_key"] == "random_token"
+
+
+def test_config_property_loads_user_defined_config() -> None:
+    user_defined_config = {
+        "transport": {
+            "type": "http",
+            "url": "http://localhost:5050",
+            "auth": {"api_key": "random_token"},
+        }
+    }
+    client = OpenLineageClient(config=user_defined_config)
+    config = client.config
+    assert config.transport["type"] == "http"
+    assert config.transport["url"] == "http://localhost:5050"
+    assert config.transport["auth"]["api_key"] == "random_token"
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE__TRANSPORT__TYPE": "http",
+        "OPENLINEAGE__TRANSPORT__URL": "http://localhost:5050",
+    },
+)
+def test_client_from_empty_dict_with_dynamic_env_vars() -> None:
+    client = OpenLineageClient.from_dict({})
+    assert client.transport.url == "http://localhost:5050"
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE_URL": "http://example.com",
+    },
+)
+def test_client_from_empty_dict_with_url_env_var() -> None:
+    client = OpenLineageClient.from_dict({})
+    assert client.transport.url == "http://example.com"
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE__TRANSPORT__TYPE": "http",
+        "OPENLINEAGE__TRANSPORT__URL": "http://localhost:5050",
+    },
+)
+def test_client_from_facets_config_in_dict_and_env_vars() -> None:
+    user_defined_config = {
+        "facets": {
+            "environment_variables": ["VAR1", "VAR2"],
+        }
+    }
+    client = OpenLineageClient.from_dict(user_defined_config)
+    assert client.config.facets.environment_variables == ["VAR1", "VAR2"]
+    assert client.transport.url == "http://localhost:5050"
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE__FACETS__ENVIRONMENT_VARIABLES": '["VAR1", "VAR2"]',
+    },
+)
+def test_client_from_facets_config_in_env_vars_and_transport_in_config() -> None:
+    user_defined_config = {
+        "transport": {
+            "type": "http",
+            "url": "http://localhost:5050",
+        }
+    }
+    client = OpenLineageClient.from_dict(user_defined_config)
+    assert client.config.facets.environment_variables == ["VAR1", "VAR2"]
+    assert client.transport.url == "http://localhost:5050"
+
+
+@patch.dict(
+    os.environ,
+    {
+        "OPENLINEAGE__TRANSPORT__AUTH__API_KEY": "random_token",
+    },
+)
+@patch("openlineage.client.client.OpenLineageClient._find_yaml_config_path")
+@patch("openlineage.client.client.OpenLineageClient._get_config_file_content")
+def test_config_merge_precedence(mock_get_config_content, mock_find_yaml) -> None:
+    user_defined_config = {
+        "transport": {
+            "type": "http",
+            "url": "http://localhost:5050",
+        }
+    }
+    mock_find_yaml.return_value = "config.yml"
+    mock_get_config_content.return_value = {
+        "transport": {
+            "url": "http://another.host:5050",
+            "auth": {"api_key": "another_token"},
+        }
+    }
+    client = OpenLineageClient.from_dict(user_defined_config)
+    config = client.config
+    assert config.transport["type"] == "http"
+    assert config.transport["url"] == "http://localhost:5050"
+    assert config.transport["auth"]["api_key"] == "another_token"
+
+
 class TestOpenLineageConfigLoader:
     @pytest.mark.parametrize(
         ("env_vars", "expected_config"),

openlineage_python-1.24.0/tests/test_utils.py

@@ -0,0 +1,65 @@
+# Copyright 2018-2024 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import pytest
+from openlineage.client.utils import deep_merge_dicts, import_from_string, try_import_from_string
+
+
+def test_import_from_string():
+    from openlineage.client.filter import ExactMatchFilter
+
+    result = import_from_string("openlineage.client.filter.ExactMatchFilter")
+    assert result == ExactMatchFilter
+
+
+def test_import_from_string_unknown_path():
+    with pytest.raises(ImportError):
+        import_from_string("openlineage.client.non-existing-module")
+
+
+def test_try_import_from_string():
+    from openlineage.client.filter import ExactMatchFilter
+
+    result = try_import_from_string("openlineage.client.filter.ExactMatchFilter")
+    assert result == ExactMatchFilter
+
+
+def test_try_import_from_string_unknown():
+    result = try_import_from_string("openlineage.client.non-existing-module")
+    assert result is None
+
+
+def test_deep_merge_dicts_simple():
+    dict1 = {"a": 1, "b": 2}
+    dict2 = {"b": 3, "c": 4}
+    expected = {"a": 1, "b": 3, "c": 4}
+    assert deep_merge_dicts(dict1, dict2) == expected
+
+
+def test_deep_merge_dicts_nested():
+    dict1 = {"a": {"x": 1}, "b": 2}
+    dict2 = {"a": {"y": 2}, "b": 3, "c": 4}
+    expected = {"a": {"x": 1, "y": 2}, "b": 3, "c": 4}
+    assert deep_merge_dicts(dict1, dict2) == expected
+
+
+def test_deep_merge_dicts_overwrite():
+    dict1 = {"a": {"x": 1}}
+    dict2 = {"a": {"x": 2}}
+    expected = {"a": {"x": 2}}
+    assert deep_merge_dicts(dict1, dict2) == expected
+
+
+def test_deep_merge_dicts_non_dict_values():
+    dict1 = {"a": 1, "b": {"x": 1}}
+    dict2 = {"b": 2, "c": 3}
+    expected = {"a": 1, "b": 2, "c": 3}
+    assert deep_merge_dicts(dict1, dict2) == expected
+
+
+def test_deep_merge_dicts_empty_dicts():
+    dict1 = {}
+    dict2 = {"a": 1}
+    expected = {"a": 1}
+    assert deep_merge_dicts(dict1, dict2) == expected

openlineage_python-1.23.0/tests/test_utils.py

@@ -1,30 +0,0 @@
-# Copyright 2018-2024 contributors to the OpenLineage project
-# SPDX-License-Identifier: Apache-2.0
-from __future__ import annotations
-
-import pytest
-from openlineage.client.utils import import_from_string, try_import_from_string
-
-
-def test_import_from_string():
-    from openlineage.client.filter import ExactMatchFilter
-
-    result = import_from_string("openlineage.client.filter.ExactMatchFilter")
-    assert result == ExactMatchFilter
-
-
-def test_import_from_string_unknown_path():
-    with pytest.raises(ImportError):
-        import_from_string("openlineage.client.non-existing-module")
-
-
-def test_try_import_from_string():
-    from openlineage.client.filter import ExactMatchFilter
-
-    result = try_import_from_string("openlineage.client.filter.ExactMatchFilter")
-    assert result == ExactMatchFilter
-
-
-def test_try_import_from_string_unknown():
-    result = try_import_from_string("openlineage.client.non-existing-module")
-    assert result is None