一个可控的生成器流处理系统

# -*- coding: utf-8 -*-
# 实现一个可控的生成器流处理系统，核心目标是提供对生成器执行的动态控制能力（暂停、恢复、停止）
import time
class Test:
    def __init__(self,size:str):
        self.size = size
        pass
    
    def put(self, callback = None):
        while True:
            if callback:
                callback(self.size,time.ctime())
            time.sleep(0.5)

def call_back(*args,**kwargs):
    print('回调数据',args,kwargs)
# test = Test('big')
# test.put(call_back)
import threading
import copy
class StreamController:
    def __init__(self, generator = None):
        self.event = threading.Event()
        self.set()
        self.is_close = False
        self.generator = generator
    
    def wait(self):
        self.event.wait()
    
    # 恢复
    def set(self):
        self.event.set()
    
    # 暂停 
    def clear(self):
        self.event.clear()
    
    # 流程彻底关闭，执行完毕
    def close(self):
        self.is_close = True # 保证能运行到close处
        self.set()

    def controlled_iter(self):
        for _ in self.generator:
            if not self.event.is_set():
                self.event.wait()
            if self.is_close:
                return
class StreamTest(StreamController):
    def __init__(self, call_fun = None):
        self.call_fun = call_fun
        super().__init__(generator = self.transmission_task())
        self.now_count = None
        
    def transmission_task(self):
        count = 1
        while True:
            count += 1
            if self.call_fun:
                self.call_fun(count)
            self.now_count = count
            print(count)
            yield count
            time.sleep(0.5)
            if count == 100:
                return

stream = StreamTest(call_fun=call_back)
t = threading.Thread(target=stream.controlled_iter)
t.start()
time.sleep(2)
print('暂停')
stream.clear()
time.sleep(2)
print('恢复')
stream.set()
time.sleep(2)
print('停止')
stream.close()