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

pyxllib/debug/_1_typelib.py

@@ -1,277 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/06/02 11:09
-
-
-from collections import defaultdict, Counter
-
-import pandas as pd
-
-from pyxllib.basic import *
-
-
-def east_asian_len(s, ambiguous_width=None):
-    import pandas.io.formats.format as fmt
-    return fmt.EastAsianTextAdjustment().len(s)
-
-
-def east_asian_shorten(s, width=50, placeholder='...'):
-    """考虑中文情况下的域宽截断
-
-    :param s: 要处理的字符串
-    :param width: 宽度上限，仅能达到width-1的宽度
-    :param placeholder: 如果做了截断，末尾补足字符
-
-    # width比placeholder还小
-    >>> east_asian_shorten('a', 2)
-    'a'
-    >>> east_asian_shorten('a啊b'*4, 3)
-    '..'
-    >>> east_asian_shorten('a啊b'*4, 4)
-    '...'
-
-    >>> east_asian_shorten('a啊b'*4, 5, '...')
-    'a...'
-    >>> east_asian_shorten('a啊b'*4, 11)
-    'a啊ba啊...'
-    >>> east_asian_shorten('a啊b'*4, 16, '...')
-    'a啊ba啊ba啊b...'
-    >>> east_asian_shorten('a啊b'*4, 18, '...')
-    'a啊ba啊ba啊ba啊b'
-    """
-    # 一、如果字符串本身不到width设限，返回原值
-    s = textwrap.shorten(s, width * 3, placeholder='')  # 用textwrap的折行功能，尽量不删除文本
-    n = east_asian_len(s)
-    if n < width: return s
-
-    # 二、如果输入的width比placeholder还短
-    width -= 1
-    m = east_asian_len(placeholder)
-    if width <= m:
-        return placeholder[:width]
-
-    # 三、需要添加 placeholder
-    # 1 计算长度
-    width -= m
-
-    # 2 截取s
-    try:
-        s = s.encode('gbk')[:width].decode('gbk', errors='ignore')
-    except UnicodeEncodeError:
-        i, count = 0, m
-        while i < n and count <= width:
-            if ord(s[i]) > 127:
-                count += 2
-            else:
-                count += 1
-            i += 1
-        s = s[:i]
-
-    return s + placeholder
-
-
-def dataframe_str(df, *args, ambiguous_as_wide=None, shorten=True):
-    """输出DataFrame
-    DataFrame可以直接输出的，这里是增加了对中文字符的对齐效果支持
-
-    :param df: DataFrame数据结构
-    :param args: option_context格式控制
-    :param ambiguous_as_wide: 是否对①②③这种域宽有歧义的设为宽字符
-        win32平台上和linux上①域宽不同，默认win32是域宽2，linux是域宽1
-    :param shorten: 是否对每个元素提前进行字符串化并控制长度在display.max_colwidth以内
-        因为pandas的字符串截取遇到中文是有问题的，可以用我自定义的函数先做截取
-        默认开启，不过这步比较消耗时间
-
-    >> df = pd.DataFrame({'哈哈': ['a'*100, '哈\n①'*10, 'a哈'*100]})
-                                                        哈哈
-        0  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...
-        1   哈 ①哈 ①哈 ①哈 ①哈 ①哈 ①哈 ①哈 ①哈 ①...
-        2  a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a哈a...
-    """
-    import pandas as pd
-
-    if ambiguous_as_wide is None:
-        ambiguous_as_wide = sys.platform == 'win32'
-    with pd.option_context('display.unicode.east_asian_width', True,  # 中文输出必备选项，用来控制正确的域宽
-                           'display.unicode.ambiguous_as_wide', ambiguous_as_wide,
-                           'max_columns', 20,  # 最大列数设置到20列
-                           'display.width', 200,  # 最大宽度设置到200
-                           *args):
-        if shorten:  # applymap可以对所有的元素进行映射处理，并返回一个新的df
-            df = df.applymap(lambda x: east_asian_shorten(str(x), pd.options.display.max_colwidth))
-        s = str(df)
-    return s
-
-
-def prettifystr(s):
-    """对一个对象用更友好的方式字符串化
-
-    :param s: 输入类型不做限制，会将其以友好的形式格式化
-    :return: 格式化后的字符串
-    """
-    title = ''
-    if isinstance(s, str):
-        pass
-    elif isinstance(s, Counter):  # Counter要按照出现频率显示
-        li = s.most_common()
-        title = f'collections.Counter长度：{len(s)}\n'
-        # 不使用复杂的pd库，先简单用pprint即可
-        # df = pd.DataFrame.from_records(s, columns=['value', 'count'])
-        # s = dataframe_str(df)
-        s = pprint.pformat(li)
-    elif isinstance(s, (list, tuple)):
-        title = f'{typename(s)}长度：{len(s)}\n'
-        s = pprint.pformat(s)
-    elif isinstance(s, (dict, set)):
-        title = f'{typename(s)}长度：{len(s)}\n'
-        s = pprint.pformat(s)
-    else:  # 其他的采用默认的pformat
-        s = pprint.pformat(s)
-    return title + s
-
-
-class PrettifyStrDecorator:
-    """将函数的返回值字符串化（调用 prettifystr 美化）"""
-
-    def __init__(self, func):
-        self.func = func  # 使用self.func可以索引回原始函数名称
-        self.last_raw_res = None  # last raw result，上一次执行函数的原始结果
-
-    def __call__(self, *args, **kwargs):
-        self.last_raw_res = self.func(*args, **kwargs)
-        return prettifystr(self.last_raw_res)
-
-
-def dict2list(d: dict, *, nsort=False):
-    """字典转n*2的list
-    :param d: 字典
-    :param nsort:
-        True: 对key使用自然排序
-        False: 使用d默认的遍历顺序
-    :return:
-    """
-    ls = list(d.items())
-    if nsort:
-        ls = sorted(ls, key=lambda x: natural_sort_key(str(x[0])))
-    return ls
-
-
-def dict2df(d):
-    """dict类型转DataFrame类型"""
-    name = typename(d)
-    if isinstance(d, Counter):
-        li = d.most_common()
-    else:
-        li = dict2list(d, nsort=True)
-    return pd.DataFrame.from_records(li, columns=(f'{name}-key', f'{name}-value'))
-
-
-def list2df(li):
-    if li and isinstance(li[0], (list, tuple)):  # 有两维时按表格显示
-        df = pd.DataFrame.from_records(li)
-    else:  # 只有一维时按一列显示
-        df = pd.DataFrame(pd.Series(li), columns=(typename(li),))
-    return df
-
-
-def try2df(arg):
-    """尝试将各种不同的类型转成dataframe"""
-    if isinstance(arg, dict):
-        df = dict2df(arg)
-    elif isinstance(arg, (list, tuple)):
-        df = list2df(arg)
-    elif isinstance(arg, pd.Series):
-        df = pd.DataFrame(arg)
-    else:
-        df = arg
-    return df
-
-
-class NestedDict:
-    """ 字典嵌套结构相关功能
-
-    TODO 感觉跟 pprint 的嵌套识别美化输出相关，可能有些代码是可以结合简化的~~
-    """
-
-    @classmethod
-    def has_subdict(cls, data, include_self=True):
-        """是否含有dict子结构
-        :param include_self: 是否包含自身，即data本身是一个dict的话，也认为has_subdict是True
-        """
-        if include_self and isinstance(data, dict):
-            return True
-        elif isinstance(data, (list, tuple, set)):
-            for v in data:
-                if cls.has_subdict(v):
-                    return True
-        return False
-
-    @classmethod
-    def to_html_table(cls, data, max_items=10):
-        """ 以html表格套表格的形式，展示一个嵌套结构数据
-        :param data: 数据
-        :param max_items: 项目显示上限，有些数据项目太多了，要精简下
-            设为假值则不设上限
-        :return:
-        """
-
-        def tohtml(d):
-            if max_items:
-                df = try2df(d)
-                if len(df) > max_items:
-                    n = len(df)
-                    return df[:max_items].to_html(escape=False) + f'... {n - 1}'
-                else:
-                    return df.to_html(escape=False)
-            else:
-                return try2df(d).to_html(escape=False)
-
-        if not cls.has_subdict(data):
-            res = str(data)
-        elif isinstance(data, dict):
-            if isinstance(data, Counter):
-                d = data
-            else:
-                d = dict()
-                for k, v in data.items():
-                    if cls.has_subdict(v):
-                        v = cls.to_html_table(v, max_items=max_items)
-                    d[k] = v
-            res = tohtml(d)
-        else:
-            li = [cls.to_html_table(x, max_items=max_items) for x in data]
-            res = tohtml(li)
-
-        return res.replace('\n', ' ')
-
-
-class KeyValuesCounter:
-    """ 各种键值对出现次数的统计
-    会递归找子字典结构，但不存储结构信息，只记录纯粹的键值对信息
-
-    应用场景：对未知的json结构，批量读取后，显示所有键值对的出现情况
-    """
-
-    def __init__(self):
-        self.kvs = defaultdict(Counter)
-
-    def add(self, data, max_value_length=100):
-        """
-        :param max_value_length: 添加的值，进行截断，防止有些值太长
-        """
-        if not NestedDict.has_subdict(data):
-            return
-        elif isinstance(data, dict):
-            for k, v in data.items():
-                if NestedDict.has_subdict(v):
-                    self.add(v)
-                else:
-                    self.kvs[k][shorten(str(v), max_value_length)] += 1
-        else:  # 否则 data 应该是个可迭代对象，才可能含有dict
-            for x in data:
-                self.add(x)
-
-    def to_html_table(self, max_items=10):
-        return NestedDict.to_html_table(self.kvs, max_items=max_items)

