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

pyxllib/prog/specialist/tictoc.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2020/09/20
+
+
+import time
+import timeit
+
+from loguru import logger
+from humanfriendly import format_timespan
+
+from pyxllib.algo.pupil import natural_sort, ValuesStat
+from pyxllib.text.pupil import shorten, listalign
+from pyxllib.prog.newbie import human_readable_number
+
+__tictoc = """
+基于 pytictoc 代码，做了些自定义扩展
+
+原版备注：
+Module with class TicToc to replicate the functionality of MATLAB's tic and toc.
+Documentation: https://pypi.python.org/pypi/pytictoc
+__author__       = 'Eric Fields'
+__version__      = '1.4.0'
+__version_date__ = '29 April 2017'
+"""
+
+
+class TicToc:
+    """
+    Replicate the functionality of MATLAB's tic and toc.
+
+    #Methods
+    TicToc.tic()       #start or re-start the timer
+    TicToc.toc()       #print elapsed time since timer start
+    TicToc.tocvalue()  #return floating point value of elapsed time since timer start
+
+    #Attributes
+    TicToc.start     #Time from timeit.default_timer() when t.tic() was last called
+    TicToc.end       #Time from timeit.default_timer() when t.toc() or t.tocvalue() was last called
+    TicToc.elapsed   #t.end - t.start; i.e., time elapsed from t.start when t.toc() or t.tocvalue() was last called
+    """
+
+    def __init__(self, title='', *, disable=False, min_display_seconds=None):
+        """Create instance of TicToc class."""
+        self.start = timeit.default_timer()
+        self.end = float('nan')
+        self.elapsed = float('nan')
+        self.title = title
+        self.disable = disable
+        # 只有达到这个时间，才会显示耗时
+        self.min_display_seconds = min_display_seconds
+
+    def tic(self):
+        """Start the timer."""
+        self.start = timeit.default_timer()
+
+    def toc(self, msg='', restart=False):
+        """
+        Report time elapsed since last call to tic().
+
+        Optional arguments:
+            msg     - String to replace default message of 'Elapsed time is'
+            restart - Boolean specifying whether to restart the timer
+        """
+        self.end = timeit.default_timer()
+        self.elapsed = self.end - self.start
+        if not self.disable:
+            # print(f'{self.title} {msg} {self.elapsed:.3f} 秒.')
+            print(f'{self.title} {msg} elapsed {human_readable_number(self.elapsed, "秒")}.')
+        if restart:
+            self.start = timeit.default_timer()
+
+    def tocvalue(self, restart=False):
+        """
+        Return time elapsed seconds since last call to tic().
+
+        Optional argument:
+            restart - Boolean specifying whether to restart the timer
+        """
+        self.end = timeit.default_timer()
+        self.elapsed = self.end - self.start
+        if restart:
+            self.start = timeit.default_timer()
+        return self.elapsed
+
+    @staticmethod
+    def process_time(msg='time.process_time():'):
+        """计算从python程序启动到目前为止总用时"""
+        print(f'{msg} {human_readable_number(time.process_time(), "秒")}.')
+
+    def __enter__(self):
+        """Start the timer when using TicToc in a context manager."""
+        if self.title == '__main__' and not self.disable:
+            logger.info(f'time.process_time(): {human_readable_number(time.process_time(), "秒")}.')
+        self.start = timeit.default_timer()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """On exit, print time elapsed since entering context manager."""
+        elapsed = self.tocvalue()
+
+        if exc_tb is None:
+            if not self.disable and (self.min_display_seconds is None or elapsed >= self.min_display_seconds):
+                logger.info(f'{self.title} finished in {human_readable_number(elapsed, "秒")}.')
+        else:
+            logger.info(f'{self.title} interrupt in {human_readable_number(elapsed, "秒")},')
+
+
+__timer = """
+
+"""
+
+
+class Timer:
+    """分析性能用的计时器类，支持with语法调用
+    必须显示地指明每一轮的start()和end()，否则会报错
+    """
+
+    def __init__(self, title=''):
+        """
+        :param title: 计时器名称
+        """
+        # 不同的平台应该使用的计时器不同，这个直接用timeit中的配置最好
+        self.default_timer = timeit.default_timer
+        # 标题
+        self.title = title
+        self.data = []
+        self.start_clock = float('nan')
+
+    def start(self):
+        self.start_clock = self.default_timer()
+
+    def stop(self):
+        self.data.append(self.default_timer() - self.start_clock)
+
+    def report(self, msg=''):
+        """ 报告目前性能统计情况
+        """
+        msg = f'{self.title} {msg}'
+        n = len(self.data)
+
+        if n >= 1:
+            print(msg, '用时(秒) ' + ValuesStat(self.data).summary(valfmt='.3f'))
+        elif n == 1:
+            sum_ = sum(self.data)
+            print(f'{msg} 用时: {sum_:.3f}s')
+        else:  # 没有统计数据，则补充执行一次stop后汇报
+            print(f'{msg} 暂无计时信息')
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.report()
+
+
+def performit(title, stmt="pass", setup="pass", repeat=1, number=1, globals=None):
+    """ 在timeit.repeat的基础上，做了层封装
+
+    200920周日15:33，简化函数，该函数不再获得执行结果，避免重复运行
+
+    :param title: 测试标题、名称功能
+    :return: 返回原函数单次执行结果
+    """
+    data = timeit.repeat(stmt=stmt, setup=setup, repeat=repeat, number=number, globals=globals)
+    print(title, '用时(秒) ' + ValuesStat(data).summary(valfmt='.3f'))
+    return data
+
+
+def perftest(title, stmt="pass", repeat=1, number=1, globals=None, res_width=None, print_=True):
+    """ 与performit的区别是，自己手动循环，记录程序运行结果
+
+    :param title: 测试标题、名称功能
+    :param res_width: 运行结果内容展示的字符上限数
+    :param print_: 输出报告
+    :return: 返回原函数单次执行结果
+
+    这里为了同时获得表达式返回值，就没有用标注你的timeit.repeat实现了
+    """
+    # 1 确保stmt是可调用对象
+    if callable(stmt):
+        func = stmt
+    else:
+        code = compile(stmt, '', 'eval')
+
+        def func():
+            return eval(code, globals)
+
+    # 2 原函数运行结果（这里要先重载stdout）
+    data = []
+    res = ''
+    for i in range(repeat):
+        start = time.time()
+        for j in range(number):
+            res = func()
+        data.append(time.time() - start)
+
+    # 3 报告格式
+    if res_width is None:
+        # 如果性能报告比较短，只有一次测试，那res_width默认长度可以高一点
+        res_width = 50 if len(data) > 1 else 200
+    if res is None:
+        res = ''
+    else:
+        res = '运行结果：' + shorten(str(res), res_width)
+    if print_:
+        print(title, '用时(秒) ' + ValuesStat(data).summary(valfmt='.3f'), res)
+
+    return data
+
+
+class PerfTest:
+    """ 这里模仿了unittest的机制
+
+    v0.0.38 重要改动，将number等参数移到perf操作，而不是类初始化中操作，继承使用上会更简单
+    """
+
+    def perf(self, number=1, repeat=1, globals=None):
+        """
+
+        :param number: 有些代码运算过快，可以多次运行迭代为一个单元
+        :param repeat: 对单元重复执行次数，最后会计算平均值、标准差
+            关于number和repeat的区别：
+                number张纸量repeat次
+                如果是纸箱这么厚的纸，number可以不设，默认是1
+        """
+        # 1 找到所有perf_为前缀，且callable的函数方法
+        funcnames = []
+        for k in dir(self):
+            if k.startswith('perf_'):
+                if callable(getattr(self, k)):
+                    funcnames.append(k)
+
+        # 2 自然排序
+        funcnames = natural_sort(funcnames)
+        funcnames2 = listalign([fn[5:] for fn in funcnames], 'r')
+        for i, funcname in enumerate(funcnames):
+            perftest(funcnames2[i], getattr(self, funcname),
+                     number=int(number), repeat=int(repeat), globals=globals)

