pymover 0.3.0.dev3__py3-none-any.whl

pymover/__version__.py

@@ -0,0 +1,7 @@
+__version__ = "0.3.0.dev3"
+__license__ = "n.a."
+__copyright__ = "2023, Thorbjörn Mumme"
+__description__ = "Custom move command with progress bar"
+__maintainer__ = "Thorbjoern Mumme"
+__dev_url__ = "https://gitlab.com/thomumme/file-mover"
+__doc_url__ = ""

pymover/cli.py

@@ -0,0 +1,23 @@
+import click
+
+from .pymover import move_with_progress, copy_with_progress
+
+
+@click.command()
+@click.argument('src', type=click.Path(), nargs=-1)
+@click.argument('dst', type=click.Path())
+@click.option("--simulate", is_flag=True, default=False)
+def move(**kwargs):
+    move_with_progress(src=kwargs['src'], dst=kwargs['dst'], simulate=kwargs['simulate'])
+
+
+@click.command()
+@click.argument('src', type=click.Path(), nargs=-1)
+@click.argument('dst', type=click.Path())
+@click.option("--simulate", is_flag=True, default=False)
+def copy(**kwargs):
+    copy_with_progress(src=kwargs['src'], dst=kwargs['dst'])
+
+
+if __name__ == '__main__':
+    move()

pymover/pymover.py

