prefect 3.6.13__py3-none-any.whl → 3.6.13.dev2__py3-none-any.whl

prefect/results.py

@@ -33,10 +33,7 @@ from typing_extensions import ParamSpec, Self
 import prefect
 import prefect.types._datetime
 from prefect._internal.compatibility.async_dispatch import async_dispatch
-from prefect._internal.compatibility.blocks import (
-    call_explicitly_async_block_method,
-    call_explicitly_sync_block_method,
-)
+from prefect._internal.compatibility.blocks import call_explicitly_async_block_method
 from prefect._internal.concurrency.event_loop import get_running_loop
 from prefect._result_records import R, ResultRecord, ResultRecordMetadata
 from prefect.blocks.core import Block
@@ -55,6 +52,7 @@ from prefect.serializers import Serializer
 from prefect.settings.context import get_current_settings
 from prefect.types import DateTime
 from prefect.utilities.annotations import NotSet
+from prefect.utilities.asyncutils import sync_compatible
 
 if TYPE_CHECKING:
     import logging
@@ -371,7 +369,8 @@ class ResultStore(BaseModel):
         result = await store.aread(metadata.storage_key)
         return result
 
-    async def aupdate_for_flow(self, flow: "Flow[..., Any]") -> Self:
+    @sync_compatible
+    async def update_for_flow(self, flow: "Flow[..., Any]") -> Self:
         """
         Create a new result store for a flow with updated settings.
 
@@ -394,31 +393,8 @@ class ResultStore(BaseModel):
         update["metadata_storage"] = NullFileSystem()
         return self.model_copy(update=update)
 
-    @async_dispatch(aupdate_for_flow)
-    def update_for_flow(self, flow: "Flow[..., Any]") -> Self:
-        """
-        Create a new result store for a flow with updated settings.
-
-        Args:
-            flow: The flow to update the result store for.
-
-        Returns:
-            An updated result store.
-        """
-        update: dict[str, Any] = {}
-        update["cache_result_in_memory"] = flow.cache_result_in_memory
-        if flow.result_storage is not None:
-            update["result_storage"] = resolve_result_storage(
-                flow.result_storage, _sync=True
-            )
-        if flow.result_serializer is not None:
-            update["serializer"] = resolve_serializer(flow.result_serializer)
-        if self.result_storage is None and update.get("result_storage") is None:
-            update["result_storage"] = get_default_result_storage(_sync=True)
-        update["metadata_storage"] = NullFileSystem()
-        return self.model_copy(update=update)
-
-    async def aupdate_for_task(self: Self, task: "Task[P, R]") -> Self:
+    @sync_compatible
+    async def update_for_task(self: Self, task: "Task[P, R]") -> Self:
         """
         Create a new result store for a task.
 
@@ -470,59 +446,6 @@ class ResultStore(BaseModel):
             update["metadata_storage"] = None
         return self.model_copy(update=update)
 
-    @async_dispatch(aupdate_for_task)
-    def update_for_task(self: Self, task: "Task[P, R]") -> Self:
-        """
-        Create a new result store for a task.
-
-        Args:
-            task: The task to update the result store for.
-
-        Returns:
-            An updated result store.
-        """
-        from prefect.transactions import get_transaction
-
-        update: dict[str, Any] = {}
-        update["cache_result_in_memory"] = task.cache_result_in_memory
-        if task.result_storage is not None:
-            update["result_storage"] = resolve_result_storage(
-                task.result_storage, _sync=True
-            )
-        if task.result_serializer is not None:
-            update["serializer"] = resolve_serializer(task.result_serializer)
-        if task.result_storage_key is not None:
-            update["storage_key_fn"] = partial(
-                _format_user_supplied_storage_key, task.result_storage_key
-            )
-
-        # use the lock manager from a parent transaction if it exists
-        if (current_txn := get_transaction()) and isinstance(
-            current_txn.store, ResultStore
-        ):
-            update["lock_manager"] = current_txn.store.lock_manager
-
-        from prefect.cache_policies import CachePolicy
-
-        if isinstance(task.cache_policy, CachePolicy):
-            if task.cache_policy.key_storage is not None:
-                storage = task.cache_policy.key_storage
-                if isinstance(storage, str) and not len(storage.split("/")) == 2:
-                    storage = Path(storage)
-                update["metadata_storage"] = resolve_result_storage(storage, _sync=True)
-            # if the cache policy has a lock manager, it takes precedence over the parent transaction
-            if task.cache_policy.lock_manager is not None:
-                update["lock_manager"] = task.cache_policy.lock_manager
-
-        if self.result_storage is None and update.get("result_storage") is None:
-            update["result_storage"] = get_default_result_storage(_sync=True)
-        if (
-            isinstance(self.metadata_storage, NullFileSystem)
-            and update.get("metadata_storage", NotSet) is NotSet
-        ):
-            update["metadata_storage"] = None
-        return self.model_copy(update=update)
-
     @staticmethod
     def generate_default_holder() -> str:
         """
@@ -544,7 +467,8 @@ class ResultStore(BaseModel):
                 return f"{hostname}:{pid}:{thread_id}:{thread_name}:{id(current_task)}"
         return f"{hostname}:{pid}:{thread_id}:{thread_name}"
 
-    async def _aexists(self, key: str) -> bool:
+    @sync_compatible
+    async def _exists(self, key: str) -> bool:
         """
         Check if a result record exists in storage.
 
