prefect-client 3.1.9__py3-none-any.whl → 3.1.11__py3-none-any.whl

prefect/context.py

@@ -9,21 +9,10 @@ For more user-accessible information about the current run, see [`prefect.runtim
 import os
 import sys
 import warnings
+from collections.abc import AsyncGenerator, Generator, Mapping
 from contextlib import ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar, Token
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncGenerator,
-    Dict,
-    Generator,
-    Mapping,
-    Optional,
-    Set,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, TypeVar, Union
 
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
 from typing_extensions import Self
@@ -58,13 +47,8 @@ if TYPE_CHECKING:
     from prefect.flows import Flow
     from prefect.tasks import Task
 
-# Define the global settings context variable
-# This will be populated downstream but must be null here to facilitate loading the
-# default settings.
-GLOBAL_SETTINGS_CONTEXT = None  # type: ignore
-
 
-def serialize_context() -> Dict[str, Any]:
+def serialize_context() -> dict[str, Any]:
     """
     Serialize the current context for use in a remote execution environment.
     """
@@ -84,9 +68,9 @@ def serialize_context() -> Dict[str, Any]:
 
 @contextmanager
 def hydrated_context(
-    serialized_context: Optional[Dict[str, Any]] = None,
+    serialized_context: Optional[dict[str, Any]] = None,
     client: Union[PrefectClient, SyncPrefectClient, None] = None,
-):
+) -> Generator[None, Any, None]:
     with ExitStack() as stack:
         if serialized_context:
             # Set up settings context
@@ -123,10 +107,15 @@ class ContextModel(BaseModel):
     a context manager
     """
 
+    if TYPE_CHECKING:
+        # subclasses can pass through keyword arguments to the pydantic base model
+        def __init__(self, **kwargs: Any) -> None:
+            ...
+
     # The context variable for storing data must be defined by the child class
-    __var__: ContextVar[Self]
+    __var__: ClassVar[ContextVar[Self]]
     _token: Optional[Token[Self]] = PrivateAttr(None)
-    model_config = ConfigDict(
+    model_config: ClassVar[ConfigDict] = ConfigDict(
         arbitrary_types_allowed=True,
         extra="forbid",
     )
@@ -139,7 +128,7 @@ class ContextModel(BaseModel):
         self._token = self.__var__.set(self)
         return self
 
-    def __exit__(self, *_):
+    def __exit__(self, *_: Any) -> None:
         if not self._token:
             raise RuntimeError(
                 "Asymmetric use of context. Context exit called without an enter."
@@ -148,13 +137,13 @@ class ContextModel(BaseModel):
         self._token = None
 
     @classmethod
-    def get(cls: Type[Self]) -> Optional[Self]:
+    def get(cls: type[Self]) -> Optional[Self]:
         """Get the current context instance"""
         return cls.__var__.get(None)
 
     def model_copy(
         self: Self, *, update: Optional[Mapping[str, Any]] = None, deep: bool = False
-    ):
+    ) -> Self:
         """
         Duplicate the context model, optionally choosing which fields to include, exclude, or change.
 
@@ -173,7 +162,7 @@ class ContextModel(BaseModel):
         new._token = None
         return new
 
-    def serialize(self, include_secrets: bool = True) -> Dict[str, Any]:
+    def serialize(self, include_secrets: bool = True) -> dict[str, Any]:
         """
         Serialize the context model to a dictionary that can be pickled with cloudpickle.
         """
@@ -202,19 +191,19 @@ class SyncClientContext(ContextModel):
         assert c1 is ctx.client
     """
 
-    __var__: ContextVar[Self] = ContextVar("sync-client-context")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("sync-client-context")
     client: SyncPrefectClient
     _httpx_settings: Optional[dict[str, Any]] = PrivateAttr(None)
     _context_stack: int = PrivateAttr(0)
 
-    def __init__(self, httpx_settings: Optional[dict[str, Any]] = None):
+    def __init__(self, httpx_settings: Optional[dict[str, Any]] = None) -> None:
         super().__init__(
-            client=get_client(sync_client=True, httpx_settings=httpx_settings),  # type: ignore[reportCallIssue]
+            client=get_client(sync_client=True, httpx_settings=httpx_settings),
         )
         self._httpx_settings = httpx_settings
         self._context_stack = 0
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         self._context_stack += 1
         if self._context_stack == 1:
             self.client.__enter__()
@@ -223,20 +212,20 @@ class SyncClientContext(ContextModel):
         else:
             return self
 
-    def __exit__(self, *exc_info: Any):
+    def __exit__(self, *exc_info: Any) -> None:
         self._context_stack -= 1
         if self._context_stack == 0:
-            self.client.__exit__(*exc_info)  # type: ignore[reportUnknownMemberType]
-            return super().__exit__(*exc_info)  # type: ignore[reportUnknownMemberType]
+            self.client.__exit__(*exc_info)
+            return super().__exit__(*exc_info)
 
     @classmethod
     @contextmanager
-    def get_or_create(cls) -> Generator["SyncClientContext", None, None]:
-        ctx = SyncClientContext.get()
+    def get_or_create(cls) -> Generator[Self, None, None]:
+        ctx = cls.get()
         if ctx:
             yield ctx
         else:
-            with SyncClientContext() as ctx:
+            with cls() as ctx:
                 yield ctx
 
 
@@ -260,14 +249,14 @@ class AsyncClientContext(ContextModel):
         assert c1 is ctx.client
     """
 
-    __var__ = ContextVar("async-client-context")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("async-client-context")
     client: PrefectClient
     _httpx_settings: Optional[dict[str, Any]] = PrivateAttr(None)
     _context_stack: int = PrivateAttr(0)
 
     def __init__(self, httpx_settings: Optional[dict[str, Any]] = None):
         super().__init__(
-            client=get_client(sync_client=False, httpx_settings=httpx_settings),  # type: ignore[reportCallIssue]
+            client=get_client(sync_client=False, httpx_settings=httpx_settings)
         )
         self._httpx_settings = httpx_settings
         self._context_stack = 0
@@ -284,8 +273,8 @@ class AsyncClientContext(ContextModel):
     async def __aexit__(self: Self, *exc_info: Any) -> None:
         self._context_stack -= 1
         if self._context_stack == 0:
-            await self.client.__aexit__(*exc_info)  # type: ignore[reportUnknownMemberType]
-            return super().__exit__(*exc_info)  # type: ignore[reportUnknownMemberType]
+            await self.client.__aexit__(*exc_info)
+            return super().__exit__(*exc_info)
 
     @classmethod
     @asynccontextmanager
@@ -308,16 +297,16 @@ class RunContext(ContextModel):
         client: The Prefect client instance being used for API communication
     """
 
-    def __init__(self, *args: Any, **kwargs: Any):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
         start_client_metrics_server()
 
     start_time: DateTime = Field(default_factory=lambda: DateTime.now("UTC"))
-    input_keyset: Optional[Dict[str, Dict[str, str]]] = None
+    input_keyset: Optional[dict[str, dict[str, str]]] = None
     client: Union[PrefectClient, SyncPrefectClient]
 
-    def serialize(self: Self, include_secrets: bool = True) -> Dict[str, Any]:
+    def serialize(self: Self, include_secrets: bool = True) -> dict[str, Any]:
         return self.model_dump(
             include={"start_time", "input_keyset"},
             exclude_unset=True,
@@ -344,7 +333,7 @@ class EngineContext(RunContext):
     flow_run: Optional[FlowRun] = None
     task_runner: TaskRunner[Any]
     log_prints: bool = False
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
 
     # Flag signaling if the flow run context has been serialized and sent
     # to remote infrastructure.
@@ -355,10 +344,10 @@ class EngineContext(RunContext):
     persist_result: bool = Field(default_factory=get_default_persist_setting)
 
     # Counter for task calls allowing unique
-    task_run_dynamic_keys: Dict[str, Union[str, int]] = Field(default_factory=dict)
+    task_run_dynamic_keys: dict[str, Union[str, int]] = Field(default_factory=dict)
 
     # Counter for flow pauses
-    observed_flow_pauses: Dict[str, int] = Field(default_factory=dict)
+    observed_flow_pauses: dict[str, int] = Field(default_factory=dict)
 
     # Tracking for result from task runs in this flow run for dependency tracking
     # Holds the ID of the object returned by the task run and task run state
@@ -367,9 +356,9 @@ class EngineContext(RunContext):
     # Events worker to emit events
     events: Optional[EventsWorker] = None
 
-    __var__: ContextVar[Self] = ContextVar("flow_run")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("flow_run")
 
-    def serialize(self: Self, include_secrets: bool = True) -> Dict[str, Any]:
+    def serialize(self: Self, include_secrets: bool = True) -> dict[str, Any]:
         return self.model_dump(
             include={
                 "flow_run",
@@ -403,15 +392,15 @@ class TaskRunContext(RunContext):
     task: "Task[Any, Any]"
     task_run: TaskRun
     log_prints: bool = False
-    parameters: Dict[str, Any]
+    parameters: dict[str, Any]
 
     # Result handling
     result_store: ResultStore
     persist_result: bool = Field(default_factory=get_default_persist_setting_for_tasks)
 
-    __var__ = ContextVar("task_run")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("task_run")
 
-    def serialize(self: Self, include_secrets: bool = True) -> Dict[str, Any]:
+    def serialize(self: Self, include_secrets: bool = True) -> dict[str, Any]:
         return self.model_dump(
             include={
                 "task_run",
@@ -437,14 +426,14 @@ class TagsContext(ContextModel):
         current_tags: A set of current tags in the context
     """
 
-    current_tags: Set[str] = Field(default_factory=set)
+    current_tags: set[str] = Field(default_factory=set)
 
     @classmethod
-    def get(cls) -> "TagsContext":
+    def get(cls) -> Self:
         # Return an empty `TagsContext` instead of `None` if no context exists
-        return cls.__var__.get(TagsContext())
+        return cls.__var__.get(cls())
 
-    __var__: ContextVar[Self] = ContextVar("tags")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("tags")
 
 
 class SettingsContext(ContextModel):
@@ -461,15 +450,21 @@ class SettingsContext(ContextModel):
     profile: Profile
     settings: Settings
 
-    __var__: ContextVar[Self] = ContextVar("settings")
+    __var__: ClassVar[ContextVar[Self]] = ContextVar("settings")
 
     def __hash__(self: Self) -> int:
         return hash(self.settings)
 
     @classmethod
-    def get(cls) -> "SettingsContext":
+    def get(cls) -> Optional["SettingsContext"]:
         # Return the global context instead of `None` if no context exists
-        return super().get() or GLOBAL_SETTINGS_CONTEXT
+        try:
+            return super().get() or GLOBAL_SETTINGS_CONTEXT
+        except NameError:
+            # GLOBAL_SETTINGS_CONTEXT has not yet been set; in order to create
+            # it profiles need to be loaded, and that process calls
+            # SettingsContext.get().
+            return None
 
 
 def get_run_context() -> Union[FlowRunContext, TaskRunContext]:
@@ -512,7 +507,7 @@ def get_settings_context() -> SettingsContext:
 
 
 @contextmanager
-def tags(*new_tags: str) -> Generator[Set[str], None, None]:
+def tags(*new_tags: str) -> Generator[set[str], None, None]:
     """
     Context manager to add tags to flow and task run calls.
 
@@ -570,10 +565,10 @@ def tags(*new_tags: str) -> Generator[Set[str], None, None]:
 
 @contextmanager
 def use_profile(
-    profile: Union[Profile, str, Any],
+    profile: Union[Profile, str],
     override_environment_variables: bool = False,
     include_current_context: bool = True,
-):
+) -> Generator[SettingsContext, Any, None]:
     """
     Switch to a profile for the duration of this context.
 
@@ -595,11 +590,12 @@ def use_profile(
         profiles = prefect.settings.load_profiles()
         profile = profiles[profile]
 
-    if not isinstance(profile, Profile):
-        raise TypeError(
-            f"Unexpected type {type(profile).__name__!r} for `profile`. "
-            "Expected 'str' or 'Profile'."
-        )
+    if not TYPE_CHECKING:
+        if not isinstance(profile, Profile):
+            raise TypeError(
+                f"Unexpected type {type(profile).__name__!r} for `profile`. "
+                "Expected 'str' or 'Profile'."
+            )
 
     # Create a copy of the profiles settings as we will mutate it
     profile_settings = profile.settings.copy()
@@ -620,7 +616,7 @@ def use_profile(
         yield ctx
 
 
-def root_settings_context():
+def root_settings_context() -> SettingsContext:
     """
     Return the settings context that will exist as the root context for the module.
 
@@ -670,9 +666,9 @@ def root_settings_context():
     # an override in the `SettingsContext.get` method.
 
 
-GLOBAL_SETTINGS_CONTEXT: SettingsContext = root_settings_context()  # type: ignore[reportConstantRedefinition]
+GLOBAL_SETTINGS_CONTEXT: SettingsContext = root_settings_context()
 
 
 # 2024-07-02: This surfaces an actionable error message for removed objects
 # in Prefect 3.0 upgrade.
-__getattr__ = getattr_migration(__name__)
+__getattr__: Callable[[str], Any] = getattr_migration(__name__)

prefect/deployments/base.py

@@ -5,27 +5,19 @@ build system for managing flows and deployments.
 To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
 """
 
-import ast
-import asyncio
-import math
 import os
-import subprocess
-import sys
 from copy import deepcopy
 from pathlib import Path
 from typing import Any, Dict, List, Optional, cast
 
-import anyio
 import yaml
 from ruamel.yaml import YAML
 
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import ConcurrencyLimitStrategy
 from prefect.client.schemas.schedules import IntervalSchedule
-from prefect.logging import get_logger
-from prefect.settings import PREFECT_DEBUG_MODE
-from prefect.utilities.asyncutils import LazySemaphore
-from prefect.utilities.filesystem import create_default_ignore_file, get_open_file_limit
+from prefect.utilities._git import get_git_branch, get_git_remote_origin_url
+from prefect.utilities.filesystem import create_default_ignore_file
 from prefect.utilities.templating import apply_values
 
 
@@ -146,36 +138,6 @@ def configure_project_by_recipe(recipe: str, **formatting_kwargs) -> dict:
     return config
 
 
-def _get_git_remote_origin_url() -> Optional[str]:
-    """
-    Returns the git remote origin URL for the current directory.
-    """
-    try:
-        origin_url = subprocess.check_output(
-            ["git", "config", "--get", "remote.origin.url"],
-            shell=sys.platform == "win32",
-            stderr=subprocess.DEVNULL,
-        )
-        origin_url = origin_url.decode().strip()
-    except subprocess.CalledProcessError:
-        return None
-
-    return origin_url
-
-
-def _get_git_branch() -> Optional[str]:
-    """
-    Returns the git branch for the current directory.
-    """
-    try:
-        branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-        branch = branch.decode().strip()
-    except subprocess.CalledProcessError:
-        return None
-
-    return branch
-
-
 def initialize_project(
     name: Optional[str] = None,
     recipe: Optional[str] = None,
@@ -198,11 +160,11 @@ def initialize_project(
     formatting_kwargs = {"directory": str(Path(".").absolute().resolve())}
     dir_name = os.path.basename(os.getcwd())
 
-    remote_url = _get_git_remote_origin_url()
+    remote_url = get_git_remote_origin_url()
     if remote_url:
         formatting_kwargs["repository"] = remote_url
         is_git_based = True
-        branch = _get_git_branch()
+        branch = get_git_branch()
         formatting_kwargs["branch"] = branch or "main"
 
     formatting_kwargs["name"] = dir_name
@@ -373,105 +335,3 @@ def _save_deployment_to_prefect_file(
 
         with prefect_file.open(mode="w") as f:
             ryaml.dump(parsed_prefect_file_contents, f)
-
-
-# Only allow half of the open file limit to be open at once to allow for other
-# actors to open files.
-OPEN_FILE_SEMAPHORE = LazySemaphore(lambda: math.floor(get_open_file_limit() * 0.5))
-
-
-async def _find_flow_functions_in_file(filename: str) -> List[Dict]:
-    decorator_name = "flow"
-    decorator_module = "prefect"
-    decorated_functions = []
-    async with OPEN_FILE_SEMAPHORE:
-        try:
-            async with await anyio.open_file(filename) as f:
-                try:
-                    tree = ast.parse(await f.read())
-                except SyntaxError:
-                    if PREFECT_DEBUG_MODE:
-                        get_logger().debug(
-                            f"Could not parse {filename} as a Python file. Skipping."
-                        )
-                    return decorated_functions
-        except Exception as exc:
-            if PREFECT_DEBUG_MODE:
-                get_logger().debug(f"Could not open {filename}: {exc}. Skipping.")
-            return decorated_functions
-
-    for node in ast.walk(tree):
-        if isinstance(
-            node,
-            (
-                ast.FunctionDef,
-                ast.AsyncFunctionDef,
-            ),
-        ):
-            for decorator in node.decorator_list:
-                # handles @flow
-                is_name_match = (
-                    isinstance(decorator, ast.Name) and decorator.id == decorator_name
-                )
-                # handles @flow()
-                is_func_name_match = (
-                    isinstance(decorator, ast.Call)
-                    and isinstance(decorator.func, ast.Name)
-                    and decorator.func.id == decorator_name
-                )
-                # handles @prefect.flow
-                is_module_attribute_match = (
-                    isinstance(decorator, ast.Attribute)
-                    and isinstance(decorator.value, ast.Name)
-                    and decorator.value.id == decorator_module
-                    and decorator.attr == decorator_name
-                )
-                # handles @prefect.flow()
-                is_module_attribute_func_match = (
-                    isinstance(decorator, ast.Call)
-                    and isinstance(decorator.func, ast.Attribute)
-                    and decorator.func.attr == decorator_name
-                    and isinstance(decorator.func.value, ast.Name)
-                    and decorator.func.value.id == decorator_module
-                )
-                if is_name_match or is_module_attribute_match:
-                    decorated_functions.append(
-                        {
-                            "flow_name": node.name,
-                            "function_name": node.name,
-                            "filepath": str(filename),
-                        }
-                    )
-                if is_func_name_match or is_module_attribute_func_match:
-                    name_kwarg_node = next(
-                        (kw for kw in decorator.keywords if kw.arg == "name"), None
-                    )
-                    flow_name = (
-                        name_kwarg_node.value.value
-                        if isinstance(name_kwarg_node, ast.Constant)
-                        else node.name
-                    )
-                    decorated_functions.append(
-                        {
-                            "flow_name": flow_name,
-                            "function_name": node.name,
-                            "filepath": str(filename),
-                        }
-                    )
-    return decorated_functions
-
-
-async def _search_for_flow_functions(directory: str = ".") -> List[Dict]:
-    """
-    Search for flow functions in the provided directory. If no directory is provided,
-    the current working directory is used.
-
-    Returns:
-        List[Dict]: the flow name, function name, and filepath of all flow functions found
-    """
-    path = anyio.Path(directory)
-    coros = []
-    async for file in path.rglob("*.py"):
-        coros.append(_find_flow_functions_in_file(file))
-
-    return [fn for file_fns in await asyncio.gather(*coros) for fn in file_fns]

prefect/deployments/flow_runs.py

@@ -10,9 +10,12 @@ from prefect.client.schemas import FlowRun
 from prefect.client.utilities import inject_client
 from prefect.context import FlowRunContext, TaskRunContext
 from prefect.logging import get_logger
-from prefect.results import BaseResult, ResultRecordMetadata
+from prefect.results import ResultRecordMetadata
 from prefect.states import Pending, Scheduled
 from prefect.tasks import Task
+from prefect.telemetry.run_telemetry import (
+    LABELS_TRACEPARENT_KEY,
+)
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.slugify import slugify
 
@@ -22,7 +25,6 @@ if TYPE_CHECKING:
 
 prefect.client.schemas.StateCreate.model_rebuild(
     _types_namespace={
-        "BaseResult": BaseResult,
         "ResultRecordMetadata": ResultRecordMetadata,
     }
 )
@@ -156,6 +158,13 @@ async def run_deployment(
     else:
         parent_task_run_id = None
 
+    if flow_run_ctx and flow_run_ctx.flow_run:
+        traceparent = flow_run_ctx.flow_run.labels.get(LABELS_TRACEPARENT_KEY)
+    else:
+        traceparent = None
+
+    trace_labels = {LABELS_TRACEPARENT_KEY: traceparent} if traceparent else {}
+
     flow_run = await client.create_flow_run_from_deployment(
         deployment.id,
         parameters=parameters,
@@ -166,6 +175,7 @@ async def run_deployment(
         parent_task_run_id=parent_task_run_id,
         work_queue_name=work_queue_name,
         job_variables=job_variables,
+        labels=trace_labels,
     )
 
     flow_run_id = flow_run.id

prefect/deployments/runner.py

@@ -33,7 +33,7 @@ import importlib
 import tempfile
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Iterable, List, Optional, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable, List, Optional, Union
 from uuid import UUID
 
 from pydantic import (
@@ -41,6 +41,7 @@ from pydantic import (
     ConfigDict,
     Field,
     PrivateAttr,
+    field_validator,
     model_validator,
 )
 from rich.console import Console
@@ -129,7 +130,7 @@ class RunnerDeployment(BaseModel):
             available settings.
     """
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
 
     name: str = Field(..., description="The name of the deployment.")
     flow_name: Optional[str] = Field(
@@ -220,6 +221,13 @@ class RunnerDeployment(BaseModel):
     def entrypoint_type(self) -> EntrypointType:
         return self._entrypoint_type
 
+    @field_validator("name", mode="before")
+    @classmethod
+    def validate_name(cls, value: str) -> str:
+        if value.endswith(".py"):
+            return Path(value).stem
+        return value
+
     @model_validator(mode="after")
     def validate_automation_names(self):
         """Ensure that each trigger has a name for its automation if none is provided."""
@@ -508,7 +516,7 @@ class RunnerDeployment(BaseModel):
             concurrency_options = None
 
         deployment = cls(
-            name=Path(name).stem,
+            name=name,
             flow_name=flow.name,
             schedules=constructed_schedules,
             concurrency_limit=concurrency_limit,

prefect/deployments/steps/pull.py

@@ -50,6 +50,7 @@ async def agit_clone(
     include_submodules: bool = False,
     access_token: Optional[str] = None,
     credentials: Optional["Block"] = None,
+    directories: Optional[list[str]] = None,
 ) -> dict[str, str]:
     """
     Asynchronously clones a git repository into the current working directory.
@@ -81,6 +82,7 @@ async def agit_clone(
         credentials=_credentials,
         branch=branch,
         include_submodules=include_submodules,
+        directories=directories,
     )
 
     await _pull_git_repository_with_retries(storage)
@@ -95,6 +97,7 @@ def git_clone(
     include_submodules: bool = False,
     access_token: Optional[str] = None,
     credentials: Optional["Block"] = None,
+    directories: Optional[list[str]] = None,
 ) -> dict[str, str]:
     """
     Clones a git repository into the current working directory.
@@ -107,6 +110,7 @@ def git_clone(
             the repository will be cloned using the default git credentials
         credentials: a GitHubCredentials, GitLabCredentials, or BitBucketCredentials block can be used to specify the
             credentials to use for cloning the repository.
+        directories: Specify directories you want to be included (uses git sparse-checkout)
 
     Returns:
         dict: a dictionary containing a `directory` key of the new directory that was created
@@ -164,6 +168,14 @@ def git_clone(
             - prefect.deployments.steps.git_clone:
                 repository: git@github.com:org/repo.git
         ```
+
+        Clone a repository using sparse-checkout (allows specific folders of the repository to be checked out)
+        ```yaml
+        pull:
+            - prefect.deployments.steps.git_clone:
+                repository: https://github.com/org/repo.git
+                directories: ["dir_1", "dir_2", "prefect"]
+        ```
     """
     if access_token and credentials:
         raise ValueError(
@@ -177,6 +189,7 @@ def git_clone(
         credentials=_credentials,
         branch=branch,
         include_submodules=include_submodules,
+        directories=directories,
     )
 
     run_coro_as_sync(_pull_git_repository_with_retries(storage))