acryl-datahub 0.15.0.4rc3__py3-none-any.whl → 0.15.0.5__py3-none-any.whl

datahub/metadata/schemas/PostInfo.avsc

@@ -7,15 +7,18 @@
   "namespace": "com.linkedin.pegasus2avro.post",
   "fields": [
     {
+      "Searchable": {},
       "type": {
         "type": "enum",
         "symbolDocs": {
+          "ENTITY_ANNOUNCEMENT": "The Post is an Entity level announcement.",
           "HOME_PAGE_ANNOUNCEMENT": "The Post is an Home Page announcement."
         },
         "name": "PostType",
         "namespace": "com.linkedin.pegasus2avro.post",
         "symbols": [
-          "HOME_PAGE_ANNOUNCEMENT"
+          "HOME_PAGE_ANNOUNCEMENT",
+          "ENTITY_ANNOUNCEMENT"
         ],
         "doc": "Enum defining types of Posts."
       },
@@ -203,13 +206,25 @@
           "dataset",
           "schemaField",
           "chart",
+          "container",
           "dashboard",
           "dataFlow",
           "dataJob",
+          "dataProduct",
+          "glossaryTerm",
+          "glossaryNode",
+          "mlModel",
+          "mlFeature",
+          "notebook",
+          "mlFeatureTable",
+          "mlPrimaryKey",
+          "mlModelGroup",
+          "domain",
           "dataProduct"
         ],
         "name": "PostTarget"
       },
+      "Searchable": {},
       "java": {
         "class": "com.linkedin.pegasus2avro.common.urn.Urn"
       },
@@ -219,15 +234,26 @@
       ],
       "name": "target",
       "default": null,
-      "doc": "Optional URN that the post is associated with.",
+      "doc": "Optional Entity URN that the post is associated with.",
       "Urn": "Urn",
       "entityTypes": [
         "dataset",
         "schemaField",
         "chart",
+        "container",
         "dashboard",
         "dataFlow",
         "dataJob",
+        "dataProduct",
+        "glossaryTerm",
+        "glossaryNode",
+        "mlModel",
+        "mlFeature",
+        "notebook",
+        "mlFeatureTable",
+        "mlPrimaryKey",
+        "mlModelGroup",
+        "domain",
         "dataProduct"
       ]
     }

datahub/metadata/schemas/SchemaFieldKey.avsc

@@ -12,7 +12,8 @@
       "status",
       "schemaFieldAliases",
       "documentation",
-      "testResults"
+      "testResults",
+      "deprecation"
     ]
   },
   "name": "SchemaFieldKey",

datahub/specific/dashboard.py

@@ -161,7 +161,7 @@ class DashboardPatchBuilder(
                 lastModified=self._mint_auditstamp(),
             )
 
