pyxllib 0.0.43__py3-none-any.whl → 0.3.197__py3-none-any.whl

pyxllib/{basic/_5_dirlib.py → file/specialist/dirlib.py}

@@ -2,67 +2,215 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/05/30
+# @Date   : 2020/05/30
 
 
+import collections
 import filecmp
 import os
+import pathlib
+import random
 import re
 import shutil
+import tempfile
 
-# 大小写不敏感字典
-from requests.structures import CaseInsensitiveDict
-
-from pyxllib.basic._1_strlib import strfind, natural_sort
-from pyxllib.basic._2_timelib import Datetime
-from pyxllib.basic._3_pathlib import Path
-from pyxllib.basic._4_loglib import Iterate
+import humanfriendly
 
-____file = """
-路径、文件、目录相关操作功能
+# 大小写不敏感字典
+from pyxllib.prog.newbie import first_nonnone
+from pyxllib.algo.pupil import natural_sort
+from pyxllib.text.pupil import strfind
+from pyxllib.file.specialist import get_etag, PathBase, File, XlPath
 
-主要是为了提供readfile、wrritefile函数
-与普通的读写文件相比，有以下优点：
-1、智能识别pkl等特殊格式文件的处理
-2、智能处理编码
-3、目录不存在自动创建
-4、自动备份旧文件，而不是强制覆盖写入
 
-其他相关文件处理组件：isfile、get_encoding、ensure_folders
-以及同时支持文件或文件夹的对比复制删除等操作的函数：filescmp、filesdel、filescopy
-"""
+def __1_Dir类():
+    """
+    支持文件或文件夹的对比复制删除等操作的函数：filescmp、filesdel、filescopy
+    """
 
 
-class Dir(Path):
+class Dir(PathBase):
     r"""类似NestEnv思想的文件夹处理类
 
     这里的测试可以全程自己造一个
     """
-    __slots__ = ('files', '_origin_wkdir')
+    __slots__ = ('_path', 'subs', '_origin_wkdir')
+
+    # 零、常用的目录类
+    TEMP = pathlib.Path(tempfile.gettempdir())
+    if os.getenv('Desktop', None):  # 如果修改了win10默认的桌面路径，需要在环境变量添加一个正确的Desktop路径值
+        DESKTOP = os.environ['Desktop']
+    else:
+        DESKTOP = os.path.join(str(pathlib.Path.home()), 'Desktop')  # 这个不一定准，桌面是有可能被移到D盘等的
+    DESKTOP = pathlib.Path(DESKTOP)
 
-    def __init__(self, path=None, *, root=None, files=None):
+    # 添加 HOME 目录？ 方便linux操作？
+
+    # 一、基本目录类功能
+
+    def __init__(self, path=None, root=None, *, subs=None, check=True):
         """根目录、工作目录
 
         >> Dir()  # 以当前文件夹作为root
         >> Dir(r'C:/pycode/code4101py')  # 指定目录
+
+        :param path: 注意哪怕path传入的是Dir，也只会设置目录，不会取其paths成员值
+        :param subs: 该目录下，选中的子文件（夹）
         """
-        super().__init__(path, root=root)
-        self.files = files or []  # 初始默认没有选中任何文件（文件夹）
+
+        self._path = None
+        self.subs = subs or []  # 初始默认没有选中任何文件（夹）
+
+        # 1 快速初始化
+        if root is None:
+            if isinstance(path, Dir):
+                self._path = path._path
+                # 注意用Dir A 初始化 Dir B，并不会把A的subs传递给B
+                return
+            elif isinstance(path, pathlib.Path):
+                self._path = path
+
+        # 2 普通初始化
+        if self._path is None:
+            self._path = self.abspath(path, root)
+
+        # 3 检查
+        if check:
+            if not self._path:
+                raise ValueError(f'无效路径 {self._path}')
+            elif self._path.is_file():
+                raise ValueError(f'不能用文件初始化一个Dir对象 {self._path}')
+
+    @classmethod
+    def safe_init(cls, path, root=None, *, subs=None):
+        """ 如果失败不raise，而是返回None的初始化方式 """
+        try:
+            d = Dir(path, root, subs=subs)
+            d._path.is_file()  # 有些问题上一步不一定测的出来，要再补一个测试
+            return d
+        except (ValueError, TypeError, OSError, PermissionError):
+            # ValueError：文件名过长，代表输入很可能是一段文本，根本不是路径
+            # TypeError：不是str等正常的参数
+            # OSError：非法路径名，例如有 *? 等
+            # PermissionError: linux上访问无权限、不存在的路径
+            return None
 
     @property
