魔のkyo的BLOG

import os
import functools
import redis
from redis.connection import ConnectionPool
import msgpack
import msgpack_numpy
import numpy as np
import pandas as pd
import io

class _HashedSeq(list):
    __slots__ = 'hashvalue'

    def __init__(self, tup, hash=hash):
        self[:] = tup
        self.hashvalue = hash(tup)

    def __hash__(self):
        return self.hashvalue


def _make_key(args, kw, typed=False):
    key = args
    if kw:
        kwd_mark = (object(),)
        key += kwd_mark
        for item in kw.items():
            key += item
    if typed:
        key += tuple(type(v) for v in args)
        if kw:
            key += tuple(type(v) for v in kw.values())
    elif len(key) == 1 and type(key[0]) in {int, str}:
        return key[0]
    return _HashedSeq(key)


def dumps_to_feather(df):
    columns = df.columns
    df.columns = [str(e) for e in df.columns]
    buffer = io.BytesIO()  # 创建一个内存中的字节流缓冲区
    df.to_feather(buffer)  # 将 DataFrame 序列化为 Feather 格式并存储到缓冲区
    buffer.seek(0)  # 重新定位到字节流的开头
    serialized_data = buffer.getvalue()  # 获取序列化后的二进制数据
    return {"data": serialized_data, "columns": list(columns)}


def loads_from_feather(data):
    buffer = io.BytesIO(data["data"])  # 创建一个内存中的字节流缓冲区，并加载序列化的数据
    df = pd.read_feather(buffer)  # 从 Feather 格式的序列化数据中加载 DataFrame
    df.columns = data["columns"]
    return df


def _custom_encode(obj):
    if isinstance(obj, set):
        return {b'__set__': list(obj)}  # 将 set 对象转换为字典形式
    if isinstance(obj, pd.DataFrame):
        return {b'__feather__': dumps_to_feather(obj)}
    return msgpack_numpy.encode(obj)


def _custom_decode(obj):
    if b'__set__' in obj:  # 判断是否是我们之前转换过的 set 对象
        return set(obj[b'__set__'])  # 将字典形式的 set 转换回原始的 set 对象
    if b'__feather__' in obj:
        return loads_from_feather(obj[b'__feather__'])
    return msgpack_numpy.decode(obj)  # 不需要转换的情况下直接返回原始对象


class RedisTTLCache:
    def __init__(self, host='localhost', port=6379):
        self.pool = ConnectionPool(host=host, port=port)

    def cache(self, ttl, scope=os.path.basename(__file__)):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                # 构建唯一的缓存键
                cache_key = f"FUNC_CACHE_{(scope, func.__name__, _make_key(args, kwargs))}"
                
                # 尝试从Redis中获取缓存
                redis_client = redis.Redis(connection_pool=self.pool)
                result = redis_client.get(cache_key)
                if result is not None:
                    # 如果缓存存在，直接返回结果
                    result = msgpack.loads(result, object_hook=_custom_decode)
                    return result
                
                # 如果缓存中不存在该结果，则重新计算函数结果
                result = func(*args, **kwargs)
                
                # 将计算结果存入Redis缓存
                redis_client.set(cache_key, msgpack.dumps(result, default=_custom_encode), ex=ttl)
                
                return result
            return wrapper
        return decorator


if __name__ == '__main__':
    redis_ttl_cache = RedisTTLCache(host="localhost")
    ttl_cached = redis_ttl_cache.cache

    @ttl_cached(ttl=5)
    def func(a, b):
        print("Hello world")
        return {
            'result': a + b,
            'colors': {'red', 'green', 'blue'},
            'arr': np.array([[0, 1], [2,3]]),
            'df': pd.DataFrame([[0, 1], [2,3]]),
        }

    print(func(1, 2))
    print(func(1, 2))

# -*- coding: utf-8 -*-
import openpyxl
import xlrd
import os

class Sheet:
    def cell_value(self, row, col):
        pass


class XlsxSheet(Sheet):
    def __init__(self, sheet):
        self.sheet = sheet

    def cell_value(self, row, col):
        return self.sheet.cell(row=row+1, column=col+1).value


