wandb 0.15.3__py3-none-any.whl → 0.15.5__py3-none-any.whl

wandb/apis/reports/_panels.py

@@ -2,7 +2,7 @@ from typing import Optional, Union
 
 from .helpers import LineKey, PCColumn
 from .util import Attr, Panel, coalesce, nested_get, nested_set
-from .validators import (  # MARKS,; Between,
+from .validators import (
     AGGFUNCS,
     CODE_COMPARE_DIFF,
     FONT_SIZES,
@@ -570,9 +570,9 @@ class ParallelCoordinatesPlot(Panel):
         validators=[TypeValidator(Union[PCColumn, str], how="keys")],
     )
     title: Optional[str] = Attr(json_path="spec.config.chartTitle")
+    gradient: Optional[list] = Attr(json_path="spec.config.customGradient")
 
     # Attr(json_path="spec.config.dimensions")
-    # Attr(json_path="spec.config.customGradient")
     # Attr(json_path="spec.config.gradientColor")
     # Attr(json_path="spec.config.legendFields")
     font_size: Optional[str] = Attr(
@@ -720,14 +720,32 @@ class Vega(Panel):
 class CustomChart(Panel):
     query: dict = Attr(json_path="spec.config.userQuery.queryFields")
     chart_name: str = Attr(json_path="spec.config.panelDefId")
-    user_fields: dict = Attr(json_path="spec.config.fieldSettings")
+    chart_fields: dict = Attr(json_path="spec.config.fieldSettings")
+    chart_strings: dict = Attr(json_path="spec.config.stringSettings")
 
-    def __init__(self, query=None, chart_name="", user_fields=None, *args, **kwargs):
+    def __init__(
+        self,
+        query=None,
+        chart_name="",
+        chart_fields=None,
+        chart_strings=None,
+        *args,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.spec["config"] = {"transform": {"name": "tableWithLeafColNames"}}
         self.query = coalesce(query, {})
         self.chart_name = chart_name
-        self.user_fields = coalesce(user_fields, {})
+        self.chart_fields = coalesce(chart_fields, {})
+        self.chart_strings = coalesce(chart_strings, {})
+
+    @classmethod
+    def from_table(cls, table_name, chart_fields=None, chart_strings=None):
+        return CustomChart(
+            query={"summaryTable": {"tableKey": table_name}},
+            chart_fields=chart_fields,
+            chart_strings=chart_strings,
+        )
 
     @property
     def view_type(self) -> str:
@@ -735,46 +753,51 @@ class CustomChart(Panel):
 
     @query.getter
     def query(self):
-        d = nested_get(self, self._get_path("query"))
-        fields = d[0]["fields"]
-        query = {o["name"]: o.get("args") for o in fields}
-        query = {
-            k: v[0]["value"] if v is not None else None
-            for k, v in query.items()
-            if k not in ("id", "name")
-        }
-        return query
+        def fields_to_dict(fields):
+            d = {}
+            for field in fields:
+                keys = set(field.keys())
+                name = field["name"]
+
+                if keys == {"name", "fields"}:
+                    d[name] = {}
+                elif keys == {"name", "value"}:
+                    d[name] = field["value"]
+                elif keys == {"name", "args", "fields"}:
+                    d[name] = fields_to_dict(field["args"])
+            return d
+
+        fields = nested_get(self, self._get_path("query"))
+        return fields_to_dict(fields)
 
     @query.setter
     def query(self, d):
-        def make_fields(d):
+        def dict_to_fields(d):
             fields = []
             for k, v in d.items():
-                if v is None:
+                if isinstance(v, dict) and len(v) > 0:
+                    field = {"name": k, "args": dict_to_fields(v), "fields": []}
+                elif isinstance(v, dict) and len(v) == 0 or v is None:
                     field = {"name": k, "fields": []}
                 else:
-                    field = {
-                        "name": k,
-                        "fields": [],
-                        "args": [{"name": "keys", "value": v}],
-                    }
+                    field = {"name": k, "value": v}
                 fields.append(field)
-            if "id" not in d:
-                fields.append({"name": "id", "fields": []})
-            if "name" not in d:
-                fields.append({"name": "name", "fields": []})
             return fields
 
-        query = {
-            "args": [
-                {"name": "runSets", "value": "${runSets}"},
-                {"name": "limit", "value": 500},
-            ],
-            "name": "runSets",
-        }
-        query["fields"] = make_fields(d)
-        query = [query]
-        nested_set(self, self._get_path("query"), query)
+        d.setdefault("id", [])
+        d.setdefault("name", [])
+
+        _query = [
+            {
+                "args": [
+                    {"name": "runSets", "value": r"${runSets}"},
+                    {"name": "limit", "value": 500},
+                ],
+                "fields": dict_to_fields(d),
+                "name": "runSets",
+            }
+        ]
+        nested_set(self, self._get_path("query"), _query)
 
 
 class Vega3(Panel):

wandb/beta/workflows.py

@@ -5,12 +5,12 @@ from typing import Any, Dict, List, Optional, Union
 import wandb
 import wandb.data_types as data_types
 from wandb.data_types import _SavedModel
-from wandb.sdk.interface.artifacts import Artifact as ArtifactInterface
-from wandb.sdk.interface.artifacts import ArtifactManifestEntry
+from wandb.sdk.artifacts.artifact import Artifact
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
 
 
 def _add_any(
-    artifact: ArtifactInterface,
+    artifact: Artifact,
     path_or_obj: Union[
         str, ArtifactManifestEntry, data_types.WBValue
     ],  # todo: add dataframe
@@ -23,8 +23,7 @@ def _add_any(
     be moved to the Artifact class in the future.
 
     Args:
-        artifact: `ArtifactInterface` - most likely a LocalArtifact created with
-            `wandb.Artifact(...)`
+        artifact: `Artifact` - artifact created with `wandb.Artifact(...)`
         path_or_obj: `Union[str, ArtifactManifestEntry, data_types.WBValue]` - either a
             str or valid object which indicates what to add to an artifact.
 
@@ -62,7 +61,7 @@ def _log_artifact_version(
     project: Optional[str] = None,
     scope_project: Optional[bool] = None,
     job_type: str = "auto",
-) -> ArtifactInterface:
+) -> Artifact:
     """Create an artifact, populate it, and log it with a run.
 
     If a run is not present, we create one.
@@ -83,7 +82,7 @@ def _log_artifact_version(
             Used to identify runs of a certain job type, i.e "evaluation".
 
     Returns:
-        ArtifactInterface
+        Artifact
 
     """
     if wandb.run is None:

wandb/cli/cli.py

@@ -15,7 +15,7 @@ import textwrap
 import time
 import traceback
 from functools import wraps
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 import click
 import yaml
@@ -32,13 +32,13 @@ import wandb.sdk.verify.verify as wandb_verify
 from wandb import Config, Error, env, util, wandb_agent, wandb_sdk
 from wandb.apis import InternalApi, PublicApi
 from wandb.integration.magic import magic_install
+from wandb.sdk.artifacts.artifacts_cache import get_artifacts_cache
+from wandb.sdk.launch.errors import ExecutionError, LaunchError
 from wandb.sdk.launch.launch_add import _launch_add
-from wandb.sdk.launch.sweeps import SCHEDULER_URI
 from wandb.sdk.launch.sweeps import utils as sweep_utils
+from wandb.sdk.launch.sweeps.scheduler import Scheduler
 from wandb.sdk.launch.utils import (
     LAUNCH_DEFAULT_PROJECT,
-    ExecutionError,
-    LaunchError,
     check_logged_in,
     construct_launch_spec,
 )
@@ -921,12 +921,6 @@ def sweep(
     default=None,
     help="Resume a launch sweep by passing an 8-char sweep id. Queue required",
 )
-@click.option(
-    "--num_workers",
-    "-n",
-    default=1,
-    help="Number of concurrent jobs a scheduler can run",
-)
 @click.argument("config", required=False, type=click.Path(exists=True))
 @click.pass_context
 @display_error
@@ -937,36 +931,14 @@ def launch_sweep(
     queue,
     config,
     resume_id,
-    num_workers,
 ):
     api = _get_cling_api()
+    env = os.environ
     if api.api_key is None:
         wandb.termlog("Login to W&B to use the sweep feature")
         ctx.invoke(login, no_offline=True)
         api = _get_cling_api(reset=True)
 
-    # if not sweep_config XOR resume_id
-    if not (config or resume_id):
-        wandb.termerror("'config' and/or 'resume_id' required")
-        return
-
-    parsed_config = sweep_utils.load_launch_sweep_config(config)
-    # Rip special keys out of config
-    scheduler_args: Dict[str, Any] = parsed_config.get("scheduler", {})
-    launch_args: Dict[str, Any] = parsed_config.get("launch", {})
-    if scheduler_args:
-        del parsed_config["scheduler"]
-    if launch_args:
-        del parsed_config["launch"]
-
-    queue = queue or launch_args.get("queue")
-    if not queue:
-        wandb.termerror(
-            "Launch-sweeps require setting a 'queue', use --queue option or a 'queue' key in the 'launch' section in the config"
-        )
-        return
-
-    env = os.environ
     entity = entity or env.get("WANDB_ENTITY") or api.settings("entity")
     if entity is None:
         wandb.termerror("Must specify entity when using launch")
@@ -977,51 +949,146 @@ def launch_sweep(
         wandb.termerror("A project must be configured when using launch")
         return
 
-    parsed_sweep_config, sweep_obj_id = None, None
-    if resume_id:  # Resuming an existing sweep
+    # get personal username, not team name or service account, default to entity
+    author = api.viewer().get("username") or entity
+
+    # if not sweep_config XOR resume_id
+    if not (config or resume_id):
+        wandb.termerror("'config' and/or 'resume_id' required")
+        return
+
+    parsed_user_config = sweep_utils.load_launch_sweep_config(config)
+    # Rip special keys out of config, store in scheduler run_config
+    launch_args: Dict[str, Any] = parsed_user_config.pop("launch", {})
+    scheduler_args: Dict[str, Any] = parsed_user_config.pop("scheduler", {})
+    settings: Dict[str, Any] = scheduler_args.pop("settings", {})
+
+    scheduler_job: Optional[str] = scheduler_args.get("job")
+    if scheduler_job:
+        wandb.termwarn(
+            "Using a scheduler job for launch sweeps is *experimental* and may change without warning"
+        )
+    queue: Optional[str] = queue or launch_args.get("queue")
+
+    sweep_config, sweep_obj_id = None, None
+    if not resume_id:
+        sweep_config = parsed_user_config
+
+        # check method
+        method = sweep_config.get("method")
+        if scheduler_job and not method:
+            sweep_config["method"] = "custom"
+        elif scheduler_job and method != "custom":
+            # TODO(gst): Check if using Anaconda2
+            wandb.termwarn(
+                "Use 'method': 'custom' in the sweep config when using scheduler jobs, "
+                "or omit it entirely. For jobs using the wandb optimization engine (WandbScheduler), "
+                "set the method in the sweep config under scheduler.settings.method "
+            )
+            settings["method"] = method
+
+        if settings.get("method"):
+            # assume WandbScheduler, and user is using this right
+            sweep_config["method"] = settings["method"]
+
+    else:  # Resuming an existing sweep
         found = api.sweep(resume_id, "{}", entity=entity, project=project)
         if not found:
             wandb.termerror(f"Could not find sweep {entity}/{project}/{resume_id}")
             return
+
+        if found.get("state") == "RUNNING":
+            wandb.termerror(
+                f"Cannot resume sweep {entity}/{project}/{resume_id}, it is already running"
+            )
+            return
+
         sweep_obj_id = found["id"]
-        parsed_sweep_config = yaml.safe_load(found["config"])
+        sweep_config = yaml.safe_load(found["config"])
         wandb.termlog(f"Resuming from existing sweep {entity}/{project}/{resume_id}")
-        if len(parsed_config.keys()) > 0:
+        if len(parsed_user_config.keys()) > 0:
             wandb.termwarn(
-                "Sweep params loaded from resumed sweep, ignoring provided keys"
+                "Sweep parameters loaded from resumed sweep, ignoring provided config"
             )
-    else:
-        parsed_sweep_config = parsed_config
 
-    num_workers = num_workers or scheduler_args.get("num_workers", 8)
-    scheduler_entrypoint = sweep_utils.construct_scheduler_entrypoint(
-        sweep_config=parsed_sweep_config,
+        prev_scheduler = json.loads(found.get("scheduler") or "{}")
+        run_spec = json.loads(prev_scheduler.get("run_spec", "{}"))
+        if (
+            scheduler_job
+            and run_spec.get("job")
+            and run_spec.get("job") != scheduler_job
+        ):
+            wandb.termerror(
+                f"Resuming a launch sweep with a different scheduler job is not supported. Job loaded from sweep: {run_spec.get('job')}, job in config: {scheduler_job}"
+            )
+            return
+
+        prev_scheduler_args, prev_settings = sweep_utils.get_previous_args(run_spec)
+        # Passed in scheduler_args and settings override previous
+        scheduler_args.update(prev_scheduler_args)
+        settings.update(prev_settings)
+    if not queue:
+        wandb.termerror(
+            "Launch-sweeps require setting a 'queue', use --queue option or a 'queue' key in the 'launch' section in the config"
+        )
+        return
+
+    entrypoint = Scheduler.ENTRYPOINT if not scheduler_job else None
+    args = sweep_utils.construct_scheduler_args(
+        return_job=scheduler_job is not None,
+        sweep_config=sweep_config,
         queue=queue,
         project=project,
-        num_workers=num_workers,
-        author=entity,
+        author=author,
     )
-    if not scheduler_entrypoint:
-        # error already logged
+    if not args:
         return
 
+    # validate training job existence
+    if not sweep_utils.check_job_exists(PublicApi(), sweep_config.get("job")):
+        return False
+
+    # validate scheduler job existence, if present
+    if not sweep_utils.check_job_exists(PublicApi(), scheduler_job):
+        return False
+
+    # Set run overrides for the Scheduler
+    overrides = {"run_config": {}}
+    if launch_args:
+        overrides["run_config"]["launch"] = launch_args
+    if scheduler_args:
+        overrides["run_config"]["scheduler"] = scheduler_args
+    if settings:
+        overrides["run_config"]["settings"] = settings
+
+    if scheduler_job:
+        overrides["run_config"]["sweep_args"] = args
+    else:
+        overrides["args"] = args
+
+    # set name of scheduler
+    prefix = "sweep" if scheduler_job else "wandb"
+    name = f"{prefix}-scheduler-WANDB_SWEEP_ID"
+    if scheduler_args.get("name"):
+        name = scheduler_args["name"]
+
     # Launch job spec for the Scheduler
     launch_scheduler_spec = construct_launch_spec(
-        uri=SCHEDULER_URI,
+        uri=Scheduler.PLACEHOLDER_URI,
         api=api,
-        name="Scheduler.WANDB_SWEEP_ID",
+        name=name,
         project=project,
         entity=entity,
         docker_image=scheduler_args.get("docker_image"),
         resource=scheduler_args.get("resource", "local-process"),
-        entry_point=scheduler_entrypoint,
+        entry_point=entrypoint,
         resource_args=scheduler_args.get("resource_args", {}),
         repository=launch_args.get("registry", {}).get("url", None),
-        job=None,
+        job=scheduler_job,
         version=None,
-        launch_config=None,
-        run_id=None,
-        author=None,  # author gets passed into scheduler command
+        launch_config={"overrides": overrides},
+        run_id="WANDB_SWEEP_ID",  # scheduler inits run with sweep_id=run_id
+        author=None,  # author gets passed into scheduler override args
     )
     launch_scheduler_with_queue = json.dumps(
         {
@@ -1032,7 +1099,7 @@ def launch_sweep(
     )
 
     sweep_id, warnings = api.upsert_sweep(
-        parsed_sweep_config,
+        sweep_config,
         project=project,
         entity=entity,
         obj_id=sweep_obj_id,  # if resuming
@@ -1040,7 +1107,6 @@ def launch_sweep(
         state="PENDING",
     )
     sweep_utils.handle_sweep_config_violations(warnings)
-
     # Log nicely formatted sweep information
     styled_id = click.style(sweep_id, fg="yellow")
     wandb.termlog(f"{'Resumed' if resume_id else 'Created'} sweep with ID: {styled_id}")
@@ -1169,6 +1235,7 @@ def launch_sweep(
     "--project-queue",
     "-pq",
     default=None,
+    hidden=True,
     help="Name of the project containing the queue to push to. If none, defaults to entity level queues.",
 )
 @display_error
@@ -1359,6 +1426,7 @@ def launch_agent(
 
     from wandb.sdk.launch import launch as wandb_launch
 
+    api = _get_cling_api()
     wandb._sentry.configure_scope(process_context="launch_agent")
     agent_config, api = wandb_launch.resolve_agent_config(
         entity, project, max_jobs, queues, config
@@ -1439,7 +1507,8 @@ def scheduler(
                 _args = int(_args)
             kwargs[_key] = _args
     try:
-        _scheduler = load_scheduler("sweep")(
+        sweep_type = kwargs.get("sweep_type", "wandb")
+        _scheduler = load_scheduler(scheduler_type=sweep_type)(
             api,
             sweep_id=sweep_id,
             **kwargs,
@@ -1937,11 +2006,12 @@ def cache():
     help="Clean up less frequently used files from the artifacts cache",
 )
 @click.argument("target_size")
+@click.option("--remove-temp/--no-remove-temp", default=False, help="Remove temp files")
 @display_error
-def cleanup(target_size):
+def cleanup(target_size, remove_temp):
     target_size = util.from_human_size(target_size)
-    cache = wandb_sdk.wandb_artifacts.get_artifacts_cache()
-    reclaimed_bytes = cache.cleanup(target_size)
+    cache = get_artifacts_cache()
+    reclaimed_bytes = cache.cleanup(target_size, remove_temp)
     print(f"Reclaimed {util.to_human_size(reclaimed_bytes)} of space")
 
 

wandb/data_types.py

@@ -47,6 +47,7 @@ from .sdk.data_types.molecule import Molecule
 from .sdk.data_types.object_3d import Object3D
 from .sdk.data_types.plotly import Plotly
 from .sdk.data_types.saved_model import _SavedModel
+from .sdk.data_types.trace_tree import WBTraceTree
 from .sdk.data_types.video import Video
 from .sdk.lib import runid
 
@@ -67,6 +68,7 @@ __all__ = [
     "Object3D",
     "Plotly",
     "Video",
+    "WBTraceTree",
     "_SavedModel",
     # Typed Legacy Exports (I'd like to remove these)
     "ImageMask",
@@ -633,7 +635,7 @@ class Table(Media):
                 }
             )
 
-        elif isinstance(run_or_artifact, wandb.wandb_sdk.wandb_artifacts.Artifact):
+        elif isinstance(run_or_artifact, wandb.Artifact):
             artifact = run_or_artifact
             mapped_data = []
             data = self._to_table_json(Table.MAX_ARTIFACT_ROWS)["data"]

wandb/filesync/dir_watcher.py

@@ -5,18 +5,11 @@ import logging
 import os
 import queue
 import time
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Mapping,
-    MutableMapping,
-    MutableSet,
-    NewType,
-    Optional,
-)
+from typing import TYPE_CHECKING, Any, Mapping, MutableMapping, MutableSet, Optional
 
 from wandb import util
 from wandb.sdk.interface.interface import GlobStr
+from wandb.sdk.lib.paths import LogicalPath
 
 if TYPE_CHECKING:
     import wandb.vendor.watchdog_0_9_0.observers.api as wd_api
@@ -30,7 +23,7 @@ else:
     wd_events = util.vendor_import("wandb_watchdog.events")
 
 PathStr = str  # TODO(spencerpearson): would be nice to use Path here
-SaveName = NewType("SaveName", str)
+
 
 logger = logging.getLogger(__name__)
 
@@ -39,15 +32,14 @@ class FileEventHandler(abc.ABC):
     def __init__(
         self,
         file_path: PathStr,
-        save_name: SaveName,
+        save_name: LogicalPath,
         file_pusher: "FilePusher",
         *args: Any,
         **kwargs: Any,
     ) -> None:
         self.file_path = file_path
         # Convert windows paths to unix paths
-        save_name = SaveName(util.to_forward_slash_path(save_name))
-        self.save_name = save_name
+        self.save_name = LogicalPath(save_name)
         self._file_pusher = file_pusher
         self._last_sync: Optional[float] = None
 
@@ -64,7 +56,7 @@ class FileEventHandler(abc.ABC):
     def finish(self) -> None:
         raise NotImplementedError
 
-    def on_renamed(self, new_path: PathStr, new_name: SaveName) -> None:
+    def on_renamed(self, new_path: PathStr, new_name: LogicalPath) -> None:
         self.file_path = new_path
         self.save_name = new_name
         self.on_modified()
@@ -120,7 +112,7 @@ class PolicyLive(FileEventHandler):
     def __init__(
         self,
         file_path: PathStr,
-        save_name: SaveName,
+        save_name: LogicalPath,
         file_pusher: "FilePusher",
         settings: Optional["wandb_settings.Settings"] = None,
         *args: Any,
@@ -203,14 +195,14 @@ class DirWatcher:
         self._file_count = 0
         self._dir = file_dir or settings.files_dir
         self._settings = settings
-        self._savename_file_policies: MutableMapping[SaveName, "PolicyName"] = {}
+        self._savename_file_policies: MutableMapping[LogicalPath, "PolicyName"] = {}
         self._user_file_policies: Mapping["PolicyName", MutableSet[GlobStr]] = {
             "end": set(),
             "live": set(),
             "now": set(),
         }
         self._file_pusher = file_pusher
-        self._file_event_handlers: MutableMapping[SaveName, FileEventHandler] = {}
+        self._file_event_handlers: MutableMapping[LogicalPath, FileEventHandler] = {}
         self._file_observer = wd_polling.PollingObserver()
         self._file_observer.schedule(
             self._per_file_event_handler(), self._dir, recursive=True
@@ -232,7 +224,9 @@ class DirWatcher:
         # faster if the name happens to include glob escapable characters.  In
         # the future we may add a flag to "files" records that indicates it's
         # policy is not dynamic and doesn't need to be stored / checked.
-        save_name = SaveName(os.path.relpath(os.path.join(self._dir, path), self._dir))
+        save_name = LogicalPath(
+            os.path.relpath(os.path.join(self._dir, path), self._dir)
+        )
         if save_name.startswith("media/"):
             pass
         elif path == glob.escape(path):
@@ -240,7 +234,7 @@ class DirWatcher:
         else:
             self._user_file_policies[policy].add(path)
         for src_path in glob.glob(os.path.join(self._dir, path)):
-            save_name = SaveName(os.path.relpath(src_path, self._dir))
+            save_name = LogicalPath(os.path.relpath(src_path, self._dir))
             feh = self._get_file_event_handler(src_path, save_name)
             # handle the case where the policy changed
             if feh.policy != policy:
@@ -284,18 +278,18 @@ class DirWatcher:
             emitter = self.emitter
             if emitter:
                 emitter._timeout = int(self._file_count / 100) + 1
-        save_name = SaveName(os.path.relpath(event.src_path, self._dir))
+        save_name = LogicalPath(os.path.relpath(event.src_path, self._dir))
         self._get_file_event_handler(event.src_path, save_name).on_modified()
 
     # TODO(spencerpearson): this pattern repeats so many times we should have a method/function for it
-    # def _save_name(self, path: PathStr) -> SaveName:
-    #     return SaveName(os.path.relpath(path, self._dir))
+    # def _save_name(self, path: PathStr) -> LogicalPath:
+    #     return LogicalPath(os.path.relpath(path, self._dir))
 
     def _on_file_modified(self, event: "wd_events.FileModifiedEvent") -> None:
         logger.info(f"file/dir modified: { event.src_path}")
         if os.path.isdir(event.src_path):
             return None
-        save_name = SaveName(os.path.relpath(event.src_path, self._dir))
+        save_name = LogicalPath(os.path.relpath(event.src_path, self._dir))
         self._get_file_event_handler(event.src_path, save_name).on_modified()
 
     def _on_file_moved(self, event: "wd_events.FileMovedEvent") -> None:
@@ -303,8 +297,8 @@ class DirWatcher:
         logger.info(f"file/dir moved: {event.src_path} -> {event.dest_path}")
         if os.path.isdir(event.dest_path):
             return None
-        old_save_name = SaveName(os.path.relpath(event.src_path, self._dir))
-        new_save_name = SaveName(os.path.relpath(event.dest_path, self._dir))
+        old_save_name = LogicalPath(os.path.relpath(event.src_path, self._dir))
+        new_save_name = LogicalPath(os.path.relpath(event.dest_path, self._dir))
 
         # We have to move the existing file handler to the new name
         handler = self._get_file_event_handler(event.src_path, old_save_name)
@@ -314,7 +308,7 @@ class DirWatcher:
         handler.on_renamed(event.dest_path, new_save_name)
 
     def _get_file_event_handler(
-        self, file_path: PathStr, save_name: SaveName
+        self, file_path: PathStr, save_name: LogicalPath
     ) -> FileEventHandler:
         """Get or create an event handler for a particular file.
 
@@ -397,7 +391,7 @@ class DirWatcher:
         for dirpath, _, filenames in os.walk(self._dir):
             for fname in filenames:
                 file_path = os.path.join(dirpath, fname)
-                save_name = SaveName(os.path.relpath(file_path, self._dir))
+                save_name = LogicalPath(os.path.relpath(file_path, self._dir))
                 ignored = False
                 for glb in self._settings.ignore_globs:
                     if len(fnmatch.filter([save_name], glb)) > 0: