nebu 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

nebu/processors/consumer.py

@@ -6,10 +6,11 @@ import sys
 import time
 import traceback
 from datetime import datetime
-from typing import Dict, TypeVar
+from typing import Any, Dict, TypeVar, cast
 
 import redis
 import socks
+from redis import ConnectionError, ResponseError
 
 # Define TypeVar for generic models
 T = TypeVar("T")
@@ -247,7 +248,7 @@ except Exception as e:
 try:
     r.xgroup_create(REDIS_STREAM, REDIS_CONSUMER_GROUP, id="0", mkstream=True)
     print(f"Created consumer group {REDIS_CONSUMER_GROUP} for stream {REDIS_STREAM}")
-except redis.exceptions.ResponseError as e:
+except ResponseError as e:
     if "BUSYGROUP" in str(e):
         print(f"Consumer group {REDIS_CONSUMER_GROUP} already exists")
     else:
@@ -262,17 +263,19 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
     user_id = None
 
     try:
-        # Get the message content from field 'data'
-        if b"data" not in message_data:
-            print(f"Message {message_id} has no 'data' field")
-            return
+        # Assign message_data directly to raw_payload.
+        # Cast to Dict[str, Any] to inform type checker of the expected type due to decode_responses=True.
+        raw_payload = cast(Dict[str, Any], message_data)
 
-        # Parse the message data
-        raw_payload = json.loads(message_data[b"data"].decode("utf-8"))
+        # Validate that raw_payload is a dictionary as expected - Removed, cast handles this for type checker
+        # if not isinstance(raw_payload, dict):
+        #     raise TypeError(f"Expected message_data to be a dictionary, but got {type(raw_payload)}")
 
-        # Extract fields from the Rust structure
+        print(f"Raw payload: {raw_payload}")
+
+        # Extract fields from the parsed payload
         # These fields are extracted for completeness and potential future use
-        _ = raw_payload.get("kind", "")  # kind
+        kind = raw_payload.get("kind", "")  # kind
         msg_id = raw_payload.get("id", "")  # msg_id
         content_raw = raw_payload.get("content", {})
         created_at = raw_payload.get("created_at", 0)  # created_at
@@ -282,6 +285,31 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
         handle = raw_payload.get("handle")  # handle
         adapter = raw_payload.get("adapter")  # adapter
 
+        # --- Health Check Logic based on kind ---
+        if kind == "HealthCheck":
+            print(f"Received HealthCheck message {message_id.decode('utf-8')}")
+            health_response = {
+                "kind": "StreamResponseMessage",  # Respond with a standard message kind
+                "id": message_id.decode("utf-8"),
+                "content": {"status": "healthy", "checked_message_id": msg_id},
+                "status": "success",
+                "created_at": datetime.now().isoformat(),
+                "user_id": user_id,  # Include user_id if available
+            }
+            if return_stream:
+                # Assert type again closer to usage for type checker clarity
+                assert isinstance(return_stream, str)
+                r.xadd(return_stream, {"data": json.dumps(health_response)})
+                print(f"Sent health check response to {return_stream}")
+
+            # Assert types again closer to usage for type checker clarity
+            assert isinstance(REDIS_STREAM, str)
+            assert isinstance(REDIS_CONSUMER_GROUP, str)
+            r.xack(REDIS_STREAM, REDIS_CONSUMER_GROUP, message_id)
+            print(f"Acknowledged HealthCheck message {message_id.decode('utf-8')}")
+            return  # Exit early for health checks
+        # --- End Health Check Logic ---
+
         # Parse the content field if it's a string
         if isinstance(content_raw, str):
             try:
@@ -291,6 +319,8 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
         else:
             content = content_raw
 
+        print(f"Content: {content}")
+
         # For StreamMessage, construct the proper input object
         if is_stream_message and "V1StreamMessage" in local_namespace:
             # If we have a content type, try to construct it
@@ -298,8 +328,9 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                 # Try to create the content type model first
                 try:
                     content_model = local_namespace[content_type_name](**content)
