funboost 44.1__py3-none-any.whl → 44.3__py3-none-any.whl

funboost/consumers/redis_consumer_priority.py

@@ -60,11 +60,9 @@ class RedisPriorityConsumer(RedisConsumerAckAble):
             if task_tuple:
                 msg = task_tuple[1]
                 self.redis_db_frame.zadd(self._unack_zset_name, {msg: time.time()})
-                self.logger.debug(task_tuple)
-                self._print_message_get_from_broker('redis', msg)
+                # self.logger.debug(task_tuple)
                 # self.logger.debug(f'从redis的 [{self._queue_name}] 队列中 取出的消息是：  {task_str_list}  ')
-                task_dict = json.loads(msg)
-                kw = {'body': task_dict, 'task_str': msg}
+                kw = {'body': msg, 'task_str': msg}
                 self._submit_task(kw)
 
     def _shedual_task(self):
@@ -87,10 +85,8 @@ class RedisPriorityConsumer(RedisConsumerAckAble):
                 except redis5.WatchError:
                     continue
             if task_tuple:
-                self._print_message_get_from_broker('redis', msg)
                 # self.logger.debug(f'从redis的 [{self._queue_name}] 队列中 取出的消息是：  {task_str_list}  ')
-                task_dict = json.loads(msg)
-                kw = {'body': task_dict, 'task_str': msg}
+                kw = {'body': msg, 'task_str': msg}
                 self._submit_task(kw)
 
     def _requeue(self, kw):

funboost/consumers/redis_consumer_simple.py

@@ -17,9 +17,8 @@ class RedisConsumer(AbstractConsumer, RedisMixin):
         while True:
             result = self.redis_db_frame.blpop(self._queue_name,timeout=60)
             if result:
-                self._print_message_get_from_broker('redis',result[1])
-                task_dict = json.loads(result[1])
-                kw = {'body': task_dict}
+
+                kw = {'body': result[1]}
                 self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/consumers/redis_pubsub_consumer.py

@@ -18,8 +18,8 @@ class RedisPbSubConsumer(AbstractConsumer, RedisMixin):
         pub.subscribe(self.queue_name)
         for item in pub.listen():
             if item['type'] == 'message':
-                self._print_message_get_from_broker('reids', item['data'])
-                kw = {'body': json.loads(item['data'])}
+
+                kw = {'body': item['data']}
                 self._submit_task(kw)
 
     def _shedual_task(self):
@@ -29,7 +29,7 @@ class RedisPbSubConsumer(AbstractConsumer, RedisMixin):
         while True:  # 无限循环
             msg_list = pub.parse_response(timeout=60)  # 得到消息内容
             if msg_list:
-                kw = {'body': json.loads(msg_list[2])}
+                kw = {'body': msg_list[2]}
                 self._submit_task(kw)
 
 

funboost/consumers/redis_stream_consumer.py

@@ -44,10 +44,10 @@ class RedisStreamConsumer(AbstractConsumer, RedisMixin):
                                                               {self.queue_name: ">"}, count=100, block=60 * 1000)
             if results:
                 # self.logger.debug(f'从redis的 [{self._queue_name}] stream 中 取出的消息是：  {results}  ')
-                self._print_message_get_from_broker('redis', results)
+                self._print_message_get_from_broker( results)
                 # print(results[0][1])
                 for msg_id, msg in results[0][1]:
-                    kw = {'body': json.loads(msg['']), 'msg_id': msg_id}
+                    kw = {'body': msg[''], 'msg_id': msg_id}
                     self._submit_task(kw)
 
     def _confirm_consume(self, kw):
@@ -91,5 +91,5 @@ class RedisStreamConsumer(AbstractConsumer, RedisMixin):
                                 self.logger.warning(f' {self._queue_name}  的分组 {self.group} 的消费者 {self.consumer_identification} 夺取 断开的消费者 {xinfo_item["name"]}'
                                                     f'  {len(xclaim_task_list)} 个任务，详细是 {xclaim_task_list} ')
                                 for task in xclaim_task_list:
