npcpy 1.2.28__tar.gz → 1.2.29__tar.gz

{npcpy-1.2.28/npcpy.egg-info → npcpy-1.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.28
+Version: 1.2.29
 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.28 → npcpy-1.2.29}/npcpy/ft/sft.py

@@ -154,13 +154,17 @@ def run_sft(
         save_steps=config.save_steps,
         weight_decay=config.weight_decay,
     )
-    
+            
+    def formatting_func(example):
+        return example["text"]
+
     trainer = SFTTrainer(
         model=model,
         train_dataset=dataset,
         peft_config=peft_config,
         args=training_args,
-        max_seq_length=config.max_length
+        processing_class=tokenizer,
+        formatting_func=formatting_func
     )
     
     print(f"Training on {len(dataset)} examples")
@@ -190,8 +194,6 @@ def load_sft_model(model_path: str):
         tokenizer.pad_token = tokenizer.eos_token
     
     return model, tokenizer
-
-
 def predict_sft(
     model,
     tokenizer,
@@ -202,8 +204,13 @@ def predict_sft(
 
     device = next(model.parameters()).device
     
+    formatted_prompt = (
+        f"<start_of_turn>user\n{prompt}<end_of_turn>\n"
+        f"<start_of_turn>model\n"
+    )
+    
     inputs = tokenizer(
-        prompt,
+        formatted_prompt,
         return_tensors="pt",
         truncation=True,
         max_length=512
@@ -222,9 +229,20 @@ def predict_sft(
             pad_token_id=tokenizer.eos_token_id
         )
     
-    response = tokenizer.decode(
+    full_response = tokenizer.decode(
         outputs[0],
-        skip_special_tokens=True
+        skip_special_tokens=False
     )
     
+    if "<start_of_turn>model\n" in full_response:
+        response = full_response.split(
+            "<start_of_turn>model\n"
+        )[-1]
+        response = response.split("<end_of_turn>")[0].strip()
+    else:
+        response = tokenizer.decode(
+            outputs[0][len(input_ids[0]):],
+            skip_special_tokens=True
+        )
+    
     return response

{npcpy-1.2.28 → npcpy-1.2.29}/npcpy/gen/image_gen.py

@@ -86,6 +86,16 @@ def generate_image_diffusers(
         else:
             raise e
 
+import os
+import base64
+import io
+from typing import Union, List, Optional
+
+import PIL
+from PIL import Image
+
+import requests
+from urllib.request import urlopen
 
 def openai_image_gen(
     prompt: str,
@@ -97,36 +107,47 @@ def openai_image_gen(
 ):
     """Generate or edit an image using the OpenAI API."""
     from openai import OpenAI
-    
+
     client = OpenAI()
-    
+
     if height is None:
         height = 1024
     if width is None:
-        width = 1024  
-    
-    size_str = f"{width}x{height}" 
+        width = 1024
+
+    size_str = f"{width}x{height}"
 
     if attachments is not None:
         processed_images = []
+        files_to_close = []
         for attachment in attachments:
             if isinstance(attachment, str):
-                processed_images.append(open(attachment, "rb"))
+                file_handle = open(attachment, "rb")
+                processed_images.append(file_handle)
+                files_to_close.append(file_handle)
             elif isinstance(attachment, bytes):
-                processed_images.append(io.BytesIO(attachment))
+                img_byte_arr = io.BytesIO(attachment)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
+                processed_images.append(img_byte_arr)
             elif isinstance(attachment, Image.Image):
                 img_byte_arr = io.BytesIO()
                 attachment.save(img_byte_arr, format='PNG')
                 img_byte_arr.seek(0)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
                 processed_images.append(img_byte_arr)
         
-        result = client.images.edit(
-            model=model,
-            image=processed_images[0],
-            prompt=prompt,
-            n=n_images,
-            size=size_str,
-        )
+        try:
+            result = client.images.edit(
+                model=model,
+                image=processed_images[0],
+                prompt=prompt,
+                n=n_images,
+                size=size_str,
+            )
+        finally:
+            # This ensures any files we opened are properly closed
+            for f in files_to_close:
+                f.close()
     else:
         result = client.images.generate(
             model=model,
@@ -134,7 +155,7 @@ def openai_image_gen(
             n=n_images,
             size=size_str,
         )
-    
+
     collected_images = []
     for item_data in result.data:
         if model == 'gpt-image-1':
@@ -153,6 +174,7 @@ def openai_image_gen(
     return collected_images
 
 
+
 def gemini_image_gen(
     prompt: str,
     model: str = "gemini-2.5-flash",

{npcpy-1.2.28 → npcpy-1.2.29}/npcpy/npc_compiler.py

@@ -264,7 +264,6 @@ class Jinx:
         self.inputs = jinx_data.get("inputs", [])
         self.description = jinx_data.get("description", "")
         self.steps = self._parse_steps(jinx_data.get("steps", []))
-            
     def _parse_steps(self, steps):
         """Parse steps from jinx definition"""
         parsed_steps = []
@@ -275,11 +274,12 @@ class Jinx:
                     "engine": step.get("engine", "natural"),
                     "code": step.get("code", "")
                 }
+                if "mode" in step:
+                    parsed_step["mode"] = step["mode"]
                 parsed_steps.append(parsed_step)
             else:
                 raise ValueError(f"Invalid step format: {step}")
         return parsed_steps
-        
     def execute(self,
                 input_values, 
                 jinxs_dict, 
@@ -317,24 +317,19 @@ class Jinx:
             )            
 
         return context
-            
     def _execute_step(self,
-                      step, 
-                      context, 
-                      jinja_env,
-                      npc=None,
-                      messages=None, 
-):
-        """Execute a single step of the jinx"""
+                  step, 
+                  context, 
+                  jinja_env,
+                  npc=None,
+                  messages=None, 
+    ):
         engine = step.get("engine", "natural")
         code = step.get("code", "")
         step_name = step.get("name", "unnamed_step")
-
-        
-        
+        mode = step.get("mode", "chat")
 
         try:
-            
             template = jinja_env.from_string(code)
             rendered_code = template.render(**context)
             
@@ -346,16 +341,23 @@ class Jinx:
             rendered_code = code
             rendered_engine = engine
                 
-        
         if rendered_engine == "natural":
             if rendered_code.strip():
-                
-                response = npc.get_llm_response(
-                    rendered_code,
-                    context=context,
-                    messages=messages,
-                )
-               
+                if mode == "agent":
+                    response = npc.get_llm_response(
+                        rendered_code,
+                        context=context,
+                        messages=messages,
+                        auto_process_tool_calls=True,
+                        use_core_tools=True
+                    )
+                else:
+                    response = npc.get_llm_response(
+                        rendered_code,
+                        context=context,
+                        messages=messages,
+                    )
+            
                 response_text = response.get("response", "")
                 context['output'] = response_text
                 context["llm_response"] = response_text
@@ -363,7 +365,6 @@ class Jinx:
                 context[step_name] = response_text
                 context['messages'] = response.get('messages')
         elif rendered_engine == "python":
-            
             exec_globals = {
                 "__builtins__": __builtins__,
                 "npc": npc,
@@ -379,48 +380,44 @@ class Jinx:
                 "pathlib": pathlib,
                 "subprocess": subprocess,
                 "get_llm_response": npy.llm_funcs.get_llm_response, 
-                
                 }
             
-            
-            
             exec_locals = {}
             exec(rendered_code, exec_globals, exec_locals)
             
-            
             context.update(exec_locals)
             
-            
             if "output" in exec_locals:
                 outp = exec_locals["output"]
                 context["output"] = outp
                 context[step_name] = outp
                 messages.append({'role':'assistant', 
-                                 'content': f'Jinx executed with following output: {outp}'})
+                                'content': f'Jinx executed with following output: {outp}'})
                 context['messages'] = messages
                 
         else:
-            
             context[step_name] = {"error": f"Unsupported engine: {rendered_engine}"}
             
         return context
-        
     def to_dict(self):
         """Convert to dictionary representation"""
+        steps_list = []
+        for i, step in enumerate(self.steps):
+            step_dict = {
+                "name": step.get("name", f"step_{i}"),
+                "engine": step.get("engine"),
+                "code": step.get("code")
+            }
+            if "mode" in step:
+                step_dict["mode"] = step["mode"]
+            steps_list.append(step_dict)
+        
         return {
             "jinx_name": self.jinx_name,
             "description": self.description,
             "inputs": self.inputs,
-            "steps": [
-                {
-                    "name": step.get("name", f"step_{i}"),
-                    "engine": step.get("engine"),
-                    "code": step.get("code")
-                }
-                for i, step in enumerate(self.steps)
-            ]
+            "steps": steps_list
         }
-        
     def save(self, directory):
         """Save jinx to file"""
         jinx_path = os.path.join(directory, f"{self.jinx_name}.jinx")

{npcpy-1.2.28 → npcpy-1.2.29/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.28
+Version: 1.2.29
 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.28 → npcpy-1.2.29}/setup.py

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