p4cmd 2.4.13__tar.gz → 2.6.0__tar.gz

{p4cmd-2.4.13 → p4cmd-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.4.13
+Version: 2.6.0
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes
@@ -50,7 +50,7 @@ os.environ["P4ROOT"] = "~/nisse/projects/raw"
 client = p4cmd.P4Client.from_env()
 ```
 
-Most of the functions are pretty self explanatory and have docstrings about how they work. 
+Most of the functions are pretty self-explanatory and have docstrings about how they work. 
 
 There are 2 functions called `file_to_p4files` and `folder_to_p4files` that use the `P4File` class in `p4file`. 
 

{p4cmd-2.4.13 → p4cmd-2.6.0}/README.md

@@ -29,7 +29,7 @@ os.environ["P4ROOT"] = "~/nisse/projects/raw"
 client = p4cmd.P4Client.from_env()
 ```
 
-Most of the functions are pretty self explanatory and have docstrings about how they work. 
+Most of the functions are pretty self-explanatory and have docstrings about how they work. 
 
 There are 2 functions called `file_to_p4files` and `folder_to_p4files` that use the `P4File` class in `p4file`. 
 

{p4cmd-2.4.13 → p4cmd-2.6.0}/p4cmd/__init__.py

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

{p4cmd-2.4.13 → p4cmd-2.6.0}/p4cmd/p4cmd.py

@@ -9,6 +9,7 @@ import logging
 
 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
 
 MAX_CMD_LEN = 8190
 MAX_ARG_LEN = 8000  # max length of args string when combined, close to max, but leaving some extra margin
@@ -50,6 +51,8 @@ class P4Client(object):
             self.server = self.get_p4_setting("P4PORT")
             if self.server is None:
                 raise p4errors.WorkSpaceError("Could not find P4PORT")
+        
+        self.depot_root = self.get_depot_paths([self.perforce_root])[0]
 
     @classmethod
     def from_env(cls, *args, **kwargs):
@@ -206,6 +209,7 @@ class P4Client(object):
         else:
             raise p4errors.WorkSpaceError("Tried to set a workspace/client({}) that did not exist".format(workspace))
 
+    @validate_not_empty
     def files_to_p4files(self, file_list, allow_invalid_files=False):
         """
         Turns a list of files into P4File objects. If the Perforce server can't be reached, returns a list of P4Files
@@ -232,6 +236,7 @@ class P4Client(object):
                 p4files.append(perforce_file)
             return p4files
 
+    @validate_not_empty
     def folder_to_p4files(self, folder, include_subfolders=True, allow_invalid_files=False):
         """
         Returns all the files in a folder as a list of P4File objects. Uses the files_to_p4files function if the host
@@ -301,7 +306,8 @@ class P4Client(object):
             if len(changelists):
                 return True
             return False
-
+    
+    @validate_not_empty
     def move_files_to_changelist(self, file_list, changelist="default"):
         """
         Moves the files in file_list to a changelist. Makes a new changelist if the given one doesn't exist.
@@ -371,6 +377,7 @@ class P4Client(object):
             return True
         return False
 
+    @validate_not_empty
     def revert_files(self, file_list, unchanged_only=False):
         """
         Reverts files in file_list
@@ -389,6 +396,8 @@ class P4Client(object):
 
         return info_dicts
 
+
+    @validate_not_empty
     def revert_folders(self, folder_list, unchanged_only=False):
         """
         Recursively reverts complete folders
@@ -442,6 +451,7 @@ class P4Client(object):
         info_dicts = self.run_cmd("submit", args=["-c", changelist, "--parallel", f"threads={self.max_parallel_connections}"])
         return info_dicts
 
+    @validate_not_empty
     def sync_folders(self, folder_list):
         """
         Recursively syncs complete folders
@@ -463,6 +473,7 @@ class P4Client(object):
         info_dicts = self.run_cmd("sync", args=["--parallel", f"threads={self.max_parallel_connections}"], file_list=cleaned_folder_list)
         return info_dicts
 
+    @validate_not_empty
     def sync_files(self, file_list, revision=-1, verify=True, force=False):
         """
         Syncs files
@@ -493,6 +504,7 @@ class P4Client(object):
 
         return info_dicts
 
+    @validate_not_empty
     def reconcile_offline_files(self, file_list, changelist="default"):
         """
         Adds, opens for edit or delete any files that were changed outside Perforce
@@ -508,6 +520,7 @@ class P4Client(object):
         info_dicts = self.run_cmd("reconcile", args=["-c", changelist], file_list=file_list)
         return info_dicts
 
+    @validate_not_empty
     def reconcile_offline_folders(self, folder_list, changelist="default"):
         """
         Adds, opens for edit or delete any files in the rootfolder + subfolders that were changed outside Perforce
@@ -532,6 +545,7 @@ class P4Client(object):
         info_dicts = self.run_cmd("reconcile", args=["-c", changelist], file_list=cleaned_folder_list)
         return info_dicts
 
+    @validate_not_empty
     def delete_files(self, file_list, changelist="default"):
         """
         Marks files for delete
@@ -582,6 +596,118 @@ class P4Client(object):
 
         return files_and_cl
 
+    @validate_not_empty
+    def shelve_files(self, changelist, file_list=None, revert_after_shelve=False, force=False):
+        """
+        Shelves files in a changelist. If no files are specified, shelves all files in the changelist.
+    
+        :param changelist: *string* or *int* changelist number or description
+        :param file_list: *list* or *None* list of files to shelve. If None, shelves all files in the changelist
+        :param revert_after_shelve: *bool* if True, reverts the files after shelving them
+        :param force: *bool* if True, forces the shelving operation even if files are already shelved
+        :return: *list* of info dictionaries
+        """
+        changelist = self.__ensure_changelist(changelist)
+        
+        # if no files specified, get all files in the changelist
+        if file_list is None:
+            file_list = self.get_files_in_changelist(changelist)
+        else:
+            file_list = convert_to_list(file_list) if not isinstance(file_list, list) else 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}")
+            return []
+        
+        # iuild args list based on options
+        args = ["-c", str(changelist)]
+        if force:
+            args.append("-f")
+        
+        # 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)
+            # add revert info to the return data
+            info_dicts.extend(revert_info_dicts)
+        
+        return info_dicts
+
+    def unshelve_files(self, changelist, file_list=None, target_changelist="default", force=False, delete_shelved_files=False):
+        """
+        Unshelves files from a shelved changelist. If no files are specified, unshelves all files.
+    
+        :param changelist: *string* or *int* source changelist number containing shelved files
+        :param file_list: *list* or *None* list of files to unshelve. If None, unshelves all files
+        :param target_changelist: *string* or *int* target changelist to unshelve files into
+        :param force: *bool* if True, forces the unshelve operation even if files are already opened
+        :param delete_shelved_files: *bool* if True, deletes the shelved files after unshelving them
+        :return: *list* of info dictionaries
+        """
+        source_changelist = self.__ensure_changelist(changelist)
+        target_changelist = self.__ensure_changelist(target_changelist)
+        
+        # build the arguments list
+        args = []
+        
+        # add force flag if requested
+        if force:
+            args.append("-f")
+        
+        # add source changelist (required)
+        args.extend(["-s", str(source_changelist)])
+        
+        # add target changelist if specified and not default
+        if target_changelist != "default":
+            args.extend(["-c", str(target_changelist)])
+        
+        # prepare file list if provided
+        if file_list is not None:
+            file_list = convert_to_list(file_list) if not isinstance(file_list, list) else 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
+        
+        # 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
+
+    @validate_not_empty
     def add_or_edit_folders(self, folders, include_subfolders=True, changelist="default"):
         """
         Marks a folder for add or edit
@@ -605,6 +731,8 @@ class P4Client(object):
 
         return self.add_or_edit_files(all_files, changelist=changelist)
 
+
+    @validate_not_empty
     def add_or_edit_files(self, file_list, changelist="default"):
         """
         Marks the files in file_list for add if they are new, or edit if they are already versioned
