openlineage-python 1.36.0__tar.gz → 1.38.0__tar.gz

openlineage_python-1.38.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file 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, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different 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 Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: openlineage-python
-Version: 1.36.0
+Version: 1.38.0
 Summary: OpenLineage Python Client
 Author-email: OpenLineage <info@openlineage.io>
+License-File: LICENSE
 Keywords: openlineage
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -27,9 +29,13 @@ Requires-Dist: beautifulsoup4>=4.12.0; extra == 'docs'
 Requires-Dist: pydata-sphinx-theme>=0.13; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints>=2.0.0; extra == 'docs'
 Requires-Dist: sphinx>=7.0; extra == 'docs'
+Provides-Extra: fsspec
+Requires-Dist: fsspec>=2023.1.0; extra == 'fsspec'
+Provides-Extra: gcplineage
+Requires-Dist: google-cloud-datacatalog-lineage>=0.3.14; extra == 'gcplineage'
 Provides-Extra: generator
 Requires-Dist: click; extra == 'generator'
-Requires-Dist: datamodel-code-generator==0.25.4; extra == 'generator'
+Requires-Dist: datamodel-code-generator==0.33.0; extra == 'generator'
 Requires-Dist: ruff; extra == 'generator'
 Provides-Extra: kafka
 Requires-Dist: confluent-kafka>=2.1.1; extra == 'kafka'

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/client.py

@@ -11,16 +11,10 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 import attr
 import yaml
-from openlineage.client import event_v2
+from openlineage.client import constants, event_v2
+from openlineage.client.facet_v2 import environment_variables_run, tags_job, tags_run
 from openlineage.client.facets import FacetsConfig
 from openlineage.client.filter import Filter, FilterConfig, create_filter
