npcpy 1.2.24__tar.gz → 1.2.26__tar.gz

{npcpy-1.2.24/npcpy.egg-info → npcpy-1.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.24
+Version: 1.2.26
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.24 → npcpy-1.2.26}/npcpy/npc_compiler.py

@@ -563,12 +563,9 @@ def get_npc_action_space(npc=None, team=None):
         }
     
     return actions
-
-
 def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
     inputs = {}
 
-    
     flag_mapping = {}
     for input_ in jinx.inputs:
         if isinstance(input_, str):
@@ -579,46 +576,64 @@ def extract_jinx_inputs(args: List[str], jinx: Jinx) -> Dict[str, Any]:
             flag_mapping[f"-{key[0]}"] = key
             flag_mapping[f"--{key}"] = key
 
-    
-    used_args = set()
+    if len(jinx.inputs) > 1:
+        used_args = set()
+        for i, arg in enumerate(args):
+            if '=' in arg and arg != '=' and not arg.startswith('-'):
+                key, value = arg.split('=', 1)
+                key = key.strip().strip("'\"")
+                value = value.strip().strip("'\"")
+                inputs[key] = value
+                used_args.add(i)
+    else:
+        used_args = set()
+
+
     for i, arg in enumerate(args):
-        if arg in flag_mapping:
+        if i in used_args:
+            continue
             
-            if i + 1 < len(args):
+        if arg in flag_mapping:
+            if i + 1 < len(args) and not args[i + 1].startswith('-'):
                 input_name = flag_mapping[arg]
                 inputs[input_name] = args[i + 1]
                 used_args.add(i)
                 used_args.add(i + 1)
             else:
-                print(f"Warning: {arg} flag is missing a value.")
+                input_name = flag_mapping[arg]
+                inputs[input_name] = True
+                used_args.add(i)
 
-    
     unused_args = [arg for i, arg in enumerate(args) if i not in used_args]
-    if unused_args and jinx.inputs:
-        first_input = jinx.inputs[0]
-        if isinstance(first_input, str):
-            inputs[first_input] = " ".join(unused_args)
-        elif isinstance(first_input, dict):
-            key = list(first_input.keys())[0]
-            inputs[key] = " ".join(unused_args)
-
     
+    jinx_input_names = []
+    for input_ in jinx.inputs:
+        if isinstance(input_, str):
+            jinx_input_names.append(input_)
+        elif isinstance(input_, dict):
+            jinx_input_names.append(list(input_.keys())[0])
+    if len(jinx_input_names) == 1:
+        inputs[jinx_input_names[0]] = ' '.join(unused_args).strip()
+    else:
+        for i, arg in enumerate(unused_args):
+            if i < len(jinx_input_names):
+                input_name = jinx_input_names[i]
+                if input_name not in inputs: 
+                    inputs[input_name] = arg
+
+
     for input_ in jinx.inputs:
         if isinstance(input_, str):
             if input_ not in inputs:
-                if any(args):  
-                    raise ValueError(f"Missing required input: {input_}")
-                else:
-                    inputs[input_] = None  
+                raise ValueError(f"Missing required input: {input_}")
         elif isinstance(input_, dict):
             key = list(input_.keys())[0]
+            default_value = input_[key]
             if key not in inputs:
-                inputs[key] = input_[key]
+                inputs[key] = default_value
 
     return inputs
 
-
-
 from npcpy.memory.command_history import load_kg_from_db, save_kg_to_db
 from npcpy.memory.knowledge_graph import kg_initial, kg_evolve_incremental, kg_sleep_process, kg_dream_process
 from npcpy.llm_funcs import get_llm_response, breathe

{npcpy-1.2.24 → npcpy-1.2.26}/npcpy/serve.py

@@ -504,7 +504,233 @@ def get_global_settings():
         return jsonify({"error": str(e)}), 500
 
 