@@ -653,6 +781,7 @@ class P4Client(object):
                 return int(self.__get_dict_value(info_dict, "change"))
         return -1
 
+    @validate_not_empty
     def edit_files(self, file_list, changelist="default"):
         """
         Marks the files in file_list for edit
@@ -673,6 +802,7 @@ class P4Client(object):
                 logging.error(self.__get_dict_value(info_dict, "data"))
         return info_dicts
 
+    @validate_not_empty
     def add_files(self, file_list, changelist="default"):
         """
         Marks the files in file_list for add
@@ -808,6 +938,7 @@ class P4Client(object):
 
         return workspaces
 
+    @validate_not_empty
     def get_depot_paths(self, paths):
         """
         Returns the depot path of the given files or folders, based on the client
@@ -827,6 +958,8 @@ class P4Client(object):
         depot_paths = [self.__get_dict_value(info, "depotFile").rstrip("/...") for info in info_dicts]
         return depot_paths
 
+
+    @validate_not_empty
     def get_local_paths(self, paths):
         """
         Returns the local path of the given files or folders, based on the client
@@ -847,6 +980,7 @@ class P4Client(object):
         local_paths = [self.__get_dict_value(info, "path") for info in info_dicts]
         return local_paths
 
+    @validate_not_empty
     def get_history(self, paths):
         """
         Returns changes for the given paths
@@ -1018,53 +1152,6 @@ class P4Client(object):
         # 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()):
-                raise Exception(f'{f} is not under perforce root: {self.perforce_root}')
-
-
-def split_list_into_strings_of_length(input_list, max_length=100):
-    """
-    From incoming list of strings, build joined together strings that are clamped to a max size
-
-    :param input_list:
-    :param max_length: str clamp length
-    """
-    full_list_str = " ".join([str(arg) for arg in input_list])
-
-    # if str is already below max length, just return it wrapped in a list
-    if not len(full_list_str) > max_length:
-        return [full_list_str]
-
-    # Keep appending on the last string until we hit the max length
-    # then add a new entry to the list and keep appending
-    clamped_str_list = [""]
-    for arg in input_list:
-        current_str = clamped_str_list[-1]
-        new_str = "{}{} ".format(current_str, arg)  # the space is deliberately placed, since the first item has no len
-
-        # if new string is too long, just append the arg as a new item and skip to next arg
-        if len(new_str) >= max_length:
-            clamped_str_list.append("{} ".format(arg))  #
-            continue
-
-        # set latest to updated string
-        clamped_str_list[-1] = new_str
-
-    return clamped_str_list
-
-def decode_dictionaries(info_dicts):
-    """
-    Decode list of dictionary keys and values into unicode from bytes
-    """
-    decoded_dicts = []
-    for info_dict in info_dicts:
-        decoded_dict = {k.decode(): v.decode() for k, v in info_dict.items()}
-        decoded_dicts.append(decoded_dict)
-    return decoded_dicts
-
-def convert_to_list(value):
-    if isinstance(value, tuple):
-        converted = [v for v in value]
-    else:
-        converted = [value]
-    return converted
+            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.6.0/p4cmd/utils.py

@@ -0,0 +1,77 @@
+import logging
+
+def split_list_into_strings_of_length(input_list, max_length=100):
+    """
+    From incoming list of strings, build joined together strings that are clamped to a max size
+
+    :param input_list:
+    :param max_length: str clamp length
+    """
+    full_list_str = " ".join([str(arg) for arg in input_list])
+
+    # if str is already below max length, just return it wrapped in a list
+    if not len(full_list_str) > max_length:
+        return [full_list_str]
+
+    # Keep appending on the last string until we hit the max length
+    # then add a new entry to the list and keep appending
+    clamped_str_list = [""]
+    for arg in input_list:
+        current_str = clamped_str_list[-1]
+        new_str = "{}{} ".format(current_str, arg)  # the space is deliberately placed, since the first item has no len
+
+        # if new string is too long, just append the arg as a new item and skip to next arg
+        if len(new_str) >= max_length:
+            clamped_str_list.append("{} ".format(arg))  #
+            continue
+
+        # set latest to updated string
+        clamped_str_list[-1] = new_str
+
+    return clamped_str_list
+
+
+def decode_dictionaries(info_dicts):
+    """
+    Decode list of dictionary keys and values into unicode from bytes
+    """
+    decoded_dicts = []
+    for info_dict in info_dicts:
+        decoded_dict = {k.decode(): v.decode() for k, v in info_dict.items()}
+        decoded_dicts.append(decoded_dict)
+    return decoded_dicts
+
+
+def convert_to_list(value):
+    """
+    Converts a value to a list if it isn't already one.
+    :param value: input value
+    :return: list
+    """
+    if isinstance(value, tuple):
+        converted = [v for v in value]
+    else:
+        converted = [value]
+    return converted
+
+
+def validate_not_empty(func):
+    """
+    Decorator to ensure file and folder lists are not empty before proceeding with Perforce operations
+    """
+
+    def wrapper(*args, **kwargs):
+        file_or_folder_list = args[1] if len(args) > 1 else None
+
+        if file_or_folder_list is not None and not isinstance(file_or_folder_list, list):
+            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}")
+            return []
+
+        return func(*args, **kwargs)
+
+    return wrapper

{p4cmd-2.4.13 → p4cmd-2.6.0}/p4cmd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.4.13
+Version: 2.6.0
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes
@@ -50,7 +50,7 @@ os.environ["P4ROOT"] = "~/nisse/projects/raw"
 client = p4cmd.P4Client.from_env()
 ```
 
-Most of the functions are pretty self explanatory and have docstrings about how they work. 
+Most of the functions are pretty self-explanatory and have docstrings about how they work. 
 
 There are 2 functions called `file_to_p4files` and `folder_to_p4files` that use the `P4File` class in `p4file`. 
 

{p4cmd-2.4.13 → p4cmd-2.6.0}/p4cmd.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ p4cmd/__init__.py
 p4cmd/p4cmd.py
 p4cmd/p4errors.py
 p4cmd/p4file.py
+p4cmd/utils.py
 p4cmd.egg-info/PKG-INFO
 p4cmd.egg-info/SOURCES.txt
 p4cmd.egg-info/dependency_links.txt