@@ -0,0 +1,362 @@
+import glob
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+from typing import List
+from typing import Union, Tuple
+
+from loguru import logger
+from tqdm import tqdm
+
+from .utils import to_list
+
+
+class FileMover:
+    def __init__(self, interactive_mode: bool, conflict_resolution: str = "ya", create_missing_parents: bool = False):
+        self._is_interactive: bool = interactive_mode
+
+        # if we are in interactive mode we set the conflict resolution to undefined to prompt the options
+        # otherwise we just set what has been passed
+        self._conflict_mode: str = "" if interactive_mode else conflict_resolution
+
+        # in non interactive mode the option "y" or "n" does not really make sense, because we have to apply it to all copy/move calls
+        # so we simply change it to "ya" or "na" and it gets handled as expected in the copy/move functions
+        if not interactive_mode:
+            self._conflict_mode += "a" if self._conflict_mode in {"y", "n"} else ""
+
+        self._create_missing_parents = create_missing_parents
+        pass
+
+    def prompt_overwrite_conflict(self, target_file: Path):
+        """
+        Prompts the user to handle a file overwrite conflict.
+        Returns the key (e.g., 'ya') selected by the user.
+        """
+        options = {
+            "y": "Yes",
+            "n": "No",
+            "ya": "Yes to all",
+            "na": "No to all",
+            "s": "Skip Conflict",
+            "sa": "Skip All Conflicts"
+        }
+
+        # Signal the conflict
+        logger.warning(f"Conflict Detected: Do you want to overwrite the existing file: '{target_file}'")
+
+        # Print the clean menu
+        logger.opt(raw=True).info(f"{'-' * 40}\n")
+        for key, description in options.items():
+            logger.opt(raw=True).info(f" [{key.ljust(2)}] : {description}\n")
+        logger.opt(raw=True).info(f"{'-' * 40}\n")
+
+        while True:
+            try:
+                choice = input("Select an option: ").strip().lower()
+
+                if choice in options:
+                    # Return the key instead of the descriptive value
+                    logger.success(f"Action confirmed: {choice}")
+                    return choice
+
+                logger.error(f"Invalid input '{choice}'. Valid: {', '.join(options.keys())}")
+            except KeyboardInterrupt:
+                logger.critical("\nOperation aborted by user.")
+                sys.exit(1)
+
+    def _get_source_size(self, src: List[Union[Path, str]]) -> int:
+        size: int = 0
+        for s in src:
+            if s.is_dir():
+                size += self._get_source_size(s.glob('*'))
+            else:
+                size += s.stat().st_size
+        return size
+
+    def _copy_file(self, src: Path, dst: Path, progres_bar: tqdm, simulate: bool = False):
+        assert isinstance(src, Path)
+        assert isinstance(dst, Path)
+        if dst.is_dir():
+            dst = dst / Path(src.name)
+
+        if simulate:
+            logger.info(f"Copying {src} to {dst}")
+            return
+
+        if dst.exists():
+
+            if not self._conflict_mode:
+                # no conflict mode is set, so we ask what to do
+                self._conflict_mode = self.prompt_overwrite_conflict(dst)
+
+            # now we need to evaluate the conflict mode
+            if self._conflict_mode in {"sa", "s", "na", "n"}:
+                logger.info(f"Skipping file {src}, because it already exists at target destination")
+                return
+            elif self._conflict_mode in {"ya", "y"}:
+                pass
+            else:
+                raise RuntimeError(f"Unknown conflict mode '{self._conflict_mode}'")
+
+            # we need to cleanup the conflict mode, in case it is not a "* to all" option
+            if len(self._conflict_mode) < 2:
+                self._conflict_mode = ""
+
+        # create missing parent directories
+        if self._create_missing_parents:
+            dst.parent.mkdir(parents=True, exist_ok=True)
+
+        # progres_bar.set_description(desc=src.name)
+        inner_bar = tqdm(total=src.stat().st_size, unit='B', unit_scale=True, position=1, leave=False, desc=src.name)
+        with open(src, 'rb') as fsrc:
+            with open(dst, 'wb') as fdst:
+                # with tqdm(total=size, unit='B', unit_scale=True, desc=f'Copying {src} to {dst}') as pbar:
+                while True:
+                    chunk = fsrc.read(4096)
+                    if not chunk:
+                        break
+                    fdst.write(chunk)
+                    fdst.flush()
+                    progres_bar.update(len(chunk))
+                    inner_bar.update(len(chunk))
+
+    def _copy_directory(self, src: Path, dst: Path, progres_bar: tqdm, simulate: bool = False):
+        # check if the target directory exists, if not create it
+        if not dst.exists():
+            if simulate:
+                logger.info(f"Creating directory {dst}")
+            else:
+                dst.mkdir()
+        # get the content of the directory
+        content = src.glob('*')
+        for c in content:
+            if c.is_dir():
+                self._copy_directory(c, dst / c.name, progres_bar, simulate=simulate)
+            elif c.is_file():
+                self._copy_file(c, dst / c.name, progres_bar, simulate=simulate)
+            else:
+                raise NotImplementedError("This case is not handled yet")
+
+    def copy_with_progress(self, src: Tuple[Union[Path, str]], dst: Union[Path, str], simulate: bool = False, recursive: bool = False,
+                           progress_bar=None):
+
+        assert isinstance(dst, (list, Path, str))
+
+        src = to_list(src)
+        src = [Path(x) for x in src]
+        dst = to_list(dst)
+        dst = [Path(x) for x in dst]
+
+        if all(s.is_dir() for s in src) and not recursive:
+            raise RuntimeError("Recursive mode must be enabled when copying a directory")
+
+        if len(dst) == 1 and len(src) > 1:
+            if not dst[0].is_dir():
+                raise RuntimeError("Target must be a directory when a copying multiple sources to the same destination")
+
+            # with the previous check we made sure that the destination is a directory
+            # and here we create a list of targets, which are all the same, one element for each source
+            dst = [dst[0] for s in src]
+
+        assert isinstance(src, List)
+        assert len(src) == len(dst)
+        for s, d in zip(src, dst):
+            if s.is_dir() and d.is_file():
+                raise RuntimeError("Target must be a directory when a copying directory")
+
+        size = self._get_source_size(src)
+
+        if progress_bar is None:
+            progress_bar = tqdm(total=size, unit='B', unit_scale=True)
+
+        for s, d in zip(src, dst):
+            if s.is_file():
+                if d.is_dir():
+                    new_destination = d / s.name
+                else:
+                    new_destination = d
+                self._copy_file(s, new_destination, progress_bar, simulate=simulate)
+            else:
+                # in case the target dir already exists, we want to copy the source into the existing directory
+                # otherwise we copy the source directory to the destination (and rename it)
+                _target = d / s.name if d.is_dir() else d
+                self._copy_directory(s, _target, progress_bar, simulate=simulate)
+
+    def find_mount_point(self, path):
+        path = os.path.abspath(path)
+        while not os.path.ismount(path):
+            path = os.path.dirname(path)
+        return path
+
+    def use_system_move(self, src, dst) -> bool:
+        if platform.system() == 'Windows':
+            if src.absolute().anchor == dst.absolute().anchor:
+                # when moving files on the same drive we simply edit the file system entry
+                # and do not need to copy the file
+                return True
+            else:
+                return False
+        elif platform.system() == 'Linux':
+            src_mount = self.find_mount_point(src)
+            dst_mount = self.find_mount_point(dst)
+            if src_mount == dst_mount:
+                return True
+            else:
+                return False
+
+        else:
+            logger.warning(f"Unsupported operating system '{platform.system()}'. Using working directory...")
+
+    def _move_file(self, src: Path, dst: Path, progres_bar: tqdm, simulate: bool = False,
+                   force_custom_move: bool = False):
+        if self.use_system_move(src, dst) and not force_custom_move:
+            # when moving files on the same drive we simply edit the file system entry
+            # and do not need to copy the file
+            progres_bar.set_description(desc=src.name)
+
+            if dst.exists():
+
+                if not self._conflict_mode:
+                    # no conflict mode is set, so we ask what to do
+                    self._conflict_mode = self.prompt_overwrite_conflict(dst)
+
+                # now we need to evaluate the conflict mode
+                if self._conflict_mode in {"sa", "s", "na", "n"}:
+                    logger.info(f"Skipping file {src}, because it already exists at target destination")
+                    return
+                elif self._conflict_mode in {"ya", "y"}:
+                    pass
+                else:
+                    raise RuntimeError(f"Unknown conflict mode '{self._conflict_mode}'")
+
+                # we need to cleanup the conflict mode, in case it is not a "* to all" option
+                if len(self._conflict_mode) < 2:
+                    self._conflict_mode = ""
+
+            # create missing parent directories
+            if self._create_missing_parents:
+                dst.parent.mkdir(parents=True, exist_ok=True)
+
+            shutil.move(src, dst)
+            progres_bar.update(dst.stat().st_size)
+        else:
+            self.copy_with_progress([src], dst, simulate=simulate, progress_bar=progres_bar)
+            os.remove(src)
+
+    def _move_directory(self, src: Path,
+                        dst: Path,
+                        progres_bar: tqdm,
+                        simulate: bool = False,
+                        force_custom_move: bool = False):
+        if not dst.exists():
+            dst.mkdir()
+        content = src.glob('*')
+        for c in content:
+            if c.is_dir():
+                self._move_directory(c, dst / c.name, progres_bar=progres_bar, simulate=simulate,
+                                     force_custom_move=force_custom_move)
+                # c.rmdir()
+            elif c.is_file():
+                self._move_file(c, dst / c.name, progres_bar=progres_bar, simulate=simulate,
+                                force_custom_move=force_custom_move)
+        # The root directory gets deleted after it has been moved
+        src.rmdir()
+
+    def move_with_progress(self, src: Tuple[Union[Path, str]], dst: Union[Path, str], force_custom_move: bool = False, simulate: bool = False):
+        assert isinstance(dst, (list, Path, str))
+
+        src = to_list(src)
+        src = [Path(x) for x in src]
+        dst = to_list(dst)
+        dst = [Path(x) for x in dst]
+
+        if len(dst) == 1 and len(src) > 1:
+            if not dst[0].is_dir():
+                raise FileNotFoundError("Target must be a directory when a copying multiple sources to the same destination")
+
+        if len(dst) == 1 and len(src) > 1:
+            if not dst[0].is_dir():
+                raise RuntimeError("Target must be a directory when a moving multiple objects to the same destination")
+
+            # with the previous check we made sure that the destination is a directory
+            # and here we create a list of targets, which are all the same, one element for each source
+            dst = [dst[0] for s in src]
+
+        assert len(src) == len(dst)
+        for s, d in zip(src, dst):
+            if s.is_dir() and d.is_file():
+                raise RuntimeError("Target must be a directory when a copying directory")
+
+        size = self._get_source_size(src)
+        progress_bar = tqdm(total=size, unit='B', unit_scale=True, position=0)
+
+        for s, d in zip(src, dst):
+            if s.is_file():
+                if d.is_dir():
+                    new_destination = d / s.name
+                else:
+                    new_destination = d
+                self._move_file(s, new_destination, progress_bar, simulate=simulate)
+            else:
+                # in case the target dir already exists, we want to copy the source into the existing directory
+                # otherwise we copy the source directory to the destination (and rename it)
+                _target = d / s.name if d.is_dir() else d
+                self._move_directory(s, _target, progress_bar, simulate=simulate)
+
+
+def copy_with_progress(src: Tuple[Union[Path, str]], dst: Union[Path, str],
+                       interactive: bool = False, conflict_resoluation: str = "ya", create_missing_parents: bool = False, recursive: bool = False, simulate: bool = False,
+                       progress_bar=None):
+    FileMover(interactive_mode=interactive,
+              conflict_resolution=conflict_resoluation,
+              create_missing_parents=create_missing_parents).copy_with_progress(src,
+                                                                                dst,
+                                                                                recursive=recursive,
+                                                                                simulate=simulate,
+                                                                                progress_bar=progress_bar)
+
+
+def move_with_progress(src: Tuple[Union[Path, str]], dst: Union[Path, str], force_custom_move: bool = False, interactive: bool = False, conflict_resoluation: str = "ya",
+                       simulate: bool = False, create_missing_parents: bool = False, ):
+    FileMover(interactive_mode=interactive,
+              conflict_resolution=conflict_resoluation,
+              create_missing_parents=create_missing_parents).move_with_progress(src, dst,
+                                                                                force_custom_move=force_custom_move,
+                                                                                simulate=simulate)
+
+
+def start(
+        source_glob: List[str] = ("*/*",),
+        target: str = "new",
+        amount: int = 50,
+        selector_func=None,
+        dry_run: bool = False) -> List[Path]:
+    target_directory = Path(target)
+    amount = amount
+
+    source_files = []
+    for g in source_glob:
+        source_files.extend(glob.glob(g))
+        # source_files.extend(list(Path().glob(g)))
+    source_files = [Path(x) for x in source_files]
+
+    logger.info(f"Total amount of files: {len(source_files)}")
+
+    source_files = selector_func(source_files, amount)
+
+    logger.debug("Selected files")
+    for i, f in enumerate(source_files):
+        logger.debug(f"[{i}] {f}")
+
+    if dry_run:
+        for f in source_files:
+            destination = Path(target) / f.name
+            logger.info(f"'{f}' would be moved to '{destination}'")
+
+    else:
+
+        move_with_progress(source_files, target_directory)
+
+    return source_files

