p4cmd 2.9.2__tar.gz → 2.10.1__tar.gz

{p4cmd-2.9.2 → p4cmd-2.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.9.2
+Version: 2.10.1
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes

{p4cmd-2.9.2 → p4cmd-2.10.1}/p4cmd/__init__.py

@@ -1,4 +1,4 @@
-VERSION = "2.9.2"
+VERSION = "2.10.1"
 
 from .p4cmd import P4Client
 from .p4file import P4File

{p4cmd-2.9.2 → p4cmd-2.10.1}/p4cmd/p4cmd.py

@@ -84,7 +84,7 @@ class P4Client(object):
         """
         self.max_parallel_connections = value
 
-    def run_cmd(self, cmd, args=None, file_list=None, use_global_options=True, online_check=True):
+    def run_cmd(self, cmd, args=None, file_list=None, use_global_options=True, online_check=True, raise_on_errors=False):
         """
         Reads the output stream of the command and returns it as a marshaled dict.
 
@@ -145,6 +145,20 @@ class P4Client(object):
                         dict_list.append(output_dict)
                     pipe.kill()
 
+        # Check for error dicts in the results
+        errors = [d for d in dict_list if d.get(b"code") == b"error" or d.get("code") == "error"]
+        if errors:
+            messages = []
+            for e in errors:
+                msg = e.get(b"data") or e.get("data") or e.get(b"error") or e.get("error") or "unknown error"
+                if isinstance(msg, bytes):
+                    msg = msg.decode("utf-8", errors="replace")
+                messages.append(msg.strip())
+            for msg in messages:
+                logging.warning(f"p4 {cmd}: {msg}")
+            if raise_on_errors:
+                raise p4errors.P4CommandError(cmd, messages)
+
         return dict_list
 
     def __replace_description_in_template(self, template, new_description):
@@ -1288,7 +1302,7 @@ class P4Client(object):
             if p4file.local_file_path is None:
                 data = self.__get_dict_value(file_dict, "data") or ""
                 if " - " in data:
-                    p4file.local_file_path = data.split(" - ")[0].strip()
+                    p4file.local_file_path = data.rsplit(" - ", 1)[0].strip()
             p4file.have_revision = self.__get_dict_value(file_dict, "haveRev")
             p4file.head_revision = self.__get_dict_value(file_dict, "headRev")
             p4file.last_submit_time = self.__get_dict_value(file_dict, "headTime")

{p4cmd-2.9.2 → p4cmd-2.10.1}/p4cmd/p4errors.py

@@ -15,6 +15,20 @@ class WorkSpaceError(P4cmdError):
     pass
 
 
+class P4CommandError(P4cmdError):
+    """Raised when a P4 command returns one or more error dicts.
+
+    Attributes:
+        cmd: The P4 command that failed (e.g. "sync", "edit").
+        messages: List of error message strings from the error dicts.
+    """
+    def __init__(self, cmd, messages):
+        self.cmd = cmd
+        self.messages = messages
+        joined = "; ".join(str(m).strip() for m in messages)
+        super().__init__(f"p4 {cmd}: {joined}")
+
+
 class ServerOffline(P4cmdError):
     """Raised when the Perforce server is unreachable.
 

{p4cmd-2.9.2 → p4cmd-2.10.1}/p4cmd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.9.2
+Version: 2.10.1
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes

{p4cmd-2.9.2 → p4cmd-2.10.1}/tests/test_p4client.py

@@ -1,10 +1,12 @@
 """Tests for p4cmd/p4cmd.py — P4Client with run_cmd mocked."""
+import logging
 import socket
 from unittest.mock import MagicMock, patch
 
 import pytest
 
 from p4cmd.p4cmd import P4Client
+from p4cmd.p4errors import P4CommandError
 from p4cmd.p4file import P4File, Status
 from tests.conftest import make_fstat_dict
 
@@ -210,6 +212,20 @@ def test_fstat_actionowner_field(p4client):
     assert any("charlie@testclient" in entry for entry in files[0].checked_out_by)
 
 
+def test_fstat_untracked_file_with_dash_in_name(p4client):
+    """fstat_to_p4_files correctly parses untracked file paths containing ' - '."""
+    fstat = [
+        {
+            b"code": b"error",
+            b"data": b"D:/p4/games/Animations/my_clip - Copy.pose - no such file(s).",
+        }
+    ]
+    with patch.object(p4client, "find_p4_client", return_value="testclient"):
+        files = p4client.fstat_to_p4_files(fstat)
+    assert len(files) == 1
+    assert files[0].local_file_path == "D:/p4/games/Animations/my_clip - Copy.pose"
+
+
 def test_fstat_invalid_revision_becomes_none(p4client):
     fstat = [
         make_fstat_dict(
@@ -577,6 +593,80 @@ def test_get_depot_paths_missing_depot_file(p4client):
     assert result == ["//depot/project/file.txt"]
 
 
+# ---------------------------------------------------------------------------
+# run_cmd error handling
+# ---------------------------------------------------------------------------
+
+def test_run_cmd_logs_warning_on_error_dicts(p4client, caplog):
+    """run_cmd logs a warning for each error dict returned by p4."""
+    error_dict = {b"code": b"error", b"data": b"//depot/file.txt - file(s) not on client.\n"}
+    ok_dict = {b"code": b"stat", b"depotFile": b"//depot/other.txt"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        _m.dump(ok_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with caplog.at_level(logging.WARNING):
+            result = p4client.run_cmd("sync", file_list=["//depot/file.txt", "//depot/other.txt"])
+    assert len(result) == 2  # both dicts still returned
+    assert "file(s) not on client" in caplog.text
+
+
+def test_run_cmd_raise_on_errors(p4client):
+    """run_cmd raises P4CommandError when raise_on_errors=True and errors are present."""
+    error_dict = {b"code": b"error", b"data": b"//depot/file.txt - file(s) not on client.\n"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with pytest.raises(P4CommandError, match="file\\(s\\) not on client"):
+            p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
+
+
+def test_run_cmd_no_raise_without_errors(p4client):
+    """run_cmd doesn't raise when raise_on_errors=True but no errors are present."""
+    ok_dict = {b"code": b"stat", b"depotFile": b"//depot/file.txt"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(ok_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        result = p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
+    assert result == [ok_dict]
+
+
+def test_run_cmd_handles_string_key_error_dicts(p4client, caplog):
+    """run_cmd handles error dicts with string keys (from ValueError fallback)."""
+    # String-keyed error dicts come from the ValueError handler in run_cmd
+    error_dict = {b"code": b"error", b"data": b"some error\n"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with caplog.at_level(logging.WARNING):
+            p4client.run_cmd("sync", file_list=["//depot/file.txt"])
+    assert "some error" in caplog.text
+
+
 def test_get_local_paths_missing_path(p4client):
     """get_local_paths skips entries where path is missing (e.g. unmapped paths from p4 where)."""
     info_dicts = [