pathlib-next 0.1.1__tar.gz → 0.1.3__tar.gz

{pathlib_next-0.1.1 → pathlib_next-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pathlib_next
-Version: 0.1.1
+Version: 0.1.3
 Summary: Generic Path Protocol based pathlib
 Project-URL: Homepage, https://github.com/jose-pr/pathlib_next/
 Project-URL: Issues, https://github.com/jose-pr/pathlib_next/issues

{pathlib_next-0.1.1 → pathlib_next-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathlib_next"
-version = "0.1.1"
+version = "0.1.3"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

pathlib_next-0.1.3/src/example.py

@@ -0,0 +1,66 @@
+from pathlib_next import Path, glob
+from pathlib_next.mempath import MemPath
+from pathlib_next.uri import Query, Source, UriPath
+from pathlib_next.uri.schemes import *
+from pathlib_next.utils.sync import PathSyncer
+
+mempath = MemPath("test/test3")
+mempath.parent.mkdir(parents=True, exist_ok=True)
+mempath.write_text("test")
+check = mempath.read_text()
+mempath.parent.rm(recursive=True)
+
+pass
+
+local = Path("./_ssh")
+print(list(local.iterdir()))
+query = Query({"test": "://$#!1", "test2&": [1, 2]})
+q2 = Query(str(query)).to_dict()
+for name, value in query:
+    print(f"{name}: {value}")
+src = Source(scheme="scheme", userinfo="user", host="123.com", port=0)
+test = {**src}
+test2 = [*src]
+dest = UriPath("file:./_ssh")
+
+#
+# Norm test
+#
+with_dots = UriPath("a/b/c/d/../../test/.")
+print(with_dots.normalized_path)
+
+source_host = UriPath("file://test.com/path1/path2/path3/path4")
+source_host.is_local()
+
+rel_to = source_host.relative_to("/path1/path2")
+dest = UriPath(dest)
+test_ = UriPath("file:") / "test"
+empty = UriPath()
+uri = dest.as_uri()
+
+test1 = dest / "test" / "test2/"
+print(test1)
+
+sftp_root = UriPath("sftp://root@sftpexample/")
+print(sftp_root.as_posix())
+authkeys = sftp_root / "root/.ssh/authorized_keys"
+print(authkeys.as_posix())
+
+
+def checksum(uri: UriPath):
+    stat = uri.stat()
+    return hash(stat.st_size)
+
+
+syncer = PathSyncer(checksum, remove_missing=False)
+syncer.sync((sftp_root / "root/.ssh"), dest, dry_run=True)
+
+rocky_repo = UriPath("http://dl.rockylinux.org/pub")
+
+glob_test = UriPath("file:./**/*.py")
+
+for path in glob.glob(glob_test, recursive=True):
+    print(path)
+
+print(rocky_repo.is_dir())
+print(list(rocky_repo.iterdir()))

pathlib_next-0.1.3/src/pathlib_next/mempath.py

@@ -0,0 +1,149 @@
+import io
+import posixpath as _posix
+from io import IOBase
+from urllib.parse import quote as _urlquote
+
+from .path import Path
+from .utils.stat import FileStat, FileStatLike
+
+
+class MemPathBackend(dict): ...
+
+
+class MemBytesIO(io.BytesIO):
+    def __init__(self, initial_bytes: bytearray) -> None:
+        self._bytes = initial_bytes
+        super().__init__(initial_bytes)
+
+    def close(self) -> None:
+        self.seek(0)
+        self._bytes.clear()
+        self._bytes.extend(self.read())
+        return super().close()
+
+
+class MemPath(Path):
+
+    __slots__ = ("_backend", "_segments", "_normalized")
+
+    def __init__(self, *segments: str, backend: MemPathBackend = None, **kwargs):
+        self._segments = "/".join(segments).split("/")
+        self._backend = backend if backend is not None else MemPathBackend()
+        self._normalized = None
+
+    @property
+    def backend(self):
+        return self._backend
+
+    @property
+    def normalized(self):
+        if self._normalized is None:
+            self._normalized = (
+                _posix.normpath("/".join(self.segments))
+                .removeprefix(".")
+                .removeprefix("/")
+                .split("/")
+            )
+        return self._normalized
+
+    @property
+    def segments(self):
+        return self._segments
+
+    @property
+    def parts(self):
+        return self.segments, self.backend
+
+    @property
+    def parent(self):
+        segments = self.segments[:-1]
+        if segments == self.segments:
+            return self
+        return self.with_segments(*segments)
+
+    def relative_to(self, other):
+        raise NotImplementedError()
+
+    def with_segments(self, *segments: str):
+        return type(self)(*segments, backend=self.backend)
+
+    def as_uri(self):
+        path = "/".join(self.segments)
+        return f"mempath:{_urlquote(path)}"
+
+    def _parent_container(self) -> tuple[dict[str, bytearray], str]:
+        parent = self.backend
+        *ancestors, name = self.normalized
+        for path in ancestors:
+            if path not in parent:
+                raise FileNotFoundError(self.parent)
+            else:
+                parent = parent[path]
+
+        return parent, name
+
+    def _mkdir(self, mode: int):
+        parent, name = self._parent_container()
+        if name in parent:
+            raise FileExistsError(name)
+        parent[name] = {}
+
+    def rmdir(self):
+        parent, name = self._parent_container()
+        if not name:
+            raise FileNotFoundError(self)
+        content = parent.get(name)
+        if content is None:
+            raise FileNotFoundError(self)
+        elif not isinstance(content, dict):
+            raise NotADirectoryError(self)
+        elif len(content) != 0:
+            raise FileExistsError(self)
+        parent.pop(name)
+
+    def unlink(self, missing_ok=False):
+        parent, name = self._parent_container()
+        if not name:
+            if missing_ok:
+                return
+            raise FileNotFoundError(self)
+        content = parent.get(name)
+        if content is None:
+            if missing_ok:
+                return
+            raise FileNotFoundError(self)
+        elif isinstance(content, dict):
+            raise IsADirectoryError(self)
+        parent.pop(name)
+
+    def stat(self, *, follow_symlinks=True) -> FileStatLike:
+        parent, name = self._parent_container()
+        if not name:
+            return FileStat(is_dir=True)
+
+        if name not in parent:
+            return FileNotFoundError(self)
+
+        return FileStat(is_dir=isinstance(parent[name], dict))
+
+    def iterdir(self):
+        parent, name = self._parent_container()
+        content = parent.get(name) if name else parent
+        cls = type(self)
+
+        if not isinstance(content, dict):
+            raise NotADirectoryError(self)
+        for c in list(content.keys()):
+            yield cls(*self.segments, c, backend=self.backend)
+
+    def _open(self, mode="r", buffering=-1) -> IOBase:
+        parent, name = self._parent_container()
+        if "w" in mode:
+            content = parent.setdefault(name, bytearray())
+            return MemBytesIO(content)
+        elif name not in parent:
+            return FileNotFoundError(self)
+        else:
+            content = parent[name]
+
+        return io.BytesIO(content)

{pathlib_next-0.1.1 → pathlib_next-0.1.3}/src/pathlib_next/uri/__init__.py

@@ -1,19 +1,18 @@
 import os
-import typing as _ty
-import uritools
-import posixpath as _posix
 import pathlib as _pathlib
+import posixpath as _posix
+import typing as _ty
 
+import uritools
 
 if _ty.TYPE_CHECKING:
     from typing import Self
 
 from .. import utils as _utils
+from ..path import Path, Pathname
 from .query import Query
 from .source import Source
 
-from ..path import Path, Pathname
-
 UriLike: _ty.TypeAlias = "str | Uri | os.PathLike"
 
 _NOSOURCE = Source(None, None, None, None)
@@ -404,6 +403,13 @@ class UriPath(Uri, Path):
     def _initbackend(self):
         return None
 
+    def _from_parsed_parts(
+        self, source: Source, path: str, query: str, fragment: str, /, **kwargs
+    ):
+        if "backend" not in kwargs:
+            kwargs["backend"] = self.backend
+        return super()._from_parsed_parts(source, path, query, fragment, **kwargs)
+
     def _init(
         self,
         source: Source,

pathlib_next-0.1.1/src/example.py

@@ -1,54 +0,0 @@
-from pathlib_next.uri import UriPath, Query, Source
-from pathlib_next.uri.schemes import *
-from pathlib_next.utils.sync import PathSyncer
-from pathlib_next import glob, Path
-
-local = Path('./_ssh')
-print(list(local.iterdir()))
-query = Query({'test':'://$#!1', 'test2&': [1,2]})
-q2 =  Query(str(query)).to_dict()
-for name, value in query:
-    print(f"{name}: {value}")
-src = Source(scheme='scheme',userinfo='user', host='123.com', port=0)
-test = {**src}
-test2 = [*src]
-dest = UriPath('file:./_ssh')
-
-#
-# Norm test
-#
-with_dots = UriPath('a/b/c/d/../../test/.')
-print(with_dots.normalized_path)
-
-source_host = UriPath('file://test.com/path1/path2/path3/path4')
-source_host.is_local()
-
-rel_to  = source_host.relative_to('/path1/path2')
-dest = UriPath(dest)
-test_ = UriPath('file:') / 'test'
-empty = UriPath()
-uri = dest.as_uri()
-
-test1 = dest / 'test' / 'test2/'
-print(test1)
-
-sftp_root = UriPath('sftp://root@sftpexample/')
-print(sftp_root.as_posix())
-authkeys = sftp_root / 'root/.ssh/authorized_keys'
-print(authkeys.as_posix())
-
-def checksum(uri:UriPath):
-    stat = uri.stat()
-    return hash(stat.st_size)
-syncer =PathSyncer(checksum, remove_missing=False)
-syncer.sync((sftp_root / 'root/.ssh'), dest, dry_run=True)
-
-rocky_repo = UriPath('http://dl.rockylinux.org/pub')
-
-glob_test = UriPath("file:./**/*.py")
-
-for path in glob.glob(glob_test, recursive=True):
-    print(path)
-
-print(rocky_repo.is_dir())
-print(list(rocky_repo.iterdir()))