-        self._ensure_urn_type("dataset", [chart_edge], "add_chart_edge")
+        self._ensure_urn_type("chart", [chart_edge], "add_chart_edge")
         self._add_patch(
             DashboardInfo.ASPECT_NAME,
             "add",
@@ -271,6 +271,48 @@ class DashboardPatchBuilder(
 
         return self
 
+    def add_dashboard(
+        self, dashboard: Union[Edge, Urn, str]
+    ) -> "DashboardPatchBuilder":
+        """
+        Adds an dashboard to the DashboardPatchBuilder.
+
+        Args:
+            dashboard: The dashboard, which can be an Edge object, Urn object, or a string.
+
+        Returns:
+            The DashboardPatchBuilder instance.
+
+        Raises:
+            ValueError: If the dashboard is not a Dashboard urn.
+
+        Notes:
+            If `dashboard` is an Edge object, it is used directly. If `dashboard` is a Urn object or string,
+            it is converted to an Edge object and added with default audit stamps.
+        """
+        if isinstance(dashboard, Edge):
+            dashboard_urn: str = dashboard.destinationUrn
+            dashboard_edge: Edge = dashboard
+        elif isinstance(dashboard, (Urn, str)):
+            dashboard_urn = str(dashboard)
+            if not dashboard_urn.startswith("urn:li:dashboard:"):
+                raise ValueError(f"Input {dashboard} is not a Dashboard urn")
+
+            dashboard_edge = Edge(
+                destinationUrn=dashboard_urn,
+                created=self._mint_auditstamp(),
+                lastModified=self._mint_auditstamp(),
+            )
+
+        self._ensure_urn_type("dashboard", [dashboard_edge], "add_dashboard")
+        self._add_patch(
+            DashboardInfo.ASPECT_NAME,
+            "add",
+            path=("dashboards", dashboard_urn),
+            value=dashboard_edge,
+        )
+        return self
+
     def set_dashboard_url(
         self, dashboard_url: Optional[str]
     ) -> "DashboardPatchBuilder":

datahub/telemetry/telemetry.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
 from mixpanel import Consumer, Mixpanel
 from typing_extensions import ParamSpec
 
-import datahub as datahub_package
+from datahub._version import __version__, nice_version_name
 from datahub.cli.config_utils import DATAHUB_ROOT_FOLDER
 from datahub.cli.env_utils import get_boolean_env_variable
 from datahub.configuration.common import ExceptionWithProps
@@ -106,7 +106,7 @@ SENTRY_ENVIRONMENT: str = os.environ.get("SENTRY_ENVIRONMENT", "dev")
 
 def _default_telemetry_properties() -> Dict[str, Any]:
     return {
-        "datahub_version": datahub_package.nice_version_name(),
+        "datahub_version": nice_version_name(),
         "python_version": platform.python_version(),
         "os": platform.system(),
         "arch": platform.machine(),
@@ -132,7 +132,7 @@ class Telemetry:
                 sentry_sdk.init(
                     dsn=SENTRY_DSN,
                     environment=SENTRY_ENVIRONMENT,
-                    release=datahub_package.__version__,
+                    release=__version__,
                 )
             except Exception as e:
                 # We need to print initialization errors to stderr, since logger is not initialized yet
@@ -277,7 +277,7 @@ class Telemetry:
                 "environment",
                 {
                     "environment": SENTRY_ENVIRONMENT,
-                    "datahub_version": datahub_package.nice_version_name(),
+                    "datahub_version": nice_version_name(),
                     "os": platform.system(),
                     "python_version": platform.python_version(),
                 },

datahub/testing/check_imports.py

@@ -1,4 +1,5 @@
 import pathlib
+import re
 from typing import List
 
 
@@ -32,3 +33,30 @@ def ensure_no_indirect_model_imports(dirs: List[pathlib.Path]) -> None:
                                 f"Disallowed import found in {file}: `{line.rstrip()}`. "
                                 f"Import from {replacement} instead."
                             )
+
+
+def ban_direct_datahub_imports(dirs: List[pathlib.Path]) -> None:
+    # We also want to ban all direct imports of datahub.
+    # The base `datahub` package is used to export public-facing classes.
+    # If we import it directly, we'll likely end up with circular imports.
+
+    banned_strings = [
+        r"^import datahub[\s$]",
+        r"^from datahub import",
+    ]
+    ignored_files = {
+        __file__,
+    }
+    for dir in dirs:
+        for file in dir.rglob("*.py"):
+            if str(file) in ignored_files:
+                continue
+
+            file_contents = file.read_text()
+
+            for banned_string in banned_strings:
+                if re.search(banned_string, file_contents, re.MULTILINE):
+                    raise ValueError(
+                        f"Disallowed bare datahub import found in {file}. "
+                        f"Do not import datahub directly; instead import from the underlying file."
+                    )

datahub/upgrade/upgrade.py

@@ -10,7 +10,7 @@ import humanfriendly
 from packaging.version import Version
 from pydantic import BaseModel
 
-from datahub import __version__
+from datahub._version import __version__
 from datahub.cli.config_utils import load_client_config
 from datahub.ingestion.graph.client import DataHubGraph
 from datahub.utilities.perf_timer import PerfTimer
@@ -55,11 +55,19 @@ async def get_client_version_stats():
         async with session.get(pypi_url) as resp:
             response_json = await resp.json()
             try:
-                releases = response_json.get("releases", [])
-                sorted_releases = sorted(releases.keys(), key=lambda x: Version(x))
-                latest_cli_release_string = [
-                    x for x in sorted_releases if "rc" not in x
-                ][-1]
+                releases = response_json.get("releases", {})
+                filtered_releases = {
+                    version: release_files
+                    for version, release_files in releases.items()
+                    if not all(
+                        release_file.get("yanked") for release_file in release_files
+                    )
+                    and "rc" not in version
+                }
+                sorted_releases = sorted(
+                    filtered_releases.keys(), key=lambda x: Version(x)
+                )
+                latest_cli_release_string = sorted_releases[-1]
                 latest_cli_release = Version(latest_cli_release_string)
                 current_version_info = releases.get(current_version_string)
                 current_version_date = None
@@ -93,11 +101,11 @@ async def get_github_stats():
     async with aiohttp.ClientSession(
         headers={"Accept": "application/vnd.github.v3+json"}
     ) as session:
-        gh_url = "https://api.github.com/repos/datahub-project/datahub/releases"
+        gh_url = "https://api.github.com/repos/datahub-project/datahub/releases/latest"
         async with session.get(gh_url) as gh_response:
             gh_response_json = await gh_response.json()
-            latest_server_version = Version(gh_response_json[0].get("tag_name"))
-            latest_server_date = gh_response_json[0].get("published_at")
+            latest_server_version = Version(gh_response_json.get("tag_name"))
+            latest_server_date = gh_response_json.get("published_at")
             return (latest_server_version, latest_server_date)