pyfileops 1.0.0__py3-none-any.whl

pyfileops/__init__.py

@@ -0,0 +1,52 @@
+"""
+pyfileops
+~~~~~~~~~
+A simple, friendly Python library for file and directory operations.
+
+Quickstart::
+
+    from pyfileops import fs
+
+    fs.copy("report.pdf", "backup/")
+    fs.cut("draft.txt", "archive/")
+    fs.rename("old_name.txt", "new_name.txt")
+    fs.delete("temp.log")
+
+    fs.mkdir("project/assets")
+    fs.rmdir("tmp")
+
+    fs.zip("project", "project.zip")
+    fs.unzip("project.zip", "restored/")
+
+    print(fs.exists("config.ini"))   # True / False
+    print(fs.size("video.mp4"))      # bytes
+    print(fs.is_file("data.csv"))    # True / False
+    print(fs.is_dir("src"))          # True / False
+"""
+
+from .core import FileSystem
+from .exceptions import (
+    CopyError,
+    DeleteError,
+    FileOpsError,
+    PathNotFoundError,
+    ZipError,
+)
+
+__all__ = [
+    "fs",
+    "FileSystem",
+    # Exceptions
+    "FileOpsError",
+    "PathNotFoundError",
+    "CopyError",
+    "DeleteError",
+    "ZipError",
+]
+
+__version__ = "0.1.0"
+__author__ = "pyfileops contributors"
+__license__ = "MIT"
+
+#: Global, ready-to-use :class:`~pyfileops.core.FileSystem` instance.
+fs: FileSystem = FileSystem()

pyfileops/core.py