@@ -587,49 +511,6 @@ class ResultStore(BaseModel):
             exists = True
         return exists
 
-    def _exists(self, key: str) -> bool:
-        """
-        Check if a result record exists in storage.
-
-        Args:
-            key: The key to check for the existence of a result record.
-
-        Returns:
-            bool: True if the result record exists, False otherwise.
-        """
-        if self.metadata_storage is not None:
-            # TODO: Add an `exists` method to commonly used storage blocks
-            # so the entire payload doesn't need to be read
-            try:
-                metadata_content = call_explicitly_sync_block_method(
-                    self.metadata_storage, "read_path", (key,), {}
-                )
-                if metadata_content is None:
-                    return False
-                metadata = ResultRecordMetadata.load_bytes(metadata_content)
-
-            except Exception:
-                return False
-        else:
-            try:
-                content = call_explicitly_sync_block_method(
-                    self.result_storage, "read_path", (key,), {}
-                )
-                if content is None:
-                    return False
-                record: ResultRecord[Any] = ResultRecord.deserialize(content)
-                metadata = record.metadata
-            except Exception:
-                return False
-
-        if metadata.expiration:
-            # if the result has an expiration,
-            # check if it is still in the future
-            exists = metadata.expiration > prefect.types._datetime.now("UTC")
-        else:
-            exists = True
-        return exists
-
     def exists(self, key: str) -> bool:
         """
         Check if a result record exists in storage.
@@ -640,7 +521,7 @@ class ResultStore(BaseModel):
         Returns:
             bool: True if the result record exists, False otherwise.
         """
-        return self._exists(key=key)
+        return self._exists(key=key, _sync=True)
 
     async def aexists(self, key: str) -> bool:
         """
@@ -652,7 +533,7 @@ class ResultStore(BaseModel):
         Returns:
             bool: True if the result record exists, False otherwise.
         """