class XlsSheet(Sheet):
    def __init__(self, sheet):
        self.sheet = sheet

    def cell_value(self, row, col):
        return self.sheet.cell_value(row, col)


class _Workbook:
    def sheet_by_index(self, index):
        pass


class XlsxFile(_Workbook):
    def __init__(self, path):
        self.workbook = openpyxl.load_workbook(path)

    def sheet_by_index(self, index):
        sheet = self.workbook[self.workbook.sheetnames[index]]
        return XlsxSheet(sheet)


class XlsFile(_Workbook):
    def __init__(self, path):
        self.workbook = xlrd.open_workbook(path)

    def sheet_by_index(self, index):
        sheet = self.workbook.sheet_by_index(index)
        return XlsSheet(sheet)


class Workbook:
    def __init__(self, path):
        filedir, filename = os.path.split(path)
        _, extname = os.path.splitext(filename)
        if extname == ".xlsx":
            self.impl = XlsxFile(path)
        elif extname == ".xls":
            self.impl = XlsFile(path)
        else:
            raise IOError("未知的文件类型")

    def sheet_by_index(self, index):
        return self.impl.sheet_by_index(index)

# -*- coding: utf-8 -*-
import threading
import time
import inspect
import ctypes
import traceback
import sys, os
from functools import wraps