pyxllib/debug/_2_chrome.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/05/30 22:43
-
-
-import html
-import subprocess
-import pandas as pd
-
-from pyxllib.debug._1_typelib import *
-
-
-def getasizeof(*objs, **opts):
-    """获得所有类的大小，底层用pympler.asizeof实现"""
-    from pympler import asizeof
-
-    try:
-        res = asizeof.asizeof(*objs, **opts)
-    # except TypeError:  # sqlalchemy.exc.InvalidRequestError
-    except:
-        res = -1
-    return res
-
-
-def viewfiles(procname, *files, **kwargs):
-    """调用procname相关的文件程序打开files
-    :param procname: 程序名
-    :param files: 一个文件名参数清单，每一个都是文件路径，或者是字符串等可以用writefile转成文件的路径
-    :param kwargs:
-        save: 如果True，则会按时间保存文件名；否则采用特定名称，每次运行就会把上次的覆盖掉
-        wait: 是否等待当前进程结束后，再运行后续py代码
-        filename: 控制写入的文件名
-        TODO：根据不同软件，这里还可以扩展很多功能
-    :param kwargs:
-        wait:
-            True：在同一个进程中执行子程序，即会等待bc退出后，再进入下一步
-            False：在新的进程中执行子程序
-
-    细节：注意bc跟其他程序有比较大不同，建议使用专用的bcompare函数
-    目前已知可以扩展多文件的有：chrome、notepad++、texstudio
-
-    >> ls = list(range(100))
-    >> viewfiles('notepad++', ls, save=True)
-    """
-    # 1 生成文件名
-    ls = []  # 将最终所有绝对路径文件名存储到ls
-    save = kwargs.get('save')
-
-    basename = ext = None
-    if 'filename' in kwargs and kwargs['filename']:
-        basename, ext = os.path.splitext(kwargs['filename'])
-
-    for i, t in enumerate(files):
-        if Path(t).is_file() or is_url(t):
-            ls.append(str(t))
-        else:
-            bn = basename or ''
-            ls.append(Path(bn, ext, Path.TEMP).write(t, if_exists=kwargs.get('if_exists', 'error')).fullpath)
-
-    # 2 调用程序（并计算外部操作时间）
-    tictoc = TicToc()
-    try:
-        if kwargs.get('wait'):
-            subprocess.run([procname, *ls])
-        else:
-            subprocess.Popen([procname, *ls])
-    except FileNotFoundError:
-        if procname in ('chrome', 'chrome.exe'):
-            procname = 'explorer'  # 如果是谷歌浏览器找不到，尝试用系统默认浏览器
-            viewfiles(procname, *files, **kwargs)
-        else:
-            raise FileNotFoundError(f'未找到程序：{procname}。请检查是否有安装及设置了环境变量。')
-    return tictoc.tocvalue()
-
-
-def chrome(arg_, **kwargs):
-    r"""使用谷歌浏览器查看变量、文件等内容，详细用法见底层函数 viewfiles
-
-    :param arg_: 支持输入多种类型
-        文件、url，会用浏览器直接打开
-        dict，会先转df
-    :param kwargs: 如果数据可以转为df，在使用to_html接口的时候可以设置相关格式参数，常用的有
-        escape=True，是否解析html内容，默认True不解析
-
-    >> chrome(r'C:\Users\kzche\Desktop\b.xml')  # 使用chrome查看文件内容
-    >> chrome('aabb')  # 使用chrome查看一个字符串值
-    >> chrome([123, 456])  # 使用chrome查看一个变量值
-
-    这个函数可以浏览文本、list、dict、DataFrame表格数据、图片、html等各种文件的超级工具
-    """
-    # 1 如果是文件、url，则直接打开
-    if is_file(arg_) or is_url(arg_):
-        viewfiles('chrome.exe', arg_)
-        return
-
-    # 2 如果是其他类型，则先转成文件，再打开
-    arg = try2df(arg_)
-    if isinstance(arg, pd.DataFrame):  # DataFrame在网页上有更合适的显示效果
-        t = f'==== 类继承关系：{inspect.getmro(type(arg_))}，' \
-            + f'内存消耗：{sys.getsizeof(arg_)}（递归子类总大小：{getasizeof(arg_)}）Byte ===='
-        t = '<p>' + html.escape(t) + '</p>'
-        content = arg.to_html(**kwargs)
-        filename = Path('', '.html', Path.TEMP).write(t + content, etag=True, if_exists='ignore')
-        viewfiles('chrome.exe', str(filename))
-    elif getattr(arg, 'render', None):  # pyecharts 等表格对象，可以用render生成html表格显示
-        try:
-            name = arg.options['title'][0]['text']
-        except (LookupError, TypeError):
-            name = Datetime().strftime('%H%M%S_%f')
-        filename = Path(name, '.html', Path.TEMP).fullpath
-        arg.render(path=filename)
-        viewfiles('chrome.exe', filename)
-    else:
-        name = Datetime().strftime('%H%M%S_%f')
-        filename = Path(name, '.txt', Path.TEMP).write(arg).fullpath
-        viewfiles('chrome.exe', filename)
-
-
-def view_jsons_kv(fd, files='**/*.json', encoding=None, max_items=10, max_value_length=100):
-    """ demo_keyvaluescounter，查看目录下json数据的键值对信息
-    :param fd: 目录
-    :param files: 匹配的文件格式
-    :param encoding: 文件编码
-    :param max_items: 项目显示上限，有些数据项目太多了，要精简下
-            设为假值则不设上限
-    :param max_value_length: 添加的值，进行截断，防止有些值太长
-    :return:
-    """
-    kvc = KeyValuesCounter()
-    d = Dir(fd)
-    for p in d.select(files).filepaths:
-        # print(p)
-        data = p.read(encoding=encoding, mode='.json')
-        kvc.add(data, max_value_length=max_value_length)
-    p = Path(r'demo_keyvaluescounter.html', root=Path.TEMP)
-    p.write(kvc.to_html_table(max_items=max_items), if_exists='replace')
-    chrome(p.fullpath)
-
-
-def check_repeat_filenames(dir, key='stem', link=True):
-    """ 检查目录下文件结构情况的功能函数
-
-    https://www.yuque.com/xlpr/pyxllib/check_repeat_filenames
-
-    :param dir: 目录Dir类型，也可以输入路径，如果没有files成员，则默认会获取所有子文件
-    :param key: 以什么作为行分组的key名称，基本上都是用'stem'，偶尔可能用'name'
-        遇到要忽略 -eps-to-pdf.pdf 这种后缀的，也可以自定义处理规则
-        例如 key=lambda p: re.sub(r'-eps-to-pdf', '', p.stem).lower()
-    :param link: 默认True会生成文件超链接
-    :return: 一个df表格，行按照key的规则分组，列默认按suffix扩展名分组
-    """
-    # 1 智能解析dir参数
-    if not isinstance(dir, Dir):
-        dir = Dir(dir)
-    if not dir.files:
-        dir = dir.select('**/*', type_='file')
-
-    # 2 辅助函数，智能解析key参数
-    if isinstance(key, str):
-        def extract_key(p):
-            return getattr(p, key).lower()
-    elif callable(key):
-        extract_key = key
-    else:
-        raise TypeError
-
-    # 3 制作df表格数据
-    columns = ['key', 'suffix', 'filename']
-    li = []
-    for f in dir.files:
-        p = Path(f)
-        li.append([extract_key(p), p.suffix.lower(), f])
-    df = pd.DataFrame.from_records(li, columns=columns)
-
-    # 4 分组
-    def joinfile(files):
-        if len(files):
-            if link:
-                return ', '.join([f'<a href="{dir / f}" target="_blank">{f}</a>' for f in files])
-            else:
-                return ', '.join(files)
-        else:
-            return ''
-
-    groups = df.groupby(['key', 'suffix']).agg({'filename': joinfile})
-    groups.reset_index(inplace=True)
-    view_table = groups.pivot(index='key', columns='suffix', values='filename')
-    view_table.fillna('', inplace=True)
-
-    # 5 判断每个key的文件总数
-    count_df = df.groupby('key').agg({'filename': 'count'})
-    view_table = pd.concat([view_table, count_df], axis=1)
-    view_table.rename({'filename': 'count'}, axis=1, inplace=True)
-
-    chrome(view_table, escape=not link)
-    return df