-        return await self._aexists(key=key)
+        return await self._exists(key=key, _sync=False)
 
     def _resolved_key_path(self, key: str) -> str:
         if self.result_storage_block_id is None and (
@@ -665,7 +546,8 @@ class ResultStore(BaseModel):
                 return key
         return key
 
-    async def _aread(self, key: str, holder: str) -> "ResultRecord[Any]":
+    @sync_compatible
+    async def _read(self, key: str, holder: str) -> "ResultRecord[Any]":
         """
         Read a result record from storage.
 
@@ -728,69 +610,6 @@ class ResultStore(BaseModel):
             self.cache[resolved_key_path] = result_record
         return result_record
 
-    def _read(self, key: str, holder: str) -> "ResultRecord[Any]":
-        """
-        Read a result record from storage.
-
-        This is the internal implementation. Use `read` or `aread` for synchronous and
-        asynchronous result reading respectively.
-
-        Args:
-            key: The key to read the result record from.
-            holder: The holder of the lock if a lock was set on the record.
-
-        Returns:
-            A result record.
-        """
-
-        if self.lock_manager is not None and not self.is_lock_holder(key, holder):
-            self.wait_for_lock(key)
-
-        resolved_key_path = self._resolved_key_path(key)
-
-        if resolved_key_path in self.cache:
-            return self.cache[resolved_key_path]
-
-        if self.result_storage is None:
-            self.result_storage = get_default_result_storage(_sync=True)
-
-        if self.metadata_storage is not None:
-            metadata_content = call_explicitly_sync_block_method(
-                self.metadata_storage,
-                "read_path",
-                (key,),
-                {},
-            )
-            metadata = ResultRecordMetadata.load_bytes(metadata_content)
-            assert metadata.storage_key is not None, (
-                "Did not find storage key in metadata"
-            )
-            result_content = call_explicitly_sync_block_method(
-                self.result_storage,
-                "read_path",
-                (metadata.storage_key,),
-                {},
-            )
-            result_record: ResultRecord[Any] = (
-                ResultRecord.deserialize_from_result_and_metadata(
-                    result=result_content, metadata=metadata_content
-                )
-            )
-        else:
-            content = call_explicitly_sync_block_method(
-                self.result_storage,
-                "read_path",
-                (key,),
-                {},
-            )
-            result_record: ResultRecord[Any] = ResultRecord.deserialize(
-                content, backup_serializer=self.serializer
-            )
-
-        if self.cache_result_in_memory:
-            self.cache[resolved_key_path] = result_record
-        return result_record
-
     def read(
         self,
         key: str,
@@ -807,7 +626,7 @@ class ResultStore(BaseModel):
             A result record.
         """
         holder = holder or self.generate_default_holder()
-        return self._read(key=key, holder=holder)
+        return self._read(key=key, holder=holder, _sync=True)
 
     async def aread(
         self,
@@ -825,7 +644,7 @@ class ResultStore(BaseModel):
             A result record.
         """
         holder = holder or self.generate_default_holder()
-        return await self._aread(key=key, holder=holder)
+        return await self._read(key=key, holder=holder, _sync=False)
 
     def create_result_record(
         self,
@@ -915,7 +734,8 @@ class ResultStore(BaseModel):
             holder=holder,
         )
 
-    async def _apersist_result_record(
+    @sync_compatible
+    async def _persist_result_record(
         self, result_record: "ResultRecord[Any]", holder: str
     ) -> None:
         """
@@ -978,69 +798,6 @@ class ResultStore(BaseModel):
         if self.cache_result_in_memory:
             self.cache[key] = result_record
 
-    def _persist_result_record(
-        self, result_record: "ResultRecord[Any]", holder: str
-    ) -> None:
-        """
-        Persist a result record to storage.
-
-        Args:
-            result_record: The result record to persist.
-            holder: The holder of the lock if a lock was set on the record.
-        """
-        assert result_record.metadata.storage_key is not None, (
-            "Storage key is required on result record"
-        )
-
-        key = result_record.metadata.storage_key
-        if result_record.metadata.storage_block_id is None:
-            basepath = (
-                _resolve_path("")
-                if (
-                    _resolve_path := getattr(self.result_storage, "_resolve_path", None)
-                )
-                else Path(".").resolve()
-            )
-            base_key = key if basepath is None else str(Path(key).relative_to(basepath))
-        else:
-            base_key = key
-        if (
-            self.lock_manager is not None
-            and self.is_locked(base_key)
-            and not self.is_lock_holder(base_key, holder)
-        ):
-            raise RuntimeError(
-                f"Cannot write to result record with key {base_key} because it is locked by "
-                f"another holder."
-            )
-        if self.result_storage is None:
-            self.result_storage = get_default_result_storage(_sync=True)
-
-        # If metadata storage is configured, write result and metadata separately
-        if self.metadata_storage is not None:
-            call_explicitly_sync_block_method(
-                self.result_storage,
-                "write_path",
-                (result_record.metadata.storage_key,),
-                {"content": result_record.serialize_result()},
-            )
-            call_explicitly_sync_block_method(
-                self.metadata_storage,
-                "write_path",
-                (base_key,),
-                {"content": result_record.serialize_metadata()},
-            )
-        # Otherwise, write the result metadata and result together
-        else:
-            call_explicitly_sync_block_method(
-                self.result_storage,
-                "write_path",
-                (result_record.metadata.storage_key,),
-                {"content": result_record.serialize()},
-            )
-        if self.cache_result_in_memory:
-            self.cache[key] = result_record
-
     def persist_result_record(
         self, result_record: "ResultRecord[Any]", holder: str | None = None
     ) -> None:
@@ -1051,7 +808,9 @@ class ResultStore(BaseModel):
             result_record: The result record to persist.
         """
         holder = holder or self.generate_default_holder()
-        return self._persist_result_record(result_record=result_record, holder=holder)
+        return self._persist_result_record(
+            result_record=result_record, holder=holder, _sync=True
+        )
 
     async def apersist_result_record(
         self, result_record: "ResultRecord[Any]", holder: str | None = None
@@ -1063,8 +822,8 @@ class ResultStore(BaseModel):
             result_record: The result record to persist.
         """
         holder = holder or self.generate_default_holder()
-        return await self._apersist_result_record(
-            result_record=result_record, holder=holder
+        return await self._persist_result_record(
+            result_record=result_record, holder=holder, _sync=False
         )
 
     def supports_isolation_level(self, level: "IsolationLevel") -> bool:

prefect/runner/runner.py

@@ -56,6 +56,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Coroutine,
     Dict,
     Iterable,
     List,
@@ -166,10 +167,9 @@ class Runner:
             query_seconds: The number of seconds to wait between querying for
                 scheduled flow runs; defaults to `PREFECT_RUNNER_POLL_FREQUENCY`
             prefetch_seconds: The number of seconds to prefetch flow runs for.
-            heartbeat_seconds: The number of seconds between heartbeat events emitted
-                by flow runs managed by this runner. If not provided, the value of
-                `PREFECT_FLOWS_HEARTBEAT_FREQUENCY` will be used. Heartbeats are used
-                to detect crashed flow runs.
+            heartbeat_seconds: The number of seconds to wait between emitting
+                flow run heartbeats. The runner will not emit heartbeats if the value is None.
+                Defaults to `PREFECT_RUNNER_HEARTBEAT_FREQUENCY`.
             limit: The maximum number of flow runs this runner should be running at. Provide `None` for no limit.
                 If not provided, the runner will use the value of `PREFECT_RUNNER_PROCESS_LIMIT`.
             pause_on_shutdown: A boolean for whether or not to automatically pause
@@ -202,8 +202,6 @@ class Runner:
                     asyncio.run(runner.start())
                 ```
         """
-        self._heartbeat_seconds = heartbeat_seconds
-
         settings = get_current_settings()
 
         if name and ("/" in name or "%" in name):
@@ -223,6 +221,12 @@ class Runner:
 
         self.query_seconds: float = query_seconds or settings.runner.poll_frequency
         self._prefetch_seconds: float = prefetch_seconds
+        self.heartbeat_seconds: float | None = (
+            heartbeat_seconds or settings.runner.heartbeat_frequency
+        )
+        if self.heartbeat_seconds is not None and self.heartbeat_seconds < 30:
+            raise ValueError("Heartbeat must be 30 seconds or greater.")
+        self._heartbeat_task: asyncio.Task[None] | None = None
         self._events_client: EventsClient = get_events_client(checkpoint_every=1)
 
         self._exit_stack = AsyncExitStack()
@@ -640,6 +644,9 @@ class Runner:
 
             task_status.started(process.pid)
 
+            if self.heartbeat_seconds is not None:
+                await self._emit_flow_run_heartbeat(flow_run)
+
             # Only add the process to the map if it is still running
             # The process may be a multiprocessing.context.SpawnProcess, in which case it will have an `exitcode`` attribute
             # but no `returncode` attribute
@@ -675,11 +682,6 @@ class Runner:
 
         flow_run = FlowRun.model_validate(bundle["flow_run"])
 
-        # Add heartbeat_seconds to env if configured
-        if self._heartbeat_seconds is not None:
-            env = env or {}
-            env["PREFECT_FLOWS_HEARTBEAT_FREQUENCY"] = str(int(self._heartbeat_seconds))
-
         async with context:
             if not self._acquire_limit_slot(flow_run.id):
                 return
@@ -693,6 +695,9 @@ class Runner:
                 await self._propose_crashed_state(flow_run, msg)
                 raise RuntimeError(msg)
 
+            if self.heartbeat_seconds is not None:
+                await self._emit_flow_run_heartbeat(flow_run)
+
             await self._add_flow_run_process_map_entry(
                 flow_run.id, ProcessMapEntry(pid=process.pid, flow_run=flow_run)
             )
@@ -791,14 +796,7 @@ class Runner:
         if flow_run.deployment_id is not None:
             flow = self._deployment_flow_map.get(flow_run.deployment_id)
             if flow:
-                subprocess_env: dict[str, str] = {}
-                if self._heartbeat_seconds is not None:
-                    subprocess_env["PREFECT_FLOWS_HEARTBEAT_FREQUENCY"] = str(
-                        int(self._heartbeat_seconds)
-                    )
-                process = run_flow_in_subprocess(
-                    flow, flow_run=flow_run, env=subprocess_env or None
-                )
+                process = run_flow_in_subprocess(flow, flow_run=flow_run)
                 task_status.started(process)
                 await anyio.to_thread.run_sync(process.join)
                 return process.exitcode
@@ -831,15 +829,6 @@ class Runner:
                     "PREFECT__ENABLE_CANCELLATION_AND_CRASHED_HOOKS": "false",
                 },
                 **({"PREFECT__FLOW_ENTRYPOINT": entrypoint} if entrypoint else {}),
-                **(
-                    {
-                        "PREFECT_FLOWS_HEARTBEAT_FREQUENCY": str(
-                            int(self._heartbeat_seconds)
-                        )
-                    }
-                    if self._heartbeat_seconds is not None
-                    else {}
-                ),
             }
         )
         env.update(**os.environ)  # is this really necessary??