-    def absfiles(self):
-        """返回所有files的绝对路径"""
-        return [self.fullpath + '/' + f for f in self.files]
+    def size(self) -> int:
+        """ 计算目录的大小，会递归目录计算总大小
+
+        https://stackoverflow.com/questions/1392413/calculating-a-directory-size-using-python
+
+        >> Dir('D:/slns/pyxllib').size  # 这个算的就是真实大小，不是占用空间
+        2939384
+        """
+        if self:
+            total_size = 0
+            for dirpath, dirnames, Pathnames in os.walk(str(self)):
+                for f in Pathnames:
+                    fp = os.path.join(dirpath, f)
+                    total_size += os.path.getsize(fp)
+        else:  # 不存在的对象
+            total_size = 0
+        return total_size
 
     @property
-    def filepaths(self):
-        """返回所有files的path对象"""
-        return [self / f for f in self.files]
+    def psize(self) -> str:
+        """ 美化显示的文件大小 """
+        return humanfriendly.format_size(self.size, binary=True)
 
-    def select(self, patter, nsort=True, **kwargs):
+    def __truediv__(self, key) -> pathlib.Path:
+        r""" 路径拼接功能
+
+        >>> Dir('C:/a') / 'b.txt'
+        WindowsPath('C:/a/b.txt')
+        """
+        return self._path / str(key)
+
+    def with_dirname(self, value):
+        return Dir(self.name, value)
+
+    def absdst(self, dst):
+        """ 在copy、move等中，给了个"模糊"的目标位置dst，智能推导出实际file、dir绝对路径
+        """
+        dst_ = self.abspath(dst)
+        if isinstance(dst, str) and dst[-1] in ('\\', '/'):
+            dst_ = Dir(self.name, dst_)
+        else:
+            dst_ = Dir(dst_)
+        return dst_
+
+    def ensure_dir(self):
+        r""" 确保目录存在
+        """
+        if not self:
+            os.makedirs(str(self))
+
+    def copy(self, dst, if_exists=None):
+        return self.process(dst, shutil.copytree, if_exists)
+
+    def rename(self, dst, if_exists=None):
+        r""" 重命名
+        """
+        return self.move(Dir(dst, self.parent), if_exists)
+
+    def delete(self):
+        r""" 删除自身文件
+        """
+        if self:
+            try:
+                shutil.rmtree(str(self))
+            except OSError:
+                # OSError: Cannot call rmtree on a symbolic link
+                # TODO 本来不应该try except，而是先用os.path.islink判断的，但是这个好像有bug，判断不出来~~
+                os.unlink(str(self))
+
+    # 二、目录类专有功能
+
+    def sample(self, n=None, frac=None):
+        """
+        :param n: 在 paths 中抽取n个文件
+        :param frac: 按比例抽取文件
+        :return: 新的Dir文件选取状态
+        """
+        n = n or int(frac * len(self.subs))
+        paths = random.sample(self.subs, n)
+        return Dir(self._path, subs=paths)
+
+    def subpaths(self):
+        """ 返回所有subs的绝对路径 """
+        return [self._path / p for p in self.subs]
+
+    def subfiles(self):
+        """ 返回所有subs的File对象 （过滤掉文件夹对象） """
+        return list(map(File, filter(lambda p: not p.is_dir(), self.subpaths())))
+
+    def subdirs(self):
+        """ 返回所有subs的File对象 （过滤掉文件对象） """
+        return list(map(Dir, filter(lambda p: not p.is_file(), self.subpaths())))
+
+    def select(self, patter, nsort=True, type_=None,
+               ignore_backup=False, ignore_special=False,
+               min_size=None, max_size=None,
+               min_ctime=None, max_ctime=None, min_mtime=None, max_mtime=None,
+               **kwargs):
         r""" 增加选中文件，从filesmatch衍生而来，参数含义见 filesfilter
 
-        :param nsort: 是否使用自然排序，关闭可以加速
+        :param bool nsort: 是否使用自然排序，关闭可以加速
+        :param str type_:
+            None，所有文件
+            'file'，只匹配文件
+            'dir', 只匹配目录
+        :param bool ignore_backup: 如果设为False，会过滤掉自定义的备份文件格式，不获取备份类文件
+        :param bool ignore_special: 自动过滤掉 '.git'、'$RECYCLE.BIN' 目录下文件
+        :param int min_size: 文件大小过滤，单位Byte
+        :param int max_size: ~
+        :param str min_ctime: 创建时间的过滤，格式'2019-09-01'或'2019-09-01 00:00'
+        :param str max_ctime: ~
+        :param str min_mtime: 修改时间的过滤
+        :param str max_mtime: ~
+        :param kwargs: see filesfilter
+        :seealso: filesfilter
 
         注意select和exclude的增减操作是不断叠加的，而不是每次重置！
         如果需要重置，应该重新定义一个Folder类
@@ -75,20 +223,69 @@ class Dir(Path):
         >> Dir('C:/pycode/code4101py').select('*.py', min_size=200*1024)  # 200kb以上的文件
         C:/pycode/code4101py: ['liangyb.py']
 
-        >> Dir(r'C:/pycode/code4101py').select('*.py', min_mtime=Datetime(2020, 3, 1))  # 修改时间在3月1日以上的
+        >> Dir(r'C:/pycode/code4101py').select('*.py', min_mtime=datetime.date(2020, 3, 1))  # 修改时间在3月1日以上的
         """