class KillableThread(threading.Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._return_value = None
        self._exception = None

    def _async_raise(tid, exctype):
        """raises the exception, performs cleanup if needed"""
        tid = ctypes.c_long(tid)
        if not inspect.isclass(exctype):
            exctype = type(exctype)
        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
        if res == 0:
            raise ValueError("invalid thread id")
        elif res != 1:
            # """if it returns a number greater than one, you're in trouble,
            # and you should call it again with exc=NULL to revert the effect"""
            ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
            raise SystemError("PyThreadState_SetAsyncExc failed")

    def kill(self):
        KillableThread._async_raise(self.ident, SystemExit)

    def run(self):
        try:
            self._return_value = self._target(*self._args, **self._kwargs)
        except Exception as e:
            self._exception = e

    def join(self):
        super().join()
        if self._exception is not None:
            raise self._exception
        return self._return_value

    def join(self, timeout):
        super().join(timeout)
        if self._exception is not None:
            raise self._exception
        return self._return_value


def _get_thread(tid):
    for t in threading.enumerate():
        if t.ident == tid:
            return t
    return None


def _get_frame_stack(tid):
    for thread_id, stack in sys._current_frames().items():
        if thread_id == tid:
            return stack
    return None


def _get_formated_frame_stack(tid):
    info = []
    th = _get_thread(tid)
    stack = _get_frame_stack(tid)
    info.append('%s thread_id=%d' % (th.name, tid))
    for filename, lineno, _, line in traceback.extract_stack(stack):
        info.append('    at %s(%s:%d)' % (line, filename[filename.rfind(os.path.sep) + 1:], lineno))
    return '\n'.join(info)


def timeout(seconds):
    """
    Decorator to execute a function with a specified timeout.

    Args:
    - seconds (int): The time limit in seconds for the function to complete.

    Returns:
    - function: The decorated function.

    Raises:
    - TimeoutError: If the function does not complete within the specified time limit.

    Usage:
    @timeout(seconds=10)
    def my_function():
        # Function body
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            th = KillableThread(target=func, args=args, kwargs=kwargs)
            th.daemon = True
            th.start()
            ret = th.join(seconds)
            if th.is_alive():
                formated_frame_stack = _get_formated_frame_stack(th.ident)
                th.kill()
                raise TimeoutError(f"{repr(func)} timeout. Frame stack:\n{formated_frame_stack}")
            return ret
        return wrapper
    return decorator


def retry(retries=1, retry_interval=0):
    """
    Decorator to retry a function a specified number of times with a given interval between retries.

    Args:
    - retries (int): The number of times the function should be retried if it raises an exception. If set to 1, the function will be attempted initially and retried once.
    - retry_interval (int): The time interval in seconds to wait between retries.

    Returns:
    - function: The decorated function.

    Raises:
    - The original exception raised by the function if all retries fail.

    Usage:
    @retry(retries=2, retry_interval=2)
    def my_function():
        # Function body
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(retries+1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if i < retries:
                        time.sleep(retry_interval)
                    else:
                        raise e
        return wrapper
    return decorator

# -*- coding: utf-8 -*-
import logging, os, sys, time, re
from stat import ST_MTIME
from logging.handlers import BaseRotatingHandler, _MIDNIGHT
# logging.basicConfig(format='%(asctime)s %(levelname)s [%(filename)s->%(funcName)s:%(lineno)d]\t%(message)s',
#                     level=logging.DEBUG)


class TimedRotatingFileHandler(BaseRotatingHandler):
    """
    Handler for logging to a file, rotating the log file at certain timed
    intervals.

    If backupCount is > 0, when rollover is done, no more than backupCount
    files are kept - the oldest ones are deleted.
    """
    def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None):
        BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
        self.when = when.upper()
        self.backupCount = backupCount
        self.utc = utc
        self.atTime = atTime
        # Calculate the real rollover interval, which is just the number of
        # seconds between rollovers.  Also set the filename suffix used when
        # a rollover occurs.  Current 'when' events supported:
        # S - Seconds
        # M - Minutes
        # H - Hours
        # D - Days
        # midnight - roll over at midnight
        # W{0-6} - roll over on a certain day; 0 - Monday
        #
        # Case of the 'when' specifier is not important; lower or upper case
        # will work.
        if self.when == 'S':
            self.interval = 1 # one second
            self.suffix = "%Y-%m-%d_%H-%M-%S"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'M':
            self.interval = 60 # one minute
            self.suffix = "%Y-%m-%d_%H-%M"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'H':
            self.interval = 60 * 60 # one hour
            self.suffix = "%Y-%m-%d_%H"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$"
        elif self.when == 'D' or self.when == 'MIDNIGHT':
            self.interval = 60 * 60 * 24 # one day
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when.startswith('W'):
            self.interval = 60 * 60 * 24 * 7 # one week
            if len(self.when) != 2:
                raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
            if self.when[1] < '0' or self.when[1] > '6':
                raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
            self.dayOfWeek = int(self.when[1])
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        else:
            raise ValueError("Invalid rollover interval specified: %s" % self.when)

        self.extMatch = re.compile(self.extMatch, re.ASCII)
        self.interval = self.interval * interval # multiply by units requested
        # The following line added because the filename passed in could be a
        # path object (see Issue #27493), but self.baseFilename will be a string
        filename = self.baseFilename
        if os.path.exists(filename):
            t = os.stat(filename)[ST_MTIME]
        else:
            t = int(time.time())
        self.rolloverAt = self.computeRollover(t)

    def computeRollover(self, currentTime):
        """
        Work out the rollover time based on the specified time.
        """
        result = currentTime + self.interval
        # If we are rolling over at midnight or weekly, then the interval is already known.
        # What we need to figure out is WHEN the next interval is.  In other words,
        # if you are rolling over at midnight, then your base interval is 1 day,
        # but you want to start that one day clock at midnight, not now.  So, we
        # have to fudge the rolloverAt value in order to trigger the first rollover
        # at the right time.  After that, the regular interval will take care of
        # the rest.  Note that this code doesn't care about leap seconds. :)
        if self.when == 'MIDNIGHT' or self.when.startswith('W'):
            # This could be done with less code, but I wanted it to be clear
            if self.utc:
                t = time.gmtime(currentTime)
            else:
                t = time.localtime(currentTime)
            currentHour = t[3]
            currentMinute = t[4]
            currentSecond = t[5]
            currentDay = t[6]
            # r is the number of seconds left between now and the next rotation
            if self.atTime is None:
                rotate_ts = _MIDNIGHT
            else:
                rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
                    self.atTime.second)

            r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +
                currentSecond)
            if r < 0:
                # Rotate time is before the current time (for example when
                # self.rotateAt is 13:45 and it now 14:15), rotation is
                # tomorrow.
                r += _MIDNIGHT
                currentDay = (currentDay + 1) % 7
            result = currentTime + r
            # If we are rolling over on a certain day, add in the number of days until
            # the next rollover, but offset by 1 since we just calculated the time
            # until the next day starts.  There are three cases:
            # Case 1) The day to rollover is today; in this case, do nothing
            # Case 2) The day to rollover is further in the interval (i.e., today is
            #         day 2 (Wednesday) and rollover is on day 6 (Sunday).  Days to
            #         next rollover is simply 6 - 2 - 1, or 3.
            # Case 3) The day to rollover is behind us in the interval (i.e., today
            #         is day 5 (Saturday) and rollover is on day 3 (Thursday).
            #         Days to rollover is 6 - 5 + 3, or 4.  In this case, it's the
            #         number of days left in the current week (1) plus the number
            #         of days in the next week until the rollover day (3).
            # The calculations described in 2) and 3) above need to have a day added.
            # This is because the above time calculation takes us to midnight on this
            # day, i.e. the start of the next day.
            if self.when.startswith('W'):
                day = currentDay # 0 is Monday
                if day != self.dayOfWeek:
                    if day < self.dayOfWeek:
                        daysToWait = self.dayOfWeek - day
                    else:
                        daysToWait = 6 - day + self.dayOfWeek + 1
                    newRolloverAt = result + (daysToWait * (60 * 60 * 24))
                    if not self.utc:
                        dstNow = t[-1]
                        dstAtRollover = time.localtime(newRolloverAt)[-1]
                        if dstNow != dstAtRollover:
                            if not dstNow:  # DST kicks in before next rollover, so we need to deduct an hour
                                addend = -3600
                            else:           # DST bows out before next rollover, so we need to add an hour
                                addend = 3600
                            newRolloverAt += addend
                    result = newRolloverAt
        return result

    def shouldRollover(self, record):
        """
        Determine if rollover should occur.

        record is not used, as we are just comparing times, but it is needed so
        the method signatures are the same
        """
        t = int(time.time())
        if t >= self.rolloverAt:
            return 1
        return 0

    def getFilesToDelete(self):
        """
        Determine the files to delete when rolling over.

        More specific than the earlier method, which just used glob.glob().
        """
        dirName, baseName = os.path.split(self.baseFilename)
        fileNames = os.listdir(dirName)
        result = []
        prefix = baseName + "."
        plen = len(prefix)
        for fileName in fileNames:
            if fileName[:plen] == prefix:
                suffix = fileName[plen:]
                if self.extMatch.match(suffix):
                    result.append(os.path.join(dirName, fileName))
        if len(result) < self.backupCount:
            result = []
        else:
            result.sort()
            result = result[:len(result) - self.backupCount]
        return result

    def doRollover(self):
        """
        do a rollover; in this case, a date/time stamp is appended to the filename
        when the rollover happens.  However, you want the file to be named for the
        start of the interval, not the current time.  If there is a backup count,
        then we have to get a list of matching filenames, sort them and remove
        the one with the oldest suffix.
        """
        if self.stream:
            self.stream.close()
            self.stream = None
        # get the time that this sequence started at and make it a TimeTuple
        currentTime = int(time.time())
        dstNow = time.localtime(currentTime)[-1]
        t = self.rolloverAt - self.interval
        if self.utc:
            timeTuple = time.gmtime(t)
        else:
            timeTuple = time.localtime(t)
            dstThen = timeTuple[-1]
            if dstNow != dstThen:
                if dstNow:
                    addend = 3600
                else:
                    addend = -3600
                timeTuple = time.localtime(t + addend)
        dfn = self.rotation_filename(self.baseFilename + "." +
                                     time.strftime(self.suffix, timeTuple))

        # 修正多进程时日志前一天的日志可能在滚动时被误删
        if os.path.exists(dfn):
            ori_dfn = dfn
            i = 1
            while os.path.exists(dfn):
                i += 1
                dfn = f"{ori_dfn}.{i}"
            
        self.rotate(self.baseFilename, dfn)
        if self.backupCount > 0:
            for s in self.getFilesToDelete():
                os.remove(s)
        if not self.delay:
            self.stream = self._open()
        newRolloverAt = self.computeRollover(currentTime)
        while newRolloverAt <= currentTime:
            newRolloverAt = newRolloverAt + self.interval
        #If DST changes and midnight or weekly rollover, adjust for this.
        if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc:
            dstAtRollover = time.localtime(newRolloverAt)[-1]
            if dstNow != dstAtRollover:
                if not dstNow:  # DST kicks in before next rollover, so we need to deduct an hour
                    addend = -3600
                else:           # DST bows out before next rollover, so we need to add an hour
                    addend = 3600
                newRolloverAt += addend
        self.rolloverAt = newRolloverAt

