Adds directory upload to cli.

Author: filiplajszczak

cli/path.py

@@ -1,6 +1,7 @@
 import json
 import re
 import sys
+from pathlib import Path
 
 from collections import namedtuple
 
@@ -104,22 +105,39 @@ def tree(
 
 @app.command()
 def upload(
-    path: str = typer.Argument(..., help=("Full path of FILE where CONTENTS should be uploaded to.")),
-    file: typer.FileBinaryRead = typer.Option(
+    path: str = typer.Argument(..., help="Full path on PythonAnywhere where CONTENTS should be uploaded to."),
+    contents: str = typer.Option(
         ...,
         "-c",
         "--contents",
-        help="Path to exisitng file or stdin stream that should be uploaded to PATH."
+        help="Path to existing file, directory (with -r) or '-' for stdin.",
     ),
+    recursive: bool = typer.Option(False, "-r", "--recursive", help="Upload a directory recursively."),
     quiet: bool = typer.Option(False, "-q", "--quiet", help="Disable additional logging.")
 ):
-    """
-    Upload CONTENTS to file at PATH.
+    """Upload CONTENTS to PATH.
 
     If PATH points to an existing file, it will be overwritten.
+    Use -r/--recursive to upload a directory.
     """
     pa_path = setup(path, quiet)
-    success = pa_path.upload(file)
+
+    if recursive:
+        if contents == "-":
+            typer.echo("stdin is not supported with --recursive", err=True)
+            sys.exit(1)
+        success = pa_path.upload_directory(contents)
+    else:
+        if contents == "-":
+            content = sys.stdin.buffer.read()
+        else:
+            contents_path = Path(contents)
+            if contents_path.is_dir():
+                typer.echo(f"{contents} is a directory, use --recursive flag to upload directories", err=True)
+                sys.exit(1)
+            content = contents_path.read_bytes()
+        success = pa_path.upload(content)
+
     sys.exit(0 if success else 1)
 
 

pythonanywhere/files.py

@@ -131,6 +131,19 @@ def upload(self, content):
         logger.info(snakesay(msg))
         return True
 
+    def upload_directory(self, local_dir_path):
+        """Returns `True` when contents of `local_dir_path` successfully
+        uploaded to `self.path`, `False` otherwise."""
+
+        try:
+            self.api.tree_post(local_dir_path, self.path)
+        except Exception as e:
+            logger.warning(snakesay(str(e)))
+            return False
+
+        logger.info(snakesay(f"Contents of {local_dir_path} successfully uploaded to {self.path}!"))
+        return True
+
     def get_sharing_url(self, quiet=False):
         """Returns PythonAnywhere sharing url for `self.path` if file
         is shared, empty string otherwise."""

requirements.txt

@@ -8,7 +8,7 @@ pytest==9.0.2
 pytest-cov==7.0.0
 pytest-mock==3.15.1
 pytest-mypy==1.0.1
-pythonanywhere_core==0.2.9
+pythonanywhere_core>=0.3.0
 requests==2.32.5
 responses==0.25.8
 schema==0.7.2

setup.py

@@ -36,7 +36,7 @@
         "docopt",
         "packaging",
         "python-dateutil",
-        "pythonanywhere_core==0.2.9",
+        "pythonanywhere_core>=0.3.0",
         "requests",
         "schema",
         "snakesay==0.10.4",

tests/test_cli_path.py

@@ -222,6 +222,43 @@ def test_exits_with_error_when_unsuccessful_upload(self, mock_path):
         assert result.exit_code == 1
 
 
+class TestUploadRecursive:
+    def test_calls_upload_directory_with_recursive_flag(self, mock_path, tmp_path):
+        local_dir = tmp_path / "mydir"
+        local_dir.mkdir()
+        mock_path.return_value.upload_directory.return_value = True
+
+        result = runner.invoke(app, ["upload", "~/remote_dir", "-c", str(local_dir), "-r"])
+
+        mock_path.return_value.upload_directory.assert_called_once_with(str(local_dir))
+        assert result.exit_code == 0
+
+    def test_errors_when_stdin_used_with_recursive_flag(self, mock_path):
+        result = runner.invoke(app, ["upload", "~/remote_dir", "-c", "-", "-r"])
+
+        assert result.exit_code == 1
+        assert "stdin" in result.output
+        assert "--recursive" in result.output
+
+    def test_reads_from_stdin_when_contents_is_dash(self, mock_path):
+        mock_path.return_value.upload.return_value = True
+
+        result = runner.invoke(app, ["upload", "~/remote_file", "-c", "-"], input=b"stdin content")
+
+        mock_path.return_value.upload.assert_called_once()
+        assert result.exit_code == 0
+
+    def test_errors_when_directory_passed_without_recursive_flag(self, mock_path, tmp_path):
+        local_dir = tmp_path / "mydir"
+        local_dir.mkdir()
+
+        result = runner.invoke(app, ["upload", "~/remote_dir", "-c", str(local_dir)])
+
+        assert result.exit_code == 1
+        assert "is a directory" in result.output
+        assert "--recursive" in result.output
+
+
 class TestDelete:
     def test_creates_pa_path_with_provided_path(self, mock_path, home_dir):
         runner.invoke(app, ["delete", "~/hello.txt"])

tests/test_files.py

@@ -192,6 +192,38 @@ def test_warns_when_file_has_not_been_uploaded(self, mocker):
         assert result is False
 
 
+@pytest.mark.files
+class TestPAPathUploadDirectory():
+    def test_informs_about_successful_directory_upload(self, mocker):
+        mock_tree_post = mocker.patch("pythonanywhere_core.files.Files.tree_post")
+        mock_snake = mocker.patch("pythonanywhere.files.snakesay")
+        mock_info = mocker.patch("pythonanywhere.files.logger.info")
+        local_dir = "/local/dir"
+        destination_path = "/home/user/remote"
+
+        result = PAPath(destination_path).upload_directory(local_dir)
+
+        assert mock_tree_post.call_args == call(local_dir, destination_path)
+        assert mock_snake.call_args == call(f"Contents of {local_dir} successfully uploaded to {destination_path}!")
+        assert mock_info.call_args == call(mock_snake.return_value)
+        assert result is True
+
+    def test_warns_when_directory_upload_fails(self, mocker):
+        mock_tree_post = mocker.patch("pythonanywhere_core.files.Files.tree_post")
+        mock_tree_post.side_effect = Exception("sth went wrong")
+        mock_snake = mocker.patch("pythonanywhere.files.snakesay")
+        mock_warning = mocker.patch("pythonanywhere.files.logger.warning")
+        local_dir = "/local/dir"
+        destination_path = "/home/user/remote"
+
+        result = PAPath(destination_path).upload_directory(local_dir)
+
+        assert mock_tree_post.call_args == call(local_dir, destination_path)
+        assert mock_snake.call_args == call("sth went wrong")
+        assert mock_warning.call_args == call(mock_snake.return_value)
+        assert result is False
+
+
 @pytest.mark.files
 class TestPAPathShare():
     def test_returns_full_url_for_shared_file(self, mocker):