dara-core 1.15.6a1__py3-none-any.whl → 1.16.0__py3-none-any.whl

dara/core/interactivity/actions.py

@@ -35,13 +35,14 @@ from typing import (
     Optional,
     TypeVar,
     Union,
+    cast,
     overload,
 )
 
 import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from pandas import DataFrame
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 from typing_extensions import deprecated
 
 from dara.core.base_definitions import (
@@ -49,7 +50,6 @@ from dara.core.base_definitions import (
     ActionImpl,
     ActionResolverDef,
     AnnotatedAction,
-    TemplateMarker,
 )
 from dara.core.interactivity.data_variable import DataVariable
 from dara.core.internal.download import generate_download_code
@@ -72,8 +72,7 @@ class ActionInputs(BaseModel):
     Base class for all action inputs
     """
 
-    class Config:
-        extra = 'allow'
+    model_config = ConfigDict(extra='allow')
 
 
 class ActionContext(BaseModel):
@@ -96,7 +95,7 @@ class ComponentActionContext(ActionContext):
     ActionContext for actions that only require component value
     """
 
-    inputs: ComponentActionInputs
+    inputs: ComponentActionInputs   # type: ignore
 
 
 class UpdateVariableImpl(ActionImpl):
@@ -161,7 +160,7 @@ class UpdateVariableInputs(ActionInputs):
 
 
 class UpdateVariableContext(ActionContext):
-    inputs: UpdateVariableInputs
+    inputs: UpdateVariableInputs   # type: ignore
 
 
 @deprecated('Use @action or `UpdateVariableImpl` for simple cases')
@@ -236,16 +235,16 @@ class UpdateVariable(AnnotatedAction):
     ```
     """
 
-    Ctx = UpdateVariableContext
+    Ctx: ClassVar[type[UpdateVariableContext]] = UpdateVariableContext
 
     variable: Union[Variable, DataVariable, UrlVariable]
-    extras: Optional[List[Union[AnyVariable, TemplateMarker]]]
+    extras: Optional[List[AnyVariable]]
 
     def __init__(
         self,
         resolver: Callable[[UpdateVariableContext], Any],
         variable: Union[Variable, DataVariable, UrlVariable],
-        extras: Optional[List[Union[AnyVariable, TemplateMarker]]] = None,
+        extras: Optional[List[AnyVariable]] = None,
     ):
         """
         :param resolver: a function to resolve the new value for the variable.  Takes one arguments: containing a context of type `Updatevariable.Ctx`
@@ -253,7 +252,8 @@ class UpdateVariable(AnnotatedAction):
         :param extras: any extra variables to resolve and pass to the resolution function context
         """
 
-        async def _update(ctx: action.Ctx, **kwargs):
+        async def _update(ctx: action.Ctx, **kwargs):   # type: ignore
+            ctx = cast(ActionCtx, ctx)   # type: ignore
             old = kwargs.pop('old')
             extras = [kwargs[f'kwarg_{idx}'] for idx in range(len(kwargs))]
             old_ctx = UpdateVariableContext(inputs=UpdateVariableInputs(old=old, new=ctx.input), extras=extras)
@@ -371,7 +371,7 @@ class NavigateToImpl(ActionImpl):
 
     py_name = 'NavigateTo'
 
-    url: Optional[str]
+    url: Optional[str] = None
     new_tab: bool
 
 
@@ -426,7 +426,8 @@ def NavigateTo(
         return NavigateToImpl(url=url, new_tab=new_tab)
 
     # Otherwise create a new @action with the provided resolver
-    async def _navigate(ctx: action.Ctx, **kwargs):
+    async def _navigate(ctx: action.Ctx, **kwargs):   # type: ignore
+        ctx = cast(ActionCtx, ctx)   # type: ignore
         extras = [kwargs[f'kwarg_{idx}'] for idx in range(len(kwargs))]
         old_ctx = ComponentActionContext(inputs=ComponentActionInputs(value=ctx.input), extras=extras)
         result = await run_user_handler(url, args=(old_ctx,))   # type: ignore
@@ -573,8 +574,8 @@ class Notify(ActionImpl):
     status: NotificationStatus
     title: str
 
-    Status = NotificationStatus
-    Ctx = ComponentActionContext
+    Status: ClassVar[type[NotificationStatus]] = NotificationStatus
+    Ctx: ClassVar[type[ComponentActionContext]] = ComponentActionContext
     """@deprecated retained for backwards compatibility, to be removed in 2.0"""
 
 
@@ -660,7 +661,8 @@ def DownloadContent(
     ```
     """
 
-    async def _download(ctx: action.Ctx, **kwargs):
+    async def _download(ctx: action.Ctx, **kwargs):   # type: ignore
+        ctx = cast(ActionCtx, ctx)   # type: ignore
         extras = [kwargs[f'kwarg_{idx}'] for idx in range(len(kwargs))]
         old_ctx = ComponentActionContext(inputs=ComponentActionInputs(value=ctx.input), extras=extras)
         result = await run_user_handler(resolver, args=(old_ctx,))
@@ -725,7 +727,7 @@ class DownloadVariable(ActionImpl):
 @deprecated('Use @action instead')
 def SideEffect(
     function: Callable[[ComponentActionContext], Any],
-    extras: Optional[List[Union[AnyVariable, TemplateMarker]]] = None,
+    extras: Optional[List[AnyVariable]] = None,
     block: bool = False,
 ):
     """
@@ -765,7 +767,8 @@ def SideEffect(
     ```
     """
 
-    async def _effect(ctx: action.Ctx, **kwargs):
+    async def _effect(ctx: action.Ctx, **kwargs):   # type: ignore
+        ctx = cast(ActionCtx, ctx)   # type: ignore
         extras = [kwargs[f'kwarg_{idx}'] for idx in range(len(kwargs))]
         old_ctx = ComponentActionContext(inputs=ComponentActionInputs(value=ctx.input), extras=extras)
         # Simply run the user handler
@@ -1274,7 +1277,7 @@ class action:
     ```
     """
 
-    Ctx: ClassVar = ActionCtx
+    Ctx: ClassVar[type[ActionContext]] = ActionContext
 
     def __init__(self, func: Callable[..., Any]):
         from dara.core.internal.execute_action import execute_action
@@ -1337,7 +1340,7 @@ class action:
         ...
 
     @overload
-    def __call__(self, *args: Any, **kwargs: Any) -> AnnotatedAction:
+    def __call__(self, *args: Any, **kwargs: Any) -> AnnotatedAction:   # type: ignore
         ...
 
     def __call__(self, *args, **kwargs) -> Union[AnnotatedAction, Any]:

dara/core/interactivity/any_data_variable.py

@@ -22,6 +22,7 @@ from typing import Any, Awaitable, Callable, Literal, Optional, TypedDict, Union
 
 import pandas
 from fastapi import UploadFile
+from pydantic import ConfigDict
 
 from dara.core.base_definitions import CachedRegistryEntry, UploadResolverDef
 from dara.core.interactivity.any_variable import AnyVariable
@@ -73,10 +74,7 @@ class DataVariableRegistryEntry(CachedRegistryEntry):
 
     get_schema: Callable[..., Awaitable[DataFrameSchema]]
     """Handler to get the schema for data variable. Defaults to DataVariable.get_schema for type=plain, and DerivedDataVariable.get_schema for type=derived"""
-
-    class Config:
-        extra = 'forbid'
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)
 
 
 async def upload(data: UploadFile, data_uid: Optional[str] = None, resolver_id: Optional[str] = None):

dara/core/interactivity/any_variable.py

@@ -27,10 +27,12 @@ from typing import Any, Callable, Dict, Optional, Set
 
 import anyio
 from fastapi.encoders import jsonable_encoder
-from pydantic import BaseModel
+from pydantic import ConfigDict
 
 from dara.core.auth.definitions import SESSION_ID, USER, UserData
-from dara.core.base_definitions import BaseTask, PendingTask
+from dara.core.base_definitions import BaseTask
+from dara.core.base_definitions import DaraBaseModel as BaseModel
+from dara.core.base_definitions import PendingTask
 from dara.core.interactivity.condition import Condition, Operator
 from dara.core.internal.cache_store import CacheStore
 from dara.core.internal.tasks import TaskManager
@@ -275,6 +277,8 @@ class AnyVariable(BaseModel, abc.ABC):
     Base class for all variables. Used for typing to specify that any variable can be provided.
     """
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     uid: str
 
     def __init__(self, uid: Optional[str] = None, **kwargs) -> None:
@@ -328,6 +332,10 @@ class AnyVariable(BaseModel, abc.ABC):
         assert_no_context('ctx.reset')
         return ResetVariables(variables=[self])
 
+    @classmethod
+    def isinstance(cls, obj: Any) -> bool:
+        return isinstance(obj, cls)
+
     async def get_current_value(self, timeout: float = 3) -> Any:
         """
         Retrieve the current value of the variable for the current user

dara/core/interactivity/condition.py

@@ -18,11 +18,9 @@ limitations under the License.
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, ClassVar, Union
 
-from pydantic import BaseModel
-
-from dara.core.base_definitions import TemplateMarker
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 
 # Type-only imports
 if TYPE_CHECKING:
@@ -39,13 +37,12 @@ class Operator(Enum):
     TRUTHY = 'truthy'
 
 
+OperatorType = type[Operator]
+
+
 class Condition(BaseModel):
     operator: Operator
     other: Union[BaseModel, int, float, str, bool, None, AnyVariable]
-    variable: Union[AnyVariable, TemplateMarker]
-
-    Operator = Operator
+    variable: AnyVariable
 
-    class Config:
-        # This makes it properly check the union type rather than coercing to variable type
-        smart_union = True
+    Operator: ClassVar[OperatorType] = Operator

dara/core/interactivity/data_variable.py

@@ -23,7 +23,12 @@ from typing import Optional, Union, cast
 from anyio.abc import TaskGroup
 from pandas import DataFrame
 from pandas.io.json._table_schema import build_table_schema
-from pydantic import BaseModel
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    SerializerFunctionWrapHandler,
+    model_serializer,
+)
 
 from dara.core.base_definitions import BaseCachePolicy, Cache, CacheArgType
 from dara.core.interactivity.any_data_variable import (
@@ -67,11 +72,7 @@ class DataVariable(AnyDataVariable):
     uid: str
     filters: Optional[FilterQuery] = None
     cache: Optional[BaseCachePolicy] = None
-
-    class Config:
-        extra = 'forbid'
-        arbitrary_types_allowed = True
-        use_enum_values = True
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True, use_enum_values=True)
 
     def __init__(
         self,
@@ -304,8 +305,9 @@ class DataVariable(AnyDataVariable):
 
         return UpdateVariableImpl(variable=self, value=value)
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
         if 'data' in parent_dict:
             parent_dict.pop('data')   # make sure data is not included in the serialised dict
         return {**parent_dict, '__typename': 'DataVariable', 'uid': str(parent_dict['uid'])}
@@ -319,7 +321,4 @@ class DataStoreEntry(BaseModel):
 
     data: Optional[DataFrame] = None
     path: Optional[str] = None
-
-    class Config:
-        extra = 'forbid'
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)

dara/core/interactivity/derived_data_variable.py

@@ -23,6 +23,7 @@ from uuid import uuid4
 
 from pandas import DataFrame
 from pandas.io.json._table_schema import build_table_schema
+from pydantic import ConfigDict, SerializerFunctionWrapHandler, model_serializer
 
 from dara.core.base_definitions import (
     BaseTask,
@@ -66,11 +67,9 @@ class DerivedDataVariable(AnyDataVariable, DerivedVariable):
     uid: str
     filters: Optional[FilterQuery] = None
     variables: List[AnyVariable]
-    polling_interval: Optional[int]
-    deps: Optional[List[AnyVariable]]
-
-    class Config:
-        extra = 'forbid'
+    polling_interval: Optional[int] = None
+    deps: Optional[List[AnyVariable]] = None
+    model_config = ConfigDict(extra='forbid')
 
     def __init__(
         self,
@@ -365,8 +364,9 @@ class DerivedDataVariable(AnyDataVariable, DerivedVariable):
 
         return await cls.get_data(dv_entry, data_entry, dv_result['cache_key'], store, filters)
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
         # nested is not supported for DerivedDataVariable so remove from serialised form
         # it's included because we inherit from DV which has the field
         parent_dict.pop('nested')

dara/core/interactivity/derived_variable.py

@@ -24,15 +24,22 @@ from typing import (
     Any,
     Awaitable,
     Callable,
-    Dict,
     Generic,
     List,
     Optional,
     TypeVar,
     Union,
+    cast,
 )
 
-from pydantic import validator
+from pydantic import (
+    ConfigDict,
+    Field,
+    SerializerFunctionWrapHandler,
+    ValidationInfo,
+    field_validator,
+    model_serializer,
+)
 from typing_extensions import TypedDict
 
 from dara.core.base_definitions import (
@@ -76,13 +83,10 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
     cache: Optional[BaseCachePolicy]
     variables: List[AnyVariable]
     polling_interval: Optional[int]
-    deps: Optional[List[AnyVariable]]
+    deps: Optional[List[AnyVariable]] = Field(validate_default=True)
     nested: List[str] = []
     uid: str
-
-    class Config:
-        extra = 'forbid'
-        use_enum_values = True
+    model_config = ConfigDict(extra='forbid', use_enum_values=True)
 
     def __init__(
         self,
@@ -130,7 +134,7 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
         # Explicitly disallow run_as_task within a Jupyter environment
         if run_as_task:
             try:
-                from IPython import get_ipython
+                from IPython import get_ipython  # type: ignore
             except ImportError:
                 pass
             else:
@@ -164,20 +168,20 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
             ),
         )
 
-    @validator('deps', pre=True, always=True)
+    @field_validator('deps', mode='before')
     @classmethod
-    def validate_deps(cls, deps: Any, values: Dict) -> List[AnyVariable]:
+    def validate_deps(cls, deps: Any, info: ValidationInfo) -> List[AnyVariable]:
         """
         If deps is not specified, set deps to include all variables used
         """
         if deps is None:
             # This will always be set on the variable with the type verified by pydantic
-            return values.get('variables')   # type: ignore
+            return cast(List[AnyVariable], info.data.get('variables'))
 
         return deps
 
     def get(self, key: str):
-        return self.copy(update={'nested': [*self.nested, key]}, deep=True)
+        return self.model_copy(update={'nested': [*self.nested, key]}, deep=True)
 
     def trigger(self, force: bool = True):
         """
@@ -479,8 +483,9 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
                 return True
         return False
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
         return {**parent_dict, '__typename': 'DerivedVariable', 'uid': str(parent_dict['uid'])}
 
 
@@ -492,9 +497,7 @@ class DerivedVariableRegistryEntry(CachedRegistryEntry):
     polling_interval: Optional[int]
     get_value: Callable[..., Awaitable[Any]]
     """Handler to get the value of the derived variable. Defaults to DerivedVariable.get_value, should match the signature"""
-
-    class Config:
-        extra = 'forbid'
+    model_config = ConfigDict(extra='forbid')
 
 
 class LatestValueRegistryEntry(CachedRegistryEntry):

dara/core/interactivity/filtering.py

@@ -86,7 +86,7 @@ FilterQuery = Union[ClauseQuery, ValueQuery]
 Filter query to be applied
 """
 
-ClauseQuery.update_forward_refs()
+ClauseQuery.model_rebuild()
 
 
 def coerce_to_filter_query(filters: Union[ClauseQuery, ValueQuery, dict, None]) -> Optional[FilterQuery]:

dara/core/interactivity/plain_variable.py

@@ -21,12 +21,34 @@ from contextlib import contextmanager
 from contextvars import ContextVar
 from typing import Any, Callable, Generic, List, Optional, TypeVar
 
+from pydantic import (
+    ConfigDict,
+    SerializerFunctionWrapHandler,
+    field_serializer,
+    model_serializer,
+)
+
 from dara.core.interactivity.derived_data_variable import DerivedDataVariable
 from dara.core.interactivity.derived_variable import DerivedVariable
 from dara.core.interactivity.non_data_variable import NonDataVariable
 from dara.core.internal.utils import call_async
+from dara.core.logging import dev_logger
 from dara.core.persistence import PersistenceStore
 
+
+def _is_subclass_safe(value: type, base: type) -> bool:
+    """
+    Check if a class is a subclass of another class. Returns False if the value is not a class.
+
+    :param value: the class to check
+    :param base: the class to check against
+    """
+    try:
+        return issubclass(value, base)
+    except TypeError:
+        return False
+
+
 VARIABLE_INIT_OVERRIDE = ContextVar[Optional[Callable[[dict], dict]]]('VARIABLE_INIT_OVERRIDE', default=None)
 
 VariableType = TypeVar('VariableType')
@@ -38,14 +60,12 @@ class Variable(NonDataVariable, Generic[VariableType]):
     A Variable represents a dynamic value in the system that can be read and written to by components and actions
     """
 
-    default: Optional[VariableType]
+    default: Optional[VariableType] = None
     persist_value: bool = False
     store: Optional[PersistenceStore] = None
     uid: str
     nested: List[str] = []
-
-    class Config:
-        extra = 'forbid'
+    model_config = ConfigDict(extra='forbid')
 
     def __init__(
         self,
@@ -53,6 +73,7 @@ class Variable(NonDataVariable, Generic[VariableType]):
         persist_value: Optional[bool] = False,
         uid: Optional[str] = None,
         store: Optional[PersistenceStoreType_co] = None,
+        nested: Optional[List[str]] = None,
     ):
         """
         A Variable represents a dynamic value in the system that can be read and written to by components and actions
@@ -62,6 +83,8 @@ class Variable(NonDataVariable, Generic[VariableType]):
         :param uid: the unique identifier for this variable; if not provided a random one is generated
         :param store: a persistence store to attach to the variable; modifies where the source of truth for the variable is
         """
+        if nested is None:
+            nested = []
         kwargs = {'default': default, 'persist_value': persist_value, 'uid': uid, 'store': store}
 
         # If an override is active, run the kwargs through it
@@ -78,6 +101,29 @@ class Variable(NonDataVariable, Generic[VariableType]):
         if self.store:
             call_async(self.store.init, self)
 
+    @field_serializer('default', mode='wrap')
+    def serialize_default(self, default: Any, nxt: SerializerFunctionWrapHandler):
+        """
+        Handle serializing the default value of the Variable using the registry of encoders.
+        This ensures that users can define a serializer with config.add_encoder and it will be used
+        when serializing the Variable.default.
+        """
+        from dara.core.internal.encoder_registry import encoder_registry
+
+        default_type = type(default)
+
+        try:
+            for encoder_type, encoder in encoder_registry.items():
+                if default_type is encoder_type or _is_subclass_safe(default_type, encoder_type):
+                    return encoder['serialize'](default)
+        except Exception as e:
+            dev_logger.error(
+                f'Error serializing default value of Variable {self.uid}, falling back to default serialization',
+                error=e,
+            )
+
+        return nxt(default)
+
     @staticmethod
     @contextmanager
     def init_override(override: Callable[[dict], dict]):
@@ -229,7 +275,8 @@ class Variable(NonDataVariable, Generic[VariableType]):
 
         return cls(default=other)   # type: ignore
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
 
         return {**parent_dict, '__typename': 'Variable', 'uid': str(parent_dict['uid'])}

dara/core/interactivity/url_variable.py

@@ -19,6 +19,8 @@ from __future__ import annotations
 
 from typing import Any, Generic, Optional, TypeVar
 
+from pydantic import ConfigDict, SerializerFunctionWrapHandler, model_serializer
+
 from dara.core.interactivity.non_data_variable import NonDataVariable
 
 VariableType = TypeVar('VariableType')
@@ -31,12 +33,10 @@ class UrlVariable(NonDataVariable, Generic[VariableType]):
     pages as you switch from one to the other.
     """
 
-    default: Optional[VariableType]
+    default: Optional[VariableType] = None
     query: str
     uid: str
-
-    class Config:
-        extra = 'forbid'
+    model_config = ConfigDict(extra='forbid')
 
     def __init__(self, query: str, default: Optional[VariableType] = None, uid: Optional[str] = None):
         """
@@ -130,6 +130,7 @@ class UrlVariable(NonDataVariable, Generic[VariableType]):
         assert_no_context('ctx.update')
         return UpdateVariableImpl(variable=self, value=value)
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
         return {**parent_dict, '__typename': 'UrlVariable', 'uid': str(parent_dict['uid'])}

dara/core/internal/download.py

@@ -36,7 +36,7 @@ class DownloadDataEntry(BaseModel):
     uid: str
     file_path: str
     cleanup_file: bool
-    identity_name: Optional[str]
+    identity_name: Optional[str] = None
     download: Callable[['DownloadDataEntry'], Awaitable[Tuple[anyio.AsyncFile, Callable[..., Awaitable]]]]
     """Handler for getting the file from the entry"""
 

dara/core/internal/encoder_registry.py

@@ -193,6 +193,20 @@ encoder_registry: MutableMapping[Type[Any], Encoder] = {
     ),
 }
 
+try:
+    # technically you can use dara core without this package
+    from cai_causal_graph import CausalGraph, Skeleton
+except ImportError:
+    # If the import fails, we don't need to register the encoders for these types
+    pass
+else:
+    encoder_registry.update(
+        {
+            CausalGraph: Encoder(serialize=lambda x: x.to_dict(), deserialize=lambda x: CausalGraph.from_dict(x)),
+            Skeleton: Encoder(serialize=lambda x: x.to_dict(), deserialize=lambda x: Skeleton.from_dict(x)),
+        }
+    )
+
 
 def deserialize(value: Any, typ: Optional[Type]):
     """

dara/core/internal/hashing.py

@@ -29,7 +29,7 @@ def hash_object(obj: Union[BaseModel, dict, None]):
     :param object: object to create a hash for
     """
     if isinstance(obj, BaseModel):
-        obj = obj.dict()
+        obj = obj.model_dump()
 
     filter_hash = hashlib.sha1(
         usedforsecurity=False

dara/core/internal/normalization.py

@@ -68,27 +68,6 @@ class ReferrableWithFilters(Referrable):
     filters: dict
 
 
-def _has_template_marker(obj: Any) -> bool:
-    """
-    Check if an object has a TemplateMarker
-    anywhere in its data
-    """
-    if isinstance(obj, dict):
-        if obj.get('__typename') == 'TemplateMarker':
-            return True
-
-        for val in obj.values():
-            if _has_template_marker(val):
-                return True
-
-    if isinstance(obj, list):
-        for item in obj:
-            if _has_template_marker(item):
-                return True
-
-    return False
-
-
 def _get_identifier(obj: Referrable) -> str:
     """
     Get a unique identifier from a 'referrable' object
@@ -112,15 +91,12 @@ def _get_identifier(obj: Referrable) -> str:
 def _is_referrable(obj: Any) -> TypeGuard[Referrable]:
     """
     Check if a dict is a Referrable type with a '__typename' field and 'uid'
-
-    Bails out if the object has a TemplateMarker
     """
     return (
         isinstance(obj, dict)
         and '__typename' in obj
         and 'Variable' in obj['__typename']  # Right now this is meant for Variable objects only
         and 'uid' in obj
-        and not _has_template_marker(obj)
     )