+@app.route("/api/jinxs/available", methods=["GET"])
+def get_available_jinxs():
+    """
+    Get all available jinxs for a given NPC and/or team.
+    Returns a list of jinx names that can be executed.
+    """
+    try:
+        current_path = request.args.get('currentPath')
+        npc_name = request.args.get('npc')
+        
+        jinx_names = set()  # Use set to avoid duplicates
+        
+        # Get team jinxs from project directory
+        if current_path:
+            team_jinxs_dir = os.path.join(current_path, 'npc_team', 'jinxs')
+            if os.path.exists(team_jinxs_dir):
+                for file in os.listdir(team_jinxs_dir):
+                    if file.endswith('.jinx'):
+                        jinx_names.add(file[:-5])  # Remove .jinx extension
+        
+        # Get global jinxs
+        global_jinxs_dir = os.path.expanduser('~/.npcsh/npc_team/jinxs')
+        if os.path.exists(global_jinxs_dir):
+            for file in os.listdir(global_jinxs_dir):
+                if file.endswith('.jinx'):
+                    jinx_names.add(file[:-5])
+        
+        # Get NPC-specific jinxs if NPC is specified
+        if npc_name:
+            # Try to load the NPC and get its jinxs
+            db_conn = get_db_connection()
+            npc_object = load_npc_by_name_and_source(npc_name, 'project', db_conn, current_path)
+            if not npc_object:
+                npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
+            
+            if npc_object and hasattr(npc_object, 'jinxs_dict') and npc_object.jinxs_dict:
+                jinx_names.update(npc_object.jinxs_dict.keys())
+        
+        return jsonify({
+            'jinxs': sorted(list(jinx_names)),
+            'error': None
+        })
+        
+    except Exception as e:
+        print(f"Error getting available jinxs: {str(e)}")
+        traceback.print_exc()
+        return jsonify({'jinxs': [], 'error': str(e)}), 500
+
 
+@app.route("/api/jinx/execute", methods=["POST"])
+def execute_jinx():
+    """
+    Execute a specific jinx with provided arguments.
+    Streams the output back to the client.
+    """
+    data = request.json
+    
+    stream_id = data.get("streamId")
+    if not stream_id:
+        stream_id = str(uuid.uuid4())
+    
+    with cancellation_lock:
+        cancellation_flags[stream_id] = False
+    
+    jinx_name = data.get("jinxName")
+    jinx_args = data.get("jinxArgs", [])
+    conversation_id = data.get("conversationId")
+    model = data.get("model")
+    provider = data.get("provider")
+    npc_name = data.get("npc")
+    npc_source = data.get("npcSource", "global")
+    current_path = data.get("currentPath")
+    
+    if not jinx_name:
+        return jsonify({"error": "jinxName is required"}), 400
+    
+    # Load project environment if applicable
+    if current_path:
+        load_project_env(current_path)
+    
+    # Load the NPC
+    npc_object = None
+    if npc_name:
+        db_conn = get_db_connection()
+        npc_object = load_npc_by_name_and_source(npc_name, npc_source, db_conn, current_path)
+        if not npc_object and npc_source == 'project':
+            npc_object = load_npc_by_name_and_source(npc_name, 'global', db_conn)
+    
+    # Try to find the jinx
+    jinx = None
+    
+    # Check NPC's jinxs
+    if npc_object and hasattr(npc_object, 'jinxs_dict') and jinx_name in npc_object.jinxs_dict:
+        jinx = npc_object.jinxs_dict[jinx_name]
+    
+    # Check team jinxs
+    if not jinx and current_path:
+        team_jinx_path = os.path.join(current_path, 'npc_team', 'jinxs', f'{jinx_name}.jinx')
+        if os.path.exists(team_jinx_path):
+            jinx = Jinx(jinx_path=team_jinx_path)
+    
+    # Check global jinxs
+    if not jinx:
+        global_jinx_path = os.path.expanduser(f'~/.npcsh/npc_team/jinxs/{jinx_name}.jinx')
+        if os.path.exists(global_jinx_path):
+            jinx = Jinx(jinx_path=global_jinx_path)
+    
+    if not jinx:
+        return jsonify({"error": f"Jinx '{jinx_name}' not found"}), 404
+    
+    # Extract inputs from args
+    from npcpy.npc_compiler import extract_jinx_inputs
+    input_values = extract_jinx_inputs(jinx_args, jinx)
+    
+    # Get conversation history
+    command_history = CommandHistory(app.config.get('DB_PATH'))
+    messages = fetch_messages_for_conversation(conversation_id)
+    
+    # Prepare jinxs_dict for execution
+    all_jinxs = {}
+    if npc_object and hasattr(npc_object, 'jinxs_dict'):
+        all_jinxs.update(npc_object.jinxs_dict)
+    
+    def event_stream(current_stream_id):
+        try:
+            # Execute the jinx
+            result = jinx.execute(
+                input_values=input_values,
+                jinxs_dict=all_jinxs,
+                jinja_env=npc_object.jinja_env if npc_object else None,
+                npc=npc_object,
+                messages=messages
+            )
+            
+            # Get output
+            output = result.get('output', str(result))
+            messages_updated = result.get('messages', messages)
+            
+            # Check for interruption
+            with cancellation_lock:
+                if cancellation_flags.get(current_stream_id, False):
+                    yield f"data: {json.dumps({'type': 'interrupted'})}\n\n"
+                    return
+            
+            # Stream the output in chunks for consistent UI experience
+            if isinstance(output, str):
+                chunk_size = 50  # Characters per chunk
+                for i in range(0, len(output), chunk_size):
+                    chunk = output[i:i + chunk_size]
+                    chunk_data = {
+                        "id": None,
+                        "object": None,
+                        "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                        "model": model,
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "content": chunk,
+                                "role": "assistant"
+                            },
+                            "finish_reason": None
+                        }]
+                    }
+                    yield f"data: {json.dumps(chunk_data)}\n\n"
+            else:
+                # Non-string output, send as single chunk
+                chunk_data = {
+                    "id": None,
+                    "object": None,
+                    "created": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {
+                            "content": str(output),
+                            "role": "assistant"
+                        },
+                        "finish_reason": None
+                    }]
+                }
+                yield f"data: {json.dumps(chunk_data)}\n\n"
+            
+            # Send completion message
+            yield f"data: {json.dumps({'type': 'message_stop'})}\n\n"
+            
+            # Save to conversation history
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "user",
+                f"/{jinx_name} {' '.join(jinx_args)}",
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+            message_id = generate_message_id()
+            save_conversation_message(
+                command_history,
+                conversation_id,
+                "assistant",
+                str(output),
+                wd=current_path,
+                model=model,
+                provider=provider,
+                npc=npc_name,
+                message_id=message_id
+            )
+            
+        except Exception as e:
+            print(f"Error executing jinx {jinx_name}: {str(e)}")
+            traceback.print_exc()
+            error_data = {
+                "type": "error",
+                "error": str(e)
+            }
+            yield f"data: {json.dumps(error_data)}\n\n"
+        
+        finally:
+            with cancellation_lock:
+                if current_stream_id in cancellation_flags:
+                    del cancellation_flags[current_stream_id]
+    
+    return Response(event_stream(stream_id), mimetype="text/event-stream")
 
 @app.route("/api/settings/global", methods=["POST", "OPTIONS"])
 def save_global_settings():