# name 用于支持同时输出多个日志文件，如果仅需要一个文件则可以忽略此参数，保持为'main'即可
# echo 表示需要回显到控制台
# filedir 自定义日志文件目录，默认为当前目录
# filename 自定义日志的文件名，为None或False时不输出到文件，为True时自动根据脚本名生成文件名
# level 定义日志输出的过滤等级，表示需要输出的最低等级，指定为INFO则DEBUG级别的日志不会输出
# fmt 配置每行日志的格式，None表示使用默认的格式，详见logging模块的文档
# backupCount 默认为7，日志按天切割保留最近7天的日志，如果指定为None表示不按天切割
def init_logger(name="main", echo=True, filedir=None, filename=None, level=None, fmt=None, backupCount=7):
    fmt = fmt or '%(asctime)s %(levelname)s [%(filename)s->%(funcName)s:%(lineno)d]\t%(message)s'
    formatter = logging.Formatter(fmt) #设置日志格式
    logger = logging.getLogger(name)
    if level:
        if level == "DEBUG" or level == logging.DEBUG:
            logger.setLevel(level = logging.DEBUG)
        elif level == "INFO" or level == logging.INFO:
            logger.setLevel(level = logging.INFO)
        elif level == "WARN" or level == "WARNING" or level == logging.WARN:
            logger.setLevel(level = logging.WARN)
        elif level == "FATAL" or level == logging.FATAL:
            logger.setLevel(level = logging.FATAL)
        else:
            logger.setLevel(level = level)
    if not logger.hasHandlers():
        if echo:
            console_handler = logging.StreamHandler() # 控制台Handler
            console_handler.setFormatter(formatter)
            console_handler.setLevel(logging.DEBUG)
            # if logger.hasHandlers()
            logger.addHandler(console_handler)
        if filename:
            if type(filename) == bool and filename:
                filename = get_logfile_name()
                if filedir is not None:
                    _, filename = os.path.split(filename)
                    filename = os.path.join(filedir, filename)
            else:
                if filedir is not None:
                    filename = os.path.join(filedir, filename)

            filedir, _ = os.path.split(filename)
            if filedir and not os.path.exists(filedir):
                os.makedirs(filedir)
            
            if backupCount:
                file_handler = TimedRotatingFileHandler(filename=filename, when='MIDNIGHT', interval=1, backupCount=backupCount, encoding='utf-8')
            else:
                file_handler = logging.FileHandler(filename=filename, encoding='utf-8')
            file_handler.setFormatter(formatter)
            file_handler.setLevel(logging.DEBUG)
            logger.addHandler(file_handler)
        logger.info(f"logger({name or ''}) initialized. [level] {level} [format] {fmt} [filename] {filename}")
    return logger


