nebu 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

nebu/processors/consumer.py

@@ -10,6 +10,7 @@ from typing import Dict, TypeVar
 
 import redis
 import socks
+from redis import ConnectionError, ResponseError
 
 # Define TypeVar for generic models
 T = TypeVar("T")
@@ -245,9 +246,12 @@ except Exception as e:
 
 # Create consumer group if it doesn't exist
 try:
+    # Assert types before use
+    assert isinstance(REDIS_STREAM, str)
+    assert isinstance(REDIS_CONSUMER_GROUP, str)
     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:
@@ -261,26 +265,38 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
     return_stream = None
     user_id = None
 
+    print(f"Message data inner: {message_data}")
+
     try:
-        # Check for and decode the 'data' field
-        data_bytes = message_data.get(b"data")
-        if data_bytes is None:
-            # Raise an error if 'data' field is missing
-            raise ValueError("Message missing 'data' field")
+        # Extract the JSON string payload from the b'data' field
+        # Redis keys/fields might be bytes even with decode_responses=True
+        payload_str = message_data.get(b"data")
+
+        # decode_responses=True should handle decoding, but Redis can be tricky.
+        # If errors persist, we might need to re-add explicit decode checks.
+        if not payload_str or not isinstance(payload_str, str):
+            # Add a more specific check if needed later based on runtime errors
+            raise ValueError(
+                f"Missing or invalid 'data' field (expected string): {message_data}"
+            )
 
+        # Parse the JSON string into a dictionary
         try:
-            # Decode bytes to string and parse JSON
-            raw_payload_str = data_bytes.decode("utf-8")
-            raw_payload = json.loads(raw_payload_str)
-        except (json.JSONDecodeError, UnicodeDecodeError) as decode_error:
-            # Raise a specific error for decoding/parsing issues
-            raise ValueError(f"Invalid JSON payload: {decode_error}") from decode_error
+            raw_payload = json.loads(payload_str)
+        except json.JSONDecodeError as json_err:
+            raise ValueError(f"Failed to parse JSON payload: {json_err}") from json_err
+
+        # Validate that raw_payload is a dictionary as expected
+        if not isinstance(raw_payload, dict):
+            raise TypeError(
+                f"Expected parsed payload to be a dictionary, but got {type(raw_payload)}"
+            )
 
         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
@@ -290,6 +306,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:
@@ -310,7 +351,7 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                     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,
@@ -324,7 +365,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,
@@ -338,7 +379,7 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
                 # 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,
@@ -383,12 +424,17 @@ def process_message(message_id: bytes, message_data: Dict[bytes, bytes]) -> None
 
         # 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:
@@ -410,11 +456,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)
 
 
@@ -424,9 +477,14 @@ 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(
+        # The type checker still struggles here, but the runtime types are asserted.
+        messages = r.xreadgroup(  # type: ignore[arg-type]
             REDIS_CONSUMER_GROUP, consumer_name, streams, count=1, block=5000
         )
 
@@ -434,6 +492,12 @@ 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:
@@ -441,7 +505,7 @@ while True:
             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.19.dist-info → nebu-0.1.21.dist-info}/METADATA

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

{nebu-0.1.19.dist-info → nebu-0.1.21.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=EbOhoFogS3W91BmJjqrFeipX_2G7lgAuUVGOpemcswM,16844
+nebu/processors/consumer.py,sha256=47ssdvJU7CGur0JoehNrmNGKwAAzVDVp7UTnphApQlI,20080
 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.19.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.19.dist-info/METADATA,sha256=soUNeXLW9Ikz2heD7RSSeiUW8Rut2Q9bK-P9rAuwnes,1678
-nebu-0.1.19.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.19.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.19.dist-info/RECORD,,
+nebu-0.1.21.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.21.dist-info/METADATA,sha256=SmlvWXJgnKLKph_8UCEtgVtLz80EuKrcxRNm3hdEl_8,1678
+nebu-0.1.21.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.21.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.21.dist-info/RECORD,,