-from openlineage.client.generated.environment_variables_run import (
-    EnvironmentVariable,
-    EnvironmentVariablesRunFacet,
-)
-from openlineage.client.generated.tags_job import TagsJobFacet, TagsJobFacetFields
-from openlineage.client.generated.tags_run import TagsRunFacet, TagsRunFacetFields
-from openlineage.client.run import DatasetEvent, JobEvent, RunEvent
 from openlineage.client.serde import Serde
 from openlineage.client.tags import TagsConfig
 from openlineage.client.transport import (
@@ -32,6 +26,10 @@ from openlineage.client.transport.http import HttpConfig, HttpTransport
 from openlineage.client.transport.noop import NoopConfig, NoopTransport
 from openlineage.client.utils import deep_merge_dicts
 
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", DeprecationWarning)
+    from openlineage.client.run import DatasetEvent, JobEvent, RunEvent
+
 if TYPE_CHECKING:
     from requests import Session
     from requests.adapters import HTTPAdapter
@@ -67,11 +65,9 @@ class OpenLineageConfig:
         if "filters" in params:
             config.filters = [FilterConfig(**filter_config) for filter_config in params["filters"]]
         if "tags" in params:
-            job_tags = params["tags"].get("job", {})
-            run_tags = params["tags"].get("run", {})
             config.tags = TagsConfig(
-                job=[TagsJobFacetFields(key, value, "USER") for (key, value) in job_tags.items()],
-                run=[TagsRunFacetFields(key, value, "USER") for (key, value) in run_tags.items()],
+                job=params["tags"].get("job", {}),
+                run=params["tags"].get("run", {}),
             )
         return config
 
@@ -163,6 +159,9 @@ class OpenLineageClient:
             msg = "`emit` only accepts RunEvent, DatasetEvent, JobEvent classes"
             raise ValueError(msg)
 
+        event = self.add_environment_facets(event)
+        event = self.update_event_tags_facets(event)
+
         if log.isEnabledFor(logging.DEBUG):
             val = Serde.to_json(event).encode("utf-8")
             log.debug("OpenLineageClient will *try* to emit event %s", val)
@@ -177,9 +176,6 @@ class OpenLineageClient:
             log.debug("OpenLineage event has been filtered out and will not be emitted.")
             return
 
-        event = self.add_environment_facets(event)
-        event = self.update_event_tags_facets(event)
-
         self.transport.emit(event)
         log.debug("OpenLineage event successfully emitted.")
 
@@ -312,15 +308,15 @@ class OpenLineageClient:
         """
         Create HTTP transport from legacy environment variables
         """
-        # Start with basic config from legacy environment variables
-        config_dict = {
+        config_dict: dict[str, Any] = {
             "url": os.environ["OPENLINEAGE_URL"],
-            "auth": {
-                "type": "api_key",
-                "apiKey": os.environ.get("OPENLINEAGE_API_KEY", ""),
-            },
             "endpoint": os.environ.get("OPENLINEAGE_ENDPOINT", "api/v1/lineage"),
         }
+        if api_key := os.environ.get("OPENLINEAGE_API_KEY"):
+            config_dict["auth"] = {
+                "type": "api_key",
+                "apiKey": api_key,
+            }
         return HttpTransport(HttpConfig.from_dict(config_dict))
 
     @staticmethod
@@ -426,9 +422,10 @@ class OpenLineageClient:
             env_vars := self._collect_environment_variables()
         ):
             event.run.facets = event.run.facets or {}
-            event.run.facets["environmentVariables"] = EnvironmentVariablesRunFacet(
+            event.run.facets["environmentVariables"] = environment_variables_run.EnvironmentVariablesRunFacet(
                 environmentVariables=[
-                    EnvironmentVariable(name=name, value=value) for name, value in env_vars.items()
+                    environment_variables_run.EnvironmentVariable(name=name, value=value)
+                    for name, value in env_vars.items()
                 ]
             )
         return event
@@ -446,33 +443,54 @@ class OpenLineageClient:
             )
         return filtered_vars
 
+    @property
+    def _job_tags(self) -> list[tags_job.TagsJobFacetFields]:
+        _default_tags: dict[str, str] = {}
+        user_job_tags = [
+            tags_job.TagsJobFacetFields(key, value, "USER") for (key, value) in self.config.tags.job.items()
+        ]
+        default_job_tags = [
+            tags_job.TagsJobFacetFields(key, value, "OPENLINEAGE_CLIENT")
+            for (key, value) in _default_tags.items()
+        ]
+        return [*user_job_tags, *default_job_tags]
+
+    @property
+    def _run_tags(self) -> list[tags_run.TagsRunFacetFields]:
+        _default_tags: dict[str, str] = {"openlineage_client_version": constants.__version__}
+        user_run_tags = [
+            tags_run.TagsRunFacetFields(key, value, "USER") for (key, value) in self.config.tags.run.items()
+        ]
+        default_run_tags = [
+            tags_run.TagsRunFacetFields(key, value, "OPENLINEAGE_CLIENT")
+            for (key, value) in _default_tags.items()
+        ]
+        return [*user_run_tags, *default_run_tags]
+
     def update_event_tags_facets(self, event: Event) -> Event:
         """
         Creates or updates job and run tag facets based on user-supplied environment variables
         """
         run_event_types = (RunEvent, event_v2.RunEvent)
         run_and_job_event_types = (RunEvent, event_v2.RunEvent, JobEvent, event_v2.JobEvent)
-        tags_job = self.config.tags.job
-        if isinstance(event, run_and_job_event_types) and tags_job:
-            # Ensure facets exists
-            event.job.facets = {} if not event.job.facets else event.job.facets
-            tags_facet = event.job.facets.get("tags", TagsJobFacet())
-            event.job.facets["tags"] = self._update_tag_facet(tags_facet, tags_job)  # type: ignore [arg-type, assignment]
-
-        tags_run = self.config.tags.run
-        if isinstance(event, run_event_types) and tags_run:
-            # Ensure facets exists
-            event.run.facets = {} if not event.run.facets else event.run.facets
-            tags_facet = event.run.facets.get("tags", TagsRunFacet())
-            event.run.facets["tags"] = self._update_tag_facet(tags_facet, tags_run)  # type: ignore [arg-type, assignment]
+
+        if isinstance(event, run_and_job_event_types) and self._job_tags:
+            event.job.facets = {} if not event.job.facets else event.job.facets  # Ensure facets exists
+            tags_facet = event.job.facets.get("tags", tags_job.TagsJobFacet())
+            event.job.facets["tags"] = self._update_tag_facet(tags_facet, self._job_tags)  # type: ignore [arg-type, assignment]
+
+        if isinstance(event, run_event_types) and self._run_tags:
+            event.run.facets = {} if not event.run.facets else event.run.facets  # Ensure facets exists
+            tags_facet = event.run.facets.get("tags", tags_run.TagsRunFacet())
+            event.run.facets["tags"] = self._update_tag_facet(tags_facet, self._run_tags)  # type: ignore [arg-type, assignment]
 
         return event
 
     @staticmethod
     def _update_tag_facet(
-        tags_facet: TagsJobFacet | TagsRunFacet,
-        user_tags: list[TagsJobFacetFields | TagsRunFacetFields],
-    ) -> TagsJobFacet | TagsRunFacet:
+        tags_facet: tags_job.TagsJobFacet | tags_run.TagsRunFacet,
+        user_tags: list[tags_job.TagsJobFacetFields | tags_run.TagsRunFacetFields],
+    ) -> tags_job.TagsJobFacet | tags_run.TagsRunFacet:
         """
         Handles updating tags in an existing tag facet
         """