-        files = filesmatch(patter, root=self.fullpath, **kwargs)
-        files = self.files + files
-        if nsort: files = natural_sort(files)
-        return Dir(self._path, files=files)
-
-    def procfiles(self, func, start=None, end=None, ref_dir=None, pinterval=None, max_workers=1, interrupt=True):
+        subs = filesmatch(patter, root=str(self), type_=type_,
+                          ignore_backup=ignore_backup, ignore_special=ignore_special,
+                          min_size=min_size, max_size=max_size,
+                          min_ctime=min_ctime, max_ctime=max_ctime, min_mtime=min_mtime, max_mtime=max_mtime,
+                          **kwargs)
+        subs = self.subs + subs
+        if nsort: subs = natural_sort(subs)
+        return Dir(self._path, subs=subs)
+
+    def select_files(self, patter, nsort=True,
+                     ignore_backup=False, ignore_special=False,
+                     min_size=None, max_size=None,
+                     min_ctime=None, max_ctime=None, min_mtime=None, max_mtime=None):
+        """ TODO 这系列的功能可以优化加速，在没有复杂规则的情况下，可以尽量用源生的py检索方式实现 """
+        subs = filesmatch(patter, root=str(self), type_='file',
+                          ignore_backup=ignore_backup, ignore_special=ignore_special,
+                          min_size=min_size, max_size=max_size,
+                          min_ctime=min_ctime, max_ctime=max_ctime,
+                          min_mtime=min_mtime, max_mtime=max_mtime)
+        if nsort:
+            subs = natural_sort(subs)
+        for x in subs:
+            yield File(self._path / x, check=False)
+
+    def select_dirs(self, patter, nsort=True,
+                    ignore_backup=False, ignore_special=False,
+                    min_size=None, max_size=None,
+                    min_ctime=None, max_ctime=None, min_mtime=None, max_mtime=None):
+        subs = filesmatch(patter, root=str(self), type_='dir',
+                          ignore_backup=ignore_backup, ignore_special=ignore_special,
+                          min_size=min_size, max_size=max_size,
+                          min_ctime=min_ctime, max_ctime=max_ctime,
+                          min_mtime=min_mtime, max_mtime=max_mtime)
+        if nsort:
+            subs = natural_sort(subs)
+        for x in subs:
+            yield Dir(self._path / x, check=False)
+
+    def select_paths(self, patter, nsort=True,
+                     ignore_backup=False, ignore_special=False,
+                     min_size=None, max_size=None,
+                     min_ctime=None, max_ctime=None, min_mtime=None, max_mtime=None):
+        subs = filesmatch(patter, root=str(self),
+                          ignore_backup=ignore_backup, ignore_special=ignore_special,
+                          min_size=min_size, max_size=max_size,
+                          min_ctime=min_ctime, max_ctime=max_ctime,
+                          min_mtime=min_mtime, max_mtime=max_mtime)
+        if nsort:
+            subs = natural_sort(subs)
+        for x in subs:
+            yield self._path / x
+
+    def procpaths(self, func, start=None, end=None, ref_dir=None, pinterval=None, max_workers=1, interrupt=True):
         """ 对选中的文件迭代处理
 
         :param func: 对每个文件进行处理的自定义接口函数
             参数 p: 输入参数 Path 对象
-            return: 可以没有返回值，当有返回值时，会作为信息，表示要输出查看
+            return: 可以没有返回值
                 TODO 以后可以返回字典结构，用不同的key表示不同的功能，可以控制些高级功能
+        :param ref_dir: 使用该参数时，则每次会给func传递两个路径参数
+            第一个是原始的file，第二个是ref_dir目录下对应路径的file
 
         TODO 增设可以bfs还是dfs的功能？
 
@@ -96,23 +293,25 @@ class Dir(Path):
         将目录 test 的所有文件拷贝到 test2 目录 示例代码：
 
         def func(p1, p2):
-            p1.copy(p2)
+            File(p1).copy(p2)
 
         Dir('test').select('**/*', type_='file').procfiles(func, ref_dir='test2')
 
         """