-                                    kw = {'body': json.loads(task[1]['']), 'msg_id': task[0]}
+                                    kw = {'body': task[1][''], 'msg_id': task[0]}
                                     self._submit_task(kw)

funboost/consumers/rocketmq_consumer.py

@@ -31,8 +31,8 @@ class RocketmqConsumer(AbstractConsumer):
 
         def callback(rocketmq_msg):
             # self.logger.debug(f'从rocketmq的 [{self._queue_name}] 主题的queue_id {rocketmq_msg.queue_id} 中 取出的消息是：{rocketmq_msg.body}')
-            self._print_message_get_from_broker('rocketmq', rocketmq_msg.body)
-            kw = {'body': json.loads(rocketmq_msg.body), 'rocketmq_msg': rocketmq_msg}
+
+            kw = {'body': rocketmq_msg.body, 'rocketmq_msg': rocketmq_msg}
             self._submit_task(kw)
 
         consumer.subscribe(self._queue_name, callback)

funboost/consumers/sqlachemy_consumer.py

@@ -20,7 +20,7 @@ class SqlachemyConsumer(AbstractConsumer):
             sqla_task_dict = self.queue.get()
             # self.logger.debug(f'从数据库 {frame_config.SQLACHEMY_ENGINE_URL[:25]}。。 的 [{self._queue_name}] 队列中 取出的消息是：   消息是：  {sqla_task_dict}')
             self._print_message_get_from_broker(f'从数据库 {BrokerConnConfig.SQLACHEMY_ENGINE_URL[:25]}', sqla_task_dict)
-            kw = {'body': json.loads(sqla_task_dict['body']), 'sqla_task_dict': sqla_task_dict}
+            kw = {'body': sqla_task_dict['body'], 'sqla_task_dict': sqla_task_dict}
             self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/consumers/tcp_consumer.py

@@ -42,10 +42,10 @@ class TCPConsumer(AbstractConsumer, ):
                 # print('server收到的数据', data)
                 if not data:
                     break
-                self._print_message_get_from_broker(f'udp {self._ip_port_raw}', data.decode())
+                # self._print_message_get_from_broker(f'udp {self._ip_port_raw}', data.decode())
                 tcp_cli_sock.send('has_recived'.encode())
                 # tcp_cli_sock.close()
-                kw = {'body': json.loads(data)}
+                kw = {'body': data}
                 self._submit_task(kw)
             tcp_cli_sock.close()
         except ConnectionResetError:

funboost/consumers/txt_file_consumer.py

@@ -22,8 +22,8 @@ class TxtFileConsumer(AbstractConsumer, ):
         while True:
             with file_lock:
                 item = queue.get()
-                self._print_message_get_from_broker('txt文件', item)
-                kw = {'body': json.loads(item), 'q': queue, 'item': item}
+
+                kw = {'body': item, 'q': queue, 'item': item}
                 self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/consumers/udp_consumer.py

@@ -31,9 +31,9 @@ class UDPConsumer(AbstractConsumer, ):
         while True:
             data, client_addr = server.recvfrom(self.BUFSIZE)
             # print('server收到的数据', data)
-            self._print_message_get_from_broker(f'udp {ip_port}', data.decode())
+            # self._print_message_get_from_broker(f'udp {ip_port}', data.decode())
             server.sendto('has_recived'.encode(), client_addr)
-            kw = {'body': json.loads(data)}
+            kw = {'body': data}
             self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/consumers/zeromq_consumer.py

@@ -4,10 +4,11 @@ import os
 import socket
 import json
 # import time
-import zmq
+# import zmq
 import multiprocessing
 from funboost.constant import BrokerEnum
 from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.lazy_impoter import ZmqImporter
 # from nb_log import get_logger
 from funboost.core.loggers import get_funboost_file_logger
 