pyxllib/prog/specialist/xllog.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2020/09/18 22:16
+
+import os
+import concurrent.futures
+import math
+import time
+import sys
+
+from pyxllib.prog.pupil import EmptyPoolExecutor, format_exception
+from pyxllib.text.pupil import shorten
+
+XLLOG_CONF_FILE = 'xllog.yaml'
+
+____xllog = """
+"""
+
+
+def get_xllog(name='xllog', *, log_file=None):
+    """ 获得pyxllib库的日志类
+
+    :param log_file: 增加输出到一个日志文件，该功能仅在首次初始化时有效
+        注意这个是'w'机制，会删除之前的日志文件
+        # TODO 这样的功能设计问题挺大的，工程逻辑很莫名其妙，有空要把日志功能修缮下
+        #   例如一个通用的初始化类，然后xllog只是一个特定的实例日志类
+
+    TODO 增加输出到钉钉机器人、邮箱的Handler？
+    """
+    # import logging, coloredlogs
+    import logging
+
+    # 1 判断是否已存在，直接返回
+    if ('pyxllib.' + name) in logging.root.manager.loggerDict:
+        return logging.getLogger('pyxllib.' + name)
+
+    # 2 初次构建
+    if name == 'xllog':  # 附带运行时间信息
+        if os.path.isfile(XLLOG_CONF_FILE):
+            # 尝试在默认位置是否有自定义配置文件，读取配置文件来创建
+            import logging.config
+            from pyxllib.file.specialist import File
+            data = File(XLLOG_CONF_FILE).read()
+            if isinstance(data, dict):
+                # 推荐使用yaml的字典结构，格式更简洁清晰
+                logging.config.dictConfig(data)
+            else:
+                # 但是普通的conf配置文件也支持
+                logging.config.fileConfig(XLLOG_CONF_FILE)
+        else:
+            # 3 否则生成一个非常简易版的xllog
+            xllog = logging.getLogger('pyxllib.xllog')
+            fmt = '%(asctime)s %(message)s'
+            if log_file:
+                file_handler = logging.FileHandler(f'{log_file}', 'a')
+                file_handler.setLevel(logging.DEBUG)
+                file_handler.setFormatter(logging.Formatter(fmt))
+                xllog.addHandler(file_handler)
+            # coloredlogs.install(level='DEBUG', logger=xllog, fmt=fmt)
+    elif name == 'location':  # 附带代码所处位置信息
+        loclog = logging.getLogger('pyxllib.location')
+        # coloredlogs.install(level='DEBUG', logger=loclog, fmt='%(filename)s/%(lineno)d: %(message)s')
+    return logging.getLogger('pyxllib.' + name)
+
+
+class Iterate:
+    """ 迭代器类，用来封装一些特定模式的for循环操作
+
+    TODO 双循环，需要内部两两对比的迭代功能
+
+    200920周日18:20，最初设计的时候，是提供run_pair、run_pair2的功能的
+        不过后来想想，这个其实就是排列组合，在itertools里有combinations, permutations可以代替
+        甚至有放回的组合也有combinations_with_replacement，我实在是不需要再这里写这些冗余的功能
+        所以就移除了
+    """
+
+    def __init__(self, items):
+        # 没有总长度倒也能接受，关键是可能要用start、end切片，所以还是先转成tuple更方便操作
+        self.items = tuple(items)
+        self.n_items = len(self.items)
+        self.format_width = math.ceil(math.log10(self.n_items + 1))
+        self.xllog = get_xllog()
+
+    def _format_pinterval(self, pinterval=None):
+        if isinstance(pinterval, str) and pinterval.endswith('%'):
+            # 百分比的情况，重算出间隔元素数
+            return int(round(self.n_items * float(pinterval[:-1]) / 100))
+        else:  # 其他格式暂不解析，按原格式处理
+            return pinterval
+
+    def _step1_check_number(self, pinterval, func):
+        if pinterval:
+            sys.stdout.flush()  # 让逻辑在前的标准输出先print出来，但其实这句也不一定能让print及时输出的~~可能会被日志提前抢输出了
+            self.xllog.info(f"使用 {func.__name__} 处理 {self.n_items} 个数据 {shorten(str(self.items), 30)}")
+
+    def _step2_check_range(self, start, end):
+        if start:
+            self.xllog.info(f"使用start参数，只处理≥{start}的条目")
+        else:
+            start = 0
+        if end:
+            # 这里空格是为了对齐，别删
+            self.xllog.info(f"使用 end 参数，只处理<{end}的条目")
+        else:
+            end = len(self.items)
+        return start, end
+
+    def _step3_executor(self, pinterval, max_workers):
+        if max_workers == 1:
+            # workers=1，实际上并不用多线程，用一个假的多线程类代替，能大大提速
+            executor = EmptyPoolExecutor()
+            # executor = concurrent.futures.ThreadPoolExecutor(max_workers)
+        else:
+            executor = concurrent.futures.ThreadPoolExecutor(max_workers)
+            if pinterval:
+                self.xllog.info(f'多线程执行，当前迭代所用线程数：{executor._max_workers}')
+        return executor
+
+    def _step4_iter(self, i, pinterval, executor):
+        # 队列中没有新任务时，才放入新任务，这样能确保pinterval的输出能反应实时情况，而不是一下全部进入队列，把for循环跑完了
+        while executor._work_queue.qsize(): pass
+        if pinterval and (i or pinterval == 1) and i % pinterval == 0:
+            message = f' {self.items[i]}' if pinterval == 1 else ''
+            self.xllog.info(f'{i:{self.format_width}d}/{self.n_items}={i / self.n_items:6.2%}{message}')
+
+    def _step5_finish(self, pinterval, interrupt, start_time):
+        from humanfriendly import format_timespan
+        end_time = time.time()
+        span = end_time - start_time
+        if span:
+            speed = self.n_items / span
+            msg = f'总用时：{format_timespan(span)}，速度：{speed:.2f}it/s'
+        else:
+            msg = f'总用时：{format_timespan(span)}'
+        if not interrupt and pinterval:
+            self.xllog.info(f'{self.n_items / self.n_items:6.2%} 完成迭代，{msg}')
+            sys.stderr.flush()
+
+    def run(self, func, start=0, end=None, pinterval=None, max_workers=1, interrupt=True):
+        """
+        :param func: 对每个item执行的功能
+        :param start: 跳过<start的数据，只处理>=start编号以上
+        :param end: 只处理 < end 的数据
+        :param pinterval: 每隔多少条目输出进度日志，默认不输出进度日志（但是错误日志依然会输出）
+            支持按百分比进度显示，例如每20%，pinterval='20%'，不过一些底层实现机制原因，会有些许误差
+            TODO 支持按指定时间间隔显示？ 例如每15秒，pinterval='15s' 感觉这种功能太花哨了，没必要搞
+        :param max_workers: 默认线程数，默认1，即串行
+        :type max_workers: int, None
+        :param interrupt: 出现错误时是否中断，默认True会终止程序，否则只会输出错误日志
+        :return:
+        """
+
+        # 1 统一的参数处理部分
+        pinterval = self._format_pinterval(pinterval)
+        self._step1_check_number(pinterval, func)
+        start, end = self._step2_check_range(start, end)
+        error = False
+        executor = self._step3_executor(pinterval, max_workers)
+
+        # 2 封装的子处理部分
+        def wrap_func(func, i):
+            nonlocal error
+            item = self.items[i]
+            try:
+                func(item)
+            except Exception as e:
+                error = e
+                self.xllog.error(f'💔idx={i}运行出错：{item}\n{format_exception(e)}')
+
+        # 3 执行迭代
+        start_time = time.time()
+        for i in range(start, end):
+            self._step4_iter(i, pinterval, executor)
+            executor.submit(wrap_func, func, i)
+            if interrupt and error:
+                raise error
+        executor.shutdown()  # 必须等executor结束，error才是准确的
+        self._step5_finish(pinterval, interrupt and error, start_time)