@@ -1060,6 +1049,51 @@ class Runner:
                 flow = None
         return flow, deployment
 
+    async def _emit_flow_run_heartbeats(self):
+        coros: list[Coroutine[Any, Any, Any]] = []
+        for entry in self._flow_run_process_map.values():
+            coros.append(self._emit_flow_run_heartbeat(entry["flow_run"]))
+        await asyncio.gather(*coros)
+
+    async def _emit_flow_run_heartbeat(self, flow_run: "FlowRun"):
+        from prefect import __version__
+
+        related: list[RelatedResource] = []
+        tags: list[str] = []
+
+        flow, deployment = await self._get_flow_and_deployment(flow_run)
+        if deployment:
+            related.append(deployment.as_related_resource())
+            tags.extend(deployment.tags)
+        if flow:
+            related.append(
+                RelatedResource(
+                    {
+                        "prefect.resource.id": f"prefect.flow.{flow.id}",
+                        "prefect.resource.role": "flow",
+                        "prefect.resource.name": flow.name,
+                    }
+                )
+            )
+        tags.extend(flow_run.tags)
+
+        related = [RelatedResource.model_validate(r) for r in related]
+        related += tags_as_related_resources(set(tags))
+
+        await self._events_client.emit(
+            Event(
+                event="prefect.flow-run.heartbeat",
+                resource=Resource(
+                    {
+                        "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
+                        "prefect.resource.name": flow_run.name,
+                        "prefect.version": __version__,
+                    }
+                ),
+                related=related,
+            )
+        )
+
     def _event_resource(self):
         from prefect import __version__
 