@@ -32,17 +33,17 @@ logger_zeromq_broker = get_funboost_file_logger('zeromq_broker')
 # noinspection PyUnresolvedReferences
 def start_broker(port_router: int, port_dealer: int):
     try:
-        context = zmq.Context()
+        context = ZmqImporter().zmq.Context()
         # noinspection PyUnresolvedReferences
-        frontend = context.socket(zmq.ROUTER)
-        backend = context.socket(zmq.DEALER)
+        frontend = context.socket(ZmqImporter().zmq.ROUTER)
+        backend = context.socket(ZmqImporter().zmq.DEALER)
         frontend.bind(f"tcp://*:{port_router}")
         backend.bind(f"tcp://*:{port_dealer}")
 
         # Initialize poll set
-        poller = zmq.Poller()
-        poller.register(frontend, zmq.POLLIN)
-        poller.register(backend, zmq.POLLIN)
+        poller = ZmqImporter().zmq.Poller()
+        poller.register(frontend, ZmqImporter().zmq.POLLIN)
+        poller.register(backend, ZmqImporter().zmq.POLLIN)
         logger_zeromq_broker.info(f'broker 绑定端口  {port_router}   {port_dealer}  成功')
 
         # Switch messages between sockets
@@ -50,11 +51,11 @@ def start_broker(port_router: int, port_dealer: int):
         while True:
             socks = dict(poller.poll())  # 轮询器 循环接收
 
-            if socks.get(frontend) == zmq.POLLIN:
+            if socks.get(frontend) == ZmqImporter().zmq.POLLIN:
                 message = frontend.recv_multipart()
                 backend.send_multipart(message)
 
-            if socks.get(backend) == zmq.POLLIN:
+            if socks.get(backend) == ZmqImporter().zmq.POLLIN:
                 message = backend.recv_multipart()
                 frontend.send_multipart(message)
     except BaseException as e:
@@ -87,16 +88,15 @@ class ZeroMqConsumer(AbstractConsumer):
     # noinspection DuplicatedCode
     def _shedual_task(self):
         self.start_broker_queue_name_as_port()
-        context = zmq.Context()
+        context = ZmqImporter().zmq.Context()
         # noinspection PyUnresolvedReferences
-        zsocket = context.socket(zmq.REP)
+        zsocket = context.socket(ZmqImporter().zmq.REP)
         zsocket.connect(f"tcp://localhost:{int(self._queue_name) + 1}")
 
         while True:
             message = zsocket.recv()
             # self.logger.debug(f""" 从 zeromq 取出的消息是 {message}""")
-            self._print_message_get_from_broker('zeromq', message)
-            self._submit_task({'body': json.loads(message)})
+            self._submit_task({'body': message})
             zsocket.send('recv ok'.encode())
 
     def _confirm_consume(self, kw):

funboost/core/cli/discovery_boosters.py

@@ -7,7 +7,7 @@ import importlib.util
 # import nb_log
 from funboost.core.loggers import FunboostFileLoggerMixin
 from funboost.utils.decorators import flyweight
-from funboost.core.lazy_impoter import lazy_impoter
+from funboost.core.lazy_impoter import funboost_lazy_impoter
 
 @flyweight
 class BoosterDiscovery(FunboostFileLoggerMixin):
@@ -68,7 +68,7 @@ class BoosterDiscovery(FunboostFileLoggerMixin):
                 spec = importlib.util.spec_from_file_location(module_name, file_path)
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)
-        lazy_impoter.BoostersManager.show_all_boosters()
+        funboost_lazy_impoter.BoostersManager.show_all_boosters()
 
 
 if __name__ == '__main__':

funboost/core/funboost_config_getter.py

@@ -0,0 +1,7 @@
+def _try_get_user_funboost_common_config(funboost_common_conf_field:str):
+    try:
+        import funboost_config  # 第一次启动funboost前还没这个文件,或者还没有初始化配置之前,就要使用使用配置.
+        return getattr(funboost_config.FunboostCommonConfig,funboost_common_conf_field)
+    except Exception as e:
+        print(e)
+        return None

