pathlibutil 0.1.6__tar.gz → 0.1.8__tar.gz

{pathlibutil-0.1.6 → pathlibutil-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pathlibutil
-Version: 0.1.6
+Version: 0.1.8
 Summary: inherits from pathlib.Path with methods for hashing, copying, deleting and more
 Home-page: https://d-chris.github.io
 License: MIT
@@ -40,6 +40,7 @@ Description-Content-Type: text/markdown
 - `Path.hexdigest()` to calculate and `Path.verify()` for verification of hexdigest from a file
 - `Path.default_hash` to configurate default hash algorithm for `Path` class (default: *'md5'*)
 - `Path.size()` to get size in bytes of a file or directory
+  - `byteint` function decorator converts the return value of `int` to a `ByteInt` object
 - `Path.read_lines()` to yield over all lines from a file until EOF
 - `contextmanager` to change current working directory with `with` statement
 - `Path.copy()` copy a file or directory to a new path destination
@@ -47,8 +48,11 @@ Description-Content-Type: text/markdown
 - `Path.move()` move a file or directory to a new path destination
 - `Path.make_archive()` creates and `Path.unpack_archive()` uncompresses an archive from a file or directory
 - `Path.archive_formats` to get all available archive formats
-- `byteint` function decorator to convert return value of `int` to a `ByteInt` object
-  
+- `Path.stat()` returns a `StatResult` object to get file or directory information containing
+  - `TimeInt` objects for `atime`, `ctime`, `mtime` and `birthtime`
+  - `ByteInt` object for `size`
+- `Path.relative_to()` to get relative path from a file or directory, `walk_up` to walk up the directory tree.
+
 ## Installation
 
 ```bash

{pathlibutil-0.1.6 → pathlibutil-0.1.8}/README.md

@@ -16,6 +16,7 @@
 - `Path.hexdigest()` to calculate and `Path.verify()` for verification of hexdigest from a file
 - `Path.default_hash` to configurate default hash algorithm for `Path` class (default: *'md5'*)
 - `Path.size()` to get size in bytes of a file or directory
+  - `byteint` function decorator converts the return value of `int` to a `ByteInt` object
 - `Path.read_lines()` to yield over all lines from a file until EOF
 - `contextmanager` to change current working directory with `with` statement
 - `Path.copy()` copy a file or directory to a new path destination
@@ -23,8 +24,11 @@
 - `Path.move()` move a file or directory to a new path destination
 - `Path.make_archive()` creates and `Path.unpack_archive()` uncompresses an archive from a file or directory
 - `Path.archive_formats` to get all available archive formats
-- `byteint` function decorator to convert return value of `int` to a `ByteInt` object
-  
+- `Path.stat()` returns a `StatResult` object to get file or directory information containing
+  - `TimeInt` objects for `atime`, `ctime`, `mtime` and `birthtime`
+  - `ByteInt` object for `size`
+- `Path.relative_to()` to get relative path from a file or directory, `walk_up` to walk up the directory tree.
+
 ## Installation
 
 ```bash

pathlibutil-0.1.8/pathlibutil/__init__.py

@@ -0,0 +1,8 @@
+"""
+.. include:: ../README.md
+"""
+
+from pathlibutil.path import Path, Register7zFormat
+from pathlibutil.types import ByteInt, TimeInt, byteint, StatResult
+
+__all__ = ["Path", "Register7zFormat", "ByteInt", "byteint", "TimeInt", "StatResult"]

pathlibutil-0.1.8/pathlibutil/base.py

@@ -0,0 +1,19 @@
+import os
+import pathlib
+import sys
+from typing import TypeVar
+
+_Path = TypeVar("_Path", bound=pathlib.Path)
+
+
+class BasePath(pathlib.Path):
+    """
+    Baseclass to inherit from `pathlib.Path`.
+
+    This class is only needed for python versions < 3.12.
+    """
+
+    if sys.version_info < (3, 12):
+        _flavour = (
+            pathlib._windows_flavour if os.name == "nt" else pathlib._posix_flavour
+        )

{pathlibutil-0.1.6 → pathlibutil-0.1.8}/pathlibutil/path.py

@@ -2,17 +2,14 @@ import errno
 import hashlib
 import itertools
 import os
-import pathlib
 import shutil
-import sys
-from typing import Callable, Dict, Generator, Set, TypeVar
+from typing import Callable, Dict, Generator, List, Set, Union
 
-from pathlibutil.types import ByteInt, byteint
+from pathlibutil.base import BasePath, _Path
+from pathlibutil.types import ByteInt, StatResult, _stat_result, byteint
 
-_Path = TypeVar("_Path", bound="Path")
 
-
-class Path(pathlib.Path):
+class Path(BasePath):
     """
     Path inherites from `pathlib.Path` and adds some methods to built-in python
     functions.
@@ -40,11 +37,6 @@ class Path(pathlib.Path):
     be the default
     """
 
-    if sys.version_info < (3, 12):
-        _flavour = (
-            pathlib._windows_flavour if os.name == "nt" else pathlib._posix_flavour
-        )
-
     def __init_subclass__(cls, **kwargs) -> None:
         """
         Register archive formats from subclasses.
@@ -172,7 +164,7 @@ class Path(pathlib.Path):
         if self.is_dir():
             return sum([p.size(**kwargs) for p in self.iterdir()])
 
-        return self.stat(**kwargs).st_size
+        return super().stat(**kwargs).st_size
 
     def copy(self, dst: str, exist_ok: bool = True, **kwargs) -> _Path:
         """
@@ -246,11 +238,11 @@ class Path(pathlib.Path):
         return self.__class__(_path)
 
     @staticmethod
-    def _find_archive_format(filename: "Path") -> str:
+    def _find_archive_format(filename: _Path) -> str:
         """
         Searches for a file the correct archive format.
         """
-        ext = ".".join(filename.suffixes)
+        ext = "".join(filename.suffixes)
 
         for name, extensions, _ in shutil.get_unpack_formats():
             if ext in extensions:
@@ -270,19 +262,61 @@ class Path(pathlib.Path):
         else:
             register_format()
 
-    def make_archive(self, archivename: str, **kwargs) -> _Path:
+    def make_archive(
+        self, archivename: str, *, exists_ok: bool = False, **kwargs
+    ) -> _Path:
         """
         Creates an archive file (eg. zip) and returns the path to the archive.
 
+        If `exists_ok` is `False` a `FileExistsError` is raised if the archive file
+        already exists.
+
+        If `exists_ok` is `True` the existing archive file will be deleted before
+        creating the new one.
+
         For `**kwargs` see `shutil.make_archive()`.
         - `root_dir` and `base_dir` will be resolved automatically
         - `format` will be determined by the file suffix
         - It can be overwritten with an `format` keyword-argument.
         - a `ValueError` is raised if the `format` is unknown.
+
+        >>> Path(__file__).make_archive('test.tar.gz')
+        Path('test.tar.gz')
+
+        >>> Path(__file__).make_archive('test.zpy', format='zip')
+        Path('test.zpy')
         """
+
+        def _archive_exists(file: str, exists_ok: bool) -> _Path:
+            """
+            Returns a `Path` object of the archive file or raises a `FileExistsError`
+            If `exists_ok` is `True` the file will be deleted.
+            """
+            file = self.__class__(file).resolve()
+
+            if file.exists():
+                if not exists_ok:
+                    raise FileExistsError(f"{file} already exists")
+
+                file.unlink()
+
+            return file
+
+        def _archive_filename(expect: Path, real: str) -> _Path:
+            """
+            Check if the expected archive filename matches the real filename.
+            If not try to rename the real filename.
+            """
+            file = self.__class__(real).resolve(True)
+
+            if file.suffixes != expect.suffixes:
+                return file.rename(expect)
+
+            return file
+
         _self = self.resolve(strict=True)
-        _archive = Path(archivename).resolve()
-        _format = kwargs.pop("format", self._find_archive_format(_archive))
+        _filename = _archive_exists(archivename, exists_ok)
+        _format = kwargs.pop("format", self._find_archive_format(_filename))
 
         _ = kwargs.pop("root_dir", None)
         _ = kwargs.pop("base_dir", None)
@@ -290,17 +324,19 @@ class Path(pathlib.Path):
         for _ in range(2):
             try:
                 _archive = shutil.make_archive(
-                    base_name=_archive.parent.joinpath(_archive.stem),
+                    base_name=_filename.with_suffix([]),
                     format=_format,
                     root_dir=_self.parent,
                     base_dir=_self.relative_to(_self.parent),
                     **kwargs,
                 )
 
-                return self.__class__(_archive)
+                break
             except ValueError:
                 self._register_format(_format)
 
+        return _archive_filename(_filename, _archive)
+
     def unpack_archive(self, extract_dir: str, **kwargs) -> _Path:
         """
         Unpacks an archive file (eg. zip) into a directory and returns the path to the
@@ -310,6 +346,12 @@ class Path(pathlib.Path):
         - `format` will be determined by the file suffix
         - It can be overwritten with an `format` keyword-argument.
         - a `ValueError` is raised if the `format` is unknown.
+
+        >>> Path('test.tar.gz').unpack_archive('test')
+        Path('test')
+
+        >>> Path('test.zpy').unpack_archive('test', format='zip')
+        Path('test')
         """
 
         _format = kwargs.pop("format", self._find_archive_format(self))
@@ -343,6 +385,96 @@ class Path(pathlib.Path):
 
         return set(formats)
 
+    def stat(self, **kwargs) -> _stat_result:
+        """
+        Returns a `StatResult` object which modifies following attributes:
+
+        - `st_size` is wrapped in `ByteInt`
+        - `st_atime`, `st_mtime`, `st_ctime`, `st_birthtime` are wrapped in `TimeInt`
+
+        For `**kwargs` see `pathlib.Path.stat()`.
+        """
+        return StatResult(super().stat(**kwargs))
+
+    def with_suffix(self, suffix: Union[str, List[str]]) -> _Path:
+        """
+        Return a new `Path` with changed suffix or remove it when its an empty
+        string.
+
+        Multiple suffixes can be changed at once by passing a list of suffixes.
+        With a empty list all suffixes will be removed.
+
+        >>> Path('test.a.b').with_suffix('.c')
+        Path('test.a.c')
+
+        >>> Path('test.a.b').with_suffix('')
+        Path('test.a')
+
+        >>> Path('test.a.b').with_suffix(['.c', '.d'])
+        Path('test.c.d')
+
+        >>> Path('test.a.b').with_suffix([])
+        Path('test')
+        """
+
+        try:
+            return super().with_suffix(suffix)
+        except (AttributeError, TypeError):
+            if isinstance(suffix, list) and not suffix:
+                suffix = ""
+            elif all(s.startswith(".") for s in suffix):
+                suffix = "".join(suffix)
+            elif all(not s for s in suffix):
+                suffix = ""
+            else:
+                raise ValueError(f"Invalid suffix '{suffix}'")
+
+            end = -1 * len(self.suffixes) or None
+            name = self.name.split(".")[0:end]
+            stem = self.parent.joinpath("".join(name))
+            return super(self.__class__, stem).with_suffix(suffix)
+
+    def relative_to(
+        self, *other: Union[str, _Path], walk_up: Union[bool, int] = False
+    ) -> _Path:
+        """
+        Return the relative path to another path identified by the passed
+        arguments.  If the operation is not possible (because this is not
+        related to the other path), raise `ValueError`.
+
+        The `walk_up` parameter controls whether `..` may be used to resolve
+        the path.
+
+        If `walk_up` is a integer it specifies the maximum number of `..` to resolve, if
+        max is reached a `ValueError` is raised.
+
+        >>> Path('a/b/c/d').relative_to('a/b')
+        Path('c/d')
+
+        >>> Path('a/b/c/d').relative_to('a/b/e/f/g', walk_up=True)
+        Path('../../../c/d')
+
+        >>> Path('a/b/c/d').relative_to('a/b/e/f/g', walk_up=2)
+        ValueError: '../../../c/d' is outside of the relative deepth of '2'
+        """
+        if not walk_up:
+            return super().relative_to(*other)
+
+        try:
+            relative = super().relative_to(*other, walk_up=walk_up)
+        except TypeError:
+            relative = self.__class__(os.path.relpath(self, Path(*other)))
+
+        if type(walk_up) is not int:
+            return relative
+
+        if relative.parts.count("..") > walk_up:
+            raise ValueError(
+                f"'{relative}' is outside of the relative deepth of '{walk_up}'"
+            )
+
+        return relative
+
 
 class Register7zFormat(Path, archive="7z"):
     """

{pathlibutil-0.1.6 → pathlibutil-0.1.8}/pathlibutil/types.py

@@ -1,14 +1,17 @@
 import functools
+import os
 import re
-from typing import Set, Tuple, TypeVar
+from datetime import datetime, tzinfo
+from typing import Set, Tuple, TypeVar, Iterable
 
 _ByteInt = TypeVar("_ByteInt", bound="ByteInt")
+_stat_result = TypeVar("_stat_result", bound="os.stat_result")
 
 
 class ByteInt(int):
     """
     Inherit from `int` with attributes to convert bytes to decimal or binary `units` for
-    measuring storage data. These attributes will return a `float`
+    measuring storage data. These attributes will return a `float`.
 
     >>> ByteInt(1234).kb
     1.234
@@ -17,6 +20,11 @@ class ByteInt(int):
 
     >>> f"{ByteInt(6543210):.2mib} mebibytes"
     '6.24 mebibytes'
+
+    String representation of `ByteInt` will return the most appropriate decimal unit.
+
+    >>> str(ByteInt(987654))
+    '987.7 kb'
     """
 
     __regex = re.compile(r"(?P<unit>[kmgtpezy]i?b)")
@@ -62,6 +70,36 @@ class ByteInt(int):
         """
         return set(self.__bytes.keys())
 
+    def __str__(self) -> str:
+        return self.string()
+
+    def string(self, decimal=True) -> str:
+        """
+        Return a string representation of `self` in the most appropriate unit.
+
+        If `decimal` is `False` then binary units will be used instead of `decimal`.
+
+        >>> ByteInt(12346789).string(False)
+        '11.77 mib'
+        """
+
+        def _decimal(x):
+            return "i" not in x[0]
+
+        def _binary(x):
+            return x[0].endswith("ib")
+
+        query = _decimal if decimal else _binary
+
+        for unit, (byte, _) in filter(query, self.__bytes.items()):
+            value = self / byte
+
+            if 1 <= value < 1000:
+                dec = 2 if value < 100 else 1
+                return value.__format__(f".{dec}f") + f" {unit}"
+
+        return f"{int(self)} b"
+
     @classmethod
     def info(cls, unit: str) -> Tuple[int, str]:
         """
@@ -190,3 +228,126 @@ def byteint(func):
         return value
 
     return wrapper
+
+
+class TimeInt(float):
+    """
+    Inherit from `float` with attributes to convert seconds to `datetime` objects.
+
+    >>> TimeInt(0).datetime
+    datetime.datetime(1970, 1, 1, 0, 0)
+
+    >>> TimeInt(0).string('%d.%m.%Y')
+    '01.01.1970'
+
+    Return a string representation using `TimeInt.format`.
+
+    >>> str(TimeInt(0))
+    '1970-01-01 00:00:00'
+    """
+
+    format = "%Y-%m-%d %H:%M:%S"
+    """
+    Format string to which is uesed to convert `self` to a string. Default: 'isoformat'.
+    For more information see `datetime.datetime.strftime`.
+    """
+
+    def __new__(cls, value: int, tz: tzinfo = None) -> float:
+        """
+        Create a new instance from baseclass `int`.
+        """
+        return super().__new__(cls, value)
+
+    def __init__(self, value: int, tz: tzinfo = None) -> None:
+        """
+        Create a new instance from baseclass `int` with optional `timezone` info.
+        """
+        self.timezone = tz
+        """
+        property for `datetime.timezone` object is set with `__init__` or can be
+        changed to different timezones to get the correct string reprensentation. If
+        timezone is `None` then the local timezone is used.
+        """
+
+    @functools.cached_property
+    def datetime(self) -> datetime:
+        """
+        property returns a `datetime.datetime` object.
+        """
+        return datetime.fromtimestamp(self, self.timezone)
+
+    def __str__(self) -> str:
+        """
+        Return a string representation of `datetime` using `self.format`.
+        """
+        return self.string()
+
+    def string(self, format_string: str = None) -> str:
+        """
+        Return a string representation of `datetime` using the `format_string`.
+
+        If `format_string` is `None` then `TimeInt.format` is used.
+        """
+        return self.datetime.strftime(format_string or self.format)
+
+
+class StatResult:
+    """
+    Object converts `st_size` to `ByteInt` and
+    `st_atime`, `st_mtime`, `st_ctime` and `st_birthtime` to `TimeInt`.
+
+    Inheritance was not possible due `@final` decorator is applied to `os.stat_result`
+    to prevent subclassing.
+    """
+
+    def __init__(self, stat):
+        """
+        Wrapper for `os.stat_result`.
+        """
+        self._obj = stat
+
+    def __getattr__(self, name):
+        """
+        Forward all unknown attributes to `self._obj`.
+        """
+        attr = getattr(self._obj, name)
+
+        if isinstance(attr, int):
+            if name == "st_size":
+                return ByteInt(attr)
+        elif isinstance(attr, float):
+            if name in ("st_atime", "st_mtime", "st_ctime", "st_birthtime"):
+                return TimeInt(attr)
+
+        return attr
+
+    def __str__(self) -> str:
+        """
+        Return a string of `os.stat_result` object.
+        """
+        return str(self._obj)
+
+    def __repr__(self) -> str:
+        """
+        Return representation of `os.stat_result` object.
+        """
+        return repr(self._obj)
+
+    def __dir__(self) -> Iterable[str]:
+        """
+        Return a list of attributes of `os.stat_result` object.
+        """
+        return dir(self._obj)
+
+    def __len__(self) -> int:
+        """
+        Return length of `os.stat_result` object.
+        """
+        return len(self._obj)
+
+    @property
+    def stat_result(self) -> os.stat_result:
+        """
+        Return the wrapped `os.stat_result` object.
+        """
+        return self._obj

{pathlibutil-0.1.6 → pathlibutil-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pathlibutil"
-version = "v0.1.6"
+version = "v0.1.8"
 description = "inherits from pathlib.Path with methods for hashing, copying, deleting and more"
 authors = ["Christoph Dörrer <d-chris@web.de>"]
 readme = "README.md"
@@ -33,6 +33,7 @@ tox = "^4.11.4"
 pytest-random-order = "^1.1.0"
 pytest-cov = "^4.1.0"
 pytest-mock = "^3.12.0"
+exrex = "^0.11.0"
 
 [tool.poetry.group.code.dependencies]
 flake8 = "^7.0.0"
@@ -63,8 +64,9 @@ testpaths = "tests"
 addopts = [
     "--random-order",
     "--color=yes",
-    "--cov=pathlibutil",
-    "--cov-report=term-missing:skip-covered",
-    "--cov-append",
+    "-s",
+    # "--cov=pathlibutil",
+    # "--cov-report=term-missing:skip-covered",
+    # "--cov-append",
     # "--cov-report=html",
 ]

pathlibutil-0.1.6/pathlibutil/__init__.py

@@ -1,8 +0,0 @@
-"""
-.. include:: ../README.md
-"""
-
-from pathlibutil.path import Path, Register7zFormat
-from pathlibutil.types import ByteInt, byteint
-
-__all__ = ["Path", "Register7zFormat", "ByteInt", "byteint"]