nebu 0.1.24__py3-none-any.whl → 0.1.29__py3-none-any.whl

nebu/__init__.py

@@ -3,9 +3,15 @@
 # ruff: noqa: F401
 # ruff: noqa: F403
 
+from .adapter import *
+from .auth import is_allowed
+from .cache import Cache, OwnedValue
+from .chatx.convert import *
+from .chatx.openai import *
 from .config import *
 from .containers.container import Container
 from .containers.models import *
+from .data import *
 from .meta import *
 from .processors.decorate import *
 from .processors.models import *

nebu/adapter.py

@@ -0,0 +1,11 @@
+import time
+
+from pydantic import BaseModel, Field
+
+
+class Adapter(BaseModel):
+    created_at: int = Field(default_factory=lambda: int(time.time()))
+    name: str
+    uri: str
+    base_model: str
+    owner: str

nebu/auth.py

@@ -33,3 +33,18 @@ def get_user_profile(api_key: str) -> V1UserProfile:
     response.raise_for_status()
 
     return V1UserProfile.model_validate(response.json())
+
+
+def is_allowed(
+    resource_owner: str,
+    user_id: Optional[str] = None,
+    orgs: Optional[Dict[str, Dict[str, str]]] = None,
+) -> bool:
+    if orgs is None:
+        orgs = {}
+    owners = []
+    for org_id, _ in orgs.items():
+        owners.append(org_id)
+    if user_id:
+        owners.append(user_id)
+    return resource_owner in owners

nebu/cache.py

