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

pyxllib/debug/showdir.py

@@ -1,158 +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 .typelib import dataframe_str
-from .chrome import getasizeof
-
-
-def getmembers(object, predicate=None):
-    """自己重写改动的 inspect.getmembers"""
-    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

pyxllib/debug/typelib.py

@@ -1,278 +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 textwrap
-
-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, collections.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/image/__init__.py

@@ -1,12 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/09/15 11:08
-
-
-"""
-以前用image命名的，后来改为了cv，为了跟旧版兼容，先放了一个空的image库
-"""
-
-from pyxllib.cv import *

pyxllib/torch/__init__.py

@@ -1,20 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/10/18 16:06
-
-
-"""
-
-跟pytorch有关的一些常用模型、训练的功能封装
-
-"""
-
-from pyxllib.torch.modellib import *
-from pyxllib.torch.trainlib import *
-
-# 把pytorch等常用的导入写了
-import PIL
-import torch.utils.data
-from torchvision.datasets import VisionDataset

pyxllib/torch/modellib.py

@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Data   : 2020/10/18 16:16
-
-import torch
-from torch import nn
-
-
-class LeNet5(nn.Module):
-    """ https://towardsdatascience.com/implementing-yann-lecuns-lenet-5-in-pytorch-5e05a0911320 """
-    def __init__(self, n_classes):
-        super(LeNet5, self).__init__()
-
-        self.feature_extractor = nn.Sequential(
-            nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1),
-            nn.Tanh(),
-            nn.AvgPool2d(kernel_size=2),
-            nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1),
-            nn.Tanh(),
-            nn.AvgPool2d(kernel_size=2),
-            nn.Conv2d(in_channels=16, out_channels=120, kernel_size=5, stride=1),
-            nn.Tanh()
-        )
-
-        self.classifier = nn.Sequential(
-            nn.Linear(in_features=120, out_features=84),
-            nn.Tanh(),
-            nn.Linear(in_features=84, out_features=n_classes),
-        )
-
-    def forward(self, x):
-        x = self.feature_extractor(x)
-        x = torch.flatten(x, 1)
-        logits = self.classifier(x)
-        return logits