@@ -0,0 +1,366 @@
+"""
+pyfileops.core
+~~~~~~~~~~~~~~
+Core implementation of the FileSystem class.
+Provides a simple, unified API for common file and directory operations.
+"""
+
+import os
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Union
+
+from .exceptions import (
+    CopyError,
+    DeleteError,
+    FileOpsError,
+    PathNotFoundError,
+    ZipError,
+)
+
+# Type alias accepted for all path arguments
+PathLike = Union[str, os.PathLike]
+
+
+class FileSystem:
+    """
+    A simple, friendly interface for file and directory operations.
+
+    Usage::
+
+        from pyfileops import fs
+
+        fs.copy("report.pdf", "backup/")
+        fs.delete("temp.log")
+        print(fs.size("video.mp4"))
+    """
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _resolve(path: PathLike) -> Path:
+        """Return an absolute, resolved :class:`pathlib.Path`."""
+        return Path(path).resolve()
+
+    def _require_exists(self, path: PathLike) -> Path:
+        """Resolve *path* and raise :exc:`PathNotFoundError` if it is missing."""
+        resolved = self._resolve(path)
+        if not resolved.exists():
+            raise PathNotFoundError(str(path))
+        return resolved
+
+    # ------------------------------------------------------------------
+    # File operations
+    # ------------------------------------------------------------------
+
+    def copy(self, source: PathLike, destination: PathLike) -> Path:
+        """
+        Copy a file or directory tree to *destination*.
+
+        If *destination* is an existing directory, the source is copied
+        **inside** that directory (mirroring the behaviour of the ``cp``
+        command).  If *destination* does not exist it is used as the new
+        name / path for the copy.
+
+        Args:
+            source: Path of the file or directory to copy.
+            destination: Target path or parent directory.
+
+        Returns:
+            The :class:`~pathlib.Path` of the newly created copy.
+
+        Raises:
+            PathNotFoundError: If *source* does not exist.
+            CopyError: If the copy operation fails for any reason.
+        """
+        src = self._require_exists(source)
+        dst = self._resolve(destination)
+
+        # If destination is an existing directory, place the copy inside it
+        if dst.is_dir():
+            dst = dst / src.name
+
+        try:
+            if src.is_dir():
+                shutil.copytree(src, dst)
+            else:
+                # Ensure parent directories exist
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dst)
+        except Exception as exc:
+            raise CopyError(str(source), str(destination), str(exc)) from exc
+
+        return dst
+
+    def cut(self, source: PathLike, destination: PathLike) -> Path:
+        """
+        Move a file or directory to *destination*.
+
+        Behaves like :meth:`copy` but removes the original afterwards.
+
+        Args:
+            source: Path of the file or directory to move.
+            destination: Target path or parent directory.
+
+        Returns:
+            The :class:`~pathlib.Path` where the item was moved to.
+
+        Raises:
+            PathNotFoundError: If *source* does not exist.
+            CopyError: If the move operation fails for any reason.
+        """
+        src = self._require_exists(source)
+        dst = self._resolve(destination)
+
+        if dst.is_dir():
+            dst = dst / src.name
+
+        try:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(src), str(dst))
+        except Exception as exc:
+            raise CopyError(str(source), str(destination), str(exc)) from exc
+
+        return dst
+
+    def rename(self, path: PathLike, new_name: str) -> Path:
+        """
+        Rename a file or directory.
+
+        Only the **name** of the item changes; it stays in the same
+        parent directory.  To move an item to a different location use
+        :meth:`cut` instead.
+
+        Args:
+            path: Path of the file or directory to rename.
+            new_name: The new name (not a full path, just the bare name).
+
+        Returns:
+            The :class:`~pathlib.Path` of the renamed item.
+
+        Raises:
+            PathNotFoundError: If *path* does not exist.
+            FileOpsError: If the rename operation fails for any reason.
+        """
+        src = self._require_exists(path)
+        dst = src.parent / new_name
+
+        try:
+            src.rename(dst)
+        except Exception as exc:
+            raise FileOpsError(
+                f"Could not rename '{path}' to '{new_name}' — {exc}"
+            ) from exc
+
+        return dst
+
+    def delete(self, path: PathLike) -> None:
+        """
+        Delete a file or directory (including all its contents).
+
+        Args:
+            path: Path of the file or directory to delete.
+
+        Raises:
+            PathNotFoundError: If *path* does not exist.
+            DeleteError: If the deletion fails for any reason.
+        """
+        target = self._require_exists(path)
+
+        try:
+            if target.is_dir():
+                shutil.rmtree(target)
+            else:
+                target.unlink()
+        except Exception as exc:
+            raise DeleteError(str(path), str(exc)) from exc
+
+    # ------------------------------------------------------------------
+    # Directory operations
+    # ------------------------------------------------------------------
+
+    def mkdir(self, path: PathLike) -> Path:
+        """
+        Create a directory, including any missing intermediate directories.
+
+        Does nothing if the directory already exists (idempotent).
+
+        Args:
+            path: Path of the directory to create.
+
+        Returns:
+            The :class:`~pathlib.Path` of the created (or existing) directory.
+
+        Raises:
+            FileOpsError: If the directory cannot be created.
+        """
+        target = self._resolve(path)
+
+        try:
+            target.mkdir(parents=True, exist_ok=True)
+        except Exception as exc:
+            raise FileOpsError(
+                f"Could not create directory '{path}' — {exc}"
+            ) from exc
+
+        return target
+
+    def rmdir(self, path: PathLike) -> None:
+        """
+        Remove a directory and **all** of its contents recursively.
+
+        This is an alias for calling :meth:`delete` on a directory and is
+        provided for semantic clarity.
+
+        Args:
+            path: Path of the directory to remove.
+
+        Raises:
+            PathNotFoundError: If *path* does not exist.
+            DeleteError: If the deletion fails for any reason.
+        """
+        target = self._require_exists(path)
+
+        if not target.is_dir():
+            raise FileOpsError(f"'{path}' is not a directory. Use delete() to remove files.")
+
+        self.delete(target)
+
+    # ------------------------------------------------------------------
+    # Compression
+    # ------------------------------------------------------------------
+
+    def zip(self, source: PathLike, zip_file: PathLike) -> Path:
+        """
+        Compress a file or directory into a ZIP archive.
+
+        If *source* is a directory, the entire tree is added to the
+        archive preserving the internal structure.
+
+        Args:
+            source: Path of the file or directory to compress.
+            zip_file: Path for the resulting ``.zip`` file.
+
+        Returns:
+            The :class:`~pathlib.Path` of the created ZIP file.
+
+        Raises:
+            PathNotFoundError: If *source* does not exist.
+            ZipError: If the compression fails for any reason.
+        """
+        src = self._require_exists(source)
+        dst = self._resolve(zip_file)
+
+        try:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+
+            with zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zf:
+                if src.is_dir():
+                    for file in src.rglob("*"):
+                        zf.write(file, file.relative_to(src.parent))
+                else:
+                    zf.write(src, src.name)
+        except Exception as exc:
+            raise ZipError(str(source), str(exc)) from exc
+
+        return dst
+
+    def unzip(self, zip_file: PathLike, destination: PathLike) -> Path:
+        """
+        Extract a ZIP archive to *destination*.
+
+        Args:
+            zip_file: Path to the ``.zip`` file.
+            destination: Directory where the contents will be extracted.
+
+        Returns:
+            The :class:`~pathlib.Path` of the destination directory.
+
+        Raises:
+            PathNotFoundError: If *zip_file* does not exist.
+            ZipError: If the file is not a valid ZIP or extraction fails.
+        """
+        src = self._require_exists(zip_file)
+        dst = self._resolve(destination)
+
+        if not zipfile.is_zipfile(src):
+            raise ZipError(str(zip_file), "File is not a valid ZIP archive")
+
+        try:
+            dst.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(src, "r") as zf:
+                zf.extractall(dst)
+        except ZipError:
+            raise
+        except Exception as exc:
+            raise ZipError(str(zip_file), str(exc)) from exc
+
+        return dst
+
+    # ------------------------------------------------------------------
+    # Queries
+    # ------------------------------------------------------------------
+
+    def exists(self, path: PathLike) -> bool:
+        """
+        Check whether *path* exists on the filesystem.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            ``True`` if the path exists, ``False`` otherwise.
+        """
+        return self._resolve(path).exists()
+
+    def size(self, path: PathLike) -> int:
+        """
+        Return the size of a file or directory in bytes.
+
+        For directories, the size is the total of all files within the
+        tree (not the disk usage reported by the OS).
+
+        Args:
+            path: Path of the file or directory.
+
+        Returns:
+            Size in bytes as an integer.
+
+        Raises:
+            PathNotFoundError: If *path* does not exist.
+        """
+        target = self._require_exists(path)
+
+        if target.is_dir():
+            return sum(f.stat().st_size for f in target.rglob("*") if f.is_file())
+
+        return target.stat().st_size
+
+    def is_file(self, path: PathLike) -> bool:
+        """
+        Return ``True`` if *path* points to a regular file.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            ``True`` if *path* is a file, ``False`` otherwise (including
+            when the path does not exist).
+        """
+        return self._resolve(path).is_file()
+
+    def is_dir(self, path: PathLike) -> bool:
+        """
+        Return ``True`` if *path* points to a directory.
+
+        Args:
+            path: The path to check.
+
+        Returns:
+            ``True`` if *path* is a directory, ``False`` otherwise
+            (including when the path does not exist).
+        """
+        return self._resolve(path).is_dir()

