p4cmd 2.10.2__tar.gz → 2.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.10.2
+Version: 2.11.0
 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.
 
@@ -57,6 +60,33 @@ p4 = p4cmd.P4Client.from_env()
 
 If the path you pass doesn't contain a `.p4config` file, P4Client will walk up the directory tree until it finds one and use that as `perforce_root`.
 
+### Quieting log output
+
+`p4cmd` logs warnings and errors through the standard `logging` module under the `p4cmd` logger. Setting the level on the `p4cmd` parent flows down to all submodules (`p4cmd.p4cmd`, `p4cmd.utils`).
+
+**Drop everything except criticals** — matches the old `silent=True` behavior:
+
+```python
+import logging
+logging.getLogger("p4cmd").setLevel(logging.CRITICAL)
+```
+
+**Drop literally everything from p4cmd** (including criticals):
+
+```python
+logging.getLogger("p4cmd").disabled = True
+```
+
+**Keep the messages but route them somewhere other than stderr** — e.g. a log file:
+
+```python
+p4_logger = logging.getLogger("p4cmd")
+p4_logger.propagate = False               # don't bubble to root/stderr
+p4_logger.addHandler(logging.FileHandler("p4cmd.log"))
+```
+
+The old `silent=True` constructor kwarg is deprecated and now a no-op — configure the logger instead.
+
 ## P4Client API
 
 ### Connection & settings

{p4cmd-2.10.2 → p4cmd-2.11.0}/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.
 
@@ -33,6 +36,33 @@ p4 = p4cmd.P4Client.from_env()
 
 If the path you pass doesn't contain a `.p4config` file, P4Client will walk up the directory tree until it finds one and use that as `perforce_root`.
 
+### Quieting log output
+
+`p4cmd` logs warnings and errors through the standard `logging` module under the `p4cmd` logger. Setting the level on the `p4cmd` parent flows down to all submodules (`p4cmd.p4cmd`, `p4cmd.utils`).
+
+**Drop everything except criticals** — matches the old `silent=True` behavior:
+
+```python
+import logging
+logging.getLogger("p4cmd").setLevel(logging.CRITICAL)
+```
+
+**Drop literally everything from p4cmd** (including criticals):
+
+```python
+logging.getLogger("p4cmd").disabled = True
+```
+
+**Keep the messages but route them somewhere other than stderr** — e.g. a log file:
+
+```python
+p4_logger = logging.getLogger("p4cmd")
+p4_logger.propagate = False               # don't bubble to root/stderr
+p4_logger.addHandler(logging.FileHandler("p4cmd.log"))
+```
+
+The old `silent=True` constructor kwarg is deprecated and now a no-op — configure the logger instead.
+
 ## P4Client API
 
 ### Connection & settings

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

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

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

@@ -2,6 +2,7 @@ import os
 import marshal
 import subprocess
 import socket
+import warnings
 from pprint import pformat
 
 import logging
@@ -10,24 +11,34 @@ from . import p4errors
 from .p4file import P4File, Status
 from .utils import split_list_into_strings_of_length, convert_to_list, decode_dictionaries, validate_not_empty
 
+_log = logging.getLogger(__name__)
+
 MAX_CMD_LEN = 8190
 MAX_ARG_LEN = 8000  # max length of args string when combined, close to max, but leaving some extra margin
 
 
 class P4Client(object):
-    def __init__(self, perforce_root, user=None, client=None, server=None, silent=True, max_parallel_connections=4):
+    def __init__(self, perforce_root, user=None, client=None, server=None, silent=None, max_parallel_connections=4):
         """
         Make a new P4Client
 
         :param perforce_root: *string* root of your Perforce workspace. This would also be where your .p4config file is
         :param user: *string* P4USER, if None will be tried to be found automatically
         :param client: *string* P4CLIENT, if None will be tried to be found automatically
-        :param silent: *bool* if True, suppresses error messages to cut down on terminal spam
         :param max_parallel_connections: *int* max number of connections to use while syncing/submitting. This requires
         the server to have net.parallel.max and net parallel.threads to be > 1
+        :param silent: *deprecated* — no-op. To quiet output, configure the ``p4cmd`` logger, e.g.
+        ``logging.getLogger("p4cmd").setLevel(logging.CRITICAL)``.
         """