+        from pyxllib.prog.specialist import Iterate
+
         if ref_dir:
             ref_dir = Dir(ref_dir)
-            files1 = self.filepaths
-            files2 = [(ref_dir / self.files[i]) for i in range(len(self.files))]
+            paths1 = self.subpaths()
+            paths2 = [(ref_dir / self.subs[i]) for i in range(len(self.subs))]
 
             def wrap_func(data):
                 func(*data)
 
-            data = zip(files1, files2)
+            data = zip(paths1, paths2)
 
         else:
-            data = self.filepaths
+            data = self.subpaths()
             wrap_func = func
 
         Iterate(data).run(wrap_func, start=start, end=end, pinterval=pinterval,
@@ -123,13 +322,13 @@ class Dir(Path):
 
         这里设置的选择模式，是指全集的选择范围
         """
-        files = Dir(self).select(patter, nsort, **kwargs).files
-        cur_files = set(self.files)
-        new_files = []
-        for f in files:
-            if f not in cur_files:
-                new_files.append(f)
-        return Dir(self._path, files=new_files)
+        subs = Dir(self).select(patter, nsort, **kwargs).subs
+        cur_subs = set(self.subs)
+        new_subs = []
+        for s in subs:
+            if s not in cur_subs:
+                new_subs.append(s)
+        return Dir(self._path, subs=new_subs)
 
     def exclude(self, patter, **kwargs):
         """ 去掉部分选中文件
@@ -141,15 +340,26 @@ class Dir(Path):
         print(d2.files)  # ['AA20pH-c1=1-1.eps', 'AA20pH-c1=1-2.eps']
         print(d3.files)  # ['subdir/AA20pH-c1=1-2 - 副本.eps']
         """
-        files = set(filesmatch(patter, root=self.fullpath, **kwargs))
-        new_files = []
-        for f in self.files:
-            if f not in files:
-                new_files.append(f)
-        return Dir(self._path, files=new_files)
-
-    def __repr__(self):
-        return f'{self._path}: {self.files}'
+        subs = set(filesmatch(patter, root=str(self), **kwargs))
+        new_subs = []
+        for s in self.subs:
+            if s not in subs:
+                new_subs.append(s)
+        return Dir(self._path, subs=new_subs)
+
+    def describe(self):
+        """ 输出目录的一些基本统计信息
+        """
+        msg = []
+        dir_state = self.select('*')
+        files = dir_state.subfiles()
+        suffixs = collections.Counter([f.suffix for f in files]).most_common()
+        dir_size = self.size
+        msg.append(f'size: {dir_size} ≈ {humanfriendly.format_size(dir_size, binary=True)}')
+        msg.append(f'files: {len(files)}, {suffixs}')
+        msg.append(f'dirs: {len(dir_state.subdirs())}')
+        res = '\n'.join(msg)
+        print(res)
 
     def __enter__(self):
         """ 使用with模式可以进行工作目录切换
@@ -158,13 +368,21 @@ class Dir(Path):
         切换工作目录和多线程混合使用会有意想不到的坑，要慎重！
         """
         self._origin_wkdir = os.getcwd()
-        os.chdir(self.fullpath)
+        os.chdir(str(self))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         os.chdir(self._origin_wkdir)
 
 
+def __2_filesxxx():
+    """
+    本来Path、File是能同时处理文件、目录的
+    改版后，files底层因为有用到File，现在却不能支持目录的操作了
+    可能会有些bug，尽量不要用这些旧功能，或者尽早移除
+    """
+
+
 def filescmp(f1, f2, shallow=True):
     """只有两个存在且是同类型的文件或文件夹，内容相同才会返回True，否则均返回False
     :param f1: 待比较的第1个文件（文件夹）
@@ -192,7 +410,8 @@ def filescmp(f1, f2, shallow=True):
 def filesfilter(files, *, root=os.curdir, type_=None,
                 ignore_backup=False, ignore_special=False,
                 min_size=None, max_size=None,
-                min_ctime=None, max_ctime=None, min_mtime=None, max_mtime=None):
+                min_ctime=None, max_ctime=None,
+                min_mtime=None, max_mtime=None):
     """
     :param files: 类list对象
     :param type_:
@@ -209,6 +428,7 @@ def filesfilter(files, *, root=os.curdir, type_=None,
     :param max_mtime: ~
     :return:
     """