pyfileops/exceptions.py

@@ -0,0 +1,53 @@
+"""
+pyfileops.exceptions
+~~~~~~~~~~~~~~~~~~~~
+Custom exceptions for the pyfileops library.
+All exceptions inherit from FileOpsError, which inherits from Exception.
+"""
+
+
+class FileOpsError(Exception):
+    """Base exception for all pyfileops errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class PathNotFoundError(FileOpsError):
+    """Raised when a given path does not exist on the filesystem."""
+
+    def __init__(self, path: str) -> None:
+        super().__init__(f"Path not found: '{path}'")
+        self.path = path
+
+
+class CopyError(FileOpsError):
+    """Raised when a copy or move operation fails."""
+
+    def __init__(self, source: str, destination: str, reason: str = "") -> None:
+        detail = f" — {reason}" if reason else ""
+        super().__init__(f"Could not copy '{source}' to '{destination}'{detail}")
+        self.source = source
+        self.destination = destination
+
+
+class DeleteError(FileOpsError):
+    """Raised when a delete operation fails."""
+
+    def __init__(self, path: str, reason: str = "") -> None:
+        detail = f" — {reason}" if reason else ""
+        super().__init__(f"Could not delete '{path}'{detail}")
+        self.path = path
+
+
+class ZipError(FileOpsError):
+    """Raised when a zip or unzip operation fails."""
+
+    def __init__(self, path: str, reason: str = "") -> None:
+        detail = f" — {reason}" if reason else ""
+        super().__init__(f"Zip operation failed for '{path}'{detail}")
+        self.path = path

pyfileops-1.0.0.dist-info/METADATA

@@ -0,0 +1,294 @@
+Metadata-Version: 2.4
+Name: pyfileops
+Version: 1.0.0
+Summary: A simple, friendly Python library for file and directory operations.
+License: MIT License
+        
+        Copyright (c) 2026 pyfileops contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/FefinDev/pyfileops
+Project-URL: Issues, https://github.com/FefinDev/pyfileops/issues
+Keywords: files,filesystem,copy,move,zip,utilities
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyfileops
+
+**pyfileops** is a simple, friendly Python library for everyday file and directory operations.  
+No need to juggle `os`, `shutil`, `pathlib`, or `zipfile` — everything lives behind one clean object: `fs`.
+
+```python
+from pyfileops import fs
+
+fs.copy("report.pdf", "backup/")
+fs.delete("temp.log")
+print(fs.size("video.mp4"))
+```
+
+[![PyPI version](https://img.shields.io/pypi/v/pyfileops)](https://pypi.org/project/pyfileops/)
+[![Python](https://img.shields.io/pypi/pyversions/pyfileops)](https://pypi.org/project/pyfileops/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Installation
+
+```bash
+pip install pyfileops
+```
+
+Requires **Python 3.8+**. No external dependencies — only the standard library.
+
+---
+
+## Quickstart
+
+```python
+from pyfileops import fs
+
+# ── Files ──────────────────────────────────────────────────────────────
+fs.copy("notes.txt", "backup/")           # copy into an existing folder
+fs.copy("notes.txt", "backup/notes2.txt") # copy with a new name
+fs.cut("draft.docx", "archive/")          # move file
+fs.rename("old.txt", "new.txt")           # rename in place
+fs.delete("trash.log")                    # delete a file
+
+# ── Directories ────────────────────────────────────────────────────────
+fs.mkdir("project/src/utils")             # create (nested) directories
+fs.rmdir("tmp")                           # remove directory and contents
+
+# ── Compression ────────────────────────────────────────────────────────
+fs.zip("project", "project_v1.zip")       # zip a directory
+fs.zip("report.pdf", "report.zip")        # zip a single file
+fs.unzip("project_v1.zip", "restored/")   # extract a zip
+
+# ── Queries ────────────────────────────────────────────────────────────
+fs.exists("config.ini")    # True or False
+fs.size("video.mp4")       # size in bytes (int)
+fs.is_file("data.csv")     # True or False
+fs.is_dir("assets")        # True or False
+```
+
+---
+
+## API Reference
+
+### File Operations
+
+#### `fs.copy(source, destination) → Path`
+
+Copies a file **or** directory to `destination`.
+
+- If `destination` is an **existing directory**, the source is placed inside it.
+- If `destination` does **not** exist, it becomes the new file/folder name.
+- Missing intermediate directories are created automatically.
+
+```python
+fs.copy("logo.png", "assets/")          # → assets/logo.png
+fs.copy("logo.png", "assets/icon.png")  # → assets/icon.png
+fs.copy("src/", "src_backup/")          # copies whole directory tree
+```
+
+---
+
+#### `fs.cut(source, destination) → Path`
+
+Moves a file or directory to `destination` (copy + delete original).
+
+```python
+fs.cut("uploads/photo.jpg", "gallery/")
+```
+
+---
+
+#### `fs.rename(path, new_name) → Path`
+
+Renames a file or directory **in place** (same parent directory).  
+To move to a different location, use `cut()`.
+
+```python
+fs.rename("report_draft.pdf", "report_final.pdf")
+```
+
+---
+
+#### `fs.delete(path) → None`
+
+Deletes a file or an entire directory tree.
+
+```python
+fs.delete("temp.log")    # file
+fs.delete("cache/")      # directory and all its contents
+```
+
+---
+
+### Directory Operations
+
+#### `fs.mkdir(path) → Path`
+
+Creates a directory (and any missing parent directories). Safe to call even if it already exists.
+
+```python
+fs.mkdir("project/assets/images")
+```
+
+---
+
+#### `fs.rmdir(path) → None`
+
+Removes a directory and everything inside it.
+
+```python
+fs.rmdir("build/")
+```
+
+---
+
+### Compression
+
+#### `fs.zip(source, zip_file) → Path`
+
+Compresses `source` (file or directory) into a ZIP archive at `zip_file`.
+
+```python
+fs.zip("my_project", "my_project.zip")
+fs.zip("data.csv", "data.zip")
+```
+
+---
+
+#### `fs.unzip(zip_file, destination) → Path`
+
+Extracts a ZIP archive into `destination`.
+
+```python
+fs.unzip("my_project.zip", "restored/")
+```
+
+---
+
+### Queries
+
+#### `fs.exists(path) → bool`
+
+Returns `True` if `path` exists (file or directory).
+
+```python
+if fs.exists("config.ini"):
+    print("Config found!")
+```
+
+---
+
+#### `fs.size(path) → int`
+
+Returns the size in **bytes**.
+
+- For files: the file size.
+- For directories: the total size of all contained files.
+
+```python
+bytes_used = fs.size("video.mp4")
+print(f"{bytes_used / 1_000_000:.2f} MB")
+```
+
+---
+
+#### `fs.is_file(path) → bool`
+
+Returns `True` if `path` is a regular file (returns `False` if it doesn't exist).
+
+```python
+fs.is_file("README.md")  # True
+fs.is_file("src/")       # False
+```
+
+---
+
+#### `fs.is_dir(path) → bool`
+
+Returns `True` if `path` is a directory (returns `False` if it doesn't exist).
+
+```python
+fs.is_dir("src/")        # True
+fs.is_dir("README.md")   # False
+```
+
+---
+
+## Error Handling
+
+pyfileops raises clear, specific exceptions so you always know what went wrong.
+
+| Exception | When it's raised |
+|---|---|
+| `FileOpsError` | Base class for all pyfileops errors |
+| `PathNotFoundError` | Source path does not exist |
+| `CopyError` | A copy or move operation failed |
+| `DeleteError` | A delete operation failed |
+| `ZipError` | A zip or unzip operation failed |
+
+All exceptions inherit from `FileOpsError`, which inherits from `Exception`.
+
+```python
+from pyfileops import fs
+from pyfileops import PathNotFoundError, CopyError, ZipError, FileOpsError
+
+# Catch a specific error
+try:
+    fs.copy("missing.txt", "backup/")
+except PathNotFoundError as e:
+    print(e)  # Path not found: 'missing.txt'
+
+# Catch any pyfileops error
+try:
+    fs.zip("project", "output.zip")
+    fs.delete("tmp/")
+except FileOpsError as e:
+    print(f"Operation failed: {e}")
+```
+
+---
+
+## Author
+
+Made by [Fede](https://github.com/FefinDev) · [github.com/FefinDev/pyfileops](https://github.com/FefinDev/pyfileops)
+
+---
+
+## License
+
+[MIT](LICENSE)

pyfileops-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyfileops/__init__.py,sha256=bo6-3FUPJ1yGF8RHcK7h_DNFTHHvKURiiwjDIVxHLjw,1154
+pyfileops/core.py,sha256=Z8orC-NPiYDI11GGEQIzWk2XoMw0d03i4UMmLbwgTzI,11536
+pyfileops/exceptions.py,sha256=QoFyBRflTO-POv_Qb5LV1yryMETysWhPFo4X2GcIOI0,1659
+pyfileops-1.0.0.dist-info/licenses/LICENSE,sha256=v75mLQK-p_AKlCjarAHQtaa1Fsvyttnd5z3EAGftD5U,1100
+pyfileops-1.0.0.dist-info/METADATA,sha256=CkhNGHBjwOSF5TMM4ntccew8mkOk8DPFnRmeyH7VoSo,8698
+pyfileops-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyfileops-1.0.0.dist-info/top_level.txt,sha256=1NW7GQhLW4ykXExgMcdsLT_-Hpr_HSTquOK9rfpMurs,10
+pyfileops-1.0.0.dist-info/RECORD,,

pyfileops-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyfileops-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pyfileops contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyfileops-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyfileops