acryl-datahub 1.1.1rc4__py3-none-any.whl → 1.3.0.1rc9__py3-none-any.whl

datahub/api/entities/external/external_tag.py

@@ -0,0 +1,147 @@
+"""
+External Tags Module
+
+This module provides tag types that integrate with external systems like DataHub and Unity Catalog.
+It builds on top of RestrictedText to provide sanitized, truncated tag handling with original value preservation.
+
+Classes:
+    - ExternalTag: DataHub-compatible tag with key/value parsing from URNs
+
+Example Usage:
+    # DataHub Tags
+    tag = ExternalTag.from_urn("urn:li:tag:environment:production")
+    datahub_urn = tag.get_datahub_tag  # Returns TagUrn object or string
+
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Tuple, Union
+
+from pydantic import BaseModel
+
+from datahub.api.entities.external.restricted_text import RestrictedText
+from datahub.metadata.urns import TagUrn
+
+
+class ExternalTag(BaseModel):
+    """A tag type that parses DataHub Tag URNs into key-value pairs with RestrictedText properties."""
+
+    key: RestrictedText
+    value: Optional[RestrictedText] = None
+
+    def __init__(
+        self,
+        key: Optional[Union[str, RestrictedText]] = None,
+        value: Optional[Union[str, RestrictedText]] = None,
+        **data: Any,
+    ) -> None:
+        """
+        Initialize ExternalTag from either a DataHub Tag URN or explicit key/value.
+
+        Args:
+            key: Explicit key value (optional for Pydantic initialization)
+            value: Explicit value (optional)
+            **data: Additional Pydantic data
+        """
+        if key is not None:
+            # Direct initialization with key/value
+            processed_key = (
+                RestrictedText(raw_text=key)
+                if not isinstance(key, RestrictedText)
+                else key
+            )
+            processed_value = None
+            if value is not None:
+                processed_value = (
+                    RestrictedText(raw_text=value)
+                    if not isinstance(value, RestrictedText)
+                    else value
+                )
+
+            super().__init__(
+                key=processed_key,
+                value=processed_value,
+                **data,
+            )
+        else:
+            # Standard pydantic initialization
+            super().__init__(**data)
+
+    @staticmethod
+    def _parse_tag_name(tag_name: str) -> Tuple[str, Optional[str]]:
+        """
+        Parse tag name into key and optional value.
+
+        If tag_name contains ':', split on first ':' into key:value
+        Otherwise, use entire tag_name as key with no value.
+
+        Args:
+            tag_name: The tag name portion from the URN
+
+        Returns:
+            Tuple of (key, value) where value may be None
+        """
+        if ":" in tag_name:
+            parts = tag_name.split(":", 1)  # Split on first ':' only
+            return parts[0], parts[1]
+        else:
+            return tag_name, None
+
+    def to_datahub_tag_urn(self) -> TagUrn:
+        """
+        Generate a DataHub Tag URN from the key and value.
+        This method creates the URN using the original (unprocessed) values.
+
+        Returns:
+            'urn:li:tag:key:value' if value exists, otherwise 'urn:li:tag:key'
+        """
+        if self.value is not None:
+            tag_name = f"{self.key.raw_text}:{self.value.raw_text}"
+        else:
+            tag_name = self.key.raw_text
+
+        return TagUrn(name=tag_name)
+
+    @classmethod
+    def from_urn(cls, tag_urn: Union[str, "TagUrn"]) -> "ExternalTag":
+        """
+        Create an ExternalTag from a DataHub Tag URN.
+
+        Args:
+            tag_urn: DataHub Tag URN string or TagUrn object
+
+        Returns:
+            ExternalTag instance
+        """
+        if isinstance(tag_urn, str):
+            tag_urn = TagUrn.from_string(tag_urn)
+        key, value = cls._parse_tag_name(tag_urn.name)
+        return cls(key=key, value=value)
+
+    @classmethod
+    def from_key_value(cls, key: str, value: Optional[str] = None) -> "ExternalTag":
+        """
+        Create an ExternalTag from explicit key and value.
+
+        Args:
+            key: Tag key
+            value: Optional tag value
+
+        Returns:
+            ExternalTag instance
+        """
+        return cls(key=key, value=value)
+
+    def __str__(self) -> str:
+        """String representation of the tag."""
+        if self.value is not None:
+            return f"{self.key}:{self.value}"
+        else:
+            return str(self.key)
+
+    def __repr__(self) -> str:
+        if self.value is not None:
+            return f"ExternalTag(key={self.key!r}, value={self.value!r})"
+        else:
+            return f"ExternalTag(key={self.key!r})"

datahub/api/entities/external/lake_formation_external_entites.py

@@ -0,0 +1,162 @@
+# Import RestrictedText from your existing module
+# Uncomment and adjust the import path as needed:
+# from your_restricted_text_module import RestrictedText
+# The following is a list of tag constraints:
+# You can assign a maximum of 50 tags to a single securable object.
+# The maximum length of a tag key is 255 characters.
+# The maximum length of a tag value is 1000 characters.
+# The following characters are not allowed in tag keys:
+# . , - = / :
+# Tag search using the workspace search UI is supported only for tables, views, and table columns.
+# Tag search requires exact term matching.
+# https://learn.microsoft.com/en-us/azure/databricks/database-objects/tags#constraint
+from typing import Any, Dict, Optional
+
+from pydantic import validator
+from typing_extensions import ClassVar
+
+from datahub.api.entities.external.external_tag import ExternalTag
+from datahub.api.entities.external.restricted_text import RestrictedText
+
+
+class LakeFormationTagKeyText(RestrictedText):
+    """RestrictedText configured for Lake Formation tag keys."""
+
+    DEFAULT_MAX_LENGTH: ClassVar[int] = 50
+    # Lake Formation tag keys restrictions
+    DEFAULT_REPLACEMENT_CHAR: ClassVar[str] = "_"
+    DEFAULT_TRUNCATION_SUFFIX: ClassVar[str] = ""  # No suffix for clean identifiers
+
+
+class LakeFormationTagValueText(RestrictedText):
+    """RestrictedText configured for Lake Formation tag values."""
+
+    DEFAULT_MAX_LENGTH: ClassVar[int] = 50
+    # Lake Formation tag values restrictions
+    DEFAULT_REPLACEMENT_CHAR: ClassVar[str] = " "
+    DEFAULT_TRUNCATION_SUFFIX: ClassVar[str] = "..."
+
+
+class LakeFormationTag(ExternalTag):
+    """
+    A tag type specifically designed for LakeFormation tag restrictions.
+
+    LakeFormation Tag Restrictions:
+    - Key: Max 127 characters, alphanumeric + hyphens, underscores, periods only
+    - Value: Max 256 characters, more permissive but no control characters
+    """
+
+    key: LakeFormationTagKeyText
+    value: Optional[LakeFormationTagValueText] = None
+    catalog: Optional[str] = None
+
+    # Pydantic v1 validators
+    @validator("key", pre=True)
+    @classmethod
+    def _validate_key(cls, v: Any) -> LakeFormationTagKeyText:
+        """Validate and convert key field for Pydantic v1."""
+        if isinstance(v, LakeFormationTagKeyText):
+            return v
+
+        # If we get a RestrictedText object from parent class validation, use its raw_text value
+        if hasattr(v, "raw_text"):
+            return LakeFormationTagKeyText(raw_text=v.raw_text)
+
+        return LakeFormationTagKeyText(raw_text=v)
+
+    @validator("value", pre=True)
+    @classmethod
+    def _validate_value(cls, v: Any) -> Optional[LakeFormationTagValueText]:
+        """Validate and convert value field for Pydantic v1."""
+        if v is None:
+            return None
+
+        if isinstance(v, LakeFormationTagValueText):
+            return v
+
+        # If we get a RestrictedText object from parent class validation, use its raw_text value
+        if hasattr(v, "raw_text"):
+            text_value = v.raw_text
+            # If value is an empty string, set it to None to not generate empty value in DataHub tag
+            if not str(text_value):
+                return None
+            return LakeFormationTagValueText(raw_text=text_value)
+
+        # If value is an empty string, set it to None to not generate empty value in DataHub tag
+        if not str(v):
+            return None
+
+        return LakeFormationTagValueText(raw_text=v)
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality based on key and value."""
+        if not isinstance(other, LakeFormationTag):
+            return False
+        return str(self.key) == str(other.key) and (
+            str(self.value) if self.value else None
+        ) == (str(other.value) if other.value else None)
+
+    def __hash__(self) -> int:
+        """Make LakeFormationTag hashable based on key and value."""
+        return hash((str(self.key), str(self.value) if self.value else None))
+
+    @classmethod
+    def from_dict(cls, tag_dict: Dict[str, Any]) -> "LakeFormationTag":
+        """
+        Create a LakeFormationTag from a dictionary with 'key' and optional 'value'.
+
+        Args:
+            tag_dict: Dictionary with 'key' and optional 'value' keys
+
+        Returns:
+            LakeFormationTag instance
+        """
+        return cls(key=tag_dict["key"], value=tag_dict.get("value"))
+
+    @classmethod
+    def from_key_value(
+        cls, key: str, value: Optional[str] = None
+    ) -> "LakeFormationTag":
+        """
+        Create a LakeFormationTagPlatformResource from explicit key and value.
+
+        Overrides the parent method to return the correct type.
+
+        Args:
+            key: Tag key
+            value: Optional tag value
+
+        Returns:
+            LakeFormationTag instance
+        """
+        return cls(key=key, value=value)
+
+    def to_dict(self) -> Dict[str, str]:
+        """
+        Convert to dictionary format suitable for LakeFormation tag.
+
+        Returns:
+            Dictionary with 'key' and optionally 'value'
+        """
+        result: Dict[str, str] = {"key": self.key.raw_text}
+        if self.value is not None:
+            result["value"] = self.value.raw_text
+        return result
+
+    def to_display_dict(self) -> Dict[str, str]:
+        """
+        Convert to dictionary format showing processed values.
+
+        Returns:
+            Dictionary with processed 'key' and optional 'value'
+        """
+        result: Dict[str, str] = {"key": str(self.key)}
+        if self.value is not None:
+            result["value"] = str(self.value)
+        return result
+
+    def __repr__(self) -> str:
+        if self.value:
+            return f"LakeFormationTag(key={self.key!r}, value={self.value!r})"
+        else:
+            return f"LakeFormationTag(key={self.key!r})"