def get_logger(name=None):
    return logging.getLogger(name)


def get_logfile_name():
    path, filename = os.path.split(sys.argv[0])
    name, ext = os.path.splitext(filename)
    return os.path.join(path, f"{name}.log")


logger = get_logger(name="main")

from utils.logger import logger, init_logger

if __name__ == '__main__':
    init_logger(level="INFO", echo=True, filename=True, filedir="logs")

    logger.debug("test")
    logger.info("test")
    logger.warning("test")

# -*- coding: utf-8 -*-
import multiprocessing
import queue
import threading


def call_helper(func, common_data, respective_data):
    args = []
    kw = {}
    if common_data:
        assert(isinstance(common_data, list) or isinstance(common_data, tuple) or isinstance(common_data, dict))
        if isinstance(common_data, list) or isinstance(common_data, tuple):
            args += common_data
        elif isinstance(common_data, dict):
            kw.update(common_data)
    if respective_data:
        assert(isinstance(respective_data, list) or isinstance(respective_data, tuple) or isinstance(respective_data, dict))
        if isinstance(respective_data, list) or isinstance(respective_data, tuple):
            args += respective_data
        else:
            kw.update(respective_data)
    return func(*args, **kw)


def _func(func, common_data, queue_in, queue_out):
    while True:
        try:
            (i, respective_data) = queue_in.get(False)
            r = call_helper(func, common_data, respective_data)
            if r is not None:
                queue_out.put((i, r))
        except queue.Empty as e:
            break

