ciocore 5.1.1__py2.py3-none-any.whl → 10.0.0b3__py2.py3-none-any.whl

ciocore/file_utils.py

@@ -6,6 +6,7 @@ import glob
 
 from ciocore import exceptions
 from ciocore.common import CONDUCTOR_LOGGER_NAME
+
 # Regular expressions for different path expressions that are supported
 RX_HASH = r"#+"  # image.####.exr
 RX_MAPID = r"_MAPID_"  # image_MAPID_.exr
@@ -41,14 +42,14 @@ logger = logging.getLogger(CONDUCTOR_LOGGER_NAME)
 
 
 def separate_path(path, no_extension=False):
-    '''
+    """
     Seperate the given path into three pieces:
 
         1. The directory (if any)
         2. The base filename (mandatory)
         3. The file extension (if any)
 
-    For example, given this path: "/animals/fuzzy_cat.jpg" 
+    For example, given this path: "/animals/fuzzy_cat.jpg"
     return "/animals", "fuzzy_cat", ".jpg"
 
     The path argument may be a full filepath (including the directory) or just the name of the file.
@@ -64,7 +65,7 @@ def separate_path(path, no_extension=False):
     represent a frame number or an extension. There is no way to know for sure. By default, the
     function will assume that the "10312" is an extension.  Override this behavior by setting the
     no_extensio arg to True.
-    '''
+    """
     dirpath, filename = os.path.split(path)
 
     if no_extension:
@@ -76,12 +77,12 @@ def separate_path(path, no_extension=False):
 
 
 def process_dependencies(paths):
-    '''
+    """
     For the given lists of dependency paths, return a dictionary where the keys are the depenency
     filepaths and the values are paths, and the values are a a string, describing what is wrong with
     the path (if anything). If the path is valid, the value will be None
 
-    '''
+    """
     dependencies = {}
     for path in paths:
 
@@ -96,10 +97,10 @@ def process_dependencies(paths):
 
 
 def process_upload_filepaths(paths):
-    '''
+    """
     Given the list of paths, process each one, ultimately returning a flattened
     list of all processed paths
-    '''
+    """
     processed_paths = []
     for path in paths:
         processed_paths.extend(process_upload_filepath(path))
@@ -108,10 +109,10 @@ def process_upload_filepaths(paths):
 
 
 def process_upload_filepath(path, strict=True):
-    '''
+    """
     Process the given path to ensure that the path is valid (exists on disk), and return any/all
-    files which the path may represent. 
-    
+    files which the path may represent.
+
     For example, if the path is a directory or an image
     sequence, then explicitly list and return all files that that path represents/contains.
 
@@ -121,10 +122,10 @@ def process_upload_filepath(path, strict=True):
     directory, the
 
 
-    This function should be able to handle various types of paths: 
-    
-    1. Directory path 
-    2. File path 
+    This function should be able to handle various types of paths:
+
+    1. Directory path
+    2. File path
     3. Image sequence path
 
     Process the path by doing the following:
@@ -139,7 +140,7 @@ def process_upload_filepath(path, strict=True):
 
     3. If the path is a file then ensure that it exists on disk and that it conforms to Conductor's
        expectations.
-     '''
+    """
 
     paths = []
 
@@ -207,7 +208,7 @@ def process_upload_filepath(path, strict=True):
 
 
 def get_common_dirpath(paths):
-    '''
+    """
     Find the common directory between all of the filepaths (essentially find the lowest common
     denominator of all of the given paths).  If thers is no common directory shared between the
     paths, return None
@@ -224,7 +225,7 @@ def get_common_dirpath(paths):
     directory.
 
 
-    '''
+    """
     # Using os.path.commonprefix only gets us so far, as it merely matches as
     # many characters as possible, but doesn't ensure those characters clearly end
     # on a directory. For example, given these two paths
@@ -255,13 +256,13 @@ def get_common_dirpath(paths):
 
 
 def _is_valid_path(path_str):
-    '''
+    r"""
     This is dirty/inaccurate helper function to determine whether the given "path" is considered
     valid. If so, return True.
 
     If the given path_str is any of the following characters, then it's to be considered invalid:
 
-        On linux\mac:
+        On linux/mac:
                 /
                 //
                 lettered drive (e.g. x:\)
@@ -271,25 +272,25 @@ def _is_valid_path(path_str):
             \\
             lettered drive (e.g. x:\)
 
-    '''
+    """
     # This will handle / or // on linux/mac and \ and \\ on windows
-    if path_str in [os.sep, os.sep + os.sep]:  
+    if path_str in [os.sep, os.sep + os.sep]:
         return
 
     # handle's lettered drives on Windows (e.g. g:\ )
-    if re.match(r"^[a-zA-Z]:\\$", path_str):  
+    if re.match(r"^[a-zA-Z]:\\$", path_str):
         return
 
     return True
 
 
 def get_files(dirpath, recurse=True):
