datachain 0.3.17__py3-none-any.whl → 0.3.18__py3-none-any.whl

datachain/cache.py

@@ -1,56 +1,15 @@
-import hashlib
-import json
 import os
-from datetime import datetime
-from functools import partial
 from typing import TYPE_CHECKING, Optional
 
-import attrs
 from dvc_data.hashfile.db.local import LocalHashFileDB
 from dvc_objects.fs.local import LocalFileSystem
 from fsspec.callbacks import Callback, TqdmCallback
 
-from datachain.utils import TIME_ZERO
-
 from .progress import Tqdm
 
 if TYPE_CHECKING:
     from datachain.client import Client
-    from datachain.storage import StorageURI
-
-sha256 = partial(hashlib.sha256, usedforsecurity=False)
-
-
-@attrs.frozen
-class UniqueId:
-    storage: "StorageURI"
-    path: str
-    size: int
-    etag: str
-    version: str = ""
-    is_latest: bool = True
-    location: Optional[str] = None
-    last_modified: datetime = TIME_ZERO
-
-    def get_parsed_location(self) -> Optional[dict]:
-        if not self.location:
-            return None
-
-        loc_stack = (
-            json.loads(self.location)
-            if isinstance(self.location, str)
-            else self.location
-        )
-        if len(loc_stack) > 1:
-            raise NotImplementedError("Nested v-objects are not supported yet.")
-
-        return loc_stack[0]
-
-    def get_hash(self) -> str:
-        fingerprint = f"{self.storage}/{self.path}/{self.version}/{self.etag}"
-        if self.location:
-            fingerprint += f"/{self.location}"
-        return sha256(fingerprint.encode()).hexdigest()
+    from datachain.lib.file import File
 
 
 def try_scandir(path):
@@ -77,30 +36,30 @@ class DataChainCache:
     def tmp_dir(self):
         return self.odb.tmp_dir
 
-    def get_path(self, uid: UniqueId) -> Optional[str]:
-        if self.contains(uid):
-            return self.path_from_checksum(uid.get_hash())
+    def get_path(self, file: "File") -> Optional[str]:
+        if self.contains(file):
+            return self.path_from_checksum(file.get_hash())
         return None
 
-    def contains(self, uid: UniqueId) -> bool:
-        return self.odb.exists(uid.get_hash())
+    def contains(self, file: "File") -> bool:
+        return self.odb.exists(file.get_hash())
 
     def path_from_checksum(self, checksum: str) -> str:
         assert checksum
         return self.odb.oid_to_path(checksum)
 
-    def remove(self, uid: UniqueId) -> None:
-        self.odb.delete(uid.get_hash())
+    def remove(self, file: "File") -> None:
+        self.odb.delete(file.get_hash())
 
     async def download(
-        self, uid: UniqueId, client: "Client", callback: Optional[Callback] = None
+        self, file: "File", client: "Client", callback: Optional[Callback] = None
     ) -> None:
-        from_path = f"{uid.storage}/{uid.path}"
+        from_path = f"{file.source}/{file.path}"
         from dvc_objects.fs.utils import tmp_fname
 
         odb_fs = self.odb.fs
         tmp_info = odb_fs.join(self.odb.tmp_dir, tmp_fname())  # type: ignore[arg-type]