funboost/core/funboost_time.py

@@ -0,0 +1,28 @@
+import pytz
+import time
+
+import datetime
+
+import typing
+
+from nb_time import NbTime
+from funboost.funboost_config_deafult import FunboostCommonConfig
+
+class FunboostTime(NbTime):
+    default_formatter = NbTime.FORMATTER_DATETIME_NO_ZONE
+    def get_time_zone_str(self,time_zone: typing.Union[str, datetime.tzinfo,None] = None):
+        return time_zone or self.default_time_zone or  FunboostCommonConfig.TIMEZONE  or self.get_localzone_name()
+
+
+
+if __name__ == '__main__':
+    print(NbTime())
+    for i in range(100000):
+        # print(generate_publish_time())
+        # print(generate_publish_time_format())
+        # generate_publish_time()
+        # generate_publish_time_format()
+
+        datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).strftime(NbTime.FORMATTER_DATETIME_NO_ZONE)
+        datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).timestamp()
+    print(NbTime())

funboost/core/helper_funs.py

@@ -2,6 +2,8 @@ import copy
 import time
 import uuid
 
+from funboost.core.funboost_time import FunboostTime
+
 
 def get_publish_time(paramsx: dict):
     """
@@ -37,13 +39,23 @@ def block_python_main_thread_exit():
 run_forever = block_python_main_thread_exit
 
 
-def _try_get_user_funboost_common_config(funboost_common_conf_field:str):
-    try:
-        import funboost_config  # 第一次启动funboost前还没这个文件,或者还没有初始化配置之前,就要使用使用配置.
-        return getattr(funboost_config.FunboostCommonConfig,funboost_common_conf_field)
-    except Exception as e:
-        print(e)
-        return None
+class MsgGenerater:
+    @staticmethod
+    def generate_task_id(queue_name:str) -> str:
+        return f'{queue_name}_result:{uuid.uuid4()}'
+
+    @staticmethod
+    def generate_publish_time() -> float:
+        return round(FunboostTime().timestamp,4)
+
+    @staticmethod
+    def generate_publish_time_format() -> str:
+        return FunboostTime().get_str()
+
+    @classmethod
+    def generate_pulish_time_and_task_id(cls,queue_name:str,task_id=None):
+        extra_params = {'task_id': task_id or cls.generate_task_id(queue_name), 'publish_time': cls.generate_publish_time(),
+                        'publish_time_format': cls.generate_publish_time_format()}
+        return extra_params
+
 
-def generate_task_id(queue_name:str):
-    return f'{queue_name}_result:{uuid.uuid4()}'

funboost/core/lazy_impoter.py

@@ -1,11 +1,14 @@
 import abc
 
-from funboost.utils.decorators import cached_method_result, singleton, SingletonBaseNew, SingletonBaseCustomInit
+from funboost.utils.decorators import cached_method_result, singleton, SingletonBaseNew, SingletonBaseCustomInit, singleton_no_lock
 
+"""
+延迟导入
+或者使用时候再pip安装
+"""
 
-# @singleton   # 不方便代码补全
 
-class LazyImpoter(SingletonBaseNew):
+class FunboostLazyImpoter(SingletonBaseNew):
     """
     延迟导入,避免需要互相导入.
     """
@@ -23,7 +26,7 @@ class LazyImpoter(SingletonBaseNew):
     #     return get_current_taskid
 
 
-lazy_impoter = LazyImpoter()
+funboost_lazy_impoter = FunboostLazyImpoter()
 
 
 # noinspection SpellCheckingInspection
@@ -37,34 +40,19 @@ class GeventImporter:
     from gevent.queue import JoinableQueue
     """
 