@@ -1111,7 +1145,7 @@ class Runner:
                 related=related,
             )
         )
-        self._logger.debug(f"Emitted cancelled-flow-run event for {flow_run.id}")
+        self._logger.debug(f"Emitted flow run heartbeat event for {flow_run.id}")
 
     async def _get_scheduled_flow_runs(
         self,
@@ -1255,6 +1289,9 @@ class Runner:
                     flow_run.id,
                     ProcessMapEntry(pid=readiness_result.pid, flow_run=flow_run),
                 )
+            # Heartbeats are opt-in and only emitted if a heartbeat frequency is set
+            if self.heartbeat_seconds is not None:
+                await self._emit_flow_run_heartbeat(flow_run)
 
             run_logger.info(f"Completed submission of flow run '{flow_run.id}'")
         else:
@@ -1568,6 +1605,15 @@ class Runner:
         if not hasattr(self, "_loops_task_group") or not self._loops_task_group:
             self._loops_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
 
+        if self.heartbeat_seconds is not None:
+            self._heartbeat_task = asyncio.create_task(
+                critical_service_loop(
+                    workload=self._emit_flow_run_heartbeats,
+                    interval=self.heartbeat_seconds,
+                    jitter_range=0.3,
+                )
+            )
+
         self.started = True
         return self
 