-        size = uid.size
+        size = file.size
         if size < 0:
             size = await client.get_size(from_path)
         cb = callback or TqdmCallback(
@@ -115,13 +74,13 @@ class DataChainCache:
                 cb.close()
 
         try:
-            oid = uid.get_hash()
+            oid = file.get_hash()
             self.odb.add(tmp_info, self.odb.fs, oid)
         finally:
             os.unlink(tmp_info)
 
-    def store_data(self, uid: UniqueId, contents: bytes) -> None:
-        checksum = uid.get_hash()
+    def store_data(self, file: "File", contents: bytes) -> None:
+        checksum = file.get_hash()
         dst = self.path_from_checksum(checksum)
         if not os.path.exists(dst):
             # Create the file only if it's not already in cache

datachain/catalog/catalog.py

@@ -34,7 +34,7 @@ import yaml
 from sqlalchemy import Column
 from tqdm import tqdm
 
-from datachain.cache import DataChainCache, UniqueId
+from datachain.cache import DataChainCache
 from datachain.client import Client
 from datachain.config import get_remote_config, read_config
 from datachain.dataset import (
@@ -619,13 +619,13 @@ class Catalog:
                 code_ast.body[-1:] = new_expressions
         return code_ast
 
-    def get_client(self, uri: StorageURI, **config: Any) -> Client:
+    def get_client(self, uri: str, **config: Any) -> Client:
         """
         Return the client corresponding to the given source `uri`.
         """
         config = config or self.client_config
         cls = Client.get_implementation(uri)
-        return cls.from_source(uri, self.cache, **config)
+        return cls.from_source(StorageURI(uri), self.cache, **config)
 
     def enlist_source(
         self,
@@ -1431,7 +1431,7 @@ class Catalog:
 
     def get_file_signals(
         self, dataset_name: str, dataset_version: int, row: RowDict
-    ) -> Optional[dict]:
+    ) -> Optional[RowDict]:
         """
         Function that returns file signals from dataset row.
         Note that signal names are without prefix, so if there was 'laion__file__source'
@@ -1448,7 +1448,7 @@ class Catalog:
 
         version = self.get_dataset(dataset_name).get_version(dataset_version)
 
-        file_signals_values = {}
+        file_signals_values = RowDict()
 
         schema = SignalSchema.deserialize(version.feature_schema)
         for file_signals in schema.get_signals(File):
@@ -1476,6 +1476,8 @@ class Catalog:
         use_cache: bool = True,
         **config: Any,
     ):
+        from datachain.lib.file import File
+
         file_signals = self.get_file_signals(dataset_name, dataset_version, row)
         if not file_signals:
             raise RuntimeError("Cannot open object without file signals")
@@ -1483,22 +1485,10 @@ class Catalog:
         config = config or self.client_config
         client = self.get_client(file_signals["source"], **config)
         return client.open_object(
-            self._get_row_uid(file_signals),  # type: ignore [arg-type]
+            File._from_row(file_signals),
             use_cache=use_cache,
         )
 
-    def _get_row_uid(self, row: RowDict) -> UniqueId:
-        return UniqueId(
-            row["source"],
-            row["path"],
-            row["size"],
-            row["etag"],
-            row["version"],
-            row["is_latest"],
-            row["location"],
-            row["last_modified"],
-        )
-
     def ls(
         self,
         sources: list[str],

datachain/cli.py

@@ -15,6 +15,7 @@ import shtab
 from datachain import utils
 from datachain.cli_utils import BooleanOptionalAction, CommaSeparatedArgs, KeyValueArgs
 from datachain.lib.dc import DataChain
+from datachain.telemetry import telemetry
 from datachain.utils import DataChainDir
 
 if TYPE_CHECKING:
@@ -872,6 +873,7 @@ def main(argv: Optional[list[str]] = None) -> int:  # noqa: C901, PLR0912, PLR09
         # This also sets this environment variable for any subprocesses
         os.environ["DEBUG_SHOW_SQL_QUERIES"] = "True"
 
+    error = None
     try:
         catalog = get_catalog(client_config=client_config)
         if args.command == "cp":
@@ -1003,14 +1005,16 @@ def main(argv: Optional[list[str]] = None) -> int:  # noqa: C901, PLR0912, PLR09
             print(f"invalid command: {args.command}", file=sys.stderr)
             return 1
         return 0
-    except BrokenPipeError:
+    except BrokenPipeError as exc:
         # Python flushes standard streams on exit; redirect remaining output
         # to devnull to avoid another BrokenPipeError at shutdown
         # See: https://docs.python.org/3/library/signal.html#note-on-sigpipe
+        error = str(exc)
         devnull = os.open(os.devnull, os.O_WRONLY)
         os.dup2(devnull, sys.stdout.fileno())
         return 141  # 128 + 13 (SIGPIPE)
     except (KeyboardInterrupt, Exception) as exc:
+        error = str(exc)
         if isinstance(exc, KeyboardInterrupt):
             msg = "Operation cancelled by the user"
         else:
@@ -1028,3 +1032,5 @@ def main(argv: Optional[list[str]] = None) -> int:  # noqa: C901, PLR0912, PLR09
 
             pdb.post_mortem()
         return 1
+    finally:
+        telemetry.send_cli_call(args.command, error=error)

datachain/client/fsspec.py

@@ -3,7 +3,6 @@ import functools
 import logging
 import multiprocessing
 import os
-import posixpath
 import re
 import sys
 from abc import ABC, abstractmethod
@@ -26,8 +25,8 @@ from fsspec.asyn import get_loop, sync
 from fsspec.callbacks import DEFAULT_CALLBACK, Callback
 from tqdm import tqdm
 
-from datachain.cache import DataChainCache, UniqueId
-from datachain.client.fileslice import FileSlice, FileWrapper
+from datachain.cache import DataChainCache
+from datachain.client.fileslice import FileWrapper
 from datachain.error import ClientError as DataChainClientError
 from datachain.lib.file import File
 from datachain.nodes_fetcher import NodesFetcher
@@ -187,8 +186,8 @@ class Client(ABC):
     def url(self, path: str, expires: int = 3600, **kwargs) -> str:
         return self.fs.sign(self.get_full_path(path), expiration=expires, **kwargs)
 
-    async def get_current_etag(self, uid: UniqueId) -> str:
-        info = await self.fs._info(self.get_full_path(uid.path))
+    async def get_current_etag(self, file: "File") -> str:
+        info = await self.fs._info(self.get_full_path(file.path))
         return self.info_to_file(info, "").etag
 
     async def get_size(self, path: str) -> int:
@@ -317,7 +316,7 @@ class Client(ABC):
 
     def instantiate_object(
         self,
-        uid: UniqueId,
+        file: "File",
         dst: str,
         progress_bar: tqdm,
         force: bool = False,
@@ -328,10 +327,10 @@ class Client(ABC):
             else:
                 progress_bar.close()
                 raise FileExistsError(f"Path {dst} already exists")
-        self.do_instantiate_object(uid, dst)
+        self.do_instantiate_object(file, dst)
 
-    def do_instantiate_object(self, uid: "UniqueId", dst: str) -> None:
-        src = self.cache.get_path(uid)
+    def do_instantiate_object(self, file: "File", dst: str) -> None:
+        src = self.cache.get_path(file)
         assert src is not None
 
         try:
@@ -341,66 +340,33 @@ class Client(ABC):
             copy2(src, dst)
 
     def open_object(
-        self, uid: UniqueId, use_cache: bool = True, cb: Callback = DEFAULT_CALLBACK
+        self, file: File, use_cache: bool = True, cb: Callback = DEFAULT_CALLBACK
     ) -> BinaryIO:
         """Open a file, including files in tar archives."""
-        location = uid.get_parsed_location()
-        if use_cache and (cache_path := self.cache.get_path(uid)):
+        if use_cache and (cache_path := self.cache.get_path(file)):
             return open(cache_path, mode="rb")  # noqa: SIM115
-        if location and location["vtype"] == "tar":
-            return self._open_tar(uid, use_cache=True)
-        return FileWrapper(self.fs.open(self.get_full_path(uid.path)), cb)  # type: ignore[return-value]
-
-    def _open_tar(self, uid: UniqueId, use_cache: bool = True):
-        location = uid.get_parsed_location()
-        assert location
-
-        offset = location["offset"]
-        size = location["size"]
-        parent = location["parent"]
-
-        parent_uid = UniqueId(
-            parent["source"],
-            parent["path"],
-            parent["size"],
-            parent["etag"],
-            location=parent["location"],
-        )
-        f = self.open_object(parent_uid, use_cache=use_cache)
-        return FileSlice(f, offset, size, posixpath.basename(uid.path))
-
-    def download(self, uid: UniqueId, *, callback: Callback = DEFAULT_CALLBACK) -> None:
-        sync(get_loop(), functools.partial(self._download, uid, callback=callback))
-
-    async def _download(self, uid: UniqueId, *, callback: "Callback" = None) -> None:
-        if self.cache.contains(uid):
+        assert not file.location
+        return FileWrapper(self.fs.open(self.get_full_path(file.path)), cb)  # type: ignore[return-value]
+
+    def download(self, file: File, *, callback: Callback = DEFAULT_CALLBACK) -> None:
+        sync(get_loop(), functools.partial(self._download, file, callback=callback))
+
+    async def _download(self, file: File, *, callback: "Callback" = None) -> None:
+        if self.cache.contains(file):
             # Already in cache, so there's nothing to do.
             return
-        await self._put_in_cache(uid, callback=callback)
+        await self._put_in_cache(file, callback=callback)
 
-    def put_in_cache(self, uid: UniqueId, *, callback: "Callback" = None) -> None:
-        sync(get_loop(), functools.partial(self._put_in_cache, uid, callback=callback))
+    def put_in_cache(self, file: File, *, callback: "Callback" = None) -> None:
+        sync(get_loop(), functools.partial(self._put_in_cache, file, callback=callback))
 
-    async def _put_in_cache(
-        self, uid: UniqueId, *, callback: "Callback" = None
-    ) -> None:
-        location = uid.get_parsed_location()
-        if location and location["vtype"] == "tar":
-            loop = asyncio.get_running_loop()
-            await loop.run_in_executor(
-                None, functools.partial(self._download_from_tar, uid, callback=callback)
-            )
-            return
-        if uid.etag:
-            etag = await self.get_current_etag(uid)
-            if uid.etag != etag:
+    async def _put_in_cache(self, file: File, *, callback: "Callback" = None) -> None:
+        assert not file.location
+        if file.etag:
+            etag = await self.get_current_etag(file)
+            if file.etag != etag:
                 raise FileNotFoundError(
-                    f"Invalid etag for {uid.storage}/{uid.path}: "
-                    f"expected {uid.etag}, got {etag}"
+                    f"Invalid etag for {file.source}/{file.path}: "
+                    f"expected {file.etag}, got {etag}"
                 )
-        await self.cache.download(uid, self, callback=callback)
-
-    def _download_from_tar(self, uid, *, callback: "Callback" = None):
-        with self._open_tar(uid, use_cache=False) as f:
-            contents = f.read()
-        self.cache.store_data(uid, contents)
+        await self.cache.download(file, self, callback=callback)

datachain/client/local.py

@@ -7,7 +7,6 @@ from urllib.parse import urlparse
 
 from fsspec.implementations.local import LocalFileSystem
 
-from datachain.cache import UniqueId
 from datachain.lib.file import File
 from datachain.storage import StorageURI
 
@@ -114,8 +113,8 @@ class FileClient(Client):
             use_symlinks=use_symlinks,
         )
 
-    async def get_current_etag(self, uid: UniqueId) -> str:
-        info = self.fs.info(self.get_full_path(uid.path))
+    async def get_current_etag(self, file: "File") -> str:
+        info = self.fs.info(self.get_full_path(file.path))
         return self.info_to_file(info, "").etag
 
     async def get_size(self, path: str) -> int:

datachain/lib/arrow.py

@@ -49,7 +49,8 @@ class ArrowGenerator(Generator):
 
     def process(self, file: File):
         if file._caching_enabled:
-            path = file.get_local_path(download=True)
+            file.ensure_cached()
+            path = file.get_local_path()
             ds = dataset(path, schema=self.input_schema, **self.kwargs)
         elif self.nrows:
             path = _nrows_file(file, self.nrows)

datachain/lib/dc.py

@@ -58,6 +58,7 @@ from datachain.query.dataset import (
 )
 from datachain.query.schema import DEFAULT_DELIMITER, Column, DatasetRow
 from datachain.sql.functions import path as pathfunc
+from datachain.telemetry import telemetry
 from datachain.utils import inside_notebook
 
 if TYPE_CHECKING:
@@ -246,6 +247,9 @@ class DataChain(DatasetQuery):
             **kwargs,
             indexing_column_types=File._datachain_column_types,
         )
+
+        telemetry.send_event_once("class", "datachain_init", **kwargs)
+
         if settings:
             self._settings = Settings(**settings)
         else:

datachain/lib/file.py

@@ -1,11 +1,14 @@
+import hashlib
 import io
 import json
 import logging
 import os
 import posixpath
 from abc import ABC, abstractmethod
+from collections.abc import Iterator
 from contextlib import contextmanager
 from datetime import datetime
+from functools import partial
 from io import BytesIO
 from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, Optional, Union
@@ -19,7 +22,6 @@ from pydantic import Field, field_validator
 if TYPE_CHECKING:
     from typing_extensions import Self
 
-from datachain.cache import UniqueId
 from datachain.client.fileslice import FileSlice
 from datachain.lib.data_model import DataModel
 from datachain.lib.utils import DataChainError
@@ -27,7 +29,13 @@ from datachain.sql.types import JSON, Boolean, DateTime, Int, String
 from datachain.utils import TIME_ZERO
 
 if TYPE_CHECKING:
+    from typing_extensions import Self
+
     from datachain.catalog import Catalog
+    from datachain.client.fsspec import Client
+    from datachain.dataset import RowDict
+
+sha256 = partial(hashlib.sha256, usedforsecurity=False)
 
 logger = logging.getLogger("datachain")
 
@@ -38,7 +46,7 @@ ExportPlacement = Literal["filename", "etag", "fullpath", "checksum"]
 class VFileError(DataChainError):
     def __init__(self, file: "File", message: str, vtype: str = ""):
         type_ = f" of vtype '{vtype}'" if vtype else ""
-        super().__init__(f"Error in v-file '{file.get_uid().path}'{type_}: {message}")
+        super().__init__(f"Error in v-file '{file.path}'{type_}: {message}")
 
 
 class FileError(DataChainError):
@@ -85,9 +93,8 @@ class TarVFile(VFile):
         tar_file = File(**parent)
         tar_file._set_stream(file._catalog)
 
-        tar_file_uid = tar_file.get_uid()
-        client = file._catalog.get_client(tar_file_uid.storage)
-        fd = client.open_object(tar_file_uid, use_cache=file._caching_enabled)
+        client = file._catalog.get_client(tar_file.source)
+        fd = client.open_object(tar_file, use_cache=file._caching_enabled)
         return FileSlice(fd, offset, size, file.name)
 
 
@@ -181,7 +188,11 @@ class File(DataModel):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self._catalog = None
-        self._caching_enabled = False
+        self._caching_enabled: bool = False
+
+    @classmethod
+    def _from_row(cls, row: "RowDict") -> "Self":
+        return cls(**{key: row[key] for key in cls._datachain_column_types})
 
     @property
     def name(self):
@@ -192,19 +203,18 @@ class File(DataModel):
         return str(PurePosixPath(self.path).parent)
 
     @contextmanager
-    def open(self, mode: Literal["rb", "r"] = "rb"):
+    def open(self, mode: Literal["rb", "r"] = "rb") -> Iterator[Any]:
         """Open the file and return a file object."""
         if self.location:
             with VFileRegistry.resolve(self, self.location) as f:  # type: ignore[arg-type]
                 yield f
 
         else:
-            uid = self.get_uid()
-            client = self._catalog.get_client(self.source)
             if self._caching_enabled:
-                client.download(uid, callback=self._download_cb)
+                self.ensure_cached()
+            client: Client = self._catalog.get_client(self.source)
             with client.open_object(
-                uid, use_cache=self._caching_enabled, cb=self._download_cb
+                self, use_cache=self._caching_enabled, cb=self._download_cb
             ) as f:
                 yield io.TextIOWrapper(f) if mode == "r" else f
 
@@ -252,23 +262,25 @@ class File(DataModel):
         self._caching_enabled = caching_enabled
         self._download_cb = download_cb
 
-    def get_uid(self) -> UniqueId:
-        """Returns unique ID for file."""
-        dump = self.model_dump()
-        return UniqueId(*(dump[k] for k in self._unique_id_keys))
+    def ensure_cached(self) -> None:
+        if self._catalog is None:
+            raise RuntimeError(
+                "cannot download file to cache because catalog is not setup"
+            )
+        client = self._catalog.get_client(self.source)
+        client.download(self, callback=self._download_cb)
+
+    def get_local_path(self) -> Optional[str]:
+        """Return path to a file in a local cache.
 
-    def get_local_path(self, download: bool = False) -> Optional[str]:
-        """Returns path to a file in a local cache.
-        Return None if file is not cached. Throws an exception if cache is not setup."""
+        Returns None if file is not cached.
+        Raises an exception if cache is not setup.
+        """
         if self._catalog is None:
             raise RuntimeError(
                 "cannot resolve local file path because catalog is not setup"
             )
-        uid = self.get_uid()
-        if download:
-            client = self._catalog.get_client(self.source)
-            client.download(uid, callback=self._download_cb)
-        return self._catalog.cache.get_path(uid)
+        return self._catalog.cache.get_path(self)
 
     def get_file_suffix(self):
         """Returns last part of file name with `.`."""
@@ -323,6 +335,12 @@ class File(DataModel):
         """Returns `fsspec` filesystem for the file."""
         return self._catalog.get_client(self.source).fs
 
+    def get_hash(self) -> str:
+        fingerprint = f"{self.source}/{self.path}/{self.version}/{self.etag}"
+        if self.location:
+            fingerprint += f"/{self.location}"
+        return sha256(fingerprint.encode()).hexdigest()
+
     def resolve(self) -> "Self":
         """
         Resolve a File object by checking its existence and updating its metadata.

datachain/lib/listing.py

@@ -11,6 +11,7 @@ from datachain.client import Client
 from datachain.lib.file import File
 from datachain.query.schema import Column
 from datachain.sql.functions import path as pathfunc
+from datachain.telemetry import telemetry
 from datachain.utils import uses_glob
 
 if TYPE_CHECKING:
@@ -80,6 +81,7 @@ def parse_listing_uri(uri: str, cache, client_config) -> tuple[str, str, str]:
     client_config = client_config or {}
     client = Client.get_client(uri, cache, **client_config)
     storage_uri, path = Client.parse_url(uri)
+    telemetry.log_param("client", client.PREFIX)
 
     # clean path without globs
     lst_uri_path = (

datachain/listing.py

@@ -156,12 +156,12 @@ class Listing:
 
     def instantiate_nodes(
         self,
-        all_nodes,
+        all_nodes: Iterable[NodeWithPath],
         output,
         total_files=None,
         force=False,
         shared_progress_bar=None,
-    ):
+    ) -> None:
         progress_bar = shared_progress_bar or tqdm(
             desc=f"Instantiating '{output}'",
             unit=" files",
@@ -175,8 +175,8 @@ class Listing:
             dst = os.path.join(output, *node.path)
             dst_dir = os.path.dirname(dst)
             os.makedirs(dst_dir, exist_ok=True)
-            uid = node.n.as_uid(self.client.uri)
-            self.client.instantiate_object(uid, dst, progress_bar, force)
+            file = node.n.to_file(self.client.uri)
+            self.client.instantiate_object(file, dst, progress_bar, force)
             counter += 1
             if counter > 1000:
                 progress_bar.update(counter)

datachain/node.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 import attrs
 
-from datachain.cache import UniqueId
+from datachain.lib.file import File
 from datachain.storage import StorageURI
 from datachain.utils import TIME_ZERO, time_to_str
 
@@ -99,11 +99,11 @@ class Node:
             return self.path + "/"
         return self.path
 
-    def as_uid(self, storage: Optional[StorageURI] = None) -> UniqueId:
-        if storage is None:
-            storage = self.source
-        return UniqueId(
-            storage=storage,
+    def to_file(self, source: Optional[StorageURI] = None) -> File:
+        if source is None:
+            source = self.source
+        return File(
+            source=source,
             path=self.path,
             size=self.size,
             version=self.version or "",

datachain/nodes_fetcher.py

@@ -1,12 +1,19 @@
 import logging
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
+from datachain.node import Node
 from datachain.nodes_thread_pool import NodesThreadPool
 
+if TYPE_CHECKING:
+    from datachain.cache import DataChainCache
+    from datachain.client.fsspec import Client
+
 logger = logging.getLogger("datachain")
 
 
 class NodesFetcher(NodesThreadPool):
-    def __init__(self, client, max_threads, cache):
+    def __init__(self, client: "Client", max_threads: int, cache: "DataChainCache"):
         super().__init__(max_threads)
         self.client = client
         self.cache = cache
@@ -15,7 +22,7 @@ class NodesFetcher(NodesThreadPool):
         for task in done:
             task.result()
 
-    def do_task(self, chunk):
+    def do_task(self, chunk: Iterable[Node]) -> None:
         from fsspec import Callback
 
         class _CB(Callback):
@@ -23,8 +30,8 @@ class NodesFetcher(NodesThreadPool):
                 self.increase_counter(inc)
 
         for node in chunk:
-            uid = node.as_uid(self.client.uri)
-            if self.cache.contains(uid):
+            file = node.to_file(self.client.uri)
+            if self.cache.contains(file):
                 self.increase_counter(node.size)
             else:
-                self.client.put_in_cache(uid, callback=_CB())
+                self.client.put_in_cache(file, callback=_CB())