codekingpro/portable-devtools

1from .. import filesystem2from ..asyn import AsyncFileSystem3from .chained import ChainedFileSystem4 5 6class DirFileSystem(AsyncFileSystem, ChainedFileSystem):7    """Directory prefix filesystem8 9    The DirFileSystem is a filesystem-wrapper. It assumes every path it is dealing with10    is relative to the `path`. After performing the necessary paths operation it11    delegates everything to the wrapped filesystem.12    """13 14    protocol = "dir"15 16    def __init__(17        self,18        path=None,19        fs=None,20        fo=None,21        target_protocol=None,22        target_options=None,23        **storage_options,24    ):25        """26        Parameters27        ----------28        path: str29            Path to the directory.30        fs: AbstractFileSystem31            An instantiated filesystem to wrap.32        target_protocol, target_options:33            if fs is none, construct it from these34        fo: str35            Alternate for path; do not provide both36        """37        super().__init__(**storage_options)38        if fs is None:39            fs = filesystem(protocol=target_protocol, **(target_options or {}))40        path = path or fo41 42        if self.asynchronous and not fs.async_impl:43            raise ValueError("can't use asynchronous with non-async fs")44 45        if fs.async_impl and self.asynchronous != fs.asynchronous:46            raise ValueError("both dirfs and fs should be in the same sync/async mode")47 48        self.path = fs._strip_protocol(path)49        self.fs = fs50 51    def _join(self, path):52        if isinstance(path, str):53            if not self.path:54                return path55            if not path:56                return self.path57            return self.fs.sep.join((self.path, self._strip_protocol(path)))58        if isinstance(path, dict):59            return {self._join(_path): value for _path, value in path.items()}60        return [self._join(_path) for _path in path]61 62    def _relpath(self, path):63        if isinstance(path, str):64            if not self.path:65                return path66            # We need to account for S3FileSystem returning paths that do not67            # start with a '/'68            if path == self.path or (69                self.path.startswith(self.fs.sep) and path == self.path[1:]70            ):71                return ""72            prefix = self.path + self.fs.sep73            if self.path.startswith(self.fs.sep) and not path.startswith(self.fs.sep):74                prefix = prefix[1:]75            assert path.startswith(prefix)76            return path[len(prefix) :]77        return [self._relpath(_path) for _path in path]78 79    # Wrappers below80 81    @property82    def sep(self):83        return self.fs.sep84 85    async def set_session(self, *args, **kwargs):86        return await self.fs.set_session(*args, **kwargs)87 88    async def _rm_file(self, path, **kwargs):89        return await self.fs._rm_file(self._join(path), **kwargs)90 91    def rm_file(self, path, **kwargs):92        return self.fs.rm_file(self._join(path), **kwargs)93 94    async def _rm(self, path, *args, **kwargs):95        return await self.fs._rm(self._join(path), *args, **kwargs)96 97    def rm(self, path, *args, **kwargs):98        return self.fs.rm(self._join(path), *args, **kwargs)99 100    def delete(self, path, recursive=False, maxdepth=None):101        return self.fs.delete(self._join(path), recursive=recursive, maxdepth=maxdepth)102 103    async def _cp_file(self, path1, path2, **kwargs):104        return await self.fs._cp_file(self._join(path1), self._join(path2), **kwargs)105 106    def cp_file(self, path1, path2, **kwargs):107        return self.fs.cp_file(self._join(path1), self._join(path2), **kwargs)108 109    async def _copy(110        self,111        path1,112        path2,113        *args,114        **kwargs,115    ):116        return await self.fs._copy(117            self._join(path1),118            self._join(path2),119            *args,120            **kwargs,121        )122 123    def copy(self, path1, path2, *args, **kwargs):124        return self.fs.copy(125            self._join(path1),126            self._join(path2),127            *args,128            **kwargs,129        )130 131    async def _pipe(self, path, *args, **kwargs):132        return await self.fs._pipe(self._join(path), *args, **kwargs)133 134    def pipe(self, path, *args, **kwargs):135        return self.fs.pipe(self._join(path), *args, **kwargs)136 137    async def _pipe_file(self, path, *args, **kwargs):138        return await self.fs._pipe_file(self._join(path), *args, **kwargs)139 140    def pipe_file(self, path, *args, **kwargs):141        return self.fs.pipe_file(self._join(path), *args, **kwargs)142 143    def write_text(144        self, path, value, encoding=None, errors=None, newline=None, **kwargs145    ):146        return self.fs.write_text(147            self._join(path),148            value,149            encoding=encoding,150            errors=errors,151            newline=newline,152            **kwargs,153        )154 155    async def _cat_file(self, path, *args, **kwargs):156        return await self.fs._cat_file(self._join(path), *args, **kwargs)157 158    def cat_file(self, path, *args, **kwargs):159        return self.fs.cat_file(self._join(path), *args, **kwargs)160 161    async def _cat(self, path, *args, **kwargs):162        ret = await self.fs._cat(163            self._join(path),164            *args,165            **kwargs,166        )167 168        if isinstance(ret, dict):169            return {self._relpath(key): value for key, value in ret.items()}170 171        return ret172 173    def cat(self, path, *args, **kwargs):174        ret = self.fs.cat(175            self._join(path),176            *args,177            **kwargs,178        )179 180        if isinstance(ret, dict):181            return {self._relpath(key): value for key, value in ret.items()}182 183        return ret184 185    async def _put_file(self, lpath, rpath, **kwargs):186        return await self.fs._put_file(lpath, self._join(rpath), **kwargs)187 188    def put_file(self, lpath, rpath, **kwargs):189        return self.fs.put_file(lpath, self._join(rpath), **kwargs)190 191    async def _put(192        self,193        lpath,194        rpath,195        *args,196        **kwargs,197    ):198        return await self.fs._put(199            lpath,200            self._join(rpath),201            *args,202            **kwargs,203        )204 205    def put(self, lpath, rpath, *args, **kwargs):206        return self.fs.put(207            lpath,208            self._join(rpath),209            *args,210            **kwargs,211        )212 213    async def _get_file(self, rpath, lpath, **kwargs):214        return await self.fs._get_file(self._join(rpath), lpath, **kwargs)215 216    def get_file(self, rpath, lpath, **kwargs):217        return self.fs.get_file(self._join(rpath), lpath, **kwargs)218 219    async def _get(self, rpath, *args, **kwargs):220        return await self.fs._get(self._join(rpath), *args, **kwargs)221 222    def get(self, rpath, *args, **kwargs):223        return self.fs.get(self._join(rpath), *args, **kwargs)224 225    async def _isfile(self, path):226        return await self.fs._isfile(self._join(path))227 228    def isfile(self, path):229        return self.fs.isfile(self._join(path))230 231    async def _isdir(self, path):232        return await self.fs._isdir(self._join(path))233 234    def isdir(self, path):235        return self.fs.isdir(self._join(path))236 237    async def _size(self, path):238        return await self.fs._size(self._join(path))239 240    def size(self, path):241        return self.fs.size(self._join(path))242 243    async def _exists(self, path):244        return await self.fs._exists(self._join(path))245 246    def exists(self, path):247        return self.fs.exists(self._join(path))248 249    async def _info(self, path, **kwargs):250        info = await self.fs._info(self._join(path), **kwargs)251        info = info.copy()252        info["name"] = self._relpath(info["name"])253        return info254 255    def info(self, path, **kwargs):256        info = self.fs.info(self._join(path), **kwargs)257        info = info.copy()258        info["name"] = self._relpath(info["name"])259        return info260 261    async def _ls(self, path, detail=True, **kwargs):262        ret = (await self.fs._ls(self._join(path), detail=detail, **kwargs)).copy()263        if detail:264            out = []265            for entry in ret:266                entry = entry.copy()267                entry["name"] = self._relpath(entry["name"])268                out.append(entry)269            return out270 271        return self._relpath(ret)272 273    def ls(self, path, detail=True, **kwargs):274        ret = self.fs.ls(self._join(path), detail=detail, **kwargs).copy()275        if detail:276            out = []277            for entry in ret:278                entry = entry.copy()279                entry["name"] = self._relpath(entry["name"])280                out.append(entry)281            return out282 283        return self._relpath(ret)284 285    async def _walk(self, path, *args, **kwargs):286        async for root, dirs, files in self.fs._walk(self._join(path), *args, **kwargs):287            yield self._relpath(root), dirs, files288 289    def walk(self, path, *args, **kwargs):290        for root, dirs, files in self.fs.walk(self._join(path), *args, **kwargs):291            yield self._relpath(root), dirs, files292 293    async def _glob(self, path, **kwargs):294        detail = kwargs.get("detail", False)295        ret = await self.fs._glob(self._join(path), **kwargs)296        if detail:297            return {self._relpath(path): info for path, info in ret.items()}298        return self._relpath(ret)299 300    def glob(self, path, **kwargs):301        detail = kwargs.get("detail", False)302        ret = self.fs.glob(self._join(path), **kwargs)303        if detail:304            return {self._relpath(path): info for path, info in ret.items()}305        return self._relpath(ret)306 307    async def _du(self, path, *args, **kwargs):308        total = kwargs.get("total", True)309        ret = await self.fs._du(self._join(path), *args, **kwargs)310        if total:311            return ret312 313        return {self._relpath(path): size for path, size in ret.items()}314 315    def du(self, path, *args, **kwargs):316        total = kwargs.get("total", True)317        ret = self.fs.du(self._join(path), *args, **kwargs)318        if total:319            return ret320 321        return {self._relpath(path): size for path, size in ret.items()}322 323    async def _find(self, path, *args, **kwargs):324        detail = kwargs.get("detail", False)325        ret = await self.fs._find(self._join(path), *args, **kwargs)326        if detail:327            return {self._relpath(path): info for path, info in ret.items()}328        return self._relpath(ret)329 330    def find(self, path, *args, **kwargs):331        detail = kwargs.get("detail", False)332        ret = self.fs.find(self._join(path), *args, **kwargs)333        if detail:334            return {self._relpath(path): info for path, info in ret.items()}335        return self._relpath(ret)336 337    async def _expand_path(self, path, *args, **kwargs):338        return self._relpath(339            await self.fs._expand_path(self._join(path), *args, **kwargs)340        )341 342    def expand_path(self, path, *args, **kwargs):343        return self._relpath(self.fs.expand_path(self._join(path), *args, **kwargs))344 345    async def _mkdir(self, path, *args, **kwargs):346        return await self.fs._mkdir(self._join(path), *args, **kwargs)347 348    def mkdir(self, path, *args, **kwargs):349        return self.fs.mkdir(self._join(path), *args, **kwargs)350 351    async def _makedirs(self, path, *args, **kwargs):352        return await self.fs._makedirs(self._join(path), *args, **kwargs)353 354    def makedirs(self, path, *args, **kwargs):355        return self.fs.makedirs(self._join(path), *args, **kwargs)356 357    def rmdir(self, path):358        return self.fs.rmdir(self._join(path))359 360    def mv(self, path1, path2, **kwargs):361        return self.fs.mv(362            self._join(path1),363            self._join(path2),364            **kwargs,365        )366 367    def touch(self, path, **kwargs):368        return self.fs.touch(self._join(path), **kwargs)369 370    def created(self, path):371        return self.fs.created(self._join(path))372 373    def modified(self, path):374        return self.fs.modified(self._join(path))375 376    def sign(self, path, *args, **kwargs):377        return self.fs.sign(self._join(path), *args, **kwargs)378 379    def __repr__(self):380        return f"{self.__class__.__qualname__}(path='{self.path}', fs={self.fs})"381 382    def open(383        self,384        path,385        *args,386        **kwargs,387    ):388        return self.fs.open(389            self._join(path),390            *args,391            **kwargs,392        )393 394    async def open_async(395        self,396        path,397        *args,398        **kwargs,399    ):400        return await self.fs.open_async(401            self._join(path),402            *args,403            **kwargs,404        )405