p4cmd 2.10.2__tar.gz → 2.10.3__tar.gz

{p4cmd-2.10.2 → p4cmd-2.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.10.2
+Version: 2.10.3
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes
@@ -24,6 +24,9 @@ Dynamic: summary
 
 ### P4CMD 🌴
 
+[![Tests](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml)
+[![Publish](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml)
+
 A Python Perforce package that doesn't bring in any other packages to work.
 Relies on the `p4` CLI installed on the system.
 

{p4cmd-2.10.2 → p4cmd-2.10.3}/README.md

@@ -1,5 +1,8 @@
 ### P4CMD 🌴
 
+[![Tests](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml)
+[![Publish](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml)
+
 A Python Perforce package that doesn't bring in any other packages to work.
 Relies on the `p4` CLI installed on the system.
 

{p4cmd-2.10.2 → p4cmd-2.10.3}/p4cmd/__init__.py

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

{p4cmd-2.10.2 → p4cmd-2.10.3}/p4cmd/p4cmd.py

@@ -2,6 +2,7 @@ import os
 import marshal
 import subprocess
 import socket
+import warnings
 from pprint import pformat
 
 import logging
@@ -84,18 +85,35 @@ 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, raise_on_errors=False):
+    def run_cmd(self, cmd, args=None, file_list=None, marshal_output=True, online_check=True, raise_on_errors=False, **kwargs):
         """
-        Reads the output stream of the command and returns it as a marshaled dict.
+        Reads the output stream of the command and returns it as a list of dicts.
 
         :param cmd: *string* p4 command like "change", "reopen", "move"
         :param args: *list* of string arguments like ["-c", "27277"]
         :param file_list: *list* of string arguments like ["//depot/folder/file.atom", "D:/Games/Whatever.fbx]
-        :param use_global_options: *bool*
+        :param marshal_output: *bool* when True (default), passes ``-G`` so p4 emits Python marshal-format
+            output that we parse into dicts, and also passes ``-u <user> -c <client>`` for identity. Set to
+            False for commands that don't honor ``-G`` (notably ``p4 set``, which only reads local settings)
+            or when user/client haven't been resolved yet — output is then returned verbatim under the
+            ``raw_output`` key.
         :param online_check: *bool* if set to True, will first check if the remote server is reachable before executing the command.
         :return: *list* of dictionaries with either the marshaled returns of the command or dictionaries with the
         raw output of the command
         """
+        # Backwards compat: the old name `use_global_options` was misleading — it sounded like a master
+        # switch for p4's global-option family, when it really just toggles `-G` (marshal output) plus the
+        # bundled `-u`/`-c` identity flags. Renamed to `marshal_output` to point at the actual consequence
+        # (the parsing path); old kwarg kept as a deprecated alias.
+        if "use_global_options" in kwargs:
+            warnings.warn(
+                "`use_global_options` is deprecated; use `marshal_output` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            marshal_output = kwargs.pop("use_global_options")
+        if kwargs:
+            raise TypeError(f"run_cmd() got unexpected keyword arguments: {list(kwargs)}")
 
         if not self.perforce_root:
             raise p4errors.WorkSpaceError(f"self.perforce_root (value: {self.perforce_root}) is not set!")
@@ -117,7 +135,7 @@ class P4Client(object):
         dict_list = []
         for clamped_arg in clamped_arg_list:
             for clamped_files in clamped_file_list:
-                if use_global_options:
+                if marshal_output:
                     command = f"p4 -G -u {self.user} -c {self.client} {cmd} {clamped_arg} {clamped_files}"
                 else:
                     command = f"p4 {cmd} {clamped_arg} {clamped_files}"
@@ -129,20 +147,31 @@ class P4Client(object):
 
                 with subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True, cwd=self.perforce_root) as pipe:
                     output = pipe.stdout
-                    try:
-                        while True:
-                            value_dict = marshal.load(output)
-                            dict_list.append(value_dict)
-                    except EOFError:
-                        pass
-                    except ValueError as error:
-                        output_dict = {
+                    if not marshal_output:
+                        # Without -G, p4 emits plain text (and `p4 set` ignores -G even when passed),
+                        # so marshal.load is guaranteed to fail. Read stdout directly from this Popen
+                        # — it has stdin=PIPE, so it's safe in non-interactive sessions where the old
+                        # check_output fallback hit OSError(WinError 50) on DuplicateHandle.
+                        dict_list.append({
                             "command": command,
                             "code": "raw",
-                            "error": str(error),
-                            "raw_output": subprocess.check_output(command, stderr=subprocess.STDOUT, shell=True, cwd=self.perforce_root)
-                        }
-                        dict_list.append(output_dict)
+                            "raw_output": output.read(),
+                        })
+                    else:
+                        try:
+                            while True:
+                                value_dict = marshal.load(output)
+                                dict_list.append(value_dict)
+                        except EOFError:
+                            pass
+                        except ValueError as error:
+                            output_dict = {
+                                "command": command,
+                                "code": "raw",
+                                "error": str(error),
+                                "raw_output": subprocess.check_output(command, stderr=subprocess.STDOUT, shell=True, cwd=self.perforce_root)
+                            }
+                            dict_list.append(output_dict)
                     pipe.kill()
 
         # Check for error dicts in the results
@@ -218,7 +247,7 @@ class P4Client(object):
         """
         try:
             # skipping the online check for setting commands
-            info_dict = self.run_cmd("set", [setting], use_global_options=False, online_check=False)[0]
+            info_dict = self.run_cmd("set", [setting], marshal_output=False, online_check=False)[0]
         except Exception as e:
             raise p4errors.WorkSpaceError("Unable to find setting %s" % setting) from e
 

{p4cmd-2.10.2 → p4cmd-2.10.3}/p4cmd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.10.2
+Version: 2.10.3
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes
@@ -24,6 +24,9 @@ Dynamic: summary
 
 ### P4CMD 🌴
 
+[![Tests](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/tests.yml)
+[![Publish](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml/badge.svg)](https://github.com/nielsvaes/p4cmd/actions/workflows/python-publish.yml)
+
 A Python Perforce package that doesn't bring in any other packages to work.
 Relies on the `p4` CLI installed on the system.
 

{p4cmd-2.10.2 → p4cmd-2.10.3}/tests/test_p4client.py

@@ -668,13 +668,10 @@ def test_run_cmd_handles_string_key_error_dicts(p4client, caplog):
 
 
 def test_run_cmd_value_error_fallback_no_warning(p4client, caplog):
-    """run_cmd's ValueError fallback (e.g. `p4 set`) must not log spurious error warnings."""
-    with patch("subprocess.Popen") as mock_popen, \
-         patch("p4cmd.p4cmd.subprocess.check_output", return_value=b"P4USER=niels.vaes (set)\n"):
-        # Empty stdout triggers ValueError on marshal.load (unknown type code in this case
-        # would also work; here we use bytes that aren't valid marshal data).
+    """The marshal_output=False path (e.g. `p4 set`) must not log spurious error warnings."""
+    with patch("subprocess.Popen") as mock_popen:
         import io as _io
-        buf = _io.BytesIO(b"\xff\xff\xff\xff")  # invalid marshal type code -> ValueError
+        buf = _io.BytesIO(b"P4USER=niels.vaes (set)\n")
         mock_popen.return_value.__enter__ = lambda s: s
         mock_popen.return_value.__exit__ = MagicMock(return_value=False)
         mock_popen.return_value.stdout = buf
@@ -685,6 +682,55 @@ def test_run_cmd_value_error_fallback_no_warning(p4client, caplog):
     assert caplog.records == []
 
 
+def test_run_cmd_no_global_options_does_not_spawn_second_subprocess(p4client):
+    """
+    Regression test for issue #13. When marshal_output=False (e.g. `p4 set`),
+    p4 outputs plain text — marshal.load is guaranteed to fail. The old fallback
+    spawned a second subprocess via check_output without pinning stdin, which
+    triggered OSError(WinError 50) on DuplicateHandle in non-interactive sessions
+    (UE commandlets, scheduled tasks, CI). The fix reads stdout directly from the
+    already-open Popen, which has stdin=PIPE.
+    """
+    import io as _io
+    p4_set_output = b"P4USER=niels.vaes (set)\r\n"
+    with patch("subprocess.Popen") as mock_popen, \
+         patch("p4cmd.p4cmd.subprocess.check_output") as mock_check_output:
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = _io.BytesIO(p4_set_output)
+        mock_popen.return_value.kill = MagicMock()
+
+        result = p4client.get_p4_setting("P4USER")
+
+    assert result == "niels.vaes"
+    mock_check_output.assert_not_called()
+
+
+def test_run_cmd_use_global_options_deprecation_alias(p4client):
+    """The old `use_global_options` kwarg is accepted but emits DeprecationWarning."""
+    import io as _io
+    import warnings as _warnings
+    with patch("subprocess.Popen") as mock_popen:
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = _io.BytesIO(b"P4USER=niels.vaes (set)\n")
+        mock_popen.return_value.kill = MagicMock()
+
+        with _warnings.catch_warnings(record=True) as caught:
+            _warnings.simplefilter("always")
+            result = p4client.run_cmd("set", ["P4USER"], use_global_options=False, online_check=False)
+
+    assert result[0]["raw_output"] == b"P4USER=niels.vaes (set)\n"
+    assert any(issubclass(w.category, DeprecationWarning) and "use_global_options" in str(w.message)
+               for w in caught), f"expected DeprecationWarning for use_global_options, got: {[str(w.message) for w in caught]}"
+
+
+def test_run_cmd_unknown_kwarg_raises(p4client):
+    """Unknown kwargs should raise TypeError, not be silently accepted."""
+    with pytest.raises(TypeError, match="unexpected keyword arguments"):
+        p4client.run_cmd("set", ["P4USER"], totally_made_up=True, online_check=False)
+
+
 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 = [