pyxllib/debug/_3_showdir.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/06/01
-
-
-import enum
-import html
-import subprocess
-
-import pandas as pd
-from bs4 import BeautifulSoup
-
-from pyxllib.basic import *
-from pyxllib.debug._1_typelib import dataframe_str
-from pyxllib.debug._2_chrome import getasizeof
-
-
-def getmembers(object, predicate=None):
-    """自己重写改动的 inspect.getmembers
-
-    TODO 这个实现好复杂，对于成员，直接用dir不就好了？
-    """
-    from inspect import isclass, getmro
-    import types
-
-    if isclass(object):
-        mro = (object,) + getmro(object)
-    else:
-        mro = ()
-    results = []
-    processed = set()
-    names = dir(object)
-    # :dd any DynamicClassAttributes to the list of names if object is a class;
-    # this may result in duplicate entries if, for example, a virtual
-    # attribute with the same name as a DynamicClassAttribute exists
-    try:
-        for base in object.__bases__:
-            for k, v in base.__dict__.items():
-                if isinstance(v, types.DynamicClassAttribute):
-                    names.append(k)
-    except AttributeError:
-        pass
-    for key in names:
-        # First try to get the value via getattr.  Some descriptors don't
-        # like calling their __get__ (see bug #1785), so fall back to
-        # looking in the __dict__.
-        try:
-            value = getattr(object, key)
-            # handle the duplicate key
-            if key in processed:
-                raise AttributeError
-        # except AttributeError:
-        except:  # 加了这种异常获取，190919周四15:14，sqlalchemy.exc.InvalidRequestError
-            dprint(key)  # 抓不到对应的这个属性
-            for base in mro:
-                if key in base.__dict__:
-                    value = base.__dict__[key]
-                    break
-            else:
-                # could be a (currently) missing slot member, or a buggy
-                # __dir__; discard and move on
-                continue
-
-        if not predicate or predicate(value):
-            results.append((key, value))
-        processed.add(key)
-    results.sort(key=lambda pair: pair[0])
-    return results
-
-
-def showdir(c, *, to_html=None, printf=True):
-    """查看类信息
-    会罗列出类c的所有成员方法、成员变量，并生成一个html文
-
-    查阅一个对象的成员变量及成员方法
-    为了兼容linux输出df时也能对齐，有几个中文域宽处理相关的函数
-
-    :param c: 要处理的对象
-    :param to_html:
-        win32上默认True，用chrome、explorer打开
-        linux上默认False，直接输出到控制台
-    :param printf:
-        默认是True，会输出到浏览器或控制条
-        设为False则不输出
-    """
-    # 1 输出类表头
-    res = []
-    object_name = func_input_message(2)['argnames'][0]
-    if to_html is None:
-        to_html = sys.platform == 'win32'
-    newline = '<br/>' if to_html else '\n'
-
-    t = f'==== 对象名称：{object_name}，类继承关系：{inspect.getmro(type(c))}，' \
-        + f'内存消耗：{sys.getsizeof(c)}（递归子类总大小：{getasizeof(c)}）Byte ===='
-
-    if to_html:
-        res.append('<p>')
-        t = html.escape(t) + '</p>'
-    res.append(t + newline)
-
-    # 2 html的样式精调
-    def df2str(df):
-        if to_html:
-            df = df.applymap(str)  # 不转成文本经常有些特殊函数会报错
-            df.index += 1  # 编号从1开始
-            # pd.options.display.max_colwidth = -1  # 如果临时需要显示完整内容
-            t = df.to_html()
-            table = BeautifulSoup(t, 'lxml')
-            table.thead.tr['bgcolor'] = 'LightSkyBlue'  # 设置表头颜色
-            ch = 'A' if '成员变量' in table.tr.contents[3].string else 'F'
-            table.thead.tr.th.string = f'编号{ch}{len(df)}'
-            t = table.prettify()
-        else:
-            # 直接转文本，遇到中文是会对不齐的，但是showdir主要用途本来就是在浏览器看的，这里就不做调整了
-            t = dataframe_str(df)
-        return t
-
-    # 3 添加成员变量和成员函数
-    # 成员变量
-    members = getmembers(c)
-    methods = filter(lambda m: not callable(getattr(c, m[0])), members)
-    ls = []
-    for ele in methods:
-        k, v = ele
-        if k.endswith(r'________'):  # 这个名称的变量是我代码里的特殊标记，不显示
-            continue
-        attr = getattr(c, k)
-        if isinstance(attr, enum.IntFlag):  # 对re.RegexFlag等枚举类输出整数值
-            v = typename(attr) + '，' + str(int(attr)) + '，' + str(v)
-        else:
-            try:
-                text = str(v)
-            except:
-                text = '取不到str值'
-            v = typename(attr) + '，' + text
-        ls.append([k, v])
-    df = pd.DataFrame.from_records(ls, columns=['成员变量', '描述'])
-    res.append(df2str(df) + newline)
-
-    # 成员函数
-    methods = filter(lambda m: callable(getattr(c, m[0])), members)
-    df = pd.DataFrame.from_records(methods, columns=['成员函数', '描述'])
-    res.append(df2str(df) + newline)
-    res = newline.join(res)
-
-    # 4 使用chrome.exe浏览或输出到控制台
-    #   这里底层可以封装一个chrome函数来调用，但是这个chrome需要依赖太多功能，故这里暂时手动简单调用
-    if to_html:
-        filename = Path(object_name, suffix='.html', root=Path.TEMP). \
-            write(ensure_gbk(res), if_exists='replace').fullpath
-        try:
-            subprocess.run(['chrome.exe', filename])
-        except FileNotFoundError:
-            subprocess.run(['explorer', filename], shell=True)
-            logging.warning('启动chrome.exe失败，可能是没有安装谷歌浏览器或配置环境变量。')
-    else:  # linux环境直接输出表格
-        print(res)
-
-    return res