pyxllib/prog/xlosenv.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2024/10/30
+
+
+import os
+import json
+import base64
+
+from pyxllib.text.newbie import add_quote
+
+
+class XlOsEnv:
+    """ pyxllib库自带的一套环境变量数据解析类
+
+    会将json的字符串值，或者普通str，存储到环境变量中
+
+    环境变量也可以用来实现全局变量的信息传递，虽然不太建议这样做
+
+    >> XlOsEnv.persist_set('TP10_ACCOUNT',
+                           {'server': '172.16.250.250', 'port': 22, 'user': 'ckz', 'passwd': '123456'},
+                           True)
+    >> print(XlOsEnv.get('TP10_ACCOUNT'), True)  # 展示存储的账号信息
+    eyJzZXJ2ZXIiOiAiMTcyLjE2LjE3MC4xMzQiLCAicG9ydCI6IDIyLCAidXNlciI6ICJjaGVua3VuemUiLCAicGFzc3dkIjogImNvZGV4bHByIn0=
+    >> XlOsEnv.unset('TP10_ACCOUNT')
+    """
+
+    @classmethod
+    def get(cls, name, *, decoding=False):
+        """ 获取环境变量值
+
+        :param name: 环境变量名
+        :param decoding: 是否需要先进行base64解码
+        :return:
+            返回json解析后的数据
+            或者普通的字符串值
+        """
+        value = os.getenv(name, None)
+        if value is None:
+            return value
+
+        if decoding:
+            value = base64.b64decode(value.encode())
+
+        try:
+            return json.loads(value)
+        except json.decoder.JSONDecodeError:
+            if isinstance(value, bytes):
+                return value.decode()
+            else:
+                return value
+
+    @classmethod
+    def set(cls, name, value, encoding=False):
+        """ 临时改变环境变量
+
+        :param name: 环境变量名
+        :param value: 要存储的值
+        :param encoding: 是否将内容转成base64后，再存储环境变量
+            防止一些密码信息，明文写出来太容易泄露
+            不过这个策略也很容易被破解；只防君子，难防小人
+
+            当然，谁看到这有闲情功夫的话，可以考虑做一套更复杂的加密系统
+            并且encoding支持多种不同的解加密策略，这样单看环境变量值就很难破译了
+        :return: str, 最终存储的字符串内容
+        """
+        # 1 打包
+        if isinstance(value, str):
+            value = add_quote(value)
+        else:
+            value = json.dumps(value)
+
+        # 2 编码
+        if encoding:
+            value = base64.b64encode(value.encode()).decode()
+
+        # 3 存储到环境变量
+        os.environ[name] = value
+
+        return value
+
+    @classmethod
+    def persist_set(cls, name, value, encoding=False, *, cfgfile=None):
+        """ python里默认是改不了系统变量的，需要使用一些特殊手段
+        https://stackoverflow.com/questions/17657686/is-it-possible-to-set-an-environment-variable-from-python-permanently/17657905
+
+        :param cfgfile: 在linux系统时，可以使用该参数
+            默认是把环境变量写入 ~/.bashrc，可以考虑写到
+            TODO 有这个设想，但很不好实现，不是很关键的功能，所以还未开发
+
+        """
+        # 写入环境变量这里是有点小麻烦的，要考虑unix和windows不同平台，以及怎么持久化存储的问题，这里直接调用一个三方库来解决
+        from envariable import setenv
+
+        value = cls.set(name, value, encoding)
+        if value[0] == value[-1] == '"':
+            value = '\\' + value + '\\'
+        setenv(name, value)
+
+        return value
+
+    @classmethod
+    def unset(cls, name):
+        """ 删除环境变量 """
+        from envariable import unsetenv
+        unsetenv(name)