@@ -1288,6 +1514,187 @@ def get_available_image_models(current_path=None):
 
     return unique_models
 
+@app.route('/api/generative_fill', methods=['POST'])
+def generative_fill():
+    data = request.get_json()
+    image_path = data.get('imagePath')
+    mask_data = data.get('mask')
+    prompt = data.get('prompt')
+    model = data.get('model')
+    provider = data.get('provider')
+    
+    if not all([image_path, mask_data, prompt, model, provider]):
+        return jsonify({"error": "Missing required fields"}), 400
+    
+    try:
+        image_path = os.path.expanduser(image_path)
+        
+        mask_b64 = mask_data.split(',')[1] if ',' in mask_data else mask_data
+        mask_bytes = base64.b64decode(mask_b64)
+        mask_image = Image.open(BytesIO(mask_bytes))
+        
+        original_image = Image.open(image_path)
+        
+        if provider == 'openai':
+            result = inpaint_openai(original_image, mask_image, prompt, model)
+        elif provider == 'gemini':
+            result = inpaint_gemini(original_image, mask_image, prompt, model)
+        elif provider == 'diffusers':
+            result = inpaint_diffusers(original_image, mask_image, prompt, model)
+        else:
+            return jsonify({"error": f"Provider {provider} not supported"}), 400
+        
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"inpaint_{timestamp}.png"
+        save_dir = os.path.dirname(image_path)
+        result_path = os.path.join(save_dir, filename)
+        
+        result.save(result_path)
+        
+        return jsonify({"resultPath": result_path, "error": None})
+        
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+def inpaint_openai(image, mask, prompt, model):
+    import io
+    from openai import OpenAI
+    from PIL import Image
+    import base64
+    
+    client = OpenAI()
+    
+    original_size = image.size
+    
+    if model == 'dall-e-2':
+        valid_sizes = ['256x256', '512x512', '1024x1024']
+        max_dim = max(image.width, image.height)
+        
+        if max_dim <= 256:
+            target_size = (256, 256)
+            size_str = '256x256'
+        elif max_dim <= 512:
+            target_size = (512, 512)
+            size_str = '512x512'
+        else:
+            target_size = (1024, 1024)
+            size_str = '1024x1024'
+    else:
+        valid_sizes = {
+            (1024, 1024): "1024x1024",
+            (1024, 1536): "1024x1536", 
+            (1536, 1024): "1536x1024"
+        }
+        
+        target_size = (1024, 1024)
+        for size in valid_sizes.keys():
+            if image.width > image.height and size == (1536, 1024):
+                target_size = size
+                break
+            elif image.height > image.width and size == (1024, 1536):
+                target_size = size
+                break
+        
+        size_str = valid_sizes[target_size]
+    
+    resized_image = image.resize(target_size, Image.Resampling.LANCZOS)
+    resized_mask = mask.resize(target_size, Image.Resampling.LANCZOS)
+    
+    img_bytes = io.BytesIO()
+    resized_image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    img_bytes.name = 'image.png'
+    
+    mask_bytes = io.BytesIO()
+    resized_mask.save(mask_bytes, format='PNG')
+    mask_bytes.seek(0)
+    mask_bytes.name = 'mask.png'
+    
+    response = client.images.edit(
+        model=model,
+        image=img_bytes,
+        mask=mask_bytes,
+        prompt=prompt,
+        n=1,
+        size=size_str
+    )
+    
+    if response.data[0].url:
+        import requests
+        img_data = requests.get(response.data[0].url).content
+    elif hasattr(response.data[0], 'b64_json'):
+        img_data = base64.b64decode(response.data[0].b64_json)
+    else:
+        raise Exception("No image data in response")
+    
+    result_image = Image.open(io.BytesIO(img_data))
+    return result_image.resize(original_size, Image.Resampling.LANCZOS)
+
+def inpaint_diffusers(image, mask, prompt, model):
+    from diffusers import StableDiffusionInpaintPipeline
+    import torch
+    
+    pipe = StableDiffusionInpaintPipeline.from_pretrained(
+        model,
+        torch_dtype=torch.float16
+    )
+    pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+    
+    result = pipe(
+        prompt=prompt,
+        image=image,
+        mask_image=mask
+    ).images[0]
+    
+    return result
+def inpaint_gemini(image, mask, prompt, model):
+    from npcpy.gen.image_gen import generate_image
+    import io
+    import numpy as np
+    
+    mask_np = np.array(mask.convert('L'))
+    ys, xs = np.where(mask_np > 128)
+    
+    if len(xs) == 0:
+        return image
+    
+    x_center = int(np.mean(xs))
+    y_center = int(np.mean(ys))
+    width_pct = (xs.max() - xs.min()) / image.width * 100
+    height_pct = (ys.max() - ys.min()) / image.height * 100
+    
+    position = "center"
+    if y_center < image.height / 3:
+        position = "top"
+    elif y_center > 2 * image.height / 3:
+        position = "bottom"
+    
+    if x_center < image.width / 3:
+        position += " left"
+    elif x_center > 2 * image.width / 3:
+        position += " right"
+    
+    img_bytes = io.BytesIO()
+    image.save(img_bytes, format='PNG')
+    img_bytes.seek(0)
+    
+    full_prompt =  f"""Using the provided image, change only the region in the {position} 
+        approximately {int(width_pct)}% wide by {int(height_pct)}% tall) to: {prompt}. 
+        
+        Keep everything else exactly the same, matching the original lighting and style.
+        You are in-painting the image. You should not be changing anything other than what was requested in prompt: {prompt}
+        """    
+    results = generate_image(
+        prompt=full_prompt,
+        model=model,
+        provider='gemini',
+        attachments=[img_bytes],
+        n_images=1
+    )
+    
+    return results[0] if results else None
 
 @app.route('/api/generate_images', methods=['POST'])
 def generate_images():

{npcpy-1.2.24 → npcpy-1.2.26/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.24
+Version: 1.2.26
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.24 → npcpy-1.2.26}/setup.py

@@ -83,7 +83,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.2.24",
+    version="1.2.26",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={