"""
用多进程执行func函数
Args:
    process_num: 并发的进程数量
    func: 回调函数，任务的函数体，需要接收通过common_data和respective_data_list传递的参数
    common_data: 所有func共用的数据，应为list/tuple/dict类型之一或None，为dict类型时作为具名参数传递
    respective_data_list: 每个func各自的数据，应为list/tuple/dict类型的list，为dict类型的list时作为具名参数传递

Returns:
    list: func返回值的列表，长度等于len(respective_data_list)，顺序和respective_data_list中的参数顺序保持一致
"""
def multi_process(process_num, func, common_data, respective_data_list):
    manager = multiprocessing.Manager()
    queue_in = manager.Queue()
    for i, e in enumerate(respective_data_list):
        queue_in.put((i,e))
    queue_out = manager.Queue()
    processes = []
    for i in range(0, process_num):
        proc = multiprocessing.Process(target=_func, args=(func, common_data, queue_in, queue_out))
        processes.append(proc)
    for proc in processes:
        proc.start()
    for proc in processes:
        proc.join()
    if not queue_out.empty():
        ret = [None] * len(respective_data_list)
        while True:
            try:
                (i, ret_value) = queue_out.get(False)
                ret[i] = ret_value
            except queue.Empty as e:
                break
        return ret

"""
用多线程执行func函数
Args:
    thread_num: 并发的线程数量
    func: 回调函数，任务的函数体，需要接收通过common_data和respective_data_list传递的参数
    common_data: 所有func共用的数据，应为list/tuple/dict类型之一或None，为dict类型时作为具名参数传递
    respective_data_list: 每个func各自的数据，应为list/tuple/dict类型的list，为dict类型的list时作为具名参数传递

Returns:
    list: func返回值的列表，长度等于len(respective_data_list)，顺序和respective_data_list中的参数顺序保持一致
"""
def multi_thread(thread_num, func, common_data, respective_data_list):
    queue_in = queue.Queue()
    for i, e in enumerate(respective_data_list):
        queue_in.put((i,e))
    queue_out = queue.Queue()
    threads = []
    for i in range(0, thread_num):
        thread = threading.Thread(target=_func, args=(func, common_data, queue_in, queue_out))
        threads.append(thread)
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    if not queue_out.empty():
        ret = [None] * len(respective_data_list)
        while True:
            try:
                (i, ret_value) = queue_out.get(False)
                ret[i] = ret_value
            except queue.Empty as e:
                break
        return ret

 
"""
用单线程执行func函数
Args:
    _dummy_num: 无用的参数，仅为了和其他同类函数统一调用格式
    func: 回调函数，任务的函数体，需要接收通过common_data和respective_data_list传递的参数
    common_data: 所有func共用的数据，应为list/tuple/dict类型之一或None，为dict类型时作为具名参数传递
    respective_data_list: 每个func各自的数据，应为list/tuple/dict类型的list，为dict类型的list时作为具名参数传递

Returns:
    list: func返回值的列表，长度等于len(respective_data_list)，顺序和respective_data_list中的参数顺序保持一致
"""
def single_thread(_dummy_num, func, common_data, respective_data_list):
    ret = []
    for i, respective_data in enumerate(respective_data_list):
        r = call_helper(func, common_data, respective_data)
        if r is not None:
            if not ret:
                ret = [None] * len(respective_data_list)
            ret[i] = r
    return ret