pyxllib/stdlib/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2021/01/13 15:29
+
+"""
+对标准库或一些第三方库，进行的功能扩展
+    也有可能对一些bug进行了修改
+
+有些是小的库，直接把源码搬过来了
+    有些是较大的库，仍然要（会自动在需要使用时 pip install）安装
+
+改了底层标准库一些功能，修复一些bug，或者提升功能兼容性、强度
+
+onepy: 做了些中文注解，其他修改了啥我也忘了~~可能是有改源码功能的
+"""

pyxllib/{util → stdlib}/tablepyxl/__init__.py

@@ -2,11 +2,9 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/06/02 20:00
+# @Date   : 2020/06/02 20:00
 
 
 """
 from https://github.com/martsberger/tablepyxl
 """
-
-

pyxllib/{util → stdlib}/tablepyxl/style.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/06/02 19:57
+# @Date   : 2020/06/02 19:57
 
 """
 tablepyxl.style的代码

pyxllib/{util → stdlib}/tablepyxl/tablepyxl.py

@@ -2,20 +2,18 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Data   : 2020/06/02 19:57
+# @Date   : 2020/06/02 19:57
 
 
 # Do imports like python3 so our package works for 2 and 3
 from __future__ import absolute_import
 
-import subprocess
-
 from lxml import html
 
 from openpyxl import Workbook
 from openpyxl.utils import get_column_letter
 from premailer import Premailer
-from pyxllib.util.tablepyxl.style import Table
+from pyxllib.stdlib.tablepyxl.style import Table
 
 
 def string_to_int(s):

pyxllib/text/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2020/12/08 15:33
+
+""" 一些文本处理功能 """
+

pyxllib/text/ahocorasick.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2021/06/06 16:57
+
+from pyxllib.prog.pupil import check_install_package
+
+check_install_package('ahocorasick', 'pyahocorasick')
+
+from collections import Counter
+import re
+
+import ahocorasick
+
+
+def make_automaton(words):
+    """ 根据输入的一串words模式，生成一个AC自动机 """
+    a = ahocorasick.Automaton()
+    for index, word in enumerate(words):
+        a.add_word(word, (index, word))
+    a.make_automaton()
+    return a
+
+
+def count_words(content, word, scope=2, exclude=None):
+    # 1 统计所有词汇出现次数
+    c = Counter()
+    c += Counter(re.findall(f'.{{,{scope}}}{word}.{{,{scope}}}', content))
+    # 2 排除掉不处理的词 （注意因为这里每句话都已经是被筛选过的，所以处理比较简单，并不需要复杂到用区间集处理）
+    if exclude:
+        new_c = Counter()
+        a = make_automaton(exclude)  # 创建AC自动机
+        for k in c.keys():
+            if not next(a.iter(k), None):
+                # 如果k没匹配到需要排除的词汇，则拷贝到新的计数器
+                new_c[k] = c[k]
+        c = new_c
+    return c