+    from datetime import datetime
 
     def judge(f):
         if root: f = os.path.join(root, f)
@@ -217,28 +437,31 @@ def filesfilter(files, *, root=os.curdir, type_=None,
         elif type_ == 'dir' and not os.path.isdir(f):
             return False
 
-        msg = os.stat(f)
-        if min_size is not None or max_size is not None:
-            size = Path(f).size
-            if min_size is not None and size < min_size: return False
-            if max_size is not None and size > max_size: return False
-
-        if min_ctime or max_ctime:
-            file_ctime = msg.st_ctime
-            if min_ctime and Datetime(file_ctime) < min_ctime: return False
-            if max_ctime and Datetime(file_ctime) > max_ctime: return False
-
-        if min_mtime or max_mtime:
-            file_mtime = msg.st_mtime
-            if min_mtime and Datetime(file_mtime) < min_mtime: return False
-            if max_mtime and Datetime(file_mtime) > max_mtime: return False
+        # 尽量避免调用 os.stat，判断是否有自定义大小、时间规则，没有可以跳过这部分
+        check_arg = first_nonnone([min_size, max_size, min_ctime, max_ctime, min_mtime, max_mtime])
+        if check_arg is not None:
+            msg = os.stat(f)
+            if first_nonnone([min_size, max_size]) is not None:
+                size = File(f).size
+                if min_size is not None and size < min_size: return False
+                if max_size is not None and size > max_size: return False
+
+            if min_ctime or max_ctime:
+                file_ctime = datetime.fromtimestamp(msg.st_ctime)
+                if min_ctime and file_ctime < min_ctime: return False
+                if max_ctime and file_ctime > max_ctime: return False
+
+            if min_mtime or max_mtime:
+                file_mtime = datetime.fromtimestamp(msg.st_mtime)
+                if min_mtime and file_mtime < min_mtime: return False
+                if max_mtime and file_mtime > max_mtime: return False
 
         if ignore_special:
-            parts = Path(f).parts
+            parts = File(f).parts
             if '.git' in parts or '$RECYCLE.BIN' in parts:
                 return False
 
-        if ignore_backup and Path(f).backup_time:
+        if ignore_backup and File(f).backup_time:
             return False
 
         return True
@@ -300,6 +523,7 @@ def filesmatch(patter, *, root=os.curdir, **kwargs) -> list:
     >> filesmatch('**/*', type_='file', max_size=0)  # 筛选空文件
     ['b/a', '[0-9]/3.txt']
     """
+    from pathlib import Path
     root = os.path.abspath(root)
 
     # 0 规则匹配
@@ -308,9 +532,9 @@ def filesmatch(patter, *, root=os.curdir, **kwargs) -> list:
 
     # 1 普通文本匹配  （没有通配符，单文件查找）
     if isinstance(patter, str) and glob_chars_pos == -1:
-        path = Path(patter, root=root)
-        if path.exists():  # 文件存在
-            p = str(Path(patter, root=root).resolve())
+        path = Path(os.path.join(root, patter))
+        if path:  # 文件存在
+            p = str(path.resolve())
             if p.startswith(root): p = p[len(root) + 1:]
             res = [p]
         else:  # 文件不存在
@@ -337,6 +561,10 @@ def filesmatch(patter, *, root=os.curdir, **kwargs) -> list:
     elif isinstance(patter, (list, tuple, set)):
         res = []
         for p in patter: res += filesmatch(p, root=root)
+    # 5 可调用对象
+    elif callable(patter):
+        from pyxllib.file.specialist import XlPath
+        res = [f.relpath(root).as_posix() for f in XlPath(root).rglob('*') if patter(f)]
     else:
         raise TypeError
 
@@ -376,19 +604,19 @@ def _files_copy_move_base(src, dst, filefunc, dirfunc,
             func = dirfunc
 
         # 2 根据目标是否已存在和if_exists分类处理
-        Path(dst).ensure_dir(pathtype='file')
+        File(dst).ensure_parent()
         # 目前存在，且不是把文件移向文件夹的操作
         if os.path.exists(dst):
             # 根据if_exists参数情况分类处理
             if if_exists is None:  # 智能判断
                 if not filescmp(f, dst):  # 如果内容不同则backup
-                    Path(dst).backup(move=True)
+                    File(dst).backup(move=True)
                     func(f, dst)
                 elif os.path.abspath(f).lower() == os.path.abspath(dst).lower():
                     # 如果内容相同，再判断其是否实际是一个文件，则调用重命名功能
                     os.rename(f, dst)
             elif if_exists == 'backup':
-                Path(dst).backup(move=True)
+                File(dst).backup(move=True)
                 func(f, dst)
             elif if_exists == 'replace':
                 filesdel(dst)
@@ -502,12 +730,14 @@ def writefile(ob, path='', *, encoding='utf8', if_exists='backup', suffix=None,
     :return: 返回写入的文件名，这个主要是在写临时文件时有用
     """
     if etag is None: etag = (not path)
-    return Path(path, suffix, root).write(ob,
-                                          encoding=encoding, if_exists=if_exists,
-                                          etag=etag).fullpath
+    if path == '': path = ...
+    f = File(path, root, suffix=suffix).write(ob, encoding=encoding, if_exists=if_exists)
+    if etag:
+        f = f.rename(get_etag(str(f)))
+    return str(f)
 
 
-def merge_dir(src, dst, if_exists='ignore'):
+def merge_dir(src, dst, if_exists='skip'):
     """ 将src目录下的数据拷贝到dst目录
     """
 
@@ -515,14 +745,55 @@ def merge_dir(src, dst, if_exists='ignore'):
         p1.copy(p2, if_exists=if_exists)
 
     # 只拷文件和空目录，不然逻辑会乱
-    Dir(src).select('**/*', type_='dir', max_size=0).select('**/*', type_='file').procfiles(func, ref_dir=dst)
+    Dir(src).select('**/*', type_='dir', max_size=0).select('**/*', type_='file').procpaths(func, ref_dir=dst)
 
 
 def extract_files(src, dst, pattern, if_exists='replace'):
     """ 提取满足pattern模式的文件
     """
     d1, d2 = Dir(src), Dir(dst)
-    files = d1.select(pattern).files
+    files = d1.select(pattern).subs
     for f in files:
-        p1, p2 = Path(d1 / f), Path(d2 / f)
+        p1, p2 = File(d1 / f), File(d2 / f)
         p1.copy(p2, if_exists=if_exists)
+
+
+def file_or_dir_size(path):
+    if os.path.isfile(path):
+        return File(path).size
+    elif os.path.isdir(path):
+        return Dir(path).size
+    else:
+        return 0
+
+
+def reduce_dir_depth(srcdir, unwrap=999):
+    """ 精简冗余嵌套的目录
+
+    比如a目录下只有一个文件：a/b/1.txt，
+    那么可以精简为a/1.txt，不需要多嵌套一个b目录
+
+    :param srcdir: 要处理的目录
+    :param unwrap: 打算解开的层数，未设置则会尽可能多解开
+    """
+    import tempfile
+    root = p = XlPath(srcdir)
+    depth = 0
+
+    ps = list(p.glob('*'))
+    while len(ps) == 1 and ps[0].is_dir() and depth < unwrap:
+        depth += 1
+        p = ps[0]
+        ps = list(p.glob('*'))
+
+    if depth:
+        # 注意这里技巧，为了避免多层目录里会有相对同名的目录，导致出现不可预料的bug
+        # 算法原理是把要搬家的那层目录里的文件先移到临时文件，然后把原目录树结构删除后，再报临时文件的文件移回来
+        tmpdir = tempfile.mktemp()
+        shutil.move(str(p), str(tmpdir))
+        if depth > 1:
+            shutil.rmtree(next(root.glob('*')))
+
+        for pp in XlPath(tmpdir).glob('*'):
+            shutil.move(str(pp), str(root))
+        shutil.rmtree(tmpdir)