-    @property
-    @cached_method_result
-    def gevent(self):
+    def __init__(self):
         import gevent
         print('导入gevent')
-        return gevent
-
-    @property
-    @cached_method_result
-    def gevent_pool(self):
         from gevent import pool as gevent_pool
-        return gevent_pool
-
-    @property
-    @cached_method_result
-    def monkey(self):
         from gevent import monkey
-        print('导入gevent')
-        return monkey
-
-    @property
-    @cached_method_result
-    def JoinableQueue(self):
         from gevent.queue import JoinableQueue
-        return JoinableQueue
+        self.gevent = gevent
+        self.gevent_pool = gevent_pool
+        self.monkey = monkey
+        self.JoinableQueue = JoinableQueue
 
 
-@singleton
+@singleton_no_lock
 class EventletImporter:
     """
     避免提前导入
@@ -79,23 +67,110 @@ class EventletImporter:
         self.patcher = patcher
         self.Timeout = Timeout
 
-@singleton
+
+@singleton_no_lock
 class PeeweeImporter:
     def __init__(self):
-        '''pip install peewee == 3.17'''
+        """pip install peewee == 3.17"""
         from peewee import ModelSelect, Model, BigAutoField, CharField, DateTimeField, MySQLDatabase
         from playhouse.shortcuts import model_to_dict, dict_to_model
         self.ModelSelect = ModelSelect
         self.Model = Model
         self.BigAutoField = BigAutoField
         self.CharField = CharField
-        self.DateTimeField =DateTimeField
+        self.DateTimeField = DateTimeField
         self.MySQLDatabase = MySQLDatabase
         self.model_to_dict = model_to_dict
-        self.dict_to_model =dict_to_model
+        self.dict_to_model = dict_to_model
+
+
+@singleton_no_lock
+class AioHttpImporter:
+
+    def __init__(self):
+        """pip install aiohttp==3.8.3"""
+        from aiohttp import web
+        from aiohttp.web_request import Request
+        self.web = web
+        self.Request = Request
+
+
+@singleton_no_lock
+class NatsImporter:
+    def __init__(self):
+        """pip install nats-python """
+        from pynats import NATSClient, NATSMessage
+        self.NATSClient = NATSClient
+        self.NATSMessage = NATSMessage
+
+
+@singleton_no_lock
+class GnsqImporter:
+    def __init__(self):
+        """pip install  gnsq==1.0.1"""
+        from gnsq import Consumer, Message
+        from gnsq import Producer, NsqdHTTPClient
+        from gnsq.errors import NSQHttpError
+        self.Consumer = Consumer
+        self.Message = Message
+        self.Producer = Producer
+        self.NsqdHTTPClient = NsqdHTTPClient
+        self.NSQHttpError = NSQHttpError
+
+
+@singleton_no_lock
+class ElasticsearchImporter:
+    def __init__(self):
+        """pip install elasticsearch """
+        from elasticsearch import helpers
+        self.helpers = helpers
+
+
+@singleton_no_lock
+class PsutilImporter:
+    def __init__(self):
+        """pip install  psutil"""
+        import psutil
+        self.psutil = psutil
+
+
+@singleton_no_lock
+class PahoMqttImporter:
+    def __init__(self):
+        """pip install paho-mqtt"""
+        import paho.mqtt.client as mqtt
+        self.mqtt = mqtt
+
+
+@singleton_no_lock
+class ZmqImporter:
+    def __init__(self):
+        """pip install zmq pyzmq"""
+        import zmq
+        self.zmq = zmq
+
+
+@singleton_no_lock
+class KafkaPythonImporter:
+    def __init__(self):
+        """pip install kafka-python==2.0.2"""
+
+        from kafka import KafkaConsumer as OfficialKafkaConsumer, KafkaProducer, KafkaAdminClient
+        from kafka.admin import NewTopic
+        from kafka.errors import TopicAlreadyExistsError
+
+        self.OfficialKafkaConsumer = OfficialKafkaConsumer
+        self.KafkaProducer = KafkaProducer
+        self.KafkaAdminClient = KafkaAdminClient
+        self.NewTopic = NewTopic
+        self.TopicAlreadyExistsError = TopicAlreadyExistsError
+
 
 if __name__ == '__main__':
-    for i in range(10000):
-        # lazy_impoter.BoostersManager
-        EventletImporter().greenpool
-        GeventImporter().JoinableQueue
+    print()
+    for i in range(10000000):
+        # funboost_lazy_impoter.BoostersManager
+        # EventletImporter().greenpool
+        # GeventImporter().JoinableQueue
+        ZmqImporter().zmq
+    print()

funboost/core/loggers.py

@@ -1,5 +1,5 @@
 import nb_log
-from funboost.core.helper_funs import _try_get_user_funboost_common_config
+from funboost.core.funboost_config_getter import _try_get_user_funboost_common_config
 
 # noinspection PyUnresolvedReferences
 from nb_log import get_logger, LoggerLevelSetterMixin, nb_log_config_default

funboost/core/muliti_process_enhance.py

@@ -7,11 +7,11 @@ from concurrent.futures import ProcessPoolExecutor
 from funboost.core.booster import Booster
 from funboost.core.helper_funs import run_forever
 from funboost.core.loggers import flogger
-from funboost.core.lazy_impoter import lazy_impoter
+from funboost.core.lazy_impoter import funboost_lazy_impoter
 
 
 def _run_consumer_in_new_process(queue_name, ):
-    booster_current_pid = lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
+    booster_current_pid = funboost_lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
     # booster_current_pid = boost(**boost_params)(consuming_function)
     booster_current_pid.consume()
     # ConsumersManager.join_all_consumer_shedual_task_thread()
@@ -49,7 +49,7 @@ def run_consumer_with_multi_process(booster: Booster, process_num=1):
 
 
 def _multi_process_pub_params_list_in_new_process(queue_name, msgs: List[dict]):
-    booster_current_pid = lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
+    booster_current_pid = funboost_lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
     publisher = booster_current_pid.publisher
     publisher.set_log_level(20)  # 超高速发布，如果打印详细debug日志会卡死屏幕和严重降低代码速度。
     for msg in msgs:

funboost/function_result_web/app.py

@@ -5,6 +5,9 @@
 import datetime
 import json
 
+"""
+pip install Flask flask_bootstrap  flask_wtf  wtforms flask_login       
+"""
 from flask import render_template, Flask, request, url_for, jsonify, flash, redirect
 from flask_bootstrap import Bootstrap
 from flask_wtf import FlaskForm

funboost/function_result_web/functions.py

@@ -5,7 +5,6 @@ import datetime
 import json
 from pprint import pprint
 import time
-from flask import jsonify
 import copy
 from funboost import nb_print
 from funboost.utils import time_util, decorators, LoggerMixin

funboost/publishers/base_publisher.py

@@ -9,17 +9,15 @@ import json
 import logging
 import multiprocessing
 import threading
-import uuid
 import time
 import typing
 from functools import wraps
 from threading import Lock
-import datetime
 import amqpstorm
 
 import nb_log
 from funboost.core.func_params_model import PublisherParams, PriorityConsumingControlConfig
-from funboost.core.helper_funs import generate_task_id
+from funboost.core.helper_funs import MsgGenerater
 from funboost.core.loggers import develop_logger
 
 from pikav1.exceptions import AMQPError as PikaAMQPError
@@ -28,7 +26,7 @@ from pikav1.exceptions import AMQPError as PikaAMQPError
 from funboost.core.loggers import LoggerLevelSetterMixin, FunboostFileLoggerMixin, get_logger
 from funboost.core.msg_result_getter import AsyncResult, AioAsyncResult
 from funboost.core.task_id_logger import TaskIdLogger
-from funboost.utils import decorators, time_util
+from funboost.utils import decorators
 from funboost.funboost_config_deafult import BrokerConnConfig, FunboostCommonConfig
 
 RedisAsyncResult = AsyncResult  # 别名
@@ -191,9 +189,8 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             raw_extra = msg['extra']
         if self.publish_params_checker and self.publisher_params.should_check_publish_func_params:
             self.publish_params_checker.check_params(msg_function_kw)
-        task_id = task_id or generate_task_id(self._queue_name)
-        extra_params = {'task_id': task_id, 'publish_time': round(time.time(), 4),
-                        'publish_time_format': time.strftime('%Y-%m-%d %H:%M:%S')}
+        task_id = task_id or MsgGenerater.generate_task_id(self._queue_name)
+        extra_params = MsgGenerater.generate_pulish_time_and_task_id(self._queue_name, task_id=task_id)
         if priority_control_config:
             extra_params.update(priority_control_config.dict(exclude_none=True))
         extra_params.update(raw_extra)

funboost/publishers/confluent_kafka_publisher.py

@@ -4,6 +4,8 @@
 
 import os
 
+from funboost.core.lazy_impoter import KafkaPythonImporter
+
 if os.name == 'nt':
     """
     为了保险起见，这样做一下,设置一下path，否则anaconda安装的python可能出现 ImportError: DLL load failed while importing cimpl: 找不到指定的模块。
