prefect-client 3.1.2__tar.gz → 3.1.4__tar.gz

{prefect-client-3.1.2/src/prefect_client.egg-info → prefect-client-3.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.1.2
+Version: 3.1.4
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-client-3.1.2 → prefect-client-3.1.4}/requirements-client.txt

@@ -3,7 +3,7 @@ asgi-lifespan >= 1.0, < 3.0
 cachetools >= 5.3, < 6.0
 cloudpickle >= 2.0, < 4.0
 coolname >= 1.0.4, < 3.0.0
-croniter >= 1.0.12, < 5.0.0
+croniter >= 1.0.12, < 6.0.0
 exceptiongroup >= 1.0.0
 fastapi >= 0.111.0, < 1.0.0
 fsspec >= 2022.5.0
@@ -14,6 +14,7 @@ httpx[http2] >= 0.23, != 0.23.2
 importlib_metadata >= 4.4; python_version < '3.10'
 jsonpatch >= 1.32, < 2.0
 jsonschema >= 4.0.0, < 5.0.0
+opentelemetry-api >= 1.27.0, < 2.0.0
 orjson >= 3.7, < 4.0
 packaging >= 21.3, < 24.3
 pathspec >= 0.8.0

{prefect-client-3.1.2 → prefect-client-3.1.4}/requirements.txt

@@ -12,7 +12,6 @@ graphviz >= 0.20.1
 jinja2 >= 3.0.0, < 4.0.0
 jinja2-humanize-extension >= 0.4.0
 humanize >= 4.9.0, < 5.0.0
-opentelemetry-api >= 1.27.0, < 2.0.0
 pytz >= 2021.1, < 2025
 readchar >= 4.0.0, < 5.0.0
 sqlalchemy[asyncio] >= 2.0, < 3.0.0

prefect-client-3.1.4/src/prefect/_internal/compatibility/async_dispatch.py

@@ -0,0 +1,63 @@
+import asyncio
+import inspect
+from functools import wraps
+from typing import Any, Callable, Coroutine, Optional, TypeVar, Union
+
+from typing_extensions import ParamSpec
+
+from prefect.tasks import Task
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+def is_in_async_context() -> bool:
+    """
+    Returns True if called from within an async context (coroutine or running event loop)
+    """
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
+def _is_acceptable_callable(obj: Union[Callable, Task]) -> bool:
+    if inspect.iscoroutinefunction(obj):
+        return True
+    if isinstance(obj, Task) and inspect.iscoroutinefunction(obj.fn):
+        return True
+    return False
+
+
+def async_dispatch(
+    async_impl: Callable[P, Coroutine[Any, Any, R]],
+) -> Callable[[Callable[P, R]], Callable[P, Union[R, Coroutine[Any, Any, R]]]]:
+    """
+    Decorator that dispatches to either sync or async implementation based on context.
+
+    Args:
+        async_impl: The async implementation to dispatch to when in async context
+    """
+
+    def decorator(
+        sync_fn: Callable[P, R],
+    ) -> Callable[P, Union[R, Coroutine[Any, Any, R]]]:
+        if not _is_acceptable_callable(async_impl):
+            raise TypeError("async_impl must be an async function")
+
+        @wraps(sync_fn)
+        def wrapper(
+            *args: P.args,
+            _sync: Optional[bool] = None,  # type: ignore
+            **kwargs: P.kwargs,
+        ) -> Union[R, Coroutine[Any, Any, R]]:
+            should_run_sync = _sync if _sync is not None else not is_in_async_context()
+
+            if should_run_sync:
+                return sync_fn(*args, **kwargs)
+            return async_impl(*args, **kwargs)
+
+        return wrapper  # type: ignore
+
+    return decorator

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/_internal/schemas/bases.py