+                    print(f"Content model: {content_model}")
                     input_obj = local_namespace["V1StreamMessage"](
-                        kind=_,
+                        kind=kind,
                         id=msg_id,
                         content=content_model,
                         created_at=created_at,
@@ -313,7 +344,7 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                     print(f"Error creating content type model: {e}")
                     # Fallback to using raw content
                     input_obj = local_namespace["V1StreamMessage"](
-                        kind=_,
+                        kind=kind,
                         id=msg_id,
                         content=content,
                         created_at=created_at,
@@ -325,8 +356,9 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                     )
             else:
                 # Just use the raw content
+                print(f"Using raw content")
                 input_obj = local_namespace["V1StreamMessage"](
-                    kind=_,
+                    kind=kind,
                     id=msg_id,
                     content=content,
                     created_at=created_at,
@@ -348,9 +380,11 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                 print(f"Error creating input model: {e}, using raw content")
                 input_obj = content
 
+        print(f"Input object: {input_obj}")
+
         # Execute the function
         result = target_function(input_obj)
-
+        print(f"Result: {result}")
         # If the result is a Pydantic model, convert to dict
         if hasattr(result, "model_dump"):
             result = result.model_dump()
@@ -365,14 +399,21 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
             "user_id": user_id,
         }
 
+        print(f"Response: {response}")
+
         # Send the result to the return stream
         if return_stream:
+            # Assert type again closer to usage for type checker clarity
+            assert isinstance(return_stream, str)
             r.xadd(return_stream, {"data": json.dumps(response)})
             print(
                 f"Processed message {message_id.decode('utf-8')}, result sent to {return_stream}"
             )
 
         # Acknowledge the message
+        # Assert types again closer to usage for type checker clarity
+        assert isinstance(REDIS_STREAM, str)
+        assert isinstance(REDIS_CONSUMER_GROUP, str)
         r.xack(REDIS_STREAM, REDIS_CONSUMER_GROUP, message_id)
 
     except Exception as e:
@@ -394,11 +435,18 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
 
         # Send the error to the return stream
         if return_stream:
+            # Assert type again closer to usage for type checker clarity
+            assert isinstance(return_stream, str)
             r.xadd(return_stream, {"data": json.dumps(error_response)})
         else:
+            # Assert type again closer to usage for type checker clarity
+            assert isinstance(REDIS_STREAM, str)
             r.xadd(f"{REDIS_STREAM}.errors", {"data": json.dumps(error_response)})
 
         # Still acknowledge the message so we don't reprocess it
+        # Assert types again closer to usage for type checker clarity
+        assert isinstance(REDIS_STREAM, str)
+        assert isinstance(REDIS_CONSUMER_GROUP, str)
         r.xack(REDIS_STREAM, REDIS_CONSUMER_GROUP, message_id)
 
 
@@ -408,9 +456,13 @@ consumer_name = f"consumer-{os.getpid()}"
 
 while True:
     try:
+        # Assert types just before use in the loop
+        assert isinstance(REDIS_STREAM, str)
+        assert isinstance(REDIS_CONSUMER_GROUP, str)
+
         # Read from stream with blocking
         streams = {REDIS_STREAM: ">"}  # '>' means read only new messages
-        messages = r.xreadgroup(
+        messages = r.xreadgroup(  # type: ignore[arg-type]
             REDIS_CONSUMER_GROUP, consumer_name, streams, count=1, block=5000
         )
 
@@ -418,12 +470,20 @@ while True:
             # No messages received, continue waiting
             continue
 
+        # Assert that messages is a list (expected synchronous return type)
+        assert isinstance(
+            messages, list
+        ), f"Expected list from xreadgroup, got {type(messages)}"
+        assert len(messages) > 0  # Ensure the list is not empty before indexing
+
         stream_name, stream_messages = messages[0]
 
         for message_id, message_data in stream_messages:
+            print(f"Processing message {message_id}")
+            print(f"Message data: {message_data}")
             process_message(message_id, message_data)
 
-    except redis.exceptions.ConnectionError as e:
+    except ConnectionError as e:
         print(f"Redis connection error: {e}")
         time.sleep(5)  # Wait before retrying
 

{nebu-0.1.18.dist-info → nebu-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nebu
-Version: 0.1.18
+Version: 0.1.20
 Summary: A globally distributed container runtime
 Requires-Python: >=3.10.14
 Description-Content-Type: text/markdown

{nebu-0.1.18.dist-info → nebu-0.1.20.dist-info}/RECORD

@@ -6,15 +6,15 @@ nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,
 nebu/containers/decorator.py,sha256=uFtzlAXRHYZECJ-NPusY7oN9GXvdHrHDd_JNrIGr8aQ,3244
 nebu/containers/models.py,sha256=0j6NGy4yto-enRDh_4JH_ZTbHrLdSpuMOqNQPnIrwC4,6815
 nebu/containers/server.py,sha256=yFa2Y9PzBn59E1HftKiv0iapPonli2rbGAiU6r-wwe0,2513
-nebu/processors/consumer.py,sha256=0HJxRLoeRdN4xY6bjIxqr5bD5JpFSyKb5s-eS5oTy9s,16063
+nebu/processors/consumer.py,sha256=kX4UT8Z5c_LWU3MOcM5qXSzHEA0CYjUZ4dRJfhUKP-M,19202
 nebu/processors/decorate.py,sha256=AeG1c1n8JtcexxAEf2sF2L2eKwVDaNQ5gvPs6EpazKo,34789
 nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
 nebu/processors/models.py,sha256=GvnI8UJrQSjHo2snP07cPfisCH90cEGTY-PZV5_AtXI,3654
 nebu/processors/processor.py,sha256=oy2YdI-cy6qQWxrZhpZahJV46oWZlu_Im-jm811R_oo,9667
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.18.dist-info/METADATA,sha256=wF7klvNGu6yoVp726tHAmn3Ouo4Kt2XhuceGw7zXGzM,1678
-nebu-0.1.18.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.18.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.18.dist-info/RECORD,,
+nebu-0.1.20.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.20.dist-info/METADATA,sha256=mmrQRfaJ6jXFMa02a7rp4ghX1wKW8m3TLHeBCsmk64g,1678
+nebu-0.1.20.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.20.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.20.dist-info/RECORD,,