nebu 0.1.30__py3-none-any.whl → 0.1.32__py3-none-any.whl

nebu/chatx/convert.py

@@ -7,9 +7,14 @@ from typing import Any, Dict, List, Tuple
 import requests
 from PIL import Image, UnidentifiedImageError
 
+# Define a standard User-Agent header
+REQUESTS_HEADERS = {
+    "User-Agent": "Nebulous-py/0.1 (https://github.com/agentsea/nebulous-py; contact@agentsea.ai)"
+}
+
 
 def convert_to_unsloth_inference(
-    old_schema: Dict[str, Any],
+    old_schema: List[Dict[str, Any]],
 ) -> Tuple[List[Dict[str, Any]], List[Image.Image]]:
     """
     Convert from an old OpenAI message format that may look like:
@@ -63,7 +68,7 @@ def convert_to_unsloth_inference(
         # Convert each URL into a PIL image
         for url in image_urls:
             # Download the image
-            response = requests.get(url)
+            response = requests.get(url, headers=REQUESTS_HEADERS)
             response.raise_for_status()
             image_data = BytesIO(response.content)
             pil_img = Image.open(image_data).convert("RGB")
@@ -74,11 +79,16 @@ def convert_to_unsloth_inference(
         # regardless of how many images were found, and merges all text into one block.
         new_content = []
         if image_urls:
-            new_content.append({"type": "image"})
+            # Add image placeholders for each image found
+            for _ in image_urls:
+                new_content.append({"type": "image"})
         if merged_text:
             new_content.append({"type": "text", "text": merged_text})
 
-        new_schema.append({"role": role, "content": new_content})
+        # Check if there's any content to add
+        if new_content:
+            new_schema.append({"role": role, "content": new_content})
+        # else: Optionally handle cases where a message might become empty
 
     return new_schema, all_images
 
@@ -93,19 +103,22 @@ def oai_to_unsloth(
     (typical in JSON Lines format) to the Nebulous conversation format.
     Images specified by URLs or base64 strings are loaded into PIL.Image objects.
 
-    Input format example (as dict from JSON line):
     {
         "messages": [
             {
                 "role": "user",
                 "content": [
-                    {"type": "input_text", "text": "Describe the image."},
-                    {"type": "input_image", "image_url": "http://... or base64 string"},
+                    {
+                        "type": "text",
+                        "text": "Who is this an image of?"
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": "https://upload.wikimedia.org/wikipedia/commons/5/57/Abraham_Lincoln_1863_Portrait_%283x4_cropped%29.jpg"
+                        }
+                    }
                 ]
-            },
-            {
-                "role": "assistant",
-                "content": [{"type": "text", "text": "This is an image of..."}] # Or potentially just a string
             }
         ]
     }
@@ -146,6 +159,7 @@ def oai_to_unsloth(
 
         role = message.get("role")
         input_content = message.get("content")  # Can be list or string
+        image_url_top_level = message.get("image_url")  # Check for top-level image_url
 
         processed_content = []
 
@@ -163,41 +177,63 @@ def oai_to_unsloth(
                     "image",
                 ):  # Accept 'image' as source key too
                     # Use "image_url" first, then fallback to "image" if needed
-                    image_source = item.get("image_url", item.get("image"))
-                    if image_source:
+                    image_source_value = item.get("image_url", item.get("image"))
+                    image_url_to_load = None
+                    pil_image_to_load = None
+
+                    if item_type == "image_url" and isinstance(
+                        image_source_value, dict
+                    ):
+                        # Handle nested {"url": "..."}
+                        image_url_to_load = image_source_value.get("url")
+                    elif isinstance(image_source_value, str):
+                        # Handle direct URL string or base64 string
+                        image_url_to_load = image_source_value  # Could be URL or base64
+                    elif isinstance(image_source_value, Image.Image):
+                        # Handle direct PIL image
+                        pil_image_to_load = image_source_value
+
+                    if pil_image_to_load:  # If we already have a PIL image
+                        processed_content.append(
+                            {"type": "image", "image": pil_image_to_load}
+                        )
+                    elif (
+                        image_url_to_load
+                    ):  # If we have a URL or base64 string to process
                         pil_image = None
                         try:
-                            if isinstance(
-                                image_source, str
-                            ) and image_source.startswith(("http://", "https://")):
+                            if image_url_to_load.startswith(("http://", "https://")):
                                 # Handle URL
-                                response = requests.get(image_source, stream=True)
+                                response = requests.get(
+                                    image_url_to_load,
+                                    stream=True,
+                                    headers=REQUESTS_HEADERS,
+                                )
                                 response.raise_for_status()  # Raise an exception for bad status codes
                                 pil_image = Image.open(response.raw)
-                            elif isinstance(image_source, str):
+                            else:  # Assume base64
                                 # Handle base64 string
                                 # Remove potential data URI prefix (e.g., "data:image/png;base64,")
-                                if "," in image_source:
-                                    image_source = image_source.split(",", 1)[1]
-                                image_bytes = base64.b64decode(image_source)
+                                if "," in image_url_to_load:
+                                    image_url_to_load = image_url_to_load.split(",", 1)[
+                                        1
+                                    ]
+                                image_bytes = base64.b64decode(image_url_to_load)
                                 pil_image = Image.open(io.BytesIO(image_bytes))
 
-                            elif isinstance(image_source, Image.Image):
-                                # Handle direct PIL.Image input
-                                pil_image = image_source
-
                             if pil_image:
                                 processed_content.append(
                                     {"type": "image", "image": pil_image}
                                 )
                             else:
+                                # This condition might be less likely now with the separated logic
                                 print(
-                                    f"Warning: Could not load image from source: {type(image_source)}"
+                                    f"Warning: Could not load image from source: {type(image_url_to_load)}"
                                 )
 
                         except requests.exceptions.RequestException as e:
                             print(
-                                f"Warning: Failed to fetch image from URL {image_source}: {e}"
+                                f"Warning: Failed to fetch image from URL {image_url_to_load}: {e}"
                             )
                         except (binascii.Error, ValueError) as e:
                             print(f"Warning: Failed to decode base64 image string: {e}")
@@ -210,7 +246,7 @@ def oai_to_unsloth(
 
                     else:
                         print(
-                            "Warning: Image item provided but 'image_url' or 'image' key is missing or empty."
+                            "Warning: Image item provided but could not resolve image source (URL, base64, or PIL Image)."
                         )
 
                 # Add handling for other potential input types if necessary
@@ -219,6 +255,45 @@ def oai_to_unsloth(
             processed_content.append({"type": "text", "text": input_content})
         # else: Handle unexpected content format (e.g., log warning, skip message)
 
+        # Handle potential top-level image_url (after processing content)
+        if image_url_top_level and isinstance(image_url_top_level, str):
+            pil_image = None
+            try:
+                if image_url_top_level.startswith(("http://", "https://")):
+                    # Handle URL
+                    response = requests.get(
+                        image_url_top_level, stream=True, headers=REQUESTS_HEADERS
+                    )
+                    response.raise_for_status()  # Raise an exception for bad status codes
+                    pil_image = Image.open(response.raw)
+                else:
+                    # Assume base64 string if not URL (could refine this check)
+                    # Remove potential data URI prefix
+                    if "," in image_url_top_level:
+                        image_url_top_level = image_url_top_level.split(",", 1)[1]
+                    image_bytes = base64.b64decode(image_url_top_level)
+                    pil_image = Image.open(io.BytesIO(image_bytes))
+
+                if pil_image:
+                    processed_content.append({"type": "image", "image": pil_image})
+                else:
+                    print(
+                        f"Warning: Could not load image from top-level source: {type(image_url_top_level)}"
+                    )
+
+            except requests.exceptions.RequestException as e:
+                print(
+                    f"Warning: Failed to fetch top-level image from URL {image_url_top_level}: {e}"
+                )
+            except (binascii.Error, ValueError) as e:
+                print(f"Warning: Failed to decode top-level base64 image string: {e}")
+            except (IOError, UnidentifiedImageError) as e:
+                print(f"Warning: Failed to open top-level image: {e}")
+            except Exception as e:
+                print(
+                    f"Warning: An unexpected error occurred while processing top-level image: {e}"
+                )
+
         if role and processed_content:
             nebu_conversation.append({"role": role, "content": processed_content})
         # else: Handle missing role or empty content if needed

nebu/processors/consumer.py

@@ -479,6 +479,7 @@ while True:
         # Read from stream with blocking
         streams = {REDIS_STREAM: ">"}  # '>' means read only new messages
         # The type checker still struggles here, but the runtime types are asserted.
+        print("reading from stream...")
         messages = r.xreadgroup(  # type: ignore[arg-type]
             REDIS_CONSUMER_GROUP, consumer_name, streams, count=1, block=5000
         )

{nebu-0.1.30.dist-info → nebu-0.1.32.dist-info}/METADATA

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

{nebu-0.1.30.dist-info → nebu-0.1.32.dist-info}/RECORD

@@ -5,13 +5,13 @@ nebu/cache.py,sha256=1aY1plIXWOPmUY6GGq_s_QDXzIi5UMuG34XYBA8PpW8,3803
 nebu/config.py,sha256=aZzQltkobtOLHFCGcIkpKoE3ITn3Z11Dp0E72w84TA0,5769
 nebu/data.py,sha256=kIH9-JJ1-iO7P2t28bku6Gn0Y5tgQszGeTW_rpmO03A,38725
 nebu/meta.py,sha256=CzFHMND9seuewzq9zNNx9WTr6JvrCBExe7BLqDSr7lM,745
-nebu/chatx/convert.py,sha256=4rjccr9bI0xmCAumKlxyFpVzW0up9Yj-gJYvDjH6C54,8798
+nebu/chatx/convert.py,sha256=jIOuGXPfLkYf_cRqh739gsKKg7cBB2zEYm3Jpmf6Xvo,12535
 nebu/chatx/openai.py,sha256=LLSPvVGnauUViAXY7OifwoWlkUGZWfgxEjxR4mjSqZg,44961
 nebu/containers/container.py,sha256=yb7KaPTVXnEEAlrpdlUi4HNqF6P7z9bmwAILGlq6iqU,13502
 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=becQxjQoerlaDdr2_wxzIux3wl8SVmo2LA93RZn0Jk8,19694
+nebu/processors/consumer.py,sha256=mSgHm6ANcsM1KtmH9Nu-D6X52d6we0Au8m29rcvb57s,19734
 nebu/processors/decorate.py,sha256=9mf25RawOX6_6WyQcRLBIHQC3oCDtofQZijJ13aQM9E,34576
 nebu/processors/default.py,sha256=W4slJenG59rvyTlJ7gRp58eFfXcNOTT2Hfi6zzJAobI,365
 nebu/processors/models.py,sha256=y40HoW-MEzDWB2dm_tsYlUy3Nf3s6eiLC0iGO9BoNog,3956
@@ -19,8 +19,8 @@ nebu/processors/processor.py,sha256=EQ3-dBf432fSAQE2A_9ATX-cG5LkJ4fjVaOtlxCoXvc,
 nebu/processors/remote.py,sha256=TeAIPGEMqnDIb7H1iett26IEZrBlcbPB_-DSm6jcH1E,1285
 nebu/redis/models.py,sha256=coPovAcVXnOU1Xh_fpJL4PO3QctgK9nBe5QYoqEcnxg,1230
 nebu/services/service.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nebu-0.1.30.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nebu-0.1.30.dist-info/METADATA,sha256=Y_o6hvOdihVgFJMRQPIpALA2V6JfaXybtrlSaQyMNtI,1786
-nebu-0.1.30.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nebu-0.1.30.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
-nebu-0.1.30.dist-info/RECORD,,
+nebu-0.1.32.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nebu-0.1.32.dist-info/METADATA,sha256=zjHxnA7sDhRyFcO7z3l6MnBjuox-ydeKL4TR09J_R1w,1786
+nebu-0.1.32.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nebu-0.1.32.dist-info/top_level.txt,sha256=uLIbEKJeGSHWOAJN5S0i5XBGwybALlF9bYoB1UhdEgQ,5
+nebu-0.1.32.dist-info/RECORD,,