@@ -492,7 +510,8 @@ class OpenLineageClient:
         for user_tag in user_tags:
             if user_tag.key in facet_tag_keys:
                 facet_tag_key = facet_tag_keys[user_tag.key]
-                log.info("Overriding integration-supplied tag `%s` with user-supplied tag", facet_tag_key)
+                if user_tag.source == "USER":
+                    log.info("Overriding integration-supplied tag `%s` with user-supplied tag", facet_tag_key)
                 user_tag.key = facet_tag_key
 
         all_tags = keep_tags + user_tags

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/constants.py

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

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/event_v2.py

@@ -13,6 +13,7 @@ from openlineage.client.generated.base import (
     OutputDataset,
     Run,
     RunEvent,
+    StaticDataset,
     set_producer,
 )
 from openlineage.client.generated.base import (
@@ -31,5 +32,6 @@ __all__ = [
     "Run",
     "RunEvent",
     "RunState",
+    "StaticDataset",
     "set_producer",
 ]

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/facet_v2.py

@@ -2,9 +2,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from openlineage.client.generated import (
+    base_subset_dataset,
     catalog_dataset,
     column_lineage_dataset,
     data_quality_assertions_dataset,
+    data_quality_metrics_dataset,
     data_quality_metrics_input_dataset,
     dataset_type_dataset,
     dataset_version_dataset,
@@ -54,9 +56,11 @@ __all__ = [
     "OutputDatasetFacet",
     "RunFacet",
     "set_producer",
+    "base_subset_dataset",
     "catalog_dataset",
     "column_lineage_dataset",
     "data_quality_assertions_dataset",
+    "data_quality_metrics_dataset",
     "data_quality_metrics_input_dataset",
     "dataset_type_dataset",
     "dataset_version_dataset",

openlineage_python-1.38.0/openlineage/client/generated/base_subset_dataset.py

@@ -0,0 +1,110 @@
+# Copyright 2018-2025 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Union
+
+import attr
+from openlineage.client.generated.base import InputDatasetFacet, OutputDatasetFacet
+from openlineage.client.utils import RedactMixin
+
+BaseSubsetCondition = Union[
+    "LocationSubsetCondition", "PartitionSubsetCondition", "BinarySubsetCondition", "CompareSubsetCondition"
+]
+
+
+BaseSubsetDatasetFacet = Union["InputSubsetInputDatasetFacet", "OutputSubsetOutputDatasetFacet"]
+
+
+@attr.define
+class BinarySubsetCondition(RedactMixin):
+    left: BaseSubsetCondition
+    right: BaseSubsetCondition
+    operator: str
+    """Allowed values: 'AND' or 'OR'"""
+
+    type: str = "binary"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/BinarySubsetCondition"
+
+
+@attr.define
+class CompareSubsetCondition(RedactMixin):
+    left: FieldBaseCompareExpression | LiteralCompareExpression
+    right: FieldBaseCompareExpression | LiteralCompareExpression
+    comparison: str
+    """Allowed values: 'EQUAL', 'GREATER_THAN', 'GREATER_EQUAL_THAN', 'LESS_THAN', 'LESS_EQUAL_THAN'"""
+
+    type: str = "compare"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/CompareSubsetCondition"
+
+
+@attr.define
+class FieldBaseCompareExpression(RedactMixin):
+    field: str
+    type: str = "field"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/FieldBaseCompareExpression"
+
+
+@attr.define
+class InputSubsetInputDatasetFacet(InputDatasetFacet):
+    inputCondition: BaseSubsetCondition  # noqa: N815
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/InputSubsetInputDatasetFacet"
+
+
+@attr.define
+class LiteralCompareExpression(RedactMixin):
+    value: str
+    type: str = "literal"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/LiteralCompareExpression"
+
+
+@attr.define
+class LocationSubsetCondition(RedactMixin):
+    locations: list[str]
+    type: str = "location"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/LocationSubsetCondition"
+
+
+@attr.define
+class OutputSubsetOutputDatasetFacet(OutputDatasetFacet):
+    outputCondition: BaseSubsetCondition  # noqa: N815
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/OutputSubsetOutputDatasetFacet"
+
+
+@attr.define
+class Partition(RedactMixin):
+    dimensions: dict[str, Any]
+    identifier: str | None = attr.field(default=None)
+    """Optionally provided identifier of the partition specified"""
+
+
+@attr.define
+class PartitionSubsetCondition(RedactMixin):
+    partitions: list[Partition]
+    type: str = "partition"  # noqa: A003
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/BaseSubsetDatasetFacet.json#/$defs/PartitionSubsetCondition"

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/generated/catalog_dataset.py

@@ -27,6 +27,9 @@ class CatalogDatasetFacet(DatasetFacet):
     source: str | None = attr.field(default=None)
     """Source system where the catalog is configured."""
 
+    catalogProperties: dict[str, str] | None = attr.field(factory=dict)  # noqa: N815
+    """Additional catalog properties"""
+
     @staticmethod
     def _get_schema() -> str:
-        return "https://openlineage.io/spec/facets/1-0-0/CatalogDatasetFacet.json#/$defs/CatalogDatasetFacet"
+        return "https://openlineage.io/spec/facets/1-1-0/CatalogDatasetFacet.json#/$defs/CatalogDatasetFacet"

openlineage_python-1.38.0/openlineage/client/generated/data_quality_metrics_dataset.py

@@ -0,0 +1,62 @@
+# Copyright 2018-2025 contributors to the OpenLineage project
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import attr
+from openlineage.client.generated.base import DatasetFacet
+from openlineage.client.utils import RedactMixin
+
+
+@attr.define
+class ColumnMetrics(RedactMixin):
+    nullCount: int | None = attr.field(default=None)  # noqa: N815
+    """The number of null values in this column for the rows evaluated"""
+
+    distinctCount: int | None = attr.field(default=None)  # noqa: N815
+    """The number of distinct values in this column for the rows evaluated"""
+
+    sum: float | None = attr.field(default=None)  # noqa: A003
+    """The total sum of values in this column for the rows evaluated"""
+
+    count: float | None = attr.field(default=None)
+    """The number of values in this column"""
+
+    min: float | None = attr.field(default=None)  # noqa: A003
+    max: float | None = attr.field(default=None)  # noqa: A003
+    quantiles: dict[str, float] | None = attr.field(factory=dict)
+    """The property key is the quantile. Examples: 0.1 0.25 0.5 0.75 1"""
+
+
+@attr.define
+class DataQualityMetricsDatasetFacet(DatasetFacet):
+    columnMetrics: dict[str, ColumnMetrics]  # noqa: N815
+    """The property key is the column name"""
+
+    rowCount: int | None = attr.field(default=None)  # noqa: N815
+    """The number of rows evaluated"""
+
+    bytes: int | None = attr.field(default=None)  # noqa: A003
+    """The size in bytes"""
+
+    fileCount: int | None = attr.field(default=None)  # noqa: N815
+    """The number of files evaluated"""
+
+    lastUpdated: str | None = attr.field(default=None)  # noqa: N815
+    """The last time the dataset was changed"""
+
+    @staticmethod
+    def _get_schema() -> str:
+        return "https://openlineage.io/spec/facets/1-0-0/DataQualityMetricsDatasetFacet.json#/$defs/DataQualityMetricsDatasetFacet"
+
+    @lastUpdated.validator
+    def lastupdated_check(self, attribute: str, value: str) -> None:  # noqa: ARG002
+        if value is None:
+            return
+        from dateutil import parser
+
+        parser.isoparse(value)
+        if "t" not in value.lower():
+            # make sure date-time contains time
+            msg = f"Parsed date-time has to contain time: {value}"
+            raise ValueError(msg)

{openlineage_python-1.36.0 → openlineage_python-1.38.0}/openlineage/client/generated/data_quality_metrics_input_dataset.py

@@ -42,6 +42,21 @@ class DataQualityMetricsInputDatasetFacet(InputDatasetFacet):
     fileCount: int | None = attr.field(default=None)  # noqa: N815
     """The number of files evaluated"""
 
+    lastUpdated: str | None = attr.field(default=None)  # noqa: N815
+    """The last time the dataset was changed"""
+
     @staticmethod
     def _get_schema() -> str:
-        return "https://openlineage.io/spec/facets/1-0-2/DataQualityMetricsInputDatasetFacet.json#/$defs/DataQualityMetricsInputDatasetFacet"
+        return "https://openlineage.io/spec/facets/1-0-3/DataQualityMetricsInputDatasetFacet.json#/$defs/DataQualityMetricsInputDatasetFacet"
+
+    @lastUpdated.validator
+    def lastupdated_check(self, attribute: str, value: str) -> None:  # noqa: ARG002
+        if value is None:
+            return
+        from dateutil import parser
+
+        parser.isoparse(value)
+        if "t" not in value.lower():
+            # make sure date-time contains time
+            msg = f"Parsed date-time has to contain time: {value}"
+            raise ValueError(msg)