@@ -1586,6 +1632,13 @@ class Runner:
         shutil.rmtree(str(self._tmp_dir), ignore_errors=True)
         del self._runs_task_group, self._loops_task_group
 
+        if self._heartbeat_task:
+            self._heartbeat_task.cancel()
+            try:
+                await self._heartbeat_task
+            except asyncio.CancelledError:
+                pass
+
     def __repr__(self) -> str:
         return f"Runner(name={self.name!r})"
 

prefect/runner/storage.py

@@ -346,12 +346,11 @@ class GitRepository:
             )
             existing_repo_url = None
             existing_repo_url = strip_auth_from_url(result.stdout.decode().strip())
-            configured_repo_url = strip_auth_from_url(self._url)
 
-            if existing_repo_url != configured_repo_url:
+            if existing_repo_url != self._url:
                 raise ValueError(
                     f"The existing repository at {str(self.destination)} "
-                    f"does not match the configured repository {configured_repo_url}"
+                    f"does not match the configured repository {self._url}"
                 )
 
             # Sparsely checkout the repository if directories are specified and the repo is not in sparse-checkout mode already

prefect/server/schemas/filters.py

@@ -645,45 +645,6 @@ class FlowRunFilterIdempotencyKey(PrefectFilterBaseModel):
         return filters
 
 
-class FlowRunFilterCreatedBy(PrefectOperatorFilterBaseModel):
-    """Filter by `FlowRun.created_by`."""
-
-    id_: Optional[list[UUID]] = Field(
-        default=None,
-        description="A list of creator IDs to include",
-    )
-    type_: Optional[list[str]] = Field(
-        default=None,
-        description=(
-            "A list of creator types to include. For example, 'DEPLOYMENT' for "
-            "scheduled runs or 'AUTOMATION' for runs triggered by automations."
-        ),
-        examples=[["DEPLOYMENT", "AUTOMATION"]],
-    )
-    is_null_: Optional[bool] = Field(
-        default=None,
-        description="If true, only include flow runs without a creator",
-    )
-
-    def _get_filter_list(
-        self, db: "PrefectDBInterface"
-    ) -> Iterable[sa.ColumnExpressionArgument[bool]]:
-        filters: list[sa.ColumnExpressionArgument[bool]] = []
-        if self.id_ is not None:
-            # JSON stores UUIDs as strings, use astext for text extraction
-            id_strings = [str(id_val) for id_val in self.id_]
-            filters.append(db.FlowRun.created_by["id"].astext.in_(id_strings))
-        if self.type_ is not None:
-            filters.append(db.FlowRun.created_by["type"].astext.in_(self.type_))
-        if self.is_null_ is not None:
-            filters.append(
-                db.FlowRun.created_by.is_(None)
-                if self.is_null_
-                else db.FlowRun.created_by.is_not(None)
-            )
-        return filters
-
-
 class FlowRunFilter(PrefectOperatorFilterBaseModel):
     """Filter flow runs. Only flow runs matching all criteria will be returned"""
 
@@ -730,9 +691,6 @@ class FlowRunFilter(PrefectOperatorFilterBaseModel):
     idempotency_key: Optional[FlowRunFilterIdempotencyKey] = Field(
         default=None, description="Filter criteria for `FlowRun.idempotency_key`"
     )
-    created_by: Optional[FlowRunFilterCreatedBy] = Field(
-        default=None, description="Filter criteria for `FlowRun.created_by`"
-    )
 
     def only_filters_on_id(self) -> bool:
         return bool(
@@ -751,7 +709,6 @@ class FlowRunFilter(PrefectOperatorFilterBaseModel):
             and self.parent_flow_run_id is None
             and self.parent_task_run_id is None
             and self.idempotency_key is None
-            and self.created_by is None
         )
 
     def _get_filter_list(
@@ -787,8 +744,6 @@ class FlowRunFilter(PrefectOperatorFilterBaseModel):
             filters.append(self.parent_task_run_id.as_sql_filter())
         if self.idempotency_key is not None:
             filters.append(self.idempotency_key.as_sql_filter())
-        if self.created_by is not None:
-            filters.append(self.created_by.as_sql_filter())
 
         return filters