@@ -84,9 +84,12 @@ class PrefectBaseModel(BaseModel):
         Returns:
             PrefectBaseModel: A new instance of the model with the reset fields.
         """
+        data = self.model_dump()
         return self.model_copy(
             update={
-                field: self.model_fields[field].get_default(call_default_factory=True)
+                field: self.model_fields[field].get_default(
+                    call_default_factory=True, validated_data=data
+                )
                 for field in self._reset_fields
             }
         )

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-12T13:38:45-0800",
+ "date": "2024-11-20T19:37:35-0600",
  "dirty": true,
  "error": null,
- "full-revisionid": "02b99f0a756f0395e4292952dcb2d963fc839750",
- "version": "3.1.2"
+ "full-revisionid": "78ee41cb26058cc2dfba8aece6a2471ec5ea3675",
+ "version": "3.1.4"
 }
 '''  # END VERSION_JSON
 

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/blocks/notifications.py

@@ -494,6 +494,7 @@ class OpsgenieWebhook(AbstractAppriseNotificationBlock):
                 entity=self.entity,
                 batch=self.batch,
                 tags=self.tags,
+                action="new",
             ).url()
         )
         self._start_apprise_client(url)

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/cache_policies.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional,
 from typing_extensions import Self
 
 from prefect.context import TaskRunContext
+from prefect.exceptions import HashError
 from prefect.utilities.hashing import hash_objects
 
 if TYPE_CHECKING:
@@ -223,7 +224,6 @@ class TaskSource(CachePolicy):
                 lines = task_ctx.task.fn.__code__.co_code
             else:
                 raise
-
         return hash_objects(lines, raise_on_failure=True)
 
 
@@ -293,7 +293,18 @@ class Inputs(CachePolicy):
             if key not in exclude:
                 hashed_inputs[key] = val
 
-        return hash_objects(hashed_inputs, raise_on_failure=True)
+        try:
+            return hash_objects(hashed_inputs, raise_on_failure=True)
+        except HashError as exc:
+            msg = (
+                f"{exc}\n\n"
+                "This often occurs when task inputs contain objects that cannot be cached "
+                "like locks, file handles, or other system resources.\n\n"
+                "To resolve this, you can:\n"
+                "  1. Exclude these arguments by defining a custom `cache_key_fn`\n"
+                "  2. Disable caching by passing `cache_policy=NONE`\n"
+            )
+            raise ValueError(msg) from exc
 
     def __sub__(self, other: str) -> "CachePolicy":
         if not isinstance(other, str):

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/client/cloud.py

@@ -13,7 +13,6 @@ from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.client.schemas.objects import (
     IPAllowlist,
     IPAllowlistMyAccessResponse,
-    KeyValueLabels,
     Workspace,
 )
 from prefect.exceptions import ObjectNotFound, PrefectException
@@ -23,6 +22,7 @@ from prefect.settings import (
     PREFECT_CLOUD_API_URL,
     PREFECT_TESTING_UNIT_TEST_MODE,
 )
+from prefect.types import KeyValueLabels
 
 PARSE_API_URL_REGEX = re.compile(r"accounts/(.{36})/workspaces/(.{36})")
 

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/client/orchestration.py

@@ -3925,13 +3925,13 @@ class SyncPrefectClient:
     def read_flow_runs(
         self,
         *,
-        flow_filter: FlowFilter = None,
-        flow_run_filter: FlowRunFilter = None,
-        task_run_filter: TaskRunFilter = None,
-        deployment_filter: DeploymentFilter = None,
-        work_pool_filter: WorkPoolFilter = None,
-        work_queue_filter: WorkQueueFilter = None,
-        sort: FlowRunSort = None,
+        flow_filter: Optional[FlowFilter] = None,
+        flow_run_filter: Optional[FlowRunFilter] = None,
+        task_run_filter: Optional[TaskRunFilter] = None,
+        deployment_filter: Optional[DeploymentFilter] = None,
+        work_pool_filter: Optional[WorkPoolFilter] = None,
+        work_queue_filter: Optional[WorkQueueFilter] = None,
+        sort: Optional[FlowRunSort] = None,
         limit: Optional[int] = None,
         offset: int = 0,
     ) -> List[FlowRun]:

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/client/schemas/objects.py

@@ -23,9 +23,6 @@ from pydantic import (
     HttpUrl,
     IPvAnyNetwork,
     SerializationInfo,
-    StrictBool,
-    StrictFloat,
-    StrictInt,
     Tag,
     field_validator,
     model_serializer,
@@ -56,6 +53,7 @@ from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.settings import PREFECT_CLOUD_API_URL, PREFECT_CLOUD_UI_URL
 from prefect.types import (
     MAX_VARIABLE_NAME_LENGTH,
+    KeyValueLabels,
     Name,
     NonNegativeInteger,
     PositiveInteger,
@@ -71,8 +69,6 @@ if TYPE_CHECKING:
 
 R = TypeVar("R", default=Any)
 
-KeyValueLabels = dict[str, Union[StrictBool, StrictInt, StrictFloat, str]]
-
 
 DEFAULT_BLOCK_SCHEMA_VERSION = "non-versioned"
 DEFAULT_AGENT_WORK_POOL_NAME = "default-agent-pool"
@@ -497,6 +493,9 @@ class FlowRunPolicy(PrefectBaseModel):
     resuming: Optional[bool] = Field(
         default=False, description="Indicates if this run is resuming from a pause."
     )
+    retry_type: Optional[Literal["in_process", "reschedule"]] = Field(
+        default=None, description="The type of retry this run is undergoing."
+    )
 
     @model_validator(mode="before")
     @classmethod
@@ -560,6 +559,11 @@ class FlowRun(ObjectBaseModel):
         description="A list of tags on the flow run",
         examples=[["tag-1", "tag-2"]],
     )
+    labels: KeyValueLabels = Field(
+        default_factory=dict,
+        description="Prefect Cloud: A dictionary of key-value labels. Values can be strings, numbers, or booleans.",
+        examples=[{"key": "value1", "key2": 42}],
+    )
     parent_task_run_id: Optional[UUID] = Field(
         default=None,
         description=(
@@ -1180,27 +1184,6 @@ class ConcurrencyLimit(ObjectBaseModel):
     )
 
 
-class BlockSchema(ObjectBaseModel):
-    """An ORM representation of a block schema."""
-
-    checksum: str = Field(default=..., description="The block schema's unique checksum")
-    fields: Dict[str, Any] = Field(
-        default_factory=dict, description="The block schema's field schema"
-    )
-    block_type_id: Optional[UUID] = Field(default=..., description="A block type ID")
-    block_type: Optional[BlockType] = Field(
-        default=None, description="The associated block type"
-    )
-    capabilities: List[str] = Field(
-        default_factory=list,
-        description="A list of Block capabilities",
-    )
-    version: str = Field(
-        default=DEFAULT_BLOCK_SCHEMA_VERSION,
-        description="Human readable identifier for the block schema",
-    )
-
-
 class BlockSchemaReference(ObjectBaseModel):
     """An ORM representation of a block schema reference."""
 

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/deployments/runner.py

@@ -77,6 +77,7 @@ from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_UI_URL,
 )
+from prefect.types import ListOfNonEmptyStrings
 from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.callables import ParameterSchema, parameter_schema
@@ -140,7 +141,7 @@ class RunnerDeployment(BaseModel):
     version: Optional[str] = Field(
         default=None, description="An optional version for the deployment."
     )
-    tags: List[str] = Field(
+    tags: ListOfNonEmptyStrings = Field(
         default_factory=list,
         description="One of more tags to apply to this deployment.",
     )

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/events/filters.py

@@ -83,17 +83,18 @@ class EventOccurredFilter(EventDataFilter):
 
 class EventNameFilter(EventDataFilter):
     prefix: Optional[List[str]] = Field(
-        None, description="Only include events matching one of these prefixes"
+        default=None, description="Only include events matching one of these prefixes"
     )
     exclude_prefix: Optional[List[str]] = Field(
-        None, description="Exclude events matching one of these prefixes"
+        default=None, description="Exclude events matching one of these prefixes"
     )
 
     name: Optional[List[str]] = Field(
-        None, description="Only include events matching one of these names exactly"
+        default=None,
+        description="Only include events matching one of these names exactly",
     )
     exclude_name: Optional[List[str]] = Field(
-        None, description="Exclude events matching one of these names exactly"
+        default=None, description="Exclude events matching one of these names exactly"
     )
 
     def includes(self, event: Event) -> bool:
@@ -230,17 +231,20 @@ class EventFilter(EventDataFilter):
         description="Filter criteria for when the events occurred",
     )
     event: Optional[EventNameFilter] = Field(
-        None,
+        default=None,
         description="Filter criteria for the event name",
     )
     any_resource: Optional[EventAnyResourceFilter] = Field(
-        None, description="Filter criteria for any resource involved in the event"
+        default=None,
+        description="Filter criteria for any resource involved in the event",
     )
     resource: Optional[EventResourceFilter] = Field(
-        None, description="Filter criteria for the resource of the event"
+        default=None,
+        description="Filter criteria for the resource of the event",
     )
     related: Optional[EventRelatedFilter] = Field(
-        None, description="Filter criteria for the related resources of the event"
+        default=None,
+        description="Filter criteria for the related resources of the event",
     )
     id: EventIDFilter = Field(
         default_factory=lambda: EventIDFilter(id=[]),
@@ -248,6 +252,6 @@ class EventFilter(EventDataFilter):
     )
 
     order: EventOrder = Field(
-        EventOrder.DESC,
+        default=EventOrder.DESC,
         description="The order to return filtered events",
     )

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/exceptions.py

@@ -443,3 +443,7 @@ class ProfileSettingsValidationError(PrefectException):
 
     def __init__(self, errors: List[Tuple[Any, ValidationError]]) -> None:
         self.errors = errors
+
+
+class HashError(PrefectException):
+    """Raised when hashing objects fails"""

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/flow_engine.py

@@ -22,8 +22,11 @@ from typing import (
 )
 from uuid import UUID
 
+from opentelemetry import trace
+from opentelemetry.trace import Tracer, get_tracer
 from typing_extensions import ParamSpec
 
+import prefect
 from prefect import Task
 from prefect.client.orchestration import SyncPrefectClient, get_client
 from prefect.client.schemas import FlowRun, TaskRun
@@ -124,6 +127,10 @@ class FlowRunEngine(Generic[P, R]):
     _client: Optional[SyncPrefectClient] = None
     short_circuit: bool = False
     _flow_run_name_set: bool = False
+    _tracer: Tracer = field(
+        default_factory=lambda: get_tracer("prefect", prefect.__version__)
+    )
+    _span: Optional[trace.Span] = None
 
     def __post_init__(self):
         if self.flow is None and self.flow_run_id is None:
@@ -233,6 +240,17 @@ class FlowRunEngine(Generic[P, R]):
         self.flow_run.state = state  # type: ignore
         self.flow_run.state_name = state.name  # type: ignore
         self.flow_run.state_type = state.type  # type: ignore
+
+        if self._span:
+            self._span.add_event(
+                state.name,
+                {
+                    "prefect.state.message": state.message or "",
+                    "prefect.state.type": state.type,
+                    "prefect.state.name": state.name or state.type,
+                    "prefect.state.id": str(state.id),
+                },
+            )
         return state
 
     def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
@@ -281,6 +299,9 @@ class FlowRunEngine(Generic[P, R]):
         )
         self.set_state(terminal_state)
         self._return_value = resolved_result
+
+        self._end_span_on_success()
+
         return result
 
     def handle_exception(
@@ -311,6 +332,9 @@ class FlowRunEngine(Generic[P, R]):
             )
             state = self.set_state(Running())
         self._raised = exc
+
+        self._end_span_on_error(exc, state.message)
+
         return state
 
     def handle_timeout(self, exc: TimeoutError) -> None:
@@ -329,6 +353,8 @@ class FlowRunEngine(Generic[P, R]):
         self.set_state(state)
         self._raised = exc
 
+        self._end_span_on_error(exc, message)
+
     def handle_crash(self, exc: BaseException) -> None:
         state = run_coro_as_sync(exception_to_crashed_state(exc))
         self.logger.error(f"Crash detected! {state.message}")
@@ -336,6 +362,23 @@ class FlowRunEngine(Generic[P, R]):
         self.set_state(state, force=True)
         self._raised = exc
 
+        self._end_span_on_error(exc, state.message)
+
+    def _end_span_on_success(self):
+        if not self._span:
+            return
+        self._span.set_status(trace.Status(trace.StatusCode.OK))
+        self._span.end(time.time_ns())
+        self._span = None
+
+    def _end_span_on_error(self, exc: BaseException, description: Optional[str]):
+        if not self._span:
+            return
+        self._span.record_exception(exc)
+        self._span.set_status(trace.Status(trace.StatusCode.ERROR, description))
+        self._span.end(time.time_ns())
+        self._span = None
+
     def load_subflow_run(
         self,
         parent_task_run: TaskRun,
@@ -578,6 +621,18 @@ class FlowRunEngine(Generic[P, R]):
                     flow_version=self.flow.version,
                     empirical_policy=self.flow_run.empirical_policy,
                 )
+
+            self._span = self._tracer.start_span(
+                name=self.flow_run.name,
+                attributes={
+                    **self.flow_run.labels,
+                    "prefect.run.type": "flow",
+                    "prefect.run.id": str(self.flow_run.id),
+                    "prefect.tags": self.flow_run.tags,
+                    "prefect.flow.name": self.flow.name,
+                },
+            )
+
             try:
                 yield self
 
@@ -632,7 +687,7 @@ class FlowRunEngine(Generic[P, R]):
 
     @contextmanager
     def start(self) -> Generator[None, None, None]:
-        with self.initialize_run():
+        with self.initialize_run(), trace.use_span(self._span):
             self.begin_run()
 
             if self.state.is_running():

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/logging/handlers.py

@@ -32,7 +32,6 @@ from prefect.settings import (
     PREFECT_LOGGING_TO_API_BATCH_SIZE,
     PREFECT_LOGGING_TO_API_MAX_LOG_SIZE,
     PREFECT_LOGGING_TO_API_WHEN_MISSING_FLOW,
-    get_current_settings,
 )
 
 
@@ -241,10 +240,12 @@ class APILogHandler(logging.Handler):
 
 class WorkerAPILogHandler(APILogHandler):
     def emit(self, record: logging.LogRecord):
-        if get_current_settings().experiments.worker_logging_to_api_enabled:
-            super().emit(record)
-        else:
+        # Open-source API servers do not currently support worker logs, and
+        # worker logs only have an associated worker ID when connected to Cloud,
+        # so we won't send worker logs to the API unless they have a worker ID.
+        if not getattr(record, "worker_id", None):
             return
+        super().emit(record)
 
     def prepare(self, record: logging.LogRecord) -> Dict[str, Any]:
         """

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/settings/models/experiments.py

