onestep 0.1.76__tar.gz → 0.1.78__tar.gz

{onestep-0.1.76 → onestep-0.1.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: onestep
-Version: 0.1.76
+Version: 0.1.78
 Summary: 
 Author: miclon
 Author-email: jcnd@163.com

{onestep-0.1.76 → onestep-0.1.78}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "onestep"
-version = "0.1.76"
+version = "0.1.78"
 description = ""
 authors = ["miclon <jcnd@163.com>"]
 readme = "README.md"

{onestep-0.1.76 → onestep-0.1.78}/src/onestep/__init__.py

@@ -19,7 +19,7 @@ from .exception import (
 
 __all__ = [
     'step',
-
+    
     # broker
     'BaseBroker',
     'BaseConsumer',
@@ -29,7 +29,7 @@ __all__ = [
     'RabbitMQBroker',
     'WebHookBroker',
     'CronBroker',
-
+    
     # retry
     'BaseRetry',
     'NeverRetry',
@@ -40,7 +40,7 @@ __all__ = [
     # error callback
     'BaseErrorCallback',
     'NackErrorCallBack',
-
+    
     # middleware
     'BaseMiddleware',
     'BaseConfigMiddleware',
@@ -48,7 +48,7 @@ __all__ = [
     'NacosConsumeConfigMiddleware',
     'RedisPublishConfigMiddleware',
     'RedisConsumeConfigMiddleware',
-
+    
     # exception
     'StopMiddleware',
     'DropMessage',

{onestep-0.1.76 → onestep-0.1.78}/src/onestep/broker/base.py

@@ -2,73 +2,74 @@
 import abc
 import json
 from queue import Queue, Empty
+from typing import Any
 
 from ..exception import StopMiddleware
 from ..message import Message
 
 
 class BaseBroker:
-
+    
     def __init__(self, name=None, queue=None, middlewares=None):
         self.queue = queue
         self.name = name or "broker"
         self.middlewares = []
-
+        
         if middlewares:
             for middleware in middlewares:
                 self.add_middleware(middleware)
-
+    
     def add_middleware(self, middleware):
         self.middlewares.append(middleware)
-
+    
     def send(self, message):
         """对消息进行预处理，然后再发送"""
         if not isinstance(message, Message):
             message = Message(body=message)
         # TODO: 对消息发送进行N次重试，确保消息发送成功。
         return self.publish(message.to_json())
-
+    
     @abc.abstractmethod
-    def publish(self, message):
+    def publish(self, message: Any):
         """
         如果当前Broker是Job的to_broker, 则必须实现此方法
         """
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     @abc.abstractmethod
     def consume(self, *args, **kwargs):
         """
         如果当前Broker是Job的from_broker, 则必须实现此方法
         """
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     @abc.abstractmethod
-    def confirm(self, message):
+    def confirm(self, message: Message):
         """确认消息"""
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     @abc.abstractmethod
-    def reject(self, message):
+    def reject(self, message: Message):
         """拒绝消息"""
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     @abc.abstractmethod
-    def requeue(self, message, is_source=False):
+    def requeue(self, message: Message, is_source=False):
         """
         重发消息：先拒绝 再 重入
         is_source = False 重入使用消息的当前状态
         is_source = True 重入使用消息的初始状态
         """
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     def before_emit(self, signal, *args, **kwargs):
         signal = "before_" + signal
         self._emit(signal, *args, **kwargs)
-
+    
     def after_emit(self, signal, *args, **kwargs):
         signal = "after_" + signal
         self._emit(signal, *args, **kwargs)
-
+    
     def _emit(self, signal, *args, **kwargs):
         for middleware in self.middlewares:
             if not hasattr(middleware, signal):
@@ -77,74 +78,75 @@ class BaseBroker:
                 getattr(middleware, signal)(self, *args, **kwargs)
             except StopMiddleware:
                 break
-
+    
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.name}>"
-
+    
     def __str__(self):
         return self.name
 
 
 class BaseConsumer:
-
+    
     def __init__(self, queue: Queue, *args, **kwargs):
         self.queue = queue
         self.timeout = kwargs.pop("timeout", 1000)
-
+    
     @abc.abstractmethod
-    def _to_message(self, data):
+    def _to_message(self, data: Any):
         """
         转换消息内容到 Message , 则必须实现此方法
         """
         raise NotImplementedError('Please implement in subclasses.')
-
+    
     def __next__(self):
         try:
-            return self._to_message(self.queue.get(timeout=self.timeout / 1000))
+            data = self.queue.get(timeout=self.timeout / 1000)
+            return self._to_message(data)
         except Empty:
             return None
-
+    
     def __iter__(self):
         return self
 
 
 class BaseLocalBroker(BaseBroker):
-
+    
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.queue = Queue()
-
-    def publish(self, message):
+    
+    def publish(self, message: Any):
         self.queue.put_nowait(message)
-
+    
     def consume(self, *args, **kwargs):
         return BaseLocalConsumer(self.queue, *args, **kwargs)
-
-    def confirm(self, message):
+    
+    def confirm(self, message: Message):
         """确认消息"""
         pass
-
-    def reject(self, message):
+    
+    def reject(self, message: Message):
         """拒绝消息"""
         pass
-
-    def requeue(self, message, is_source=False):
+    
+    def requeue(self, message: Message, is_source=False):
         """重发消息：先拒绝 再 重入"""
         if is_source:
             self.publish(message.msg)
         else:
             self.send(message)
-
+    
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.name}>"
-
+    
     def __str__(self):
         return self.name
 
 
 class BaseLocalConsumer(BaseConsumer):
-
-    def _to_message(self, data):
+    
+    def _to_message(self, data: Any):
         message = Message(msg=data)
         try:
             body = json.loads(data)

{onestep-0.1.76 → onestep-0.1.78}/src/onestep/broker/rabbitmq.py

@@ -1,12 +1,12 @@
 import json
 import threading
 from queue import Queue
-from typing import Optional, Dict
+from typing import Optional, Dict, Any
 
 import amqpstorm
 
 from .base import BaseBroker, BaseConsumer
-from ..store.rabbitmq import RabbitmqStore
+from ..store.rabbitmq import RabbitMQStore
 from ..message import Message
 
 
@@ -17,12 +17,12 @@ class RabbitMQBroker(BaseBroker):
         self.queue_name = queue_name
         self.queue = Queue()
         params = params or {}
-        self.client = RabbitmqStore(**params)
+        self.client = RabbitMQStore(**params)
         self.client.declare_queue(self.queue_name)
         self.prefetch = prefetch
 
     def _consume(self, *args, **kwargs):
-        def callback(message):
+        def callback(message: amqpstorm.Message):
             self.queue.put(message)
 
         prefetch = kwargs.pop("prefetch", self.prefetch)
@@ -32,23 +32,28 @@ class RabbitMQBroker(BaseBroker):
         threading.Thread(target=self._consume, *args, **kwargs).start()
         return RabbitMQConsumer(self.queue)
 
-    def publish(self, message):
+    def publish(self, message: Any):
         self.client.send(self.queue_name, message)
 
-    def confirm(self, message):
+    def confirm(self, message: Message):
         """确认消息"""
-        message.msg.ack()
+        self.client.channel.basic.ack(message.msg.delivery_tag)
 
-    def reject(self, message):
+    def reject(self, message: Message):
         """拒绝消息"""
-        message.msg.nack(requeue=False)
+        self.client.channel.basic.nack(message.msg.delivery_tag, requeue=False)
 
-    def requeue(self, message, is_source=False):
-        """重发消息：先拒绝 再 重入"""
+    def requeue(self, message: Message, is_source=False):
+        """
+        重发消息：先拒绝 再 重入
+        
+        :param message: 消息
+        :param is_source: 是否是源消息，True: 使用消息的最新数据重入当前队列，False: 使用消息的最新数据重入当前队列
+        """
         if is_source:
-            message.msg.nack(requeue=True)
+            self.client.channel.basic.nack(message.msg.delivery_tag, requeue=True)
         else:
-            message.msg.nack(requeue=False)
+            self.client.channel.basic.nack(message.msg.delivery_tag, requeue=False)
             self.send(message)
 
 

{onestep-0.1.76 → onestep-0.1.78}/src/onestep/message.py

@@ -115,14 +115,18 @@ class Message:
             self.broker.confirm(self)
     
     def reject(self):
-        """拒绝消息 （原始状态重入）"""
+        """拒绝消息"""
         if self.broker:
             self.broker.reject(self)
     
-    def requeue(self):
-        """重发消息 （最新状态重入）"""
+    def requeue(self, is_source=False):
+        """
+        重发消息：先拒绝 再 重入
+        
+        :param is_source: 是否是源消息，True: 使用消息的最新数据重入当前队列，False: 使用消息的最新数据重入当前队列
+        """
         if self.broker:
-            self.broker.requeue(self)
+            self.broker.requeue(self, is_source=is_source)
     
     def __getattr__(self, item):
         return None

onestep-0.1.78/src/onestep/store/__init__.py

@@ -0,0 +1,2 @@
+from .rabbitmq import RabbitMQStore
+from .rabbitmq import RabbitmqStore  # deprecated

{onestep-0.1.76 → onestep-0.1.78}/src/onestep/store/rabbitmq.py

@@ -1,4 +1,5 @@
 import logging
+import time
 from threading import local
 import amqpstorm
 from amqpstorm.exception import AMQPConnectionError
@@ -9,8 +10,8 @@ MAX_CONNECTION_ATTEMPTS = float('inf')  # 最大连接重试次数
 logger = logging.Logger(__name__)
 
 
-class RabbitmqStore:
-
+class RabbitMQStore:
+    
     def __init__(self, *, confirm_delivery=True, host=None, port=None, username=None, password=None,
                  **kwargs):
         """
@@ -31,33 +32,34 @@ class RabbitmqStore:
         if kwargs:
             self.parameters.update(kwargs)
         self.confirm_delivery = confirm_delivery
-
+    
     def _create_connection(self):
         attempts = 1
         while attempts <= MAX_CONNECTION_ATTEMPTS:
             try:
+                # logger.warning("RabbitmqStore connection try: attempts=%s", attempts)
                 return amqpstorm.Connection(**self.parameters)
             except AMQPConnectionError as exc:
                 attempts += 1
                 logger.warning("RabbitmqStore connection error: %s", exc)
         raise AMQPConnectionError("RabbitmqStore connection error, max attempts reached")
-
+    
     @property
-    def connection(self):
+    def connection(self) -> amqpstorm.Connection:
         connection = getattr(self.state, "connection", None)
         if connection is None or not connection.is_open:
             connection = self.state.connection = self._create_connection()
         return connection
-
+    
     @connection.deleter
     def connection(self):
         if _connection := getattr(self.state, "connection", None):
             _connection.close()
             del self.state.connection
             del self.state.channel
-
+    
     @property
-    def channel(self):
+    def channel(self) -> amqpstorm.Channel:
         connection = getattr(self.state, "connection", None)
         channel = getattr(self.state, "channel", None)
         if all([connection, channel]) and all([connection.is_open, channel.is_open]):
@@ -66,13 +68,13 @@ class RabbitmqStore:
         if self.confirm_delivery:
             channel.confirm_deliveries()
         return channel
-
+    
     def declare_queue(self, queue_name, arguments=None):
         """声明队列"""
         if arguments is None:
             arguments = {}
         return self.channel.queue.declare(queue_name, durable=True, arguments=arguments)
-
+    
     def send(self, queue_name, message, priority=None, **kwargs):
         """发送消息"""
         attempts = 1
@@ -88,16 +90,16 @@ class RabbitmqStore:
                 attempts += 1
                 if attempts > MAX_SEND_ATTEMPTS:
                     raise exc
-
+    
     def flush_queue(self, queue_name):
         """清空队列"""
         self.channel.queue.purge(queue_name)
-
+    
     def get_message_counts(self, queue_name: str) -> int:
         """获取消息数量"""
         queue_response = self.declare_queue(queue_name)
         return queue_response.get("message_count", 0)
-
+    
     def start_consuming(self, queue_name, callback, prefetch=1, **kwargs):
         """开始消费"""
         while True:
@@ -108,6 +110,11 @@ class RabbitmqStore:
             except AMQPConnectionError:
                 logger.warning("RabbitmqStore consume connection error, reconnecting...")
                 del self.connection
+                time.sleep(1)
             except Exception as e:
                 logger.exception(f"RabbitmqStore consume error<{e}>, reconnecting...")
                 del self.connection
+                time.sleep(1)
+
+
+RabbitmqStore = RabbitMQStore  # 兼容旧版本

onestep-0.1.76/src/onestep/store/__init__.py

@@ -1 +0,0 @@
-from .rabbitmq import RabbitmqStore