+        if silent is not None:
+            warnings.warn(
+                "`silent` is deprecated and has no effect; configure the `p4cmd` logger "
+                "instead, e.g. `logging.getLogger('p4cmd').setLevel(logging.CRITICAL)`.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.perforce_root = perforce_root
-        self.silent = silent
 
         self.max_parallel_connections = max_parallel_connections
         self.user = user
@@ -35,8 +46,7 @@ class P4Client(object):
         self.server = server
 
         if not self.__p4config_exists():
-            if not silent:
-                logging.warning("No .p4config file found in %s!" % self.perforce_root)
+            _log.warning("No .p4config file found in %s!" % self.perforce_root)
 
         if user is None:
             self.user = self.get_p4_setting("P4USER")
@@ -84,18 +94,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,32 +144,43 @@ 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}"
 
                 if len(command) > MAX_CMD_LEN:
                     # This shouldn't happen, but just in case the command prefix end up really long
-                    logging.warning(
+                    _log.warning(
                         f"Command length: {format(len(command))} exceeds MAX_CMD_LEN {MAX_CMD_LEN} on command: {MAX_CMD_LEN}")
 
                 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
@@ -155,7 +193,7 @@ class P4Client(object):
                     msg = msg.decode("utf-8", errors="replace")
                 messages.append(msg.strip())
             for msg in messages:
-                logging.warning(f"p4 {cmd}: {msg}")
+                _log.warning(f"p4 {cmd}: {msg}")
             if raise_on_errors:
                 raise p4errors.P4CommandError(cmd, messages)
 
@@ -218,7 +256,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
 
@@ -367,12 +405,12 @@ class P4Client(object):
 
         parts = output.split(" ")
         if len(parts) < 2:
-            logging.error(f"Unexpected output from p4 change: {output!r}")
+            _log.error(f"Unexpected output from p4 change: {output!r}")
             return None
         try:
             return int(parts[1])
         except ValueError:
-            logging.error(f"Could not parse changelist number from: {output!r}")
+            _log.error(f"Could not parse changelist number from: {output!r}")
             return None
 
     def changelist_exists(self, changelist):
@@ -420,14 +458,10 @@ class P4Client(object):
 
             return True
         except subprocess.CalledProcessError as e:
-            logging.debug(f"p4 command failed: {e}")
-            if not self.silent:
-                logging.error(f"Failed to update changelist description: {e}")
+            _log.error(f"Failed to update changelist description: {e}")
             return False
         except OSError as e:
-            logging.debug(f"OS error: {e}")
-            if not self.silent:
-                logging.error(f"Failed to update changelist description: {e}")
+            _log.error(f"Failed to update changelist description: {e}")
             return False
 
     @validate_not_empty
@@ -442,11 +476,6 @@ class P4Client(object):
         file_list = convert_to_list(file_list)
         changelist = self.__ensure_changelist(changelist)
         info_dicts = self.run_cmd("reopen", args=["-c", changelist], file_list=file_list)
-
-        for info_dict in info_dicts:
-            if self.__get_dict_value(info_dict, "code") == "error" and not self.silent:
-                logging.error(self.__get_dict_value(info_dict, "data"))
-
         return info_dicts
 
     def combine_changelists(self, source_changelists, target_changelist):
@@ -510,8 +539,6 @@ class P4Client(object):
         :return: *list* of info dictionaries
         """
         file_list = convert_to_list(file_list)
-        if not self.silent:
-            self.__validate_file_list(file_list)
         if unchanged_only:
             info_dicts = self.run_cmd("revert", ["-a"], file_list=file_list)
         else:
@@ -534,9 +561,6 @@ class P4Client(object):
         :return: *list* of info dicts
         """
         folder_list = convert_to_list(folder_list)
-        if not self.silent:
-            self.__validate_file_list(folder_list)
-
         cleaned_folder_list = [self._normalize_folder(f) for f in folder_list]
 
         if unchanged_only:
@@ -583,9 +607,6 @@ class P4Client(object):
         :return: *list* of info dicts
         """
         folder_list = convert_to_list(folder_list)
-        if not self.silent:
-            self.__validate_file_list(folder_list)
-
         cleaned_folder_list = [self._normalize_folder(f) for f in folder_list]
 
         info_dicts = self.run_cmd("sync", args=["--parallel", f"threads={self.max_parallel_connections}"],
@@ -611,9 +632,6 @@ class P4Client(object):
 
         initial_arg_list = ["-f", "--parallel", f"threads={self.max_parallel_connections}"] if force else ["--parallel",
                                                                                                            f"threads={self.max_parallel_connections}"]
-        if not self.silent:
-            self.__validate_file_list(file_list)
-
         info_dicts = self.run_cmd("sync", args=initial_arg_list, file_list=file_list)
 
         if verify:
@@ -622,7 +640,7 @@ class P4Client(object):
                 if local_file_path is None:
                     continue
                 if not os.path.isfile(local_file_path):
-                    logging.warning(f"File didn't exist after syncing, try force syncing it instead: {local_file_path}")
+                    _log.warning(f"File didn't exist after syncing, try force syncing it instead: {local_file_path}")
 
         return info_dicts
 
@@ -672,8 +690,6 @@ class P4Client(object):
         :return: *list* of info dicts
         """
         folder_list = convert_to_list(folder_list)
-        if not self.silent:
-            self.__validate_file_list(folder_list)
         cleaned_folder_list = [self._normalize_folder(f) for f in folder_list]
         changelist = self.__ensure_changelist(changelist)
         args = self._build_reconcile_args(changelist, add, edit, delete)
@@ -691,9 +707,6 @@ class P4Client(object):
         :return: *list* of info dictionaries
         """
         file_list = convert_to_list(file_list)
-        if not self.silent:
-            self.__validate_file_list(file_list)
-
         changelist = self.__ensure_changelist(changelist)
 
         info_dicts = self.run_cmd("delete", args=["-c", changelist], file_list=file_list)
@@ -761,13 +774,10 @@ class P4Client(object):
             file_list = self.get_files_in_changelist(changelist)
         else:
             file_list = convert_to_list(file_list)
-            if not self.silent:
-                self.__validate_file_list(file_list)
 
         # if there are no files to shelve, return empty list
         if not file_list:
-            if not self.silent:
-                logging.warning(f"No files to shelve in changelist {changelist}")
+            _log.warning(f"No files to shelve in changelist {changelist}")
             return []
 
         # iuild args list based on options
@@ -778,10 +788,6 @@ class P4Client(object):
         # run the shelve command
         info_dicts = self.run_cmd("shelve", args=args, file_list=file_list)
 
-        for info_dict in info_dicts:
-            if self.__get_dict_value(info_dict, "code") == "error" and not self.silent:
-                logging.error(self.__get_dict_value(info_dict, "data"))
-
         # revert files if requested
         if revert_after_shelve and file_list:
             revert_info_dicts = self.revert_files(file_list)
@@ -822,35 +828,20 @@ class P4Client(object):
         # prepare file list if provided
         if file_list is not None:
             file_list = convert_to_list(file_list)
-            if not self.silent:
-                self.__validate_file_list(file_list)
         else:
             file_list = []
 
         # run the unshelve command
         info_dicts = self.run_cmd("unshelve", args=args, file_list=file_list)
 
-        # check for errors in the unshelve operation
-        has_error = False
-        for info_dict in info_dicts:
-            if self.__get_dict_value(info_dict, "code") == "error" and not self.silent:
-                logging.error(self.__get_dict_value(info_dict, "data"))
-                has_error = True
+        has_error = any(
+            self.__get_dict_value(d, "code") == "error" for d in info_dicts
+        )
 
         # delete shelved files if requested and unshelve was successful
         if delete_shelved_files and not has_error:
-            # build the arguments for the shelve -d command
             delete_args = ["-d", "-c", str(source_changelist)]
-
-            # if file_list provided, use it for the delete operation as well
             delete_info_dicts = self.run_cmd("shelve", args=delete_args, file_list=file_list)
-
-            # check for errors in the delete operation
-            for info_dict in delete_info_dicts:
-                if self.__get_dict_value(info_dict, "code") == "error" and not self.silent:
-                    logging.error(self.__get_dict_value(info_dict, "data"))
-
-            # add the delete info to the return data
             info_dicts.extend(delete_info_dicts)
 
         return info_dicts
@@ -868,8 +859,7 @@ class P4Client(object):
 
             # Don't allow deleting shelves from the default changelist
             if changelist == "default":
-                if not self.silent:
-                    logging.error("Cannot delete shelved files from the default changelist")
+                _log.error("Cannot delete shelved files from the default changelist")
                 return [{"code": "error", "data": "Cannot delete shelved files from the default changelist"}]
 
             # Check if the changelist has shelved files
@@ -884,8 +874,7 @@ class P4Client(object):
                     break
 
             if not has_shelved_files:
-                if not self.silent:
-                    logging.warning(f"No shelved files found in changelist {changelist}")
+                _log.warning(f"No shelved files found in changelist {changelist}")
                 return [{"code": "info", "data": f"No shelved files found in changelist {changelist}"}]
 
             # Delete all shelved files in the changelist
@@ -893,14 +882,10 @@ class P4Client(object):
             return info_dicts
 
         except subprocess.CalledProcessError as e:
-            logging.debug(f"p4 command failed: {e}")
-            if not self.silent:
-                logging.error(f"Failed to delete shelved files: {e}")
+            _log.error(f"Failed to delete shelved files: {e}")
             return [{"code": "error", "data": str(e)}]
         except OSError as e:
-            logging.debug(f"OS error: {e}")
-            if not self.silent:
-                logging.error(f"Failed to delete shelved files: {e}")
+            _log.error(f"Failed to delete shelved files: {e}")
             return [{"code": "error", "data": str(e)}]
 
     @validate_not_empty
@@ -938,8 +923,6 @@ class P4Client(object):
         :return: *list* of info dictionaries
         """
         file_list = convert_to_list(file_list)
-        if not self.silent:
-            self.__validate_file_list(file_list)
 
         files_for_add = []
         files_for_checkout = []
@@ -985,15 +968,9 @@ class P4Client(object):
         :return: *list* of info dictionaries
         """
         file_list = convert_to_list(file_list)
-        if not self.silent:
-            self.__validate_file_list(file_list)
-
         changelist = self.__ensure_changelist(changelist)
 
         info_dicts = self.run_cmd("edit", args=["-c", changelist], file_list=file_list)
-        for info_dict in info_dicts:
-            if self.__get_dict_value(info_dict, "code") == "error" and not self.silent:
-                logging.error(self.__get_dict_value(info_dict, "data"))
         return info_dicts
 
     @validate_not_empty
@@ -1005,9 +982,6 @@ class P4Client(object):
         :return: *list* of info dictionaries
         """
         file_list = convert_to_list(file_list)
-        if not self.silent:
-            self.__validate_file_list(file_list)
-
         changelist = self.__ensure_changelist(changelist)
 
         info_dicts = self.run_cmd("add", args=["-c", changelist], file_list=file_list)
@@ -1071,7 +1045,7 @@ class P4Client(object):
             cl_description = desc_value.rstrip("\n")
 
             if not cl_description:
-                logging.warning(f"The CL description is empty in this return object!\n{pformat(info_dict)}")
+                _log.warning(f"The CL description is empty in this return object!\n{pformat(info_dict)}")
 
             if not case_sensitive:
                 cl_description = cl_description.lower()
@@ -1211,13 +1185,13 @@ class P4Client(object):
             with socket.create_connection((host, port), timeout=timeout):
                 return True
         except socket.timeout:
-            logging.warning(f"Connection to {host} on port {port} timed out after {timeout} seconds, the running command might not complete correctly")
+            _log.warning(f"Connection to {host} on port {port} timed out after {timeout} seconds, the running command might not complete correctly")
             return False
         except ConnectionRefusedError:
-            logging.warning(f"Connection to {host} on port {port} refused to connect, is the server still up?")
+            _log.warning(f"Connection to {host} on port {port} refused to connect, is the server still up?")
             return False
         except OSError as e:
-            logging.warning(f"oserror: {e.strerror or e}")
+            _log.warning(f"oserror: {e.strerror or e}")
             return False
 
     def __server_address(self):
@@ -1344,7 +1318,7 @@ class P4Client(object):
         while last_dir != current_dir:
             if os.path.exists(current_dir):
                 if ".p4config" in os.listdir(current_dir):
-                    logging.info(".p4config found in %s" % current_dir)
+                    _log.info(".p4config found in %s" % current_dir)
                     self.perforce_root = current_dir
                     return True
 
@@ -1352,22 +1326,3 @@ class P4Client(object):
             current_dir = os.path.dirname(last_dir)
         return False
 
-    def __validate_file_list(self, file_list):
-        """
-        Validation function to ensure correct files are being synced to correct workspaces & clients etc.
-        Is an extendable function
-        :param file_list: List of files to iterate
-        :return:
-        """
-        if not self.perforce_root:
-            raise p4errors.WorkSpaceError(f"self.perforce_root (value: {self.perforce_root}) is not set!")
-
-        file_list = convert_to_list(file_list)
-
-        # Easy utility to check that the file is underneath the correct perforce root
-        # Quicker than waiting for the result of a p4 fstat
-        for f in file_list:
-            if not f.lower().startswith(self.perforce_root.lower()) and not f.lower().startswith(
-                    self.depot_root.lower()):
-                raise Exception(f'{f} is not under perforce root: {self.perforce_root}, {self.depot_root}')
-

{p4cmd-2.10.2 → p4cmd-2.11.0}/p4cmd/utils.py

@@ -1,6 +1,8 @@
 import logging
 import functools
 
+_log = logging.getLogger(__name__)
+
 
 def split_list_into_strings_of_length(input_list, max_length=100):
     """
@@ -66,9 +68,9 @@ def validate_not_empty(func):
             file_or_folder_list = convert_to_list(file_or_folder_list)
 
         if not file_or_folder_list:
-            logging.warning(f"Empty file list provided to {func.__name__}, operation skipped.")
-            logging.warning(f"args: {args}")
-            logging.warning(f"kwargs: {kwargs}")
+            _log.warning(f"Empty file list provided to {func.__name__}, operation skipped.")
+            _log.warning(f"args: {args}")
+            _log.warning(f"kwargs: {kwargs}")
             return []
 
         return func(*args, **kwargs)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.10.2
+Version: 2.11.0
 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.
 
@@ -57,6 +60,33 @@ p4 = p4cmd.P4Client.from_env()
 
 If the path you pass doesn't contain a `.p4config` file, P4Client will walk up the directory tree until it finds one and use that as `perforce_root`.
 
+### Quieting log output
+
+`p4cmd` logs warnings and errors through the standard `logging` module under the `p4cmd` logger. Setting the level on the `p4cmd` parent flows down to all submodules (`p4cmd.p4cmd`, `p4cmd.utils`).
+
+**Drop everything except criticals** — matches the old `silent=True` behavior:
+
+```python
+import logging
+logging.getLogger("p4cmd").setLevel(logging.CRITICAL)
+```
+
+**Drop literally everything from p4cmd** (including criticals):
+
+```python
+logging.getLogger("p4cmd").disabled = True
+```
+
+**Keep the messages but route them somewhere other than stderr** — e.g. a log file:
+
+```python
+p4_logger = logging.getLogger("p4cmd")
+p4_logger.propagate = False               # don't bubble to root/stderr
+p4_logger.addHandler(logging.FileHandler("p4cmd.log"))
+```
+
+The old `silent=True` constructor kwarg is deprecated and now a no-op — configure the logger instead.
+
 ## P4Client API
 
 ### Connection & settings

{p4cmd-2.10.2 → p4cmd-2.11.0}/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 = [
@@ -696,3 +742,52 @@ def test_get_local_paths_missing_path(p4client):
             ["//depot/project/file.txt", "//depot/project/unmapped.txt"]
         )
     assert result == ["C:/workspace/file.txt"]
+
+
+# ---------------------------------------------------------------------------
+# Regression: issue #14 — files mapped from outside perforce_root/depot_root
+# must not raise on edit (previously failed when silent=False due to a buggy
+# prefix-based pre-validation that ignored multi-mapping client views).
+# ---------------------------------------------------------------------------
+
+def test_edit_files_accepts_paths_outside_perforce_root_prefix(p4client):
+    """A file mapped from a different depot path (e.g. shared Raw assets) must
+    not be rejected before p4 sees it. perforce_root is /fake/project and
+    depot_root is //depot/project — neither prefix matches this file."""
+    outside_file = "//depot/shared_audio/Raw/voice_line.wav"
+    with patch.object(p4client, "_P4Client__ensure_changelist", return_value="default"):
+        with patch.object(p4client, "run_cmd", return_value=[]) as mock_cmd:
+            p4client.edit_files([outside_file])
+    mock_cmd.assert_called_once()
+    args, kwargs = mock_cmd.call_args
+    assert outside_file in kwargs["file_list"]
+
+
+# ---------------------------------------------------------------------------
+# silent kwarg — deprecated
+# ---------------------------------------------------------------------------
+
+def test_silent_kwarg_emits_deprecation_warning(tmp_path):
+    """Passing silent= (True or False) emits DeprecationWarning."""
+    import warnings as _warnings
+    (tmp_path / ".p4config").write_text("P4PORT=ssl:example:1666\n")
+    with patch.object(P4Client, "host_online", return_value=True):
+        with patch.object(P4Client, "run_cmd", return_value=[{b"depotFile": b"//depot/x/...", b"path": b"/fake/...", b"unmap": b""}]):
+            with _warnings.catch_warnings(record=True) as caught:
+                _warnings.simplefilter("always")
+                P4Client(str(tmp_path), user="u", client="c", server="s", silent=True)
+    assert any(issubclass(w.category, DeprecationWarning) and "silent" in str(w.message)
+               for w in caught), f"expected DeprecationWarning, got: {[str(w.message) for w in caught]}"
+
+
+def test_silent_kwarg_default_no_warning(tmp_path):
+    """Not passing silent at all must not emit a DeprecationWarning."""
+    import warnings as _warnings
+    (tmp_path / ".p4config").write_text("P4PORT=ssl:example:1666\n")
+    with patch.object(P4Client, "host_online", return_value=True):
+        with patch.object(P4Client, "run_cmd", return_value=[{b"depotFile": b"//depot/x/...", b"path": b"/fake/...", b"unmap": b""}]):
+            with _warnings.catch_warnings(record=True) as caught:
+                _warnings.simplefilter("always")
+                P4Client(str(tmp_path), user="u", client="c", server="s")
+    assert not any(issubclass(w.category, DeprecationWarning) and "silent" in str(w.message)
+                   for w in caught), f"unexpected silent warning: {[str(w.message) for w in caught]}"