@@ -18,11 +18,6 @@ class ExperimentsSettings(PrefectBaseSettings):
         ),
     )
 
-    worker_logging_to_api_enabled: bool = Field(
-        default=False,
-        description="Enables the logging of worker logs to Prefect Cloud.",
-    )
-
     telemetry_enabled: bool = Field(
         default=False,
         description="Enables sending telemetry to Prefect Cloud.",

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/telemetry/processors.py

@@ -1,6 +1,6 @@
 import time
 from threading import Event, Lock, Thread
-from typing import Optional
+from typing import Dict, Optional
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
@@ -10,7 +10,7 @@ from opentelemetry.sdk.trace.export import SpanExporter
 class InFlightSpanProcessor(SpanProcessor):
     def __init__(self, span_exporter: SpanExporter):
         self.span_exporter = span_exporter
-        self._in_flight = {}
+        self._in_flight: Dict[int, Span] = {}
         self._lock = Lock()
         self._stop_event = Event()
         self._export_thread = Thread(target=self._export_periodically, daemon=True)

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/types/__init__.py

@@ -86,10 +86,26 @@ StrictVariableValue = Annotated[VariableValue, BeforeValidator(check_variable_va
 
 LaxUrl = Annotated[str, BeforeValidator(lambda x: str(x).strip())]
 
-
 StatusCode = Annotated[int, Field(ge=100, le=599)]
 
 
+def cast_none_to_empty_dict(value: Any) -> dict[str, Any]:
+    if value is None:
+        return {}
+    return value
+
+
+KeyValueLabels = Annotated[
+    dict[str, Union[StrictBool, StrictInt, StrictFloat, str]],
+    BeforeValidator(cast_none_to_empty_dict),
+]
+
+
+ListOfNonEmptyStrings = Annotated[
+    List[str], BeforeValidator(lambda x: [s for s in x if s.strip()])
+]
+
+
 class SecretDict(pydantic.Secret[Dict[str, Any]]):
     pass
 
@@ -137,6 +153,7 @@ __all__ = [
     "LogLevel",
     "NonNegativeInteger",
     "PositiveInteger",
+    "ListOfNonEmptyStrings",
     "NonNegativeFloat",
     "Name",
     "NameOrEmpty",

{prefect-client-3.1.2 → prefect-client-3.1.4}/src/prefect/utilities/filesystem.py

@@ -7,7 +7,7 @@ import pathlib
 import threading
 from contextlib import contextmanager
 from pathlib import Path, PureWindowsPath
-from typing import Optional, Union
+from typing import Optional, Union, cast
 
 import fsspec
 import pathspec
@@ -22,8 +22,8 @@ def create_default_ignore_file(path: str) -> bool:
     Creates default ignore file in the provided path if one does not already exist; returns boolean specifying
     whether a file was created.
     """
-    path = pathlib.Path(path)
-    ignore_file = path / ".prefectignore"
+    _path = pathlib.Path(path)
+    ignore_file = _path / ".prefectignore"
     if ignore_file.exists():
         return False
     default_file = pathlib.Path(prefect.__module_path__) / ".prefectignore"
@@ -54,12 +54,34 @@ def filter_files(
 chdir_lock = threading.Lock()
 
 
+def _normalize_path(path: Union[str, Path]) -> str:
+    """
+    Normalize a path, handling UNC paths on Windows specially.
+    """
+    path = Path(path)
+
+    # Handle UNC paths on Windows differently
+    if os.name == "nt" and str(path).startswith("\\\\"):
+        # For UNC paths, use absolute() instead of resolve()
+        # to avoid the Windows path resolution issues
+        return str(path.absolute())
+    else:
+        try:
+            # For non-UNC paths, try resolve() first
+            return str(path.resolve())
+        except OSError:
+            # Fallback to absolute() if resolve() fails
+            return str(path.absolute())
+
+
 @contextmanager
 def tmpchdir(path: str):
     """
-    Change current-working directories for the duration of the context
+    Change current-working directories for the duration of the context,
+    with special handling for UNC paths on Windows.
     """
-    path = os.path.abspath(path)
+    path = _normalize_path(path)
+
     if os.path.isfile(path) or (not os.path.exists(path) and not path.endswith("/")):
         path = os.path.dirname(path)
 
@@ -67,7 +89,12 @@ def tmpchdir(path: str):
 
     with chdir_lock:
         try:
-            os.chdir(path)
+            # On Windows with UNC paths, we need to handle the directory change carefully
+            if os.name == "nt" and path.startswith("\\\\"):
+                # Use os.path.abspath to handle UNC paths
+                os.chdir(os.path.abspath(path))
+            else:
+                os.chdir(path)
             yield path
         finally:
             os.chdir(owd)
@@ -76,7 +103,7 @@ def tmpchdir(path: str):
 def filename(path: str) -> str:
     """Extract the file name from a path with remote file system support"""
     try:
-        of: OpenFile = fsspec.open(path)
+        of: OpenFile = cast(OpenFile, fsspec.open(path))
         sep = of.fs.sep
     except (ImportError, AttributeError):
         sep = "\\" if "\\" in path else "/"
@@ -98,7 +125,7 @@ def is_local_path(path: Union[str, pathlib.Path, OpenFile]):
     else:
         raise TypeError(f"Invalid path of type {type(path).__name__!r}")
 
-    return type(of.fs) == LocalFileSystem
+    return isinstance(of.fs, LocalFileSystem)
 
 
 def to_display_path(