acryl-datahub 0.15.0.4rc1__py3-none-any.whl → 0.15.0.4rc3__py3-none-any.whl

datahub/metadata/_urns/urn_defs.py

@@ -28,14 +28,25 @@ class StructuredPropertyUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "structuredProperty"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["StructuredPropertyUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = StructuredPropertyUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a StructuredPropertyUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("StructuredPropertyUrn id cannot be empty")
+        if isinstance(id, StructuredPropertyUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a StructuredPropertyUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'StructuredPropertyUrn id contains reserved characters')
 
@@ -73,14 +84,25 @@ class BusinessAttributeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "businessAttribute"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["BusinessAttributeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = BusinessAttributeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a BusinessAttributeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("BusinessAttributeUrn id cannot be empty")
+        if isinstance(id, BusinessAttributeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a BusinessAttributeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'BusinessAttributeUrn id contains reserved characters')
 
@@ -118,14 +140,25 @@ class DataProductUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataProduct"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataProductUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataProductUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataProductUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataProductUrn id cannot be empty")
+        if isinstance(id, DataProductUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataProductUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataProductUrn id contains reserved characters')
 
@@ -163,14 +196,25 @@ class DataTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataType"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataTypeUrn id cannot be empty")
+        if isinstance(id, DataTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataTypeUrn id contains reserved characters')
 
@@ -208,14 +252,25 @@ class PlatformResourceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "platformResource"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["PlatformResourceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = PlatformResourceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a PlatformResourceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("PlatformResourceUrn id cannot be empty")
+        if isinstance(id, PlatformResourceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a PlatformResourceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'PlatformResourceUrn id contains reserved characters')
 
@@ -256,15 +311,14 @@ class MlModelGroupUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelGroupUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelGroupUrn name cannot be empty")
@@ -317,14 +371,25 @@ class DataHubPolicyUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubPolicy"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubPolicyUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubPolicyUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubPolicyUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubPolicyUrn id cannot be empty")
+        if isinstance(id, DataHubPolicyUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubPolicyUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubPolicyUrn id contains reserved characters')
 
@@ -362,14 +427,25 @@ class TagUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "tag"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["TagUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = TagUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TagUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("TagUrn name cannot be empty")
+        if isinstance(name, TagUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a TagUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'TagUrn name contains reserved characters')
 
@@ -415,15 +491,14 @@ class MlModelDeploymentUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelDeploymentUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelDeploymentUrn name cannot be empty")
@@ -476,14 +551,25 @@ class DataHubActionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubAction"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubActionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubActionUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubActionUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubActionUrn id cannot be empty")
+        if isinstance(id, DataHubActionUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubActionUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubActionUrn id contains reserved characters')
 
@@ -521,14 +607,25 @@ class DataHubRoleUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubRole"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubRoleUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubRoleUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubRoleUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubRoleUrn id cannot be empty")
+        if isinstance(id, DataHubRoleUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubRoleUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubRoleUrn id contains reserved characters')
 
@@ -566,14 +663,25 @@ class DataHubUpgradeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubUpgrade"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubUpgradeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubUpgradeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubUpgradeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubUpgradeUrn id cannot be empty")
+        if isinstance(id, DataHubUpgradeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubUpgradeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubUpgradeUrn id contains reserved characters')
 
@@ -611,14 +719,25 @@ class FormUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "form"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["FormUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = FormUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a FormUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("FormUrn id cannot be empty")
+        if isinstance(id, FormUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a FormUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'FormUrn id contains reserved characters')
 
@@ -718,14 +837,25 @@ class DataHubConnectionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubConnection"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubConnectionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubConnectionUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubConnectionUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubConnectionUrn id cannot be empty")
+        if isinstance(id, DataHubConnectionUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubConnectionUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubConnectionUrn id contains reserved characters')
 
@@ -763,14 +893,25 @@ class IncidentUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "incident"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["IncidentUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = IncidentUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a IncidentUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("IncidentUrn id cannot be empty")
+        if isinstance(id, IncidentUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a IncidentUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'IncidentUrn id contains reserved characters')
 
@@ -808,14 +949,25 @@ class RoleUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "role"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["RoleUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = RoleUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a RoleUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("RoleUrn id cannot be empty")
+        if isinstance(id, RoleUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a RoleUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'RoleUrn id contains reserved characters')
 
@@ -853,14 +1005,25 @@ class DomainUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "domain"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DomainUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DomainUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DomainUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DomainUrn id cannot be empty")
+        if isinstance(id, DomainUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DomainUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DomainUrn id contains reserved characters')
 
@@ -903,14 +1066,25 @@ class DataContractUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataContract"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataContractUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataContractUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataContractUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataContractUrn id cannot be empty")
+        if isinstance(id, DataContractUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataContractUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataContractUrn id contains reserved characters')
 
@@ -948,14 +1122,25 @@ class AssertionUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "assertion"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, assertion_id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, assertion_id: Union["AssertionUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            assertion_id = UrnEncoder.encode_string(assertion_id)
+            if isinstance(assertion_id, str):
+                if assertion_id.startswith('urn:li:'):
+                    try:
+                        assertion_id = AssertionUrn.from_string(assertion_id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a AssertionUrn but got {assertion_id}')
+                else:
+                    assertion_id = UrnEncoder.encode_string(assertion_id)
 
         # Validation logic.
         if not assertion_id:
             raise InvalidUrnError("AssertionUrn assertion_id cannot be empty")
+        if isinstance(assertion_id, AssertionUrn):
+            assertion_id = assertion_id.assertion_id
+        elif isinstance(assertion_id, Urn):
+            raise InvalidUrnError(f'Expecting a AssertionUrn but got {assertion_id}')
         if UrnEncoder.contains_reserved_char(assertion_id):
             raise InvalidUrnError(f'AssertionUrn assertion_id contains reserved characters')
 
@@ -996,15 +1181,14 @@ class DatasetUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("DatasetUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("DatasetUrn name cannot be empty")
@@ -1089,12 +1273,20 @@ class DataJobUrn(_SpecificUrn):
     def __init__(self, flow: Union["DataFlowUrn", str], job_id: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
+            if isinstance(flow, str):
+                if flow.startswith('urn:li:'):
+                    try:
+                        flow = DataFlowUrn.from_string(flow)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataFlowUrn but got {flow}')
+                else:
+                    flow = UrnEncoder.encode_string(flow)
             job_id = UrnEncoder.encode_string(job_id)
 
         # Validation logic.
         if not flow:
             raise InvalidUrnError("DataJobUrn flow cannot be empty")
-        flow = str(flow)
+        flow = str(flow)  # convert urn type to str
         assert DataFlowUrn.from_string(flow)
         if not job_id:
             raise InvalidUrnError("DataJobUrn job_id cannot be empty")
@@ -1150,14 +1342,25 @@ class DataHubSecretUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubSecret"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubSecretUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubSecretUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubSecretUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubSecretUrn id cannot be empty")
+        if isinstance(id, DataHubSecretUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubSecretUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubSecretUrn id contains reserved characters')
 
@@ -1195,14 +1398,25 @@ class OwnershipTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "ownershipType"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["OwnershipTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = OwnershipTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a OwnershipTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("OwnershipTypeUrn id cannot be empty")
+        if isinstance(id, OwnershipTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a OwnershipTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'OwnershipTypeUrn id contains reserved characters')
 
@@ -1243,12 +1457,20 @@ class SchemaFieldUrn(_SpecificUrn):
     def __init__(self, parent: Union["Urn", str], field_path: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
+            if isinstance(parent, str):
+                if parent.startswith('urn:li:'):
+                    try:
+                        parent = Urn.from_string(parent)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a Urn but got {parent}')
+                else:
+                    parent = UrnEncoder.encode_string(parent)
             field_path = UrnEncoder.encode_string(field_path)
 
         # Validation logic.
         if not parent:
             raise InvalidUrnError("SchemaFieldUrn parent cannot be empty")
-        parent = str(parent)
+        parent = str(parent)  # convert urn type to str
         assert Urn.from_string(parent)
         if not field_path:
             raise InvalidUrnError("SchemaFieldUrn field_path cannot be empty")
@@ -1296,13 +1518,13 @@ class MlFeatureTableUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], name: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlFeatureTableUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlFeatureTableUrn name cannot be empty")
@@ -1401,14 +1623,25 @@ class TelemetryUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "telemetry"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["TelemetryUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = TelemetryUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TelemetryUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("TelemetryUrn name cannot be empty")
+        if isinstance(name, TelemetryUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a TelemetryUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'TelemetryUrn name contains reserved characters')
 
@@ -1500,14 +1733,25 @@ class DataHubStepStateUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubStepState"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubStepStateUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubStepStateUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubStepStateUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubStepStateUrn id cannot be empty")
+        if isinstance(id, DataHubStepStateUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubStepStateUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubStepStateUrn id contains reserved characters')
 
@@ -1545,14 +1789,25 @@ class DataHubViewUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubView"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubViewUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubViewUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubViewUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubViewUrn id cannot be empty")
+        if isinstance(id, DataHubViewUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubViewUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubViewUrn id contains reserved characters')
 
@@ -1787,14 +2042,25 @@ class CorpUserUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "corpuser"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, username: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, username: Union["CorpUserUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            username = UrnEncoder.encode_string(username)
+            if isinstance(username, str):
+                if username.startswith('urn:li:'):
+                    try:
+                        username = CorpUserUrn.from_string(username)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a CorpUserUrn but got {username}')
+                else:
+                    username = UrnEncoder.encode_string(username)
 
         # Validation logic.
         if not username:
             raise InvalidUrnError("CorpUserUrn username cannot be empty")
+        if isinstance(username, CorpUserUrn):
+            username = username.username
+        elif isinstance(username, Urn):
+            raise InvalidUrnError(f'Expecting a CorpUserUrn but got {username}')
         if UrnEncoder.contains_reserved_char(username):
             raise InvalidUrnError(f'CorpUserUrn username contains reserved characters')
 
@@ -1837,14 +2103,25 @@ class InviteTokenUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "inviteToken"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["InviteTokenUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = InviteTokenUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a InviteTokenUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("InviteTokenUrn id cannot be empty")
+        if isinstance(id, InviteTokenUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a InviteTokenUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'InviteTokenUrn id contains reserved characters')
 
@@ -1882,16 +2159,25 @@ class DataPlatformUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataPlatform"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, platform_name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, platform_name: Union["DataPlatformUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            if platform_name.startswith("urn:li:dataPlatform:"):
-                platform_name = DataPlatformUrn.from_string(platform_name).platform_name
-            platform_name = UrnEncoder.encode_string(platform_name)
+            if isinstance(platform_name, str):
+                if platform_name.startswith('urn:li:'):
+                    try:
+                        platform_name = DataPlatformUrn.from_string(platform_name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataPlatformUrn but got {platform_name}')
+                else:
+                    platform_name = UrnEncoder.encode_string(platform_name)
 
         # Validation logic.
         if not platform_name:
             raise InvalidUrnError("DataPlatformUrn platform_name cannot be empty")
+        if isinstance(platform_name, DataPlatformUrn):
+            platform_name = platform_name.platform_name
+        elif isinstance(platform_name, Urn):
+            raise InvalidUrnError(f'Expecting a DataPlatformUrn but got {platform_name}')
         if UrnEncoder.contains_reserved_char(platform_name):
             raise InvalidUrnError(f'DataPlatformUrn platform_name contains reserved characters')
 
@@ -1934,14 +2220,25 @@ class ContainerUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "container"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, guid: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, guid: Union["ContainerUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            guid = UrnEncoder.encode_string(guid)
+            if isinstance(guid, str):
+                if guid.startswith('urn:li:'):
+                    try:
+                        guid = ContainerUrn.from_string(guid)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ContainerUrn but got {guid}')
+                else:
+                    guid = UrnEncoder.encode_string(guid)
 
         # Validation logic.
         if not guid:
             raise InvalidUrnError("ContainerUrn guid cannot be empty")
+        if isinstance(guid, ContainerUrn):
+            guid = guid.guid
+        elif isinstance(guid, Urn):
+            raise InvalidUrnError(f'Expecting a ContainerUrn but got {guid}')
         if UrnEncoder.contains_reserved_char(guid):
             raise InvalidUrnError(f'ContainerUrn guid contains reserved characters')
 
@@ -1982,13 +2279,13 @@ class DataPlatformInstanceUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], instance: str, *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             instance = UrnEncoder.encode_string(instance)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("DataPlatformInstanceUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not instance:
             raise InvalidUrnError("DataPlatformInstanceUrn instance cannot be empty")
@@ -2033,14 +2330,25 @@ class GlossaryNodeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "glossaryNode"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["GlossaryNodeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = GlossaryNodeUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlossaryNodeUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("GlossaryNodeUrn name cannot be empty")
+        if isinstance(name, GlossaryNodeUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a GlossaryNodeUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'GlossaryNodeUrn name contains reserved characters')
 
@@ -2081,15 +2389,14 @@ class MlModelUrn(_SpecificUrn):
     def __init__(self, platform: Union["DataPlatformUrn", str], name: str, env: str = "PROD", *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            platform = platform.urn() if isinstance(platform, DataPlatformUrn) else DataPlatformUrn(platform).urn()
+            platform = DataPlatformUrn(platform).urn()
             name = UrnEncoder.encode_string(name)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not platform:
             raise InvalidUrnError("MlModelUrn platform cannot be empty")
-        platform = str(platform)
+        platform = str(platform)  # convert urn type to str
         assert DataPlatformUrn.from_string(platform)
         if not name:
             raise InvalidUrnError("MlModelUrn name cannot be empty")
@@ -2142,14 +2449,25 @@ class TestUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "test"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["TestUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = TestUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a TestUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("TestUrn id cannot be empty")
+        if isinstance(id, TestUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a TestUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'TestUrn id contains reserved characters')
 
@@ -2187,14 +2505,25 @@ class PostUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "post"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["PostUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = PostUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a PostUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("PostUrn id cannot be empty")
+        if isinstance(id, PostUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a PostUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'PostUrn id contains reserved characters')
 
@@ -2232,14 +2561,25 @@ class GlossaryTermUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "glossaryTerm"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["GlossaryTermUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = GlossaryTermUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlossaryTermUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("GlossaryTermUrn name cannot be empty")
+        if isinstance(name, GlossaryTermUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a GlossaryTermUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'GlossaryTermUrn name contains reserved characters')
 
@@ -2277,14 +2617,25 @@ class ErModelRelationshipUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "erModelRelationship"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["ErModelRelationshipUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = ErModelRelationshipUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a ErModelRelationshipUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("ErModelRelationshipUrn id cannot be empty")
+        if isinstance(id, ErModelRelationshipUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a ErModelRelationshipUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'ErModelRelationshipUrn id contains reserved characters')
 
@@ -2322,14 +2673,25 @@ class DataHubExecutionRequestUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubExecutionRequest"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubExecutionRequestUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubExecutionRequestUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubExecutionRequestUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubExecutionRequestUrn id cannot be empty")
+        if isinstance(id, DataHubExecutionRequestUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubExecutionRequestUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubExecutionRequestUrn id contains reserved characters')
 
@@ -2367,14 +2729,25 @@ class QueryUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "query"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["QueryUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = QueryUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a QueryUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("QueryUrn id cannot be empty")
+        if isinstance(id, QueryUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a QueryUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'QueryUrn id contains reserved characters')
 
@@ -2412,14 +2785,25 @@ class DataHubPersonaUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubPersona"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubPersonaUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubPersonaUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubPersonaUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubPersonaUrn id cannot be empty")
+        if isinstance(id, DataHubPersonaUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubPersonaUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubPersonaUrn id contains reserved characters')
 
@@ -2565,14 +2949,25 @@ class DataHubAccessTokenUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubAccessToken"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubAccessTokenUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubAccessTokenUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubAccessTokenUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubAccessTokenUrn id cannot be empty")
+        if isinstance(id, DataHubAccessTokenUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubAccessTokenUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubAccessTokenUrn id contains reserved characters')
 
@@ -2610,14 +3005,25 @@ class DataProcessInstanceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataProcessInstance"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataProcessInstanceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataProcessInstanceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataProcessInstanceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataProcessInstanceUrn id cannot be empty")
+        if isinstance(id, DataProcessInstanceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataProcessInstanceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataProcessInstanceUrn id contains reserved characters')
 
@@ -2664,14 +3070,25 @@ class CorpGroupUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "corpGroup"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, name: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, name: Union["CorpGroupUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            name = UrnEncoder.encode_string(name)
+            if isinstance(name, str):
+                if name.startswith('urn:li:'):
+                    try:
+                        name = CorpGroupUrn.from_string(name)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a CorpGroupUrn but got {name}')
+                else:
+                    name = UrnEncoder.encode_string(name)
 
         # Validation logic.
         if not name:
             raise InvalidUrnError("CorpGroupUrn name cannot be empty")
+        if isinstance(name, CorpGroupUrn):
+            name = name.name
+        elif isinstance(name, Urn):
+            raise InvalidUrnError(f'Expecting a CorpGroupUrn but got {name}')
         if UrnEncoder.contains_reserved_char(name):
             raise InvalidUrnError(f'CorpGroupUrn name contains reserved characters')
 
@@ -2720,7 +3137,6 @@ class DataProcessUrn(_SpecificUrn):
             name = UrnEncoder.encode_string(name)
             orchestrator = UrnEncoder.encode_string(orchestrator)
             env = env.upper()
-            env = UrnEncoder.encode_string(env)
 
         # Validation logic.
         if not name:
@@ -2778,14 +3194,25 @@ class DataHubIngestionSourceUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "dataHubIngestionSource"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["DataHubIngestionSourceUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = DataHubIngestionSourceUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a DataHubIngestionSourceUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("DataHubIngestionSourceUrn id cannot be empty")
+        if isinstance(id, DataHubIngestionSourceUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a DataHubIngestionSourceUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'DataHubIngestionSourceUrn id contains reserved characters')
 
@@ -2823,14 +3250,25 @@ class GlobalSettingsUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "globalSettings"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["GlobalSettingsUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = GlobalSettingsUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a GlobalSettingsUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("GlobalSettingsUrn id cannot be empty")
+        if isinstance(id, GlobalSettingsUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a GlobalSettingsUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'GlobalSettingsUrn id contains reserved characters')
 
@@ -2868,14 +3306,25 @@ class EntityTypeUrn(_SpecificUrn):
     ENTITY_TYPE: ClassVar[str] = "entityType"
     _URN_PARTS: ClassVar[int] = 1
 
-    def __init__(self, id: str, *, _allow_coercion: bool = True) -> None:
+    def __init__(self, id: Union["EntityTypeUrn", str], *, _allow_coercion: bool = True) -> None:
         if _allow_coercion:
             # Field coercion logic (if any is required).
-            id = UrnEncoder.encode_string(id)
+            if isinstance(id, str):
+                if id.startswith('urn:li:'):
+                    try:
+                        id = EntityTypeUrn.from_string(id)
+                    except InvalidUrnError:
+                        raise InvalidUrnError(f'Expecting a EntityTypeUrn but got {id}')
+                else:
+                    id = UrnEncoder.encode_string(id)
 
         # Validation logic.
         if not id:
             raise InvalidUrnError("EntityTypeUrn id cannot be empty")
+        if isinstance(id, EntityTypeUrn):
+            id = id.id
+        elif isinstance(id, Urn):
+            raise InvalidUrnError(f'Expecting a EntityTypeUrn but got {id}')
         if UrnEncoder.contains_reserved_char(id):
             raise InvalidUrnError(f'EntityTypeUrn id contains reserved characters')