datahub/api/entities/external/restricted_text.py

@@ -0,0 +1,172 @@
+"""The `RestrictedText` module provides a custom Pydantic type that stores the original
+value but returns a truncated and sanitized version when accessed.
+
+Features:
+- Configurable maximum length with truncation
+- Character replacement (default replaces with underscore)
+- Preserves original value internally
+- Customizable truncation suffix
+- Compatible with both Pydantic v1 and v2
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar, Optional, Set
+
+from datahub.configuration.common import ConfigModel
+
+
+class RestrictedText(ConfigModel):
+    """A string type that stores the original value but returns a truncated and sanitized version.
+
+    This type allows you to:
+    - Set a maximum length for the displayed value
+    - Replace specific characters with a replacement character
+    - Access both the original and processed values
+
+    ```python
+    from pydantic import BaseModel
+
+    class TestModel(BaseModel):
+        # Basic usage with default settings
+        name: RestrictedText
+
+        # Custom max length and character replacement
+        custom_field: RestrictedText = RestrictedText(
+            text="hello-world.test",
+            max_length=10,
+            forbidden_chars={' ', '-', '.'},
+            replacement_char='_'
+        )
+
+    # Usage example
+    model = TestModel(
+        name="This is a very long string with special characters!",
+        custom_field="hello-world.test"
+    )
+
+    print(model.name)  # Truncated and sanitized version
+    print(model.name.text)  # Original value
+    print(model.custom_field)  # "hello_worl..."
+    ```
+    """
+
+    # Default configuration
+    DEFAULT_MAX_LENGTH: ClassVar[Optional[int]] = 50
+    DEFAULT_FORBIDDEN_CHARS: ClassVar[Set[str]] = {" ", "\t", "\n", "\r"}
+    DEFAULT_REPLACEMENT_CHAR: ClassVar[str] = "_"
+    DEFAULT_TRUNCATION_SUFFIX: ClassVar[str] = "..."
+
+    raw_text: str
+    max_length: Optional[int] = None
+    forbidden_chars: Optional[Set[str]] = None
+    replacement_char: Optional[str] = None
+    truncation_suffix: Optional[str] = None
+    _processed_value: Optional[str] = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.validate_text()
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.pydantic_accept_raw_text
+        yield cls.validate
+        yield cls.pydantic_validate_text
+
+    @classmethod
+    def pydantic_accept_raw_text(cls, v):
+        if isinstance(v, (RestrictedText, dict)):
+            return v
+        assert isinstance(v, str), "text must be a string"
+        return {"text": v}
+
+    @classmethod
+    def pydantic_validate_text(cls, v):
+        assert isinstance(v, RestrictedText)
+        assert v.validate_text()
+        return v
+
+    @classmethod
+    def validate(cls, v):
+        """Validate and create a RestrictedText instance."""
+        if isinstance(v, RestrictedText):
+            return v
+
+        # This should be a dict at this point from pydantic_accept_raw_text
+        if isinstance(v, dict):
+            instance = cls(**v)
+            instance.validate_text()
+            return instance
+
+        raise ValueError(f"Unable to validate RestrictedText from {type(v)}")
+
+    def validate_text(self) -> bool:
+        """Validate the text and apply restrictions."""
+        # Set defaults if not provided
+        max_length = (
+            self.max_length if self.max_length is not None else self.DEFAULT_MAX_LENGTH
+        )
+        forbidden_chars = (
+            self.forbidden_chars
+            if self.forbidden_chars is not None
+            else self.DEFAULT_FORBIDDEN_CHARS
+        )
+        replacement_char = (
+            self.replacement_char
+            if self.replacement_char is not None
+            else self.DEFAULT_REPLACEMENT_CHAR
+        )
+        truncation_suffix = (
+            self.truncation_suffix
+            if self.truncation_suffix is not None
+            else self.DEFAULT_TRUNCATION_SUFFIX
+        )
+
+        # Store processed value
+        self._processed_value = self._process_value(
+            self.raw_text,
+            max_length,
+            forbidden_chars,
+            replacement_char,
+            truncation_suffix,
+        )
+        return True
+
+    def _process_value(
+        self,
+        value: str,
+        max_length: Optional[int],
+        forbidden_chars: Set[str],
+        replacement_char: str,
+        truncation_suffix: str,
+    ) -> str:
+        """Process the value by replacing characters and truncating."""
+        # Replace specified characters
+        processed = value
+        for char in forbidden_chars:
+            processed = processed.replace(char, replacement_char)
+
+        # Truncate if necessary
+        if max_length is not None and len(processed) > max_length:
+            if len(truncation_suffix) >= max_length:
+                # If suffix is too long, just truncate without suffix
+                processed = processed[:max_length]
+            else:
+                # Truncate and add suffix
+                truncate_length = max_length - len(truncation_suffix)
+                processed = processed[:truncate_length] + truncation_suffix
+
+        return processed
+
+    def __str__(self) -> str:
+        """Return the processed (truncated and sanitized) value."""
+        return self._processed_value or ""
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.raw_text!r})"
+
+    @property
+    def processed(self) -> str:
+        """Get the processed (truncated and sanitized) value."""
+        return self._processed_value or ""

datahub/api/entities/external/unity_catalog_external_entites.py

@@ -0,0 +1,172 @@
+# Import RestrictedText from your existing module
+# Uncomment and adjust the import path as needed:
+# from your_restricted_text_module import RestrictedText
+# The following is a list of tag constraints:
+# You can assign a maximum of 50 tags to a single securable object.
+# The maximum length of a tag key is 255 characters.
+# The maximum length of a tag value is 1000 characters.
+# The following characters are not allowed in tag keys:
+# . , - = / :
+# Tag search using the workspace search UI is supported only for tables, views, and table columns.
+# Tag search requires exact term matching.
+# https://learn.microsoft.com/en-us/azure/databricks/database-objects/tags#constraint
+from typing import Any, Dict, Optional, Set
+
+# Import validator for Pydantic v1 (always needed since we removed conditional logic)
+from pydantic import validator
+from typing_extensions import ClassVar
+
+from datahub.api.entities.external.external_tag import ExternalTag
+from datahub.api.entities.external.restricted_text import RestrictedText
+
+
+class UnityCatalogTagKeyText(RestrictedText):
+    """RestrictedText configured for Unity Catalog tag keys."""
+
+    DEFAULT_MAX_LENGTH: ClassVar[int] = 255
+    # Unity Catalog tag keys: forbidden characters based on constraints
+    DEFAULT_FORBIDDEN_CHARS: ClassVar[Set[str]] = {
+        "\t",
+        "\n",
+        "\r",
+        ".",
+        ",",
+        "-",
+        "=",
+        "/",
+        ":",
+    }
+    DEFAULT_REPLACEMENT_CHAR: ClassVar[str] = "_"
+    DEFAULT_TRUNCATION_SUFFIX: ClassVar[str] = ""  # No suffix for clean identifiers
+
+
+class UnityCatalogTagValueText(RestrictedText):
+    """RestrictedText configured for Unity Catalog tag values."""
+
+    DEFAULT_MAX_LENGTH: ClassVar[int] = 1000
+    # Unity Catalog tag values are more permissive but still have some restrictions
+    DEFAULT_FORBIDDEN_CHARS: ClassVar[Set[str]] = {"\t", "\n", "\r"}
+    DEFAULT_REPLACEMENT_CHAR: ClassVar[str] = " "
+    DEFAULT_TRUNCATION_SUFFIX: ClassVar[str] = "..."
+
+
+class UnityCatalogTag(ExternalTag):
+    """
+    A tag type specifically designed for Unity Catalog tag restrictions.
+
+    Unity Catalog Tag Restrictions:
+    - Key: Max 127 characters, alphanumeric + hyphens, underscores, periods only
+    - Value: Max 256 characters, more permissive but no control characters
+    """
+
+    key: UnityCatalogTagKeyText
+    value: Optional[UnityCatalogTagValueText] = None
+
+    # Pydantic v1 validators
+    @validator("key", pre=True)
+    @classmethod
+    def _validate_key(cls, v: Any) -> UnityCatalogTagKeyText:
+        """Validate and convert key field for Pydantic v1."""
+        if isinstance(v, UnityCatalogTagKeyText):
+            return v
+
+        # If we get a RestrictedText object from parent class validation, use its raw_text value
+        if hasattr(v, "raw_text"):
+            return UnityCatalogTagKeyText(raw_text=v.raw_text)
+
+        return UnityCatalogTagKeyText(raw_text=v)
+
+    @validator("value", pre=True)
+    @classmethod
+    def _validate_value(cls, v: Any) -> Optional[UnityCatalogTagValueText]:
+        """Validate and convert value field for Pydantic v1."""
+        if v is None:
+            return None
+
+        if isinstance(v, UnityCatalogTagValueText):
+            return v
+
+        # If we get a RestrictedText object from parent class validation, use its raw_text value
+        if hasattr(v, "raw_text"):
+            text_value = v.raw_text
+            # If value is an empty string, set it to None to not generate empty value in DataHub tag
+            if not str(text_value):
+                return None
+            return UnityCatalogTagValueText(raw_text=text_value)
+
+        # If value is an empty string, set it to None to not generate empty value in DataHub tag
+        if not str(v):
+            return None
+
+        return UnityCatalogTagValueText(raw_text=v)
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality based on key and value."""
+        if not isinstance(other, UnityCatalogTag):
+            return False
+        return str(self.key) == str(other.key) and (
+            str(self.value) if self.value else None
+        ) == (str(other.value) if other.value else None)
+
+    def __hash__(self) -> int:
+        """Make UnityCatalogTag hashable based on key and value."""
+        return hash((str(self.key), str(self.value) if self.value else None))
+
+    @classmethod
+    def from_dict(cls, tag_dict: Dict[str, Any]) -> "UnityCatalogTag":
+        """
+        Create a UnityCatalogTag from a dictionary with 'key' and optional 'value'.
+
+        Args:
+            tag_dict: Dictionary with 'key' and optional 'value' keys
+
+        Returns:
+            UnityCatalogTag instance
+        """
+        return cls(**tag_dict)
+
+    @classmethod
+    def from_key_value(cls, key: str, value: Optional[str] = None) -> "UnityCatalogTag":
+        """
+        Create a UnityCatalogTag from explicit key and value.
+
+        Overrides the parent method to return the correct type.
+
+        Args:
+            key: Tag key
+            value: Optional tag value
+
+        Returns:
+            UnityCatalogTag instance
+        """
+        return cls(key=key, value=value)
+
+    def to_dict(self) -> Dict[str, str]:
+        """
+        Convert to dictionary format suitable for Unity Catalog API.
+
+        Returns:
+            Dictionary with 'key' and optionally 'value'
+        """
+        result: Dict[str, str] = {"key": self.key.raw_text}
+        if self.value is not None:
+            result["value"] = self.value.raw_text
+        return result
+
+    def to_display_dict(self) -> Dict[str, str]:
+        """
+        Convert to dictionary format showing processed values.
+
+        Returns:
+            Dictionary with processed 'key' and optional 'value'
+        """
+        result: Dict[str, str] = {"key": str(self.key)}
+        if self.value is not None:
+            result["value"] = str(self.value)
+        return result
+
+    def __repr__(self) -> str:
+        if self.value:
+            return f"UnityCatalogTag(key={self.key!r}, value={self.value!r})"
+        else:
+            return f"UnityCatalogTag(key={self.key!r})"

datahub/api/entities/forms/forms.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import List, Optional, Union
 
 import yaml
-from pydantic import validator
+from pydantic import Field, validator
 from ruamel.yaml import YAML
 from typing_extensions import Literal
 
@@ -67,7 +67,7 @@ class Prompt(ConfigModel):
     description: Optional[str] = None
     type: str
     structured_property_id: Optional[str] = None
-    structured_property_urn: Optional[str] = None
+    structured_property_urn: Optional[str] = Field(default=None, validate_default=True)
     required: Optional[bool] = None
 
     @validator("structured_property_urn", pre=True, always=True)
@@ -111,7 +111,7 @@ class Actors(ConfigModel):
 
 class Forms(ConfigModel):
     id: Optional[str] = None
-    urn: Optional[str] = None
+    urn: Optional[str] = Field(default=None, validate_default=True)
     name: str
     description: Optional[str] = None
     prompts: List[Prompt] = []