@@ -0,0 +1,90 @@
+import os
+import time
+from typing import Any, Optional, cast
+
+import redis
+from pydantic import BaseModel, Field
+
+
+class OwnedValue(BaseModel):
+    created_at: int = Field(default_factory=lambda: int(time.time()))
+    value: str
+    user_id: Optional[str] = None
+    orgs: Optional[Any] = None
+    handle: Optional[str] = None
+    owner: Optional[str] = None
+
+
+class Cache:
+    """
+    A simple cache class that connects to Redis.
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 6379, db: int = 0):
+        """
+        Initializes the Redis connection.
+        Pulls connection details from environment variables REDIS_HOST,
+        REDIS_PORT, and REDIS_DB if available, otherwise uses defaults.
+        """
+        redis_host = os.environ.get("REDIS_HOST", host)
+        redis_port = int(os.environ.get("REDIS_PORT", port))
+        redis_db = int(os.environ.get("REDIS_DB", db))
+        namespace = os.environ.get("NEBU_NAMESPACE")
+        if not namespace:
+            raise ValueError("NEBU_NAMESPACE environment variable is not set")
+
+        try:
+            # decode_responses=True ensures keys and values are returned as strings
+            self.redis_client = redis.StrictRedis(
+                host=redis_host, port=redis_port, db=redis_db, decode_responses=True
+            )
+            # Ping the server to ensure connection is established
+            self.redis_client.ping()
+            print(
+                f"Successfully connected to Redis at {redis_host}:{redis_port}/{redis_db}"
+            )
+
+            self.prefix = f"cache:{namespace}"
+        except Exception as e:
+            print(f"Error connecting to Redis: {e}")
+            self.redis_client = None  # Set client to None if connection fails
+
+    def get(self, key: str) -> str | None:
+        """
+        Gets the value associated with a key from Redis.
+        Returns None if the key does not exist or connection failed.
+        """
+        if not self.redis_client:
+            print("Redis client not connected.")
+            return None
+        try:
+            key = f"{self.prefix}:{key}"
+            # Cast the result to str | None as expected
+            result = self.redis_client.get(key)
+            return cast(str | None, result)
+        except Exception as e:
+            print(f"Error getting key '{key}' from Redis: {e}")
+            return None
+
+    def set(self, key: str, value: str, expiry_seconds: int | None = None) -> bool:
+        """
+        Sets a key-value pair in Redis.
+        Optionally sets an expiry time for the key in seconds.
+        Returns True if successful, False otherwise (e.g., connection failed).
+        """
+        if not self.redis_client:
+            print("Redis client not connected.")
+            return False
+        try:
+            key = f"{self.prefix}:{key}"
+            if expiry_seconds:
+                # Cast the result to bool
+                result = self.redis_client.setex(key, expiry_seconds, value)
+                return cast(bool, result)
+            else:
+                # Cast the result to bool
+                result = self.redis_client.set(key, value)
+                return cast(bool, result)
+        except Exception as e:
+            print(f"Error setting key '{key}' in Redis: {e}")
+            return False

nebu/chatx/convert.py

@@ -0,0 +1,206 @@
+import base64
+import binascii
+import io
+from io import BytesIO
+from typing import Any, Dict, List, Tuple
+
+import requests
+from PIL import Image, UnidentifiedImageError
+
+
+def convert_to_unsloth_inference(
+    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:
+    [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "some text"},
+                {"type": "image_url", "image_url": {"url": "https://..."}},
+                ...
+            ],
+        }
+    ]
+
+    to a new format:
+    [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image"},
+                {"type": "text", "text": "merged user text"}
+            ],
+        }
+    ]
+
+    Along with the new format, return a list of downloaded PIL Image objects.
+    """
+
+    new_schema = []
+    all_images = []  # Will store PIL images as we convert them
+
+    for message in old_schema:
+        role = message.get("role", "user")
+
+        # Collect all text pieces and all image URLs
+        text_chunks = []
+        image_urls = []
+
+        for content_item in message.get("content", []):
+            content_type = content_item.get("type")
+            if content_type == "text":
+                text_chunks.append(content_item.get("text", ""))
+            elif content_type == "image_url":
+                image_url = content_item.get("image_url", {}).get("url")
+                if image_url:
+                    image_urls.append(image_url)
+
+        # Merge text chunks into one
+        merged_text = " ".join(text_chunks).strip()
+
+        # Convert each URL into a PIL image
+        for url in image_urls:
+            # Download the image
+            response = requests.get(url)
+            response.raise_for_status()
+            image_data = BytesIO(response.content)
+            pil_img = Image.open(image_data).convert("RGB")
+            all_images.append(pil_img)
+
+        # Construct new message format
+        # For simplicity, this example only places one {"type": "image"} placeholder
+        # regardless of how many images were found, and merges all text into one block.
+        new_content = []
+        if 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})
+
+    return new_schema, all_images
+
+
+def oai_to_unsloth(
+    messages_input: List[Dict[str, Any]],
+) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Converts a list of messages from an OpenAI-like chat format to the Nebulous conversation format.
+    Images specified by URLs or base64 strings are loaded into PIL.Image objects.
+
+    Input format example:
+    [
+        {
+            "role": "user",
+            "content": [
+                {"type": "input_text", "text": "Describe the image."},
+                {"type": "input_image", "image_url": "http://... or base64 string"},
+            ]
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": "This is an image of..."}] # Or potentially just a string
+        }
+    ]
+
+    Output format example:
+    {
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Describe the image."},
+                    {"type": "image", "image": <PIL.Image.Image object>},
+                ]
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": "This is an image of..."}]
+            }
+        ]
+    }
+    """
+    nebu_conversation = []
+    for message in messages_input:
+        role = message.get("role")
+        input_content = message.get("content")  # Can be list or string
+
+        processed_content = []
+
+        if isinstance(input_content, list):
+            # Process list content (multi-modal)
+            for item in input_content:
+                item_type = item.get("type")
+                if item_type in ("input_text", "text"):
+                    processed_content.append(
+                        {"type": "text", "text": item.get("text", "")}
+                    )
+                elif item_type in (
+                    "input_image",
+                    "image_url",
+                    "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:
+                        pil_image = None
+                        try:
+                            if isinstance(
+                                image_source, str
+                            ) and image_source.startswith(("http://", "https://")):
+                                # Handle URL
+                                response = requests.get(image_source, stream=True)
+                                response.raise_for_status()  # Raise an exception for bad status codes
+                                pil_image = Image.open(response.raw)
+                            elif isinstance(image_source, str):
+                                # 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)
+                                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:
+                                print(
+                                    f"Warning: Could not load image from source: {type(image_source)}"
+                                )
+
+                        except requests.exceptions.RequestException as e:
+                            print(
+                                f"Warning: Failed to fetch image from URL {image_source}: {e}"
+                            )
+                        except (binascii.Error, ValueError) as e:
+                            print(f"Warning: Failed to decode base64 image string: {e}")
+                        except (IOError, UnidentifiedImageError) as e:
+                            print(f"Warning: Failed to open image: {e}")
+                        except Exception as e:
+                            print(
+                                f"Warning: An unexpected error occurred while processing image: {e}"
+                            )
+
+                    else:
+                        print(
+                            "Warning: Image item provided but 'image_url' or 'image' key is missing or empty."
+                        )
+
+                # Add handling for other potential input types if necessary
+        elif isinstance(input_content, str):
+            # Handle simple string content (common for assistant messages)
+            processed_content.append({"type": "text", "text": input_content})
+        # else: Handle unexpected content format (e.g., log warning, skip message)
+
+        if role and processed_content:
+            nebu_conversation.append({"role": role, "content": processed_content})
+        # else: Handle missing role or empty content if needed
+
+    return {"messages": nebu_conversation}