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

pyxllib/prog/specialist/common.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2020/06/02 11:09
+
+from collections import defaultdict, Counter
+import copy
+import re
+import sys
+
+import pandas as pd
+from more_itertools import unique_everseen
+
+from pyxllib.prog.newbie import typename
+from pyxllib.algo.pupil import natural_sort_key
+from pyxllib.text.pupil import shorten, east_asian_shorten
+
+
+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
+
+
+class TypeConvert:
+    @classmethod
+    def dict2list(cls, 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
+
+    @classmethod
+    def dict2df(cls, d):
+        """dict类型转DataFrame类型"""
+        name = typename(d)
+        if isinstance(d, Counter):
+            li = d.most_common()
+        else:
+            li = cls.dict2list(d, nsort=True)
+        return pd.DataFrame.from_records(li, columns=(f'{name}-key', f'{name}-value'))
+
+    @classmethod
+    def list2df(cls, 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
+
+    @classmethod
+    def try2df(cls, arg):
+        """尝试将各种不同的类型转成dataframe"""
+        if isinstance(arg, dict):
+            df = cls.dict2df(arg)
+        elif isinstance(arg, (list, tuple)):
+            df = cls.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:
+
+        TODO 这个速度有点慢，怎么加速？
+        """
+
+        def tohtml(d):
+            if max_items:
+                df = TypeConvert.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 TypeConvert.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)
+
+
+class JsonStructParser:
+    """ 类json数据格式的结构解析
+
+    【名称定义】
+    item: 一条类json的数据条目
+    path: 用类路径的格式，表达item中某个数值的索引。例如
+        /a/b/3/c: 相当于 item['a']['b'][3]['c']
+        有一些特殊的path，例如容器类会以/结尾： /a/
+        以及一般会带上数值的类型标记，区分度更精确：/a/=dict
+    pathx: 泛指下述中某种格式
+        pathlist: list, 一条item对应的扁平化的路径
+        pathstr/struct: paths拼接成一个str
+        pathdict: paths重新组装成一个dict字典(未实装，太难写，性价比也低)
+    """
+
+    default_cfg = {'include_container': True,  # 包含容器（dict、list）的路径
+                   'value_type': True,  # 是否带上后缀：数值的类型
+                   # 可以输入一个自定义的路径合并函数 path,type=merge_path(path,type)。
+                   # 一般是字典中出现不断变化的数值id，格式不统一，使用一定的规则，可以将path几种相近的冗余形式合并。
+                   # 也可以设True，默认会将数值类统一为0。
+                   'merge_path': False,
+                   }
+
+    @classmethod
+    def _get_item_path_types(cls, item, prefix=''):
+        """
+        :param item: 类json结构的数据，可以含有类型： dict, list(tuple), int, str, bool, None
+            结点类型
+                其中 dict、list称为 container 容器类型
+                其他int、str称为数值类型
+            结构
+                item 可以看成一个树形结构
+                其中数值类型可以视为叶子结点，其他容器类是非叶子结点
+
+        瑕疵
+        1、如果key本身带有"/"，会导致混乱
+        2、list的下标转为0123，和字符串类型的key会混淆，和普通的字典key也会混淆
+        """
+        path_types = []
+        if isinstance(item, dict):
+            path_types.append([prefix + '/', 'dict'])
+            for k in sorted(item.keys()):  # 实验表明，在这里对字典的键进行排序就行，最后总的paths不要排序，不然结构会乱
+                v = item[k]
+                path_types.extend(cls._get_item_path_types(v, f'{prefix}/{k}'))
+        elif isinstance(item, (list, tuple)):
+            path_types.append([prefix + '/', type(item).__name__])
+            for k, v in enumerate(item):
+                path_types.extend(cls._get_item_path_types(v, f'{prefix}/{k}'))
+        else:
+            path_types.append([prefix, type(item).__name__])
+        return path_types
+
+    @classmethod
+    def get_item_pathlist(cls, item, prefix='', **kwargs):
+        """ 获得字典的结构标识
+        """
+        # 1 底层数据
+        cfg = copy.copy(cls.default_cfg)
+        cfg.update(kwargs)
+        paths = cls._get_item_path_types(item, prefix)
+
+        # 2 配置参数
+        if cfg['merge_path']:
+            if callable(cfg['merge_path']):
+                func = cfg['merge_path']
+            else:
+                def func(p, t):
+                    return re.sub(r'\d+', '0', p), t
+
+            # 保序去重
+            paths = list(unique_everseen(map(lambda x: func(x[0], x[1]), paths)))
+
+        if not cfg['include_container']:
+            paths = [pt for pt in paths if (pt[0][-1] != '/')]
+
+        if cfg['value_type']:
+            paths = ['='.join(pt) for pt in paths]
+        else:
+            paths = [pt[0] for pt in paths]
+
+        return paths
+
+    @classmethod
+    def get_item_pathstr(cls, item, prefix='', **kwargs):
+        paths = cls.get_item_pathlist(item, prefix, **kwargs)
+        return '\n'.join(paths)
+
+    @classmethod
+    def get_items_struct2cnt(cls, items, **kwargs):
+        # 1 统计每种结构出现的次数
+        struct2cnt = Counter()
+        for item in items:
+            pathstr = cls.get_item_pathstr(item, **kwargs)
+            struct2cnt[pathstr] += 1
+        # 2 按照从多到少排序
+        struct2cnt = Counter(dict(sorted(struct2cnt.items(), key=lambda item: -item[1])))
+        return struct2cnt
+
+    @classmethod
+    def get_items_structdf(cls, items, **kwargs):
+        """ 分析一组题目里，出现了多少种不同的json结构 """
+        # 1 获取原始数据，初始化
+        struct2cnt = cls.get_items_struct2cnt(items, **kwargs)
+        m = len(struct2cnt)
+
+        # 2 path2cnt
+        path2cnt = Counter()
+        for struct in struct2cnt.keys():
+            path2cnt.update({path: struct2cnt[struct] for path in struct.splitlines()})
+        paths = sorted(path2cnt.keys(), key=lambda path: re.split(r'/=', path))
+        path2cnt = {path: path2cnt[path] for path in paths}
+
+        # 3 生成统计表
+        ls = []
+        columns = ['path', 'total'] + [f'struct{i}' for i in range(1, m + 1)]
+        for path, cnt in path2cnt.items():
+            row = [path, cnt]
+            for struct, cnt in struct2cnt.items():
+                t = cnt if path in struct else 0
+                row.append(t)
+            ls.append(row)
+
+        df = pd.DataFrame.from_records(ls, columns=columns)
+        return df
+
+    @classmethod
+    def get_itemgroups_structdf(cls, itemgroups, **kwargs):
+        """ 分析不同套数据间的json结构区别
+
+        这里为了减少冗余开发，直接复用get_items_structdf
+            虽然会造成一些冗余功能，
+        """
+        # 1 统计所有paths出现情况
+        n = len(itemgroups)
+        d = dict()
+        for i, gs in enumerate(itemgroups):
+            for x in gs:
+                paths = cls.get_item_pathlist(x, **kwargs)
+                for p in paths:
+                    if p not in d:
+                        d[p] = [0] * n
+                    d[p][i] += 1
+
+        # 排序
+        paths = sorted(d.keys(), key=lambda path: re.split(r'/=', path))
+
+        # 2 统计表
+        ls = []
+        columns = ['path', 'total'] + [f'group{i}' for i in range(1, n + 1)]
+        for path in paths:
+            vals = d[path]
+            row = [path, sum(vals)] + vals
+            ls.append(row)
+
+        df = pd.DataFrame.from_records(ls, columns=columns)
+        return df

pyxllib/prog/specialist/datetime.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2021/06/03 23:28
+
+"""
+
+旧的Datetime类已删除，原来稍微比较有用的一个功能，是
+
+替换周几，这个算法可以参考：
+a = a - a.isoweekday() + kwargs['weekday']  # 先减去当前星期几，再加上1~7的一个目标星期
+
+"""
+
+import datetime
+import re
+
+from fastcore.utils import GetAttr
+
+
+def parse_datetime(*argv):
+    """ 解析字符串日期时间
+
+    解析算法偏私人应用，规则虽然多，但反而变得混乱隐晦，
+    实际开发能明确使用具体接口，尽量还是用具体接口。
+
+    # 建议使用 Datetime.strptime
+    >>> parse_datetime('2019年3月6日', '%Y年%m月%d日')  # 指定格式
+    datetime.datetime(2019, 3, 6, 0, 0)
+    >>> parse_datetime('w200301周日', 'w%y%m%d周日')  # 周日必须写全，有缺失会报ValueError
+    datetime.datetime(2020, 3, 1, 0, 0)
+
+    >>> parse_datetime('2019.3.6 22:30:40')
+    datetime.datetime(2019, 3, 6, 22, 30, 40)
+
+    >>> parse_datetime(180213)
+    datetime.datetime(2018, 2, 13, 0, 0)
+    >>> parse_datetime('180213')
+    datetime.datetime(2018, 2, 13, 0, 0)
+
+    # 以下只对2000~2099年的时间点有效
+    >>> parse_datetime('2015-06-15_22-19-01_HDR.jpg')
+    datetime.datetime(2015, 6, 15, 22, 19, 1)
+    >>> parse_datetime('IMG_20150615_2219011234_HDR.jpg')
+    datetime.datetime(2015, 6, 15, 22, 19, 1, 1234)
+    >>> parse_datetime('_2015.6.15_22:19:02')
+    datetime.datetime(2015, 6, 15, 22, 19, 2)
+    """
+
+    def _datetime(argv):
+        args, n = list(argv), len(argv)
+        if n < 3:  # 若没填写月、日，默认1月、1日
+            args = args + [1] * (3 - n)
+        try:
+            return datetime.datetime(*args)
+        except (ValueError, TypeError) as e:
+            return None
+
+    def _six_digits_date(s):
+        """主要是我个人常用的日期标注格式
+        """
+        s, dt = str(s), None
+        if re.match(r'\d{6}$', s):
+            year = int(s[:2])
+            year = 2000 + year if year < 50 else 1900 + year  # 小于50默认是20xx年，否则认为是19xx年
+            dt = _datetime([year, int(s[2:4]), int(s[4:])])
+        return dt
+
+    def _parse_time_string(s):
+        r"""只对2000~2099年的时间点有效
+        """
+        data, break_flag = [], False
+
+        def parse(pattern, left=None, right=None):
+            """通用底层解析器"""
+            nonlocal break_flag, s
+            if break_flag: return
+
+            m = re.search(pattern, s)
+            if m:
+                d = int(m.group())
+                if left and d < left:
+                    break_flag = True
+                elif right and d > right:
+                    break_flag = True
+                else:
+                    data.append(d)
+                    s = s[m.end():]
+            else:
+                break_flag = True
+
+        parse(r'20\d{2}')
+        parse(r'\d\d?', 1, 12)  # 有连续两个数组就获得两个，否则获得一个也行
+        parse(r'\d\d?', 1, 31)  # 这样其实不严谨，有的月份不到31天，不过反正_datetime会返回None代表处理失败的
+        parse(r'\d\d?', 0, 23)
+        parse(r'\d\d?', 0, 59)
+        parse(r'\d\d?', 0, 59)
+        parse(r'\d{1,6}')  # microsecond
+
+        return _datetime(data)
+
+    dt = None
+    # 1 没有参数则默认当前运行时间
+    if not argv:
+        dt = datetime.datetime.now()
+    if not dt and isinstance(argv[0], datetime.datetime):
+        dt = argv[0]
+    if not dt and isinstance(argv[0], datetime.date):
+        # 要转成datetime类型，time部分默认00:00:00
+        dt = datetime.datetime.combine(argv[0], datetime.time())
+    if not dt and isinstance(argv[0], float):
+        dt = datetime.datetime.fromtimestamp(argv[0])
+    # 2 如果上述解析不了，且argv恰好为两个参数，则判断为使用strptime初始化
+    if not dt and len(argv) == 2:
+        dt = datetime.datetime.strptime(str(argv[0]), argv[1])
+    # 3 判断是否我个人特用的六位日期标记
+    if not dt:
+        dt = _six_digits_date(argv[0])
+    # 4 如果仍然解析不了，开始使用一个智能推导算法
+    if not dt:
+        dt = _parse_time_string(argv[0])
+    # 5 最后任何解析方案都失败，则返回None
+
+    return dt
+
+
+def parse_timedelta(s):
+    """ 解析字符串所代表的时间差
+
+    >>> parse_timedelta('38:18')
+    datetime.timedelta(seconds=2298)
+    >>> parse_timedelta('03:55')
+    datetime.timedelta(seconds=235)
+    >>> parse_timedelta('1:34:25')
+    datetime.timedelta(seconds=5665)
+    """
+    parts = s.split(':')[::-1]
+    d = {k: int(v) for k, v in zip(['seconds', 'minutes', 'hours'], parts)}
+    td = datetime.timedelta(**d)
+    return td
+
+
+class XlWeekTag(GetAttr):
+    """ 个人周标签转换工具 """
+    _default = 'dt'
+
+    def __init__(self, dt=None):
+        """
+        :param datetime|其他类日期表达 dt: 可以输入一个日期，默认为今天
+        """
+        if dt is None:
+            dt = datetime.date.today()
+        self.dt = parse_datetime(dt)
+
+    def __1_日期移动(self):
+        pass
+
+    def add_days(self, days):
+        """ 增加指定天数，支持负数 """
+        return self.__class__(self.dt + datetime.timedelta(days=days))
+
+    def monday(self):
+        """ 移动到本周周一 """
+        return self.add_days(-self.dt.weekday())
+
+    def next_week(self):
+        """ 移动到下一周 """
+        return self.add_days(7)
+
+    def prev_week(self):
+        """ 移动到上一周 """
+        return self.add_days(-7)
+
+    def __2_生成标签(self):
+        pass
+    
+    def weektag(self):
+        """
+        :return: 周标签名，例如 'w250414'，表示所属周的周一是2025年4月14日
+        """
+        monday = self.monday()  # 获取本周周一
+        tag = 'w' + monday.strftime('%y%m%d')
+        return tag
+
+    def daytag(self):
+        """
+        :return: 日标签名，例如 '250415周二'，表示当天的日期标记，一般是语雀周报中使用
+        """
+        ch = '一二三四五六日'[self.dt.weekday()]
+        tag = self.dt.strftime('%y%m%d') + '周' + ch
+        return tag
+
+    def week_daytags(self):
+        # 循环获得本周每天的daytag
+        monday = self.monday()
+        tags = [monday.add_days(i).daytag() for i in range(7)]
+        return tags
+