-    '''
+    """
     Return all files found in the given directory.
 
     Optionally recurse the directory to also include files that are located in subdirectories as
     well
-    '''
+    """
     files = []
 
     if not os.path.isdir(dirpath):
@@ -311,39 +312,39 @@ def get_files(dirpath, recurse=True):
 
 
 def conform_platform_filepath(filepath):
-    '''
+    """
     For the given path, ensure that the path conforms to the standards that Conductor expects. Each
     platform  may potentially have different rules that it follows in order to achieve this.
-    '''
+    """
     platform = sys.platform
 
     # If the platform is windows, then run specific Windows rules
-    if platform.startswith('win'):
+    if platform.startswith("win"):
         filepath = conform_win_path(filepath)
 
     return filepath
 
 
 def conform_win_path(filepath):
-    '''
+    """
     For the given filepath, resolve any environment variables in the path and convert all backlashes
     to forward slashes
-    '''
+    """
     exp_file = os.path.abspath(os.path.expandvars(filepath))
-    return os.path.normpath(exp_file).replace('\\', "/")
+    return os.path.normpath(exp_file).replace("\\", "/")
 
 
 def validate_path(filepath):
-    '''
-    Validate that the given filepath: 
+    """
+    Validate that the given filepath:
 
-    1. Does not contain colons.  This is docker path limitation 
+    1. Does not contain colons.  This is docker path limitation
     2. Starts with a "/".  Otherwise the path cannot be mounted in a linux filesystem
 
     If the filepath is valid, return None. Otherwise return a message that describes why the
     filepath is invalid
 
-    '''
+    """
     # Strip the lettered drive portion of the filepath (if there is one).
     # This is only going to affect a path with a lettered drive on Windows filesystem
     filepath = os.path.splitdrive(filepath)[-1]
@@ -360,14 +361,14 @@ def validate_path(filepath):
 
 
 def quote_path(filepath):
-    '''
+    """
     Wrap the given filepath in double quotes and escape its content.
-    '''
+    """
     return '"%s"' % filepath.replace('"', '\\"')
 
 
 def get_files_from_path_expression(path_expression):
-    '''
+    """
     Given a path expression (such as an image sequence path), seek out all files that are part of
     that path expression (e.g all of the files that are part of that image sequence) and return a
     list of their explicit paths. This function relies on what is actually on disk, so only files
@@ -388,7 +389,7 @@ def get_files_from_path_expression(path_expression):
         /data/shot-###/image.####.exr
         /data/shot-###/image.%04d.exr
         /data/shot-###/camera-$F/image.%04d.exr
-    '''
+    """
 
     logger.debug("Evaluating path expression: %s", path_expression)
     # Cycle through all regexes and replace each match with a * so that we can glob file system.
@@ -405,10 +406,10 @@ def get_files_from_path_expression(path_expression):
 
 
 def get_rx_matches(path_expression, expressions, limit=0):
-    '''
+    """
     Loop through the given list of expressions (regexes), and return those that match the given
     path_expression.  If a limit is provided, return the first n expressions that match.
-    '''
+    """
     matches = []
     for rx in expressions:
         if re.findall(rx, path_expression, flags=re.I):
@@ -419,12 +420,12 @@ def get_rx_matches(path_expression, expressions, limit=0):
 
 
 def create_file(filepath):
-    '''
+    """
     Create an empty file with the given permissions (octal)
-    '''
+    """
     umask_original = os.umask(0)
     try:
-        handle = os.fdopen(os.open(filepath, os.O_WRONLY | os.O_CREAT, 0o666), 'w')
+        handle = os.fdopen(os.open(filepath, os.O_WRONLY | os.O_CREAT, 0o666), "w")
     finally:
         os.umask(umask_original)
     handle.write("")
@@ -432,18 +433,18 @@ def create_file(filepath):
 
 
 def get_tx_paths(filepaths, existing_only=False):
-    '''
+    """
     Return the tx filepaths for the given filepaths
-    '''
+    """
     return [get_tx_path(path, existing_only=existing_only) for path in filepaths]
 
 
 def get_tx_path(filepath, existing_only=False):
-    '''
+    """
     For the given filepath, construct a parallel *.tx filepath residing in the same directory (same
     name, different extension). If existing_only is True, only return the tx filepath if it exists
     on disk, otherwise return an empty string.
-    '''
+    """
     filepath_base, _ = os.path.splitext(filepath)
     tx_filepath = filepath_base + ".tx"
     if existing_only and not os.path.isfile(tx_filepath):
@@ -452,7 +453,7 @@ def get_tx_path(filepath, existing_only=False):
 
 
 def strip_drive_letter(filepath):
-    '''
+    r"""
     If the given filepath has a drive letter, remove it and return the rest of the path
 
         C:\cat.txt         -->    \cat.txt
@@ -467,6 +468,6 @@ def strip_drive_letter(filepath):
 
     Note that os.path.splitdrive should not be used (anymore), due to a change in behavior that was
     implemented somewhere between python 2.7.6 vs 2.7.11
-    '''
-    rx_drive = r'^[a-z]:'
+    """
+    rx_drive = r"^[a-z]:"
     return re.sub(rx_drive, "", filepath, flags=re.I)