pymover/utils.py

@@ -0,0 +1,9 @@
+def to_list(val):
+    if isinstance(val, list):
+        return val
+    if isinstance(val, (str, bytes)):
+        return [val]
+    try:
+        return list(val)
+    except TypeError:
+        return [val]

pymover-0.3.0.dev3.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: pymover
+Version: 0.3.0.dev3
+Summary: Custom move command with progress bar
+Author: Thorbjoern Mumme
+License: n.a.
+Project-URL: Homepage, https://gitlab.com/thomumme/file-mover
+Project-URL: Repository, https://gitlab.com/thomumme/file-mover
+Keywords: file,move,copy,progress
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tqdm
+Requires-Dist: loguru
+Requires-Dist: click
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: randomfiletree; extra == "dev"
+Dynamic: license-file
+
+# FileMover
+
+FileMover is a Python package that provides command-line tools for moving and copying files with progress bars. It supports both single file operations and batch operations on multiple files.
+
+![PyPI](https://img.shields.io/pypi/v/pymover)
+![Python Version](https://img.shields.io/pypi/pyversions/pymover)
+![License](https://img.shields.io/pypi/l/pymover)
+![CI](https://gitlab.com/thomumme/file-mover/badges/main/pipeline.svg)
+
+## Installation
+
+
+You can install FileMover using pip:
+
+```bash
+pip install pymover
+```
+
+Or install the latest development version from GitLab:
+
+```bash
+pip install git+https://gitlab.com/thomumme/file-mover.git
+```
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a history of changes.
+
+
+

pymover-0.3.0.dev3.dist-info/RECORD

@@ -0,0 +1,10 @@
+pymover/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymover/__version__.py,sha256=a-eastSKvU-8zkoKXkCwiOxysx2fnIaq6eoi6Rr9df0,255
+pymover/cli.py,sha256=7fXx5cCZVcL26hqQgL2FrnyV83L4n9I0DcjjknSuHRc,645
+pymover/pymover.py,sha256=R3cgWWN1GkgS2U2Lw4fWRMpG0mKvgdLDxWPNm-HYLWk,15572
+pymover/utils.py,sha256=h5yQRBAf0-o8DpHQ4RR3g6oxwpY0BzPlXR6Z6ObdFgM,203
+pymover-0.3.0.dev3.dist-info/licenses/LICENSE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+pymover-0.3.0.dev3.dist-info/METADATA,sha256=8UyzlhCkyg0_zeYxscFRFLgbfxnPvfSmT-QtBxIX6Vg,1499
+pymover-0.3.0.dev3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pymover-0.3.0.dev3.dist-info/top_level.txt,sha256=Bp9FNt2aW8AaK-auBTffK9DYHcwL3bvMFBhyC7aIl04,8
+pymover-0.3.0.dev3.dist-info/RECORD,,

pymover-0.3.0.dev3.dist-info/WHEEL

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

pymover-0.3.0.dev3.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

pymover-0.3.0.dev3.dist-info/top_level.txt

@@ -0,0 +1 @@
+pymover