lollms-client 0.9.1__tar.gz → 0.9.2__tar.gz

{lollms_client-0.9.1 → lollms_client-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lollms_client
-Version: 0.9.1
+Version: 0.9.2
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo

{lollms_client-0.9.1 → lollms_client-0.9.2}/lollms_client/lollms_core.py

@@ -36,7 +36,9 @@ class ELF_GENERATION_FORMAT(Enum):
             return format_mapping[format_string.upper()]
         except KeyError:
             raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
-        
+    
+    def __str__(self):
+        return self.name    
 class ELF_COMPLETION_FORMAT(Enum):
     Instruct = 0
     Chat = 1
@@ -51,6 +53,9 @@ class ELF_COMPLETION_FORMAT(Enum):
             return format_mapping[format_string.upper()]
         except KeyError:
             raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
+    
+    def __str__(self):
+        return self.name    
         
 class LollmsClient():
     def __init__(
@@ -155,23 +160,31 @@ class LollmsClient():
     def system_full_header(self) -> str:
         """Get the start_header_id_template."""
         return f"{self.start_header_id_template}{self.system_message_template}{self.end_header_id_template}"
+    
+    def system_custom_header(self, ai_name) -> str:
+        """Get the start_header_id_template."""
+        return f"{self.start_header_id_template}{ai_name}{self.end_header_id_template}"
+    
     @property
     def user_full_header(self) -> str:
         """Get the start_header_id_template."""
         return f"{self.start_user_header_id_template}{self.user_name}{self.end_user_header_id_template}"
+    
+    def user_custom_header(self, user_name="user") -> str:
+        """Get the start_header_id_template."""
+        return f"{self.start_user_header_id_template}{user_name}{self.end_user_header_id_template}"
+    
     @property
     def ai_full_header(self) -> str:
         """Get the start_header_id_template."""
         return f"{self.start_ai_header_id_template}{self.ai_name}{self.end_ai_header_id_template}"
 
-    def system_custom_header(self, ai_name) -> str:
-        """Get the start_header_id_template."""
-        return f"{self.start_header_id_template}{ai_name}{self.end_header_id_template}"
-
     def ai_custom_header(self, ai_name) -> str:
         """Get the start_header_id_template."""
         return f"{self.start_ai_header_id_template}{ai_name}{self.end_ai_header_id_template}"
 
+    def sink(self, s=None,i=None,d=None):
+        pass
 
     def tokenize(self, prompt:str):
         """
@@ -1582,6 +1595,182 @@ Do not split the code in multiple tags.
         
         return cleaned_text
 
+    def yes_no(
+            self,
+            question: str,
+            context: str = "",
+            max_answer_length: int = None,
+            conditionning: str = "",
+            return_explanation: bool = False,
+            callback = None
+        ) -> bool | dict:
+        """
+        Answers a yes/no question.
+
+        Args:
+            question (str): The yes/no question to answer.
+            context (str, optional): Additional context to provide for the question.
+            max_answer_length (int, optional): Maximum string length allowed for the response. Defaults to None.
+            conditionning (str, optional): An optional system message to put at the beginning of the prompt.
+            return_explanation (bool, optional): If True, returns a dictionary with the answer and explanation. Defaults to False.
+
+        Returns:
+            bool or dict: 
+                - If return_explanation is False, returns a boolean (True for 'yes', False for 'no').
+                - If return_explanation is True, returns a dictionary with the answer and explanation.
+        """
+        if not callback:
+            callback=self.sink
+
+        prompt = f"{conditionning}\nQuestion: {question}\nContext: {context}\n"
+        
+        template = """
+        {
+            "answer": true | false,
+            "explanation": "Optional explanation if return_explanation is True"
+        }
+        """
+        
+        response = self.generate_code(
+            prompt=prompt,
+            template=template,
+            language="json",
+            code_tag_format="markdown",
+            max_size=max_answer_length,
+            callback=callback
+        )
+        
+        try:
+            parsed_response = json.loads(response)
+            answer = parsed_response.get("answer", False)
+            explanation = parsed_response.get("explanation", "")
+            
+            if return_explanation:
+                return {"answer": answer, "explanation": explanation}
+            else:
+                return answer
+        except json.JSONDecodeError:
+            return False
+
+    def multichoice_question(
+            self, 
+            question: str, 
+            possible_answers: list, 
+            context: str = "", 
+            max_answer_length: int = None, 
+            conditionning: str = "", 
+            return_explanation: bool = False,
+            callback = None
+        ) -> dict:
+        """
+        Interprets a multi-choice question from a user's response. This function expects only one choice as true. 
+        All other choices are considered false. If none are correct, returns -1.
+
+        Args:
+            question (str): The multi-choice question posed by the user.
+            possible_answers (List[Any]): A list containing all valid options for the chosen value.
+            context (str, optional): Additional context to provide for the question.
+            max_answer_length (int, optional): Maximum string length allowed while interpreting the user's responses. Defaults to None.
+            conditionning (str, optional): An optional system message to put at the beginning of the prompt.
+            return_explanation (bool, optional): If True, returns a dictionary with the choice and explanation. Defaults to False.
+
+        Returns:
+            dict: 
+                - If return_explanation is False, returns a JSON object with only the selected choice index.
+                - If return_explanation is True, returns a JSON object with the selected choice index and an explanation.
+                - Returns {"index": -1} if no match is found among the possible answers.
+        """
+        if not callback:
+            callback=self.sink
+        
+        prompt = f"""
+        {conditionning}\n
+        QUESTION:\n{question}\n
+        POSSIBLE ANSWERS:\n"""
+        for i, answer in enumerate(possible_answers):
+            prompt += f"{i}. {answer}\n"
+        
+        if context:
+            prompt += f"\nADDITIONAL CONTEXT:\n{context}\n"
+        
+        prompt += "\nRespond with a JSON object containing:\n"
+        if return_explanation:
+            prompt += "{\"index\": (the selected answer index), \"explanation\": (reasoning for selection)}"
+        else:
+            prompt += "{\"index\": (the selected answer index)}"
+        
+        response = self.generate_code(prompt, language="json", max_size=max_answer_length, 
+            accept_all_if_no_code_tags_is_present=True, return_full_generated_code=False, callback=callback)
+        
+        try:
+            result = json.loads(response)
+            if return_explanation:
+                if "index" in result and isinstance(result["index"], int):
+                    return result["index"], result["index"]
+            else:
+                if "index" in result and isinstance(result["index"], int):
+                    return result["index"]
+        except json.JSONDecodeError:
+            if return_explanation:
+                return -1, "failed to decide"
+            else:
+                return -1
+            
+    def multichoice_ranking(
+            self, 
+            question: str, 
+            possible_answers: list, 
+            context: str = "", 
+            max_answer_length: int = 512, 
+            conditionning: str = "", 
+            return_explanation: bool = False,
+            callback = None
+        ) -> dict:
+        """
+        Ranks answers for a question from best to worst. Returns a JSON object containing the ranked order.
+
+        Args:
+            question (str): The question for which the answers are being ranked.
+            possible_answers (List[Any]): A list of possible answers to rank.
+            context (str, optional): Additional context to provide for the question.
+            max_answer_length (int, optional): Maximum string length allowed for the response. Defaults to 50.
+            conditionning (str, optional): An optional system message to put at the beginning of the prompt.
+            return_explanation (bool, optional): If True, returns a dictionary with the ranked order and explanations. Defaults to False.
+
+        Returns:
+            dict: 
+                - If return_explanation is False, returns a JSON object with only the ranked order.
+                - If return_explanation is True, returns a JSON object with the ranked order and explanations.
+        """
+        if not callback:
+            callback=self.sink
+        
+        prompt = f"""
+        {conditionning}\n
+        QUESTION:\n{question}\n
+        POSSIBLE ANSWERS:\n"""
+        for i, answer in enumerate(possible_answers):
+            prompt += f"{i}. {answer}\n"
+        
+        if context:
+            prompt += f"\nADDITIONAL CONTEXT:\n{context}\n"
+        
+        prompt += "\nRespond with a JSON object containing:\n"
+        if return_explanation:
+            prompt += "{\"ranking\": (list of indices ordered from best to worst), \"explanations\": (list of reasons for each ranking)}"
+        else:
+            prompt += "{\"ranking\": (list of indices ordered from best to worst)}"
+        
+        response = self.generate_code(prompt, language="json", return_full_generated_code=False, callback=callback)
+        
+        try:
+            result = json.loads(response)
+            if "ranking" in result and isinstance(result["ranking"], list):
+                return result
+        except json.JSONDecodeError:
+            return {"ranking": []}
+        
+        
     def sequential_summarize(
                                 self, 
                                 text:str,
@@ -1736,6 +1925,156 @@ The updated memory must be put in a {chunk_processing_output_format} markdown ta
             memory=code[0]["content"]
         return memory
 
+    def deepsearch(
+            self,
+            query: str,
+            text: str = None,
+            files: list = None,
+            search_prompt: str = "Extract information related to the query from the current text chunk and update the memory with new findings.",
+            aggregation_prompt: str = None,
+            output_format: str = "markdown",
+            ctx_size: int = None,
+            chunk_size: int = None,
+            bootstrap_chunk_size: int = None,
+            bootstrap_steps: int = None,
+            callback=None,
+            debug: bool = False
+        ):
+            """
+            Searches for specific information related to a query in a long text or a list of files.
+            Processes the input in chunks, updates a memory with relevant findings, and optionally aggregates them.
+
+            Parameters:
+            - query (str): The query to search for.
+            - text (str, optional): The input text to search in. Defaults to None.
+            - files (list, optional): List of file paths to search in. Defaults to None.
+            - search_prompt (str, optional): Prompt for processing each chunk. Defaults to a standard extraction prompt.
+            - aggregation_prompt (str, optional): Prompt for aggregating findings. Defaults to None.
+            - output_format (str, optional): Output format. Defaults to "markdown".
+            - ctx_size (int, optional): Context size for the model. Defaults to None (uses self.ctx_size).
+            - chunk_size (int, optional): Size of each chunk. Defaults to None (ctx_size // 4). Smaller chunk sizes yield better results but is slower.
+            - bootstrap_chunk_size (int, optional): Size for initial chunks. Defaults to None.
+            - bootstrap_steps (int, optional): Number of initial chunks using bootstrap size. Defaults to None.
+            - callback (callable, optional): Function called after each chunk. Defaults to None.
+            - debug (bool, optional): Enable debug output. Defaults to False.
+
+            Returns:
+            - str: The search findings or aggregated output in the specified format.
+            """
+            # Set defaults
+            if ctx_size is None:
+                ctx_size = self.ctx_size
+            if chunk_size is None:
+                chunk_size = ctx_size // 4
+
+            # Prepare input
+            if files:
+                all_texts = [(file, open(file, 'r', encoding='utf-8').read()) for file in files]
+            elif text:
+                all_texts = [("input_text", text)]
+            else:
+                raise ValueError("Either text or files must be provided.")
+
+            # Initialize memory and chunk counter
+            memory = ""
+            chunk_id = 0
+
+            # Define search prompt template using f-string and the provided search_prompt
+            search_prompt_template = f"""{self.system_full_header}
+You are a search assistant that processes documents chunk by chunk to find information related to a query, updating a memory of findings at each step.
+
+Your goal is to extract and combine relevant information from each text chunk with the existing memory, ensuring no key details are omitted or invented.
+
+
+----
+# Chunk number: {{chunk_id}}
+# Text chunk:
+```markdown
+{{chunk}}
+```
+
+Current findings memory:
+```markdown
+{{memory}}
+```
+{self.user_full_header}
+Query: '{query}'
+Task: {search_prompt}
+
+Update the memory by adding new relevant information from this chunk. Retain all prior findings unless contradicted or updated. Only include explicitly relevant details.
+Make sure to extrafct only information relevant to be able to answer the query of the user or at least gives important contextual information that can be completed to answer the user query.
+{self.ai_full_header}
+"""
+
+            # Calculate static prompt tokens
+            example_prompt = search_prompt_template.replace("{{chunk_id}}", "0")\
+                                                .replace("{{memory}}", "")\
+                                                .replace("{{chunk}}", "")
+            static_tokens = len(self.tokenize(example_prompt))
+
+            # Process each text (file or input)
+            for file_name, file_text in all_texts:
+                file_tokens = self.tokenize(file_text)
+                start_token_idx = 0
+
+                while start_token_idx < len(file_tokens):
+                    # Calculate available tokens
+                    current_memory_tokens = len(self.tokenize(memory))
+                    available_tokens = ctx_size - static_tokens - current_memory_tokens
+                    if available_tokens <= 0:
+                        raise ValueError("Memory too large - consider reducing chunk size or increasing context window")
+
+                    # Adjust chunk size
+                    actual_chunk_size = (
+                        min(bootstrap_chunk_size, available_tokens)
+                        if bootstrap_chunk_size is not None and bootstrap_steps is not None and chunk_id < bootstrap_steps
+                        else min(chunk_size, available_tokens)
+                    )
+                    
+                    end_token_idx = min(start_token_idx + actual_chunk_size, len(file_tokens))
+                    chunk_tokens = file_tokens[start_token_idx:end_token_idx]
+                    chunk = self.detokenize(chunk_tokens)
+
+                    # Generate updated memory
+                    prompt = search_prompt_template.replace("{chunk_id}", str(chunk_id))\
+                                                .replace("{memory}", memory)\
+                                                .replace("{chunk}", chunk)
+                    if debug:
+                        print(f"----- Chunk {chunk_id} from {file_name} ------")
+                        print(prompt)
+
+                    output = self.generate(prompt, n_predict=ctx_size // 4, streaming_callback=callback).strip()
+                    code = self.extract_code_blocks(output)
+                    memory = code[0]["content"] if code else output
+
+                    if debug:
+                        print("----- Updated Memory ------")
+                        print(memory)
+                        print("---------------------------")
+
+                    start_token_idx = end_token_idx
+                    chunk_id += 1
+
+            # Aggregate findings if requested
+            if aggregation_prompt:
+                final_prompt = f"""{self.system_full_header}
+You are a search results aggregator.
+
+{self.user_full_header}
+{aggregation_prompt}
+
+Collected findings:
+```markdown
+{memory}
+```
+
+Provide the final output in {output_format} format.
+{self.ai_full_header}
+"""
+                final_output = self.generate(final_prompt, streaming_callback=callback)
+                code = self.extract_code_blocks(final_output)
+                return code[0]["content"] if code else final_output
+            return memory
 def error(self, content, duration:int=4, client_id=None, verbose:bool=True):
     ASCIIColors.error(content)
 

{lollms_client-0.9.1 → lollms_client-0.9.2}/lollms_client/lollms_tasks.py

@@ -435,12 +435,12 @@ class TasksLibrary:
         choices = "\n".join([f"{i}. {possible_answer}" for i, possible_answer in enumerate(possible_answers)])
         elements = [conditionning] if conditionning!="" else []
         elements += [
-                "!@>system:",
+                self.lollms.system_full_header,
                 "Answer this multi choices question.",
         ]
         if context!="":
             elements+=[
-                       "!@>Context:",
+                       self.lollms.system_custom_header("Context"),
                         f"{context}",
                     ]
         elements +=[
@@ -450,11 +450,11 @@ class TasksLibrary:
                 "the output should be an integer."
         ]
         elements += [
-                f"!@>question: {question}",
-                "!@>possible answers:",
+                f'{self.lollms.user_custom_header("question")} {question}',
+                f'{self.lollms.user_custom_header("possible answers")}',
                 f"{choices}",
         ]
-        elements += ["!@>answer:"]
+        elements += [self.lollms.ai_custom_header("answer")]
         prompt = self.build_prompt(elements)
 
         gen = self.lollms.generate(prompt, max_answer_length, temperature=0.1, top_k=50, top_p=0.9, repeat_penalty=1.0, repeat_last_n=50, streaming_callback=self.sink).strip().replace("</s>","").replace("<s>","")

{lollms_client-0.9.1 → lollms_client-0.9.2}/lollms_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lollms_client
-Version: 0.9.1
+Version: 0.9.2
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo

{lollms_client-0.9.1 → lollms_client-0.9.2}/setup.py

@@ -8,7 +8,7 @@ with open('requirements.txt', 'r') as f:
     
 setuptools.setup(
     name="lollms_client",
-    version="0.9.1",
+    version="0.9.2",
     author="ParisNeo",
     author_email="parisneoai@gmail.com",
     description="A client library for LoLLMs generate endpoint",