acryl-datahub 0.15.0.1rc11__py3-none-any.whl → 0.15.0.1rc12__py3-none-any.whl

datahub/metadata/_urns/urn_defs.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 
 class StructuredPropertyUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "structuredProperty"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -43,8 +43,8 @@ class StructuredPropertyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "StructuredPropertyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"StructuredPropertyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"StructuredPropertyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -71,7 +71,7 @@ if TYPE_CHECKING:
 
 class DataTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataType"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -88,8 +88,8 @@ class DataTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -116,7 +116,7 @@ if TYPE_CHECKING:
 
 class CorpGroupUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "corpGroup"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -133,8 +133,8 @@ class CorpGroupUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "CorpGroupUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"CorpGroupUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"CorpGroupUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -166,7 +166,7 @@ if TYPE_CHECKING:
 
 class GlobalSettingsUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "globalSettings"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -183,8 +183,8 @@ class GlobalSettingsUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "GlobalSettingsUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"GlobalSettingsUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"GlobalSettingsUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -211,7 +211,7 @@ if TYPE_CHECKING:
 
 class SchemaFieldUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "schemaField"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, parent: str, field_path: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -232,8 +232,8 @@ class SchemaFieldUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "SchemaFieldUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"SchemaFieldUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"SchemaFieldUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(parent=entity_ids[0], field_path=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -264,7 +264,7 @@ if TYPE_CHECKING:
 
 class DataHubStepStateUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubStepState"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -281,8 +281,8 @@ class DataHubStepStateUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubStepStateUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubStepStateUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubStepStateUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -309,7 +309,7 @@ if TYPE_CHECKING:
 
 class CorpUserUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "corpuser"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, username: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -326,8 +326,8 @@ class CorpUserUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "CorpUserUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"CorpUserUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"CorpUserUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(username=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -359,7 +359,7 @@ if TYPE_CHECKING:
 
 class DataHubConnectionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubConnection"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -376,8 +376,8 @@ class DataHubConnectionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubConnectionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubConnectionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubConnectionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -404,7 +404,7 @@ if TYPE_CHECKING:
 
 class DashboardUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dashboard"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, dashboard_tool: str, dashboard_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -426,8 +426,8 @@ class DashboardUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DashboardUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DashboardUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DashboardUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(dashboard_tool=entity_ids[0], dashboard_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -458,7 +458,7 @@ if TYPE_CHECKING:
 
 class DataHubRoleUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubRole"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -475,8 +475,8 @@ class DataHubRoleUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRoleUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubRoleUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRoleUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -503,7 +503,7 @@ if TYPE_CHECKING:
 
 class DataHubExecutionRequestUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubExecutionRequest"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -520,8 +520,8 @@ class DataHubExecutionRequestUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubExecutionRequestUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubExecutionRequestUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubExecutionRequestUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -548,7 +548,7 @@ if TYPE_CHECKING:
 
 class DataProcessInstanceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataProcessInstance"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -565,8 +565,8 @@ class DataProcessInstanceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProcessInstanceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProcessInstanceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProcessInstanceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -602,7 +602,7 @@ if TYPE_CHECKING:
 
 class DataJobUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataJob"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, flow: str, job_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -623,8 +623,8 @@ class DataJobUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataJobUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataJobUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataJobUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(flow=entity_ids[0], job_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -666,7 +666,7 @@ if TYPE_CHECKING:
 
 class DataFlowUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataFlow"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, orchestrator: str, flow_id: str, cluster: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -693,8 +693,8 @@ class DataFlowUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataFlowUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataFlowUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataFlowUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(orchestrator=entity_ids[0], flow_id=entity_ids[1], cluster=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -755,7 +755,7 @@ if TYPE_CHECKING:
 
 class DataPlatformUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataPlatform"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, platform_name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -774,8 +774,8 @@ class DataPlatformUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataPlatformUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataPlatformUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataPlatformUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform_name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -807,7 +807,7 @@ if TYPE_CHECKING:
 
 class TagUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "tag"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -824,8 +824,8 @@ class TagUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "TagUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"TagUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"TagUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -857,7 +857,7 @@ if TYPE_CHECKING:
 
 class NotebookUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "notebook"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, notebook_tool: str, notebook_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -879,8 +879,8 @@ class NotebookUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "NotebookUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"NotebookUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"NotebookUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(notebook_tool=entity_ids[0], notebook_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -919,7 +919,7 @@ if TYPE_CHECKING:
 
 class DataHubAccessTokenUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubAccessToken"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -936,8 +936,8 @@ class DataHubAccessTokenUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubAccessTokenUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubAccessTokenUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubAccessTokenUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -964,7 +964,7 @@ if TYPE_CHECKING:
 
 class ErModelRelationshipUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "erModelRelationship"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -981,8 +981,8 @@ class ErModelRelationshipUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ErModelRelationshipUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ErModelRelationshipUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ErModelRelationshipUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1009,7 +1009,7 @@ if TYPE_CHECKING:
 
 class OwnershipTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "ownershipType"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1026,8 +1026,8 @@ class OwnershipTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "OwnershipTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"OwnershipTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"OwnershipTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1054,7 +1054,7 @@ if TYPE_CHECKING:
 
 class QueryUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "query"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1071,8 +1071,8 @@ class QueryUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "QueryUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"QueryUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"QueryUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1099,7 +1099,7 @@ if TYPE_CHECKING:
 
 class AssertionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "assertion"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, assertion_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1116,8 +1116,8 @@ class AssertionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "AssertionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"AssertionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"AssertionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(assertion_id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1144,7 +1144,7 @@ if TYPE_CHECKING:
 
 class DataContractUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataContract"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1161,8 +1161,8 @@ class DataContractUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataContractUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataContractUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataContractUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1189,7 +1189,7 @@ if TYPE_CHECKING:
 
 class DataHubPolicyUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubPolicy"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1206,8 +1206,8 @@ class DataHubPolicyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubPolicyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubPolicyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubPolicyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1234,7 +1234,7 @@ if TYPE_CHECKING:
 
 class DataHubActionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubAction"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1251,8 +1251,8 @@ class DataHubActionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubActionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubActionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubActionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1279,7 +1279,7 @@ if TYPE_CHECKING:
 
 class ContainerUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "container"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, guid: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1296,8 +1296,8 @@ class ContainerUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ContainerUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ContainerUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ContainerUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(guid=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1324,7 +1324,7 @@ if TYPE_CHECKING:
 
 class DataProcessUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataProcess"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, name: str, orchestrator: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1352,8 +1352,8 @@ class DataProcessUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProcessUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProcessUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProcessUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], orchestrator=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1388,7 +1388,7 @@ if TYPE_CHECKING:
 
 class DataHubViewUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubView"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1405,8 +1405,8 @@ class DataHubViewUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubViewUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubViewUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubViewUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1433,7 +1433,7 @@ if TYPE_CHECKING:
 
 class DataPlatformInstanceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataPlatformInstance"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, platform: str, instance: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1455,8 +1455,8 @@ class DataPlatformInstanceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataPlatformInstanceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataPlatformInstanceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataPlatformInstanceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], instance=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -1487,7 +1487,7 @@ if TYPE_CHECKING:
 
 class RoleUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "role"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1504,8 +1504,8 @@ class RoleUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "RoleUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"RoleUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"RoleUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1532,7 +1532,7 @@ if TYPE_CHECKING:
 
 class FormUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "form"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1549,8 +1549,8 @@ class FormUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "FormUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"FormUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"FormUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1577,7 +1577,7 @@ if TYPE_CHECKING:
 
 class MlFeatureUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlFeature"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, feature_namespace: str, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1599,8 +1599,8 @@ class MlFeatureUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlFeatureUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlFeatureUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlFeatureUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(feature_namespace=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -1631,7 +1631,7 @@ if TYPE_CHECKING:
 
 class PostUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "post"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1648,8 +1648,8 @@ class PostUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "PostUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"PostUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"PostUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -1676,7 +1676,7 @@ if TYPE_CHECKING:
 
 class DatasetUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataset"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1704,8 +1704,8 @@ class DatasetUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DatasetUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DatasetUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DatasetUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1769,7 +1769,7 @@ if TYPE_CHECKING:
 
 class MlModelUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlModel"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1797,8 +1797,8 @@ class MlModelUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1833,7 +1833,7 @@ if TYPE_CHECKING:
 
 class MlPrimaryKeyUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlPrimaryKey"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, feature_namespace: str, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1855,8 +1855,8 @@ class MlPrimaryKeyUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlPrimaryKeyUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlPrimaryKeyUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlPrimaryKeyUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(feature_namespace=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -1887,7 +1887,7 @@ if TYPE_CHECKING:
 
 class MlModelDeploymentUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlModelDeployment"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1915,8 +1915,8 @@ class MlModelDeploymentUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelDeploymentUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelDeploymentUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelDeploymentUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -1951,7 +1951,7 @@ if TYPE_CHECKING:
 
 class MlFeatureTableUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlFeatureTable"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, platform: str, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -1973,8 +1973,8 @@ class MlFeatureTableUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlFeatureTableUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlFeatureTableUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlFeatureTableUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2005,7 +2005,7 @@ if TYPE_CHECKING:
 
 class DataHubUpgradeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubUpgrade"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2022,8 +2022,8 @@ class DataHubUpgradeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubUpgradeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubUpgradeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubUpgradeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2050,7 +2050,7 @@ if TYPE_CHECKING:
 
 class GlossaryNodeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "glossaryNode"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2067,8 +2067,8 @@ class GlossaryNodeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "GlossaryNodeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"GlossaryNodeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"GlossaryNodeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2095,7 +2095,7 @@ if TYPE_CHECKING:
 
 class DataHubPersonaUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubPersona"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2112,8 +2112,8 @@ class DataHubPersonaUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubPersonaUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubPersonaUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubPersonaUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2140,7 +2140,7 @@ if TYPE_CHECKING:
 
 class DataHubSecretUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubSecret"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2157,8 +2157,8 @@ class DataHubSecretUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubSecretUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubSecretUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubSecretUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2185,7 +2185,7 @@ if TYPE_CHECKING:
 
 class DataHubIngestionSourceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubIngestionSource"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2202,8 +2202,8 @@ class DataHubIngestionSourceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubIngestionSourceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubIngestionSourceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubIngestionSourceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2230,7 +2230,7 @@ if TYPE_CHECKING:
 
 class DataHubRetentionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubRetention"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, entity_name: str, aspect_name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2252,8 +2252,8 @@ class DataHubRetentionUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataHubRetentionUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataHubRetentionUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataHubRetentionUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(entity_name=entity_ids[0], aspect_name=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2284,7 +2284,7 @@ if TYPE_CHECKING:
 
 class TestUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "test"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2301,8 +2301,8 @@ class TestUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "TestUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"TestUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"TestUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2329,7 +2329,7 @@ if TYPE_CHECKING:
 
 class ChartUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "chart"
-    URN_PARTS: ClassVar[int] = 2
+    _URN_PARTS: ClassVar[int] = 2
 
     def __init__(self, dashboard_tool: str, chart_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2351,8 +2351,8 @@ class ChartUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "ChartUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"ChartUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"ChartUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(dashboard_tool=entity_ids[0], chart_id=entity_ids[1], _allow_coercion=False)
 
     @classmethod
@@ -2383,7 +2383,7 @@ if TYPE_CHECKING:
 
 class MlModelGroupUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "mlModelGroup"
-    URN_PARTS: ClassVar[int] = 3
+    _URN_PARTS: ClassVar[int] = 3
 
     def __init__(self, platform: str, name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2411,8 +2411,8 @@ class MlModelGroupUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "MlModelGroupUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"MlModelGroupUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"MlModelGroupUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(platform=entity_ids[0], name=entity_ids[1], env=entity_ids[2], _allow_coercion=False)
 
     @classmethod
@@ -2447,7 +2447,7 @@ if TYPE_CHECKING:
 
 class TelemetryUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "telemetry"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2464,8 +2464,8 @@ class TelemetryUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "TelemetryUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"TelemetryUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"TelemetryUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2492,7 +2492,7 @@ if TYPE_CHECKING:
 
 class DomainUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "domain"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2509,8 +2509,8 @@ class DomainUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DomainUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DomainUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DomainUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2542,7 +2542,7 @@ if TYPE_CHECKING:
 
 class IncidentUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "incident"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2559,8 +2559,8 @@ class IncidentUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "IncidentUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"IncidentUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"IncidentUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2587,7 +2587,7 @@ if TYPE_CHECKING:
 
 class GlossaryTermUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "glossaryTerm"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2604,8 +2604,8 @@ class GlossaryTermUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "GlossaryTermUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"GlossaryTermUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"GlossaryTermUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(name=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2632,7 +2632,7 @@ if TYPE_CHECKING:
 
 class InviteTokenUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "inviteToken"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2649,8 +2649,8 @@ class InviteTokenUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "InviteTokenUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"InviteTokenUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"InviteTokenUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2677,7 +2677,7 @@ if TYPE_CHECKING:
 
 class PlatformResourceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "platformResource"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2694,8 +2694,8 @@ class PlatformResourceUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "PlatformResourceUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"PlatformResourceUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"PlatformResourceUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2722,7 +2722,7 @@ if TYPE_CHECKING:
 
 class EntityTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "entityType"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2739,8 +2739,8 @@ class EntityTypeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "EntityTypeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"EntityTypeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"EntityTypeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2767,7 +2767,7 @@ if TYPE_CHECKING:
 
 class DataProductUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataProduct"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2784,8 +2784,8 @@ class DataProductUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "DataProductUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"DataProductUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"DataProductUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod
@@ -2812,7 +2812,7 @@ if TYPE_CHECKING:
 
 class BusinessAttributeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "businessAttribute"
-    URN_PARTS: ClassVar[int] = 1
+    _URN_PARTS: ClassVar[int] = 1
 
     def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
@@ -2829,8 +2829,8 @@ class BusinessAttributeUrn(_SpecificUrn):
 
     @classmethod
     def _parse_ids(cls, entity_ids: List[str]) -> "BusinessAttributeUrn":
-        if len(entity_ids) != cls.URN_PARTS:
-            raise InvalidUrnError(f"BusinessAttributeUrn should have {cls.URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
+        if len(entity_ids) != cls._URN_PARTS:
+            raise InvalidUrnError(f"BusinessAttributeUrn should have {cls._URN_PARTS} parts, got {len(entity_ids)}: {entity_ids}")
         return cls(id=entity_ids[0], _allow_coercion=False)
 
     @classmethod