@@ -24,12 +26,7 @@ if os.name == 'nt':
 
 import atexit
 import time
-# noinspection PyPackageRequirements
-from kafka import KafkaProducer, KafkaAdminClient
-# noinspection PyPackageRequirements
-from kafka.admin import NewTopic
-# noinspection PyPackageRequirements
-from kafka.errors import TopicAlreadyExistsError
+
 from confluent_kafka import Producer as ConfluentProducer
 from funboost.funboost_config_deafult import BrokerConnConfig
 from funboost.publishers.base_publisher import AbstractPublisher
@@ -45,10 +42,10 @@ class ConfluentKafkaPublisher(AbstractPublisher, ):
 
         # self._producer = KafkaProducer(bootstrap_servers=funboost_config_deafult.KAFKA_BOOTSTRAP_SERVERS)
         try:
-            admin_client = KafkaAdminClient(bootstrap_servers=BrokerConnConfig.KAFKA_BOOTSTRAP_SERVERS)
-            admin_client.create_topics([NewTopic(self._queue_name, 10, 1)])
+            admin_client = KafkaPythonImporter().KafkaAdminClient(bootstrap_servers=BrokerConnConfig.KAFKA_BOOTSTRAP_SERVERS)
+            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name, 10, 1)])
             # admin_client.create_partitions({self._queue_name: NewPartitions(total_count=16)})
-        except TopicAlreadyExistsError:
+        except KafkaPythonImporter().TopicAlreadyExistsError:
             pass
         except BaseException as e:
             self.logger.exception(e)
@@ -92,10 +89,10 @@ class SaslPlainKafkaPublisher(ConfluentKafkaPublisher):
     def custom_init(self):
         # self._producer = KafkaProducer(bootstrap_servers=funboost_config_deafult.KAFKA_BOOTSTRAP_SERVERS)
         try:
-            admin_client = KafkaAdminClient(**BrokerConnConfig.KFFKA_SASL_CONFIG)
-            admin_client.create_topics([NewTopic(self._queue_name, 10, 1)])
+            admin_client = KafkaPythonImporter().KafkaAdminClient(**BrokerConnConfig.KFFKA_SASL_CONFIG)
+            admin_client.create_topics([KafkaPythonImporter().NewTopic(self._queue_name, 10, 1)])
             # admin_client.create_partitions({self._queue_name: NewPartitions(total_count=16)})
-        except TopicAlreadyExistsError:
+        except KafkaPythonImporter().TopicAlreadyExistsError:
             pass
         except BaseException as e:
             self.logger.exception(e)