def copydescriptions(src, dst): """ Just copy the descriptions portion of an environment directory from src to dst. """ if not dst.endswith('.d'): raise RuntimeError(f"[-] destination '{dst}' is not a descriptions " "('.d') directory") # Ensure destination directory exists. os.makedirs(dst, exist_ok=True) errors = [] try: if src.endswith('.d') and os.path.isdir(src): copytree(src, dst) else: raise RuntimeError(f"[-] source '{src}' is not a descriptions " "('.d') directory") except OSError as err: errors.append((src, dst, str(err))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) if errors: raise Error(errors) psec.utils.remove_other_perms(dst)
def copy_file(log_filename_list, dest_path): """ copy file """ for src_file in log_filename_list: if os.path.isfile(src_file): if os.path.isdir(dest_path): pass else: os.makedirs(dest_path) errors = [] srcname = src_file filename = os.path.basename(src_file) dstname = os.path.join(dest_path, filename) try: if os.path.isfile(srcname): copy2(srcname, dstname) elif os.path.isdir(dstname): os.remove(dstname) copy2(srcname, dstname) except Exception, e: initlog(str(e)) try: copystat(srcname, dstname) except Exception, e: initlog(str(e)) if errors: raise Error(errors)
def _preferences_copytree(entries, src, dst): import os import shutil from shutil import Error os.makedirs(dst, exist_ok=True) errors = [] for srcentry in entries: srcname = os.path.join(src, srcentry.name) dstname = os.path.join(dst, srcentry.name) srcobj = srcentry try: if srcentry.is_symlink(): linkto = os.readlink(srcname) os.symlink(linkto, dstname) shutil.copystat(srcobj, dstname, follow_symlinks=False) elif srcentry.is_dir(): preferences_copytree(srcobj, dstname) else: shutil.copy2(srcentry, dstname) except Error as err: errors.extend(err.args[0]) except OSError as why: errors.append((srcname, dstname, str(why))) try: shutil.copystat(src, dst) except OSError as why: if getattr(why, 'winerror', None) is None: errors.append((src, dst, str(why))) if errors: raise Error(errors) return dst
def movetree(src, dst, symlinks=False): names = os.listdir(src) if not os.path.exists(dst) : os.makedirs(dst) errors = [] for name in names: srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): movetree(srcname, dstname, symlinks) #copytree(srcname, dstname, symlinks) else: move(srcname, dstname) #copy2(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except WindowsError: # can't copy file access times on Windows pass except OSError as why: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def copytree(src, dst, symlinks=False): # Obtained from shutil names = os.listdir(src) os.makedirs(dst, exist_ok=True) # Added exist_ok=True errors = [] for name in names: srcName = os.path.join(src, name) dstName = os.path.join(dst, name) try: if symlinks and os.path.islink(srcName): linkTo = os.readlink(srcName) os.symlink(linkTo, dstName) elif os.path.isdir(srcName): copytree(srcName, dstName, symlinks) else: shutil.copy2(srcName, dstName) except OSError as why: errors.append((srcName, dstName, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: shutil.copystat(src, dst) except OSError as why: # can't copy file access times on Windows if why.winerror is None: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def get_random_seconds_divergent_seeds(restset: PreparedDataList, symbols: SymbolIdDict, seed: int, seconds: float, samples: int, n: int) -> OrderedSet[int]: available_speaker_data = get_speaker_wise(restset) if len(available_speaker_data) > 1: raise Error("This method is not supported for multiple speakers.") speaker_available = list(available_speaker_data.values())[0] speaker_available_dict = prep_data_list_to_dict_with_symbols( speaker_available, symbols) speaker_avail_durations_s = prep_data_list_to_dict_with_durations_s( speaker_available) selected_seeds = random_seconds_divergence_seeds( data=speaker_available_dict, seed=seed, durations_s=speaker_avail_durations_s, seconds=seconds, samples=samples, n=n, ) return selected_seeds
def copytree(src, names, type, dst, symlinks=False): os.makedirs(dst) errors = [] for name in names: name += type srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks) else: copy2(srcname, dstname) # XXX What about devices, sockets etc.? except OSError as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except OSError as why: # can't copy file access times on Windows if why.winerror is None: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def copytree(src, dst, symlinks=False, ignore=None): """Recursively copy a directory tree using copy2(). The destination directory must not already exist. If exception(s) occur, an Error is raised with a list of reasons. If the optional symlinks flag is true, symbolic links in the source tree result in symbolic links in the destination tree; if it is false, the contents of the files pointed to by symbolic links are copied. The optional ignore argument is a callable. If given, it is called with the `src` parameter, which is the directory being visited by copytree(), and `names` which is the list of `src` contents, as returned by os.listdir(): callable(src, names) -> ignored_names Since copytree() is called recursively, the callable will be called once for each directory that is copied. It returns a list of names relative to the `src` directory that should not be copied. XXX Consider this example code rather than the ultimate tool. """ names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore) else: # Will raise a SpecialFileError for unsupported file types copy2(srcname, dstname) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) except EnvironmentError as why: errors.append((srcname, dstname, "%s" % why)) try: copystat(src, dst) except OSError as why: errors.append((src, dst, "%s" % why)) if errors: raise Error(errors)
def get_model(model_name): model = None if model_name == 'vgg16': from models.vgg16 import Vgg16GAP model = Vgg16GAP(name="vgg16") return model if model_name == 'unet': from models.unet import UNet model = UNet() return model if model_name == 'deeplab': from models.deeplab import DeepLab model = DeepLab(name="deeplab") return model if model_name == 'affinitynet': from models.aff_net import AffNet model = AffNet(name="affinitynet") return model if model_name == 'wasscam': from models.wass import WASS model = WASS() return model raise Error('Model name has no implementation')
def copy_tree(src, dst, symlinks=False, ignore=None): """The ``copy_tree`` function is an exact copy of the built-in :func:`shutil.copytree`, with one key difference: it will not raise an exception if part of the tree already exists. It achieves this by using :func:`mkdir_p`. As of Python 3.8, you may pass :func:`shutil.copytree` the `dirs_exist_ok=True` flag to achieve the same effect. Args: src (str): Path of the source directory to copy. dst (str): Destination path. Existing directories accepted. symlinks (bool): If ``True``, copy symlinks rather than their contents. ignore (callable): A callable that takes a path and directory listing, returning the files within the listing to be ignored. For more details, check out :func:`shutil.copytree` and :func:`shutil.copy2`. """ names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() mkdir_p(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore) else: # Will raise a SpecialFileError for unsupported file types copy2(srcname, dstname) # catch the Error from the recursive copytree so that we can # continue with other files except Error as e: errors.extend(e.args[0]) except EnvironmentError as why: errors.append((srcname, dstname, str(why))) try: copystat(src, dst) except OSError as why: if WindowsError is not None and isinstance(why, WindowsError): # Copying file access times may fail on Windows pass else: errors.append((src, dst, str(why))) if errors: raise Error(errors)
def fetch_from_db_Deck(self): try: self.cursor.execute("SELECT * FROM DECK") result = self.cursor.fetchall() return result except sql.OperationalError: os.remove(f"{self.file_name}") raise Error("Table DECK not found")
def move(src, dst, overwrite=False, make_safe_path=get_safe_path, name_pairs=[]): """Recursively move a file or directory to another location. This is similar to the Unix "mv" command. If the destination is a directory or a symlink to a directory, the source is moved inside the directory. The destination path must not already exist. If the destination already exists but is not a directory, it may be overwritten depending on os.rename() semantics. If the destination is on our current filesystem, then rename() is used. Otherwise, src is copied to the destination and then removed. A lot more could be done here... A look at a mv.c shows a lot of the issues this implementation glosses over. """ real_dst = dst if os.path.isdir(dst): if _samefile(src, dst): # We might be on a case insensitive filesystem, # perform the rename anyway. os.rename(src, dst) name_pairs.append((src, dst)) return real_dst = os.path.join(dst, _basename(src)) if not overwrite: real_dst = make_safe_path(real_dst) try: os.rename(src, real_dst) name_pairs.append((src, real_dst)) except OSError: if os.path.isdir(src): if _destinsrc(src, dst): raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst)) for done in copytree(src, real_dst, symlinks=True, overwrite=overwrite, make_safe_path=make_safe_path): yield done rmtree(src) name_pairs.append((src, real_dst)) else: for done in copy2(src, real_dst, symlinks=True, overwrite=overwrite, make_safe_path=make_safe_path): yield done os.unlink(src) name_pairs.append((src, real_dst))
def copytree(src, dst, symlinks=False, ignore=None): """ Copies src tree to dst shutil.copytree method uses copy2() and copystat() to perform the recursive copy of a directory. Both of these methods copy the attributes associated with the files. When copying files from /var/cache/pulp to /var/lib/pulp, we don't want to copy the SELinux security context labels. :param src: Source directory rooted at src :type src: basestring :param dst: Destination directory, a new directory and any parent directories are created if any are missing :type dst: basestring :param symlinks: If true, symlinks are copied as symlinks and metadata of original links is not copied. If false, the contents and metadata of symlinks is copied to the new tree. :type symlinks: boolean :param ignore: If provided, it receives as its arguments the directory being visited by copytree and the content of directory as returned by os.listdir(). The callable must return a sequence of directory and file names relative to the current directory (i.e. a subset of the items in its second argument); these names will then be ignored in the copy process. :type ignore: Callable """ names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore) else: # Don't need to copy attributes copy(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) if errors: raise Error(errors)
def copyfile_custom(src, dst): """Copy data from src to dst""" if _samefile(src, dst): raise Error("`%s` and `%s` are the same file" % (src, dst)) for fn in [src, dst]: try: st = os.stat(fn) except OSError: # File most likely does not exist pass else: # XXX What about other special files? (sockets, devices...) if stat.S_ISFIFO(st.st_mode): try: raise SpecialFileError("`%s` is a named pipe" % fn) except NameError: raise Error("`%s` is a named pipe" % fn) try: # Windows O_BINARY = os.O_BINARY except: O_BINARY = 0 READ_FLAGS = os.O_RDONLY | O_BINARY WRITE_FLAGS = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | O_BINARY BUFFER_SIZE = 128 * 1024 try: fin = os.open(src, READ_FLAGS) fout = os.open(dst, WRITE_FLAGS) for x in iter(lambda: os.read(fin, BUFFER_SIZE), ""): os.write(fout, x) except Exception as e: raise finally: try: os.close(fin) os.close(fout) except: pass
def mergetree(src, dst, symlinks=False, ignore=None): """ Like shutil.copytree except it overwrites the destination If dst does not exist it is created. If dst exists but is not a directory it is repaced. If dst exists and is a directory the files in src are copied to dst. If a file already exists in dst it is overwritten. The child directories of src are copied to dst by recursive calls to mergetree. The implementation is adapted from the code for shutil.copytree at https://docs.python.org/2/library/shutil.html#copytree-example """ names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() if os.path.exists(dst) and not os.path.isdir(dst): os.remove(dst) if not os.path.isdir(dst): os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): mergetree(srcname, dstname, symlinks, ignore) else: copy2(srcname, dstname) # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except WindowsError: # can't copy file access times on Windows pass except OSError as why: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, exist_ok=False): names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() os.makedirs(dst, exist_ok = exist_ok) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if os.path.islink(srcname): linkto = os.readlink(srcname) if symlinks: # We can't just leave it to `copy_function` because legacy # code with a custom `copy_function` may rely on copytree # doing the right thing. os.symlink(linkto, dstname) copystat(srcname, dstname, follow_symlinks=not symlinks) else: # ignore dangling symlink if the flag is on if not os.path.exists(linkto) and ignore_dangling_symlinks: continue # otherwise let the copy occurs. copy2 will raise an error if os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore, copy_function, exist_ok=exist_ok) else: copy_function(srcname, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks, ignore, copy_function, exist_ok = exist_ok ) else: # Will raise a SpecialFileError for unsupported file types copy_function(srcname, dstname) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) except OSError as why: errors.append((srcname, dstname, str(why))) if errors: raise Error(errors) return dst
def CopyWorker(self): """Thread worker for file copying.""" while True: fileName = fileQueue.get() try: isdir = fileName.is_dir() # scandir object issym = fileName.is_symlink() size = fileName.stat().st_size fname = fileName.name except AttributeError: # file from txt fname, fpath, size = fileName isdir = True if os.path.isdir(fpath) else False issym = True if os.path.islink(fpath) else False if not self.is_package_task: srcname = os.path.join(self.src, fname) else: srcname = fname dstname = os.path.join(self.dst, fname) try: if isdir: #copyf = shutil.copy2 if self.copymeta else shutil.copyfile #shutil.copytree(srcname, dstname, symlinks=self.symlinks, # ignore=self.ignore, copy_function=copyf) pass else: if issym is self.symlinks: if self.copymeta: try: shutil.copy2(srcname, dstname) except (OSError, IOError) as e: self.errors.extend( (self.src, self.dst, str(e))) else: shutil.copyfile(srcname, dstname) except (OSError, IOError) as e: self.errors.append((srcname, dstname, str(e))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as e: self.errors.extend(e.args[0]) if self.errors: raise Error(self.errors) with self.lock: self.copyCount += 1 #percent = (self.copyCount * 100) / self.totalFiles #print(str(percent) + " percent copied.") self.pbar.set_postfix(file=fname[-10:], refresh=False) self.pbar.update(size) fileQueue.task_done()
def vbm_characters(self, characters: list) -> None: """ Set vbm_characters """ try: if characters != None: for element in characters: element[0] = element[0].capitalize() element[1] = element[1].lower() element[2] = float(element[2]) except: loguru.logger.error("repalce_vbm incorrectly specified") raise Error("repalce_vbm incorrectly specified") self._vbm_characters = characters
def divide_character(self, factors: int) -> None: """ Set factor that divides the correction between atoms """ try: if factors != None: for element in factors: element[0] = element[0].capitalize() element[1] = element[1].lower() element[2] = int(element[2]) except: loguru.logger.error("divide_character incorrectly specified") raise Error("divide_character incorrectly specified") self._divide_character = factors
def conduction_cut_guess(self, cut_guess: list) -> None: """ Set conduction_cut_guess """ try: if cut_guess != None: for element in cut_guess: element[0] = element[0].capitalize() element[1] = element[1].lower() element[2] = float(element[2]) except: loguru.logger.error("conduction_cut_guess incorrectly specified") raise Error("conduction_cut_guess incorrectly specified") self._conduction_cut_guess = cut_guess
def parse_bool(message: str) -> bool: message = str(message) result = message.lower() if result == "y" or result == "1" or result == "t" or result == "true": return True if result == "n" or result == "0" or result == "f" or result == "false": return False if should_quit(result): raise QuitError(result) if should_restart(result): raise RestartError(result) raise Error(message)
def copyfiles(src, dst, ignore=None): """ https://docs.python.org/2/library/shutil.html#copytree-example with some modifications (destination folder can exist) """ names = os.listdir(src) files = [] if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() if not os.path.exists(dst): os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if os.path.isdir(srcname): files += copyfiles(srcname, dstname, ignore) else: copy2(srcname, dstname) files += [dstname] # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except WindowsError: # can't copy file access times on Windows pass except OSError as why: errors.extend((src, dst, str(why))) if errors: raise Error(errors) return files
def copyfile(src, dst): """Copy data from src to dst""" if _samefile(src, dst): raise Error("`%s` and `%s` are the same file" % (src, dst)) for fn in [src, dst]: try: st = os.stat(fn) except OSError: # File most likely does not exist pass else: # XXX What about other special files? (sockets, devices...) if stat.S_ISFIFO(st.st_mode): raise SpecialFileError("`%s` is a named pipe" % fn) with open(src, 'rb') as fsrc: with open(dst, 'wb') as fdst: copyfileobj(fsrc, fdst)
def copyfile(src, dst): """Copy data from src to dst""" if _samefile(src, dst): raise Error("`%s` and `%s` are the same file" % (src, dst)) for fn in [src, dst]: # pylint: disable=invalid-name try: st = os.stat(fn) # pylint: disable=invalid-name except OSError: # File most likely does not exist pass else: # XXX What about other special files? (sockets, devices...) if stat.S_ISFIFO(st.st_mode): raise SpecialFileError("`%s` is a named pipe" % fn) with open(src, "rb") as fsrc: with open(dst, "wb") as fdst: for done in copyfileobj(fsrc, fdst): yield done
def CopyWorker(self): """Thread worker for file copying.""" try: from urlparse import urljoin except ImportError: from urllib.parse import urljoin while True: fileItem = fileQueue.get() fileName, size = fileItem url = self.tserv_lb() srcname = urljoin(url, fileName) dstname = os.path.join(self.dst, fileName) self.FetchFile(srcname, dstname) if self.errors: raise Error(self.errors) with self.lock: self.copyCount += 1 self.pbar.set_postfix(file=fileName[-10:], refresh=False) self.pbar.update(size) fileQueue.task_done()
def run_rclone(self): from subprocess import check_output, CalledProcessError, STDOUT cmd = ['rclone'] [cmd.append(f) for f in self.flags] cmd.append(self.command) cmd.append(self.src) cmd.append(self.dst) [cmd.append(a) for a in self.cmdargs] logger.debug('rclone command: {}'.format(" ".join(cmd))) logger.info('Starting rclone from %s to %s..' % (self.src, self.dst)) try: output = check_output(cmd, stderr=STDOUT) logger.debug(output) except CalledProcessError as e: self.errors.append((self.src, self.dst, str(e.output), str(e.returncode))) if self.errors: raise Error(self.errors) logger.info('Done')
def copytree(src, dst, symlinks=True): """ Modified from shutil.copytree docs code sample, merges files rather than requiring dst to not exist. """ from shutil import copy2, Error, copystat names = os.listdir(src) if not Path(dst).exists(): os.makedirs(dst) errors = [] for name in names: srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree(srcname, dstname, symlinks) else: copy2(srcname, dstname) # XXX What about devices, sockets etc.? except OSError as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except OSError as why: # can't copy file access times on Windows if why.winerror is None: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def copytree_multi(src, dst, symlinks=False, ignore=None): names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() # -------- E D I T -------- # os.path.isdir(dst) if not os.path.isdir(dst): os.makedirs(dst) # -------- E D I T -------- errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): copytree_multi(srcname, dstname, symlinks, ignore) else: copy2(srcname, dstname) except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except WindowsError: pass except OSError as why: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def my_copytree(self, src, dst, symlinks=False, ignore=None, preserve_attributes = 1, update=0): names = os.listdir(src) if ignore is not None: ignored_names = ignore(src, names) else: ignored_names = set() if not os.path.isdir(dst): os.makedirs(dst) errors = [] for name in names: if name in ignored_names: continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) try: if symlinks and os.path.islink(srcname): linkto = os.readlink(srcname) os.symlink(linkto, dstname) elif os.path.isdir(srcname): self.my_copytree(srcname, dstname, symlinks, ignore, preserve_attributes, update) else: self.copyOptionChecking(srcname, dstname, preserve_attributes, update) # XXX What about devices, sockets etc.? except (IOError, os.error) as why: errors.append((srcname, dstname, str(why))) # catch the Error from the recursive copytree so that we can # continue with other files except Error as err: errors.extend(err.args[0]) try: copystat(src, dst) except WindowsError: # can't copy file access times on Windows pass except OSError as why: errors.extend((src, dst, str(why))) if errors: raise Error(errors)
def copy_files(src, dst, symlinks=False): errors = [] if os.path.isfile(src): copy_file(src, dst, symlinks, errors) else: names = os.listdir(src) if not os.path.exists(dst): os.makedirs(dst) for name in names: src_name = os.path.join(src, name) dst_name = os.path.join(dst, name) copy_file(src_name, dst_name, symlinks, errors) try: shutil.copystat(src, dst) except WindowsError: pass except OSError as why: if why.errno not in [5, 13]: errors.append((src, dst, str(why))) if errors: raise Error(errors)