lollms-client 1.4.1__tar.gz → 1.4.6__tar.gz

{lollms_client-1.4.1/src/lollms_client.egg-info → lollms_client-1.4.6}/PKG-INFO

@@ -1,9 +1,210 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.4.1
+Version: 1.4.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
-License: Apache Software License
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
 Project-URL: Homepage, https://github.com/ParisNeo/lollms_client
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -18,6 +219,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: ascii-colors
 Requires-Dist: pipmaster

{lollms_client-1.4.1 → lollms_client-1.4.6}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=77.0", "wheel"]
+requires = ["setuptools>=80.9", "wheel"]
 build-backend = "setuptools.build_meta"
 # REMOVE THE LINE BELOW:
 # backend-path = ["."]
@@ -13,7 +13,7 @@ authors = [
 description = "A client library for LoLLMs generate endpoint"
 readme = "README.md"
 requires-python = ">=3.7"
-license = {text = "Apache Software License"}
+license = { file = "LICENSE" }
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.8",
@@ -27,6 +27,7 @@ classifiers = [
     "Intended Audience :: Science/Research",
 ]
 dependencies = [
+    "httpx",
     "requests",
     "ascii-colors",
     "pipmaster",

{lollms_client-1.4.1 → lollms_client-1.4.6}/src/lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.4.1" # Updated version
+__version__ = "1.4.6" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client-1.4.6/src/lollms_client/llm_bindings/novita_ai/__init__.py

@@ -0,0 +1,303 @@
+import os
+import json
+import requests
+from typing import Optional, Callable, List, Union, Dict
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["requests", "tiktoken"])
+
+import tiktoken
+
+BindingName = "NovitaAIBinding"
+API_BASE_URL = "https://api.novita.ai"
+
+# A hardcoded list of models based on Novita AI's documentation.
+# The API is OpenAI-compatible but does not provide a models listing endpoint.
+# Sourced from: https://docs.novita.ai/language-model/models
+_FALLBACK_MODELS = [
+    {'model_name': 'meta-llama/Llama-3-8B-Instruct', 'display_name': 'Llama 3 8B Instruct', 'description': 'Meta\'s Llama 3 8B instruction-tuned model.', 'owned_by': 'Meta'},
+    {'model_name': 'meta-llama/Llama-3-70B-Instruct', 'display_name': 'Llama 3 70B Instruct', 'description': 'Meta\'s Llama 3 70B instruction-tuned model.', 'owned_by': 'Meta'},
+    {'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1', 'display_name': 'Mixtral 8x7B Instruct', 'description': 'Mistral AI\'s Mixtral 8x7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
+    {'model_name': 'mistralai/Mistral-7B-Instruct-v0.2', 'display_name': 'Mistral 7B Instruct v0.2', 'description': 'Mistral AI\'s 7B instruction-tuned model.', 'owned_by': 'Mistral AI'},
+    {'model_name': 'google/gemma-7b-it', 'display_name': 'Gemma 7B IT', 'description': 'Google\'s Gemma 7B instruction-tuned model.', 'owned_by': 'Google'},
+    {'model_name': 'google/gemma-2-9b-it', 'display_name': 'Gemma 2 9B IT', 'description': 'Google\'s next-generation Gemma 2 9B instruction-tuned model.', 'owned_by': 'Google'},
+    {'model_name': 'deepseek-ai/deepseek-coder-33b-instruct', 'display_name': 'Deepseek Coder 33B Instruct', 'description': 'A powerful coding model from Deepseek AI.', 'owned_by': 'Deepseek AI'},
+]
+
+class NovitaAIBinding(LollmsLLMBinding):
+    """Novita AI-specific binding implementation using their OpenAI-compatible API."""
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the Novita AI binding.
+
+        Args:
+            model_name (str): Name of the Novita AI model to use.
+            service_key (str): Novita AI API key.
+        """
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")
+        self.service_key = kwargs.get("service_key")
+
+        if not self.service_key:
+            self.service_key = os.getenv("NOVITA_API_KEY")
+
+        if not self.service_key:
+            raise ValueError("Novita AI API key is required. Please set it via the 'service_key' parameter or the NOVITA_API_KEY environment variable.")
+
+        self.headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def _construct_parameters(self,
+                              temperature: float,
+                              top_p: float,
+                              n_predict: int,
+                              presence_penalty: float,
+                              frequency_penalty: float) -> Dict[str, any]:
+        """Builds a parameters dictionary for the Novita AI API."""
+        params = {}
+        if temperature is not None: params['temperature'] = float(temperature)
+        if top_p is not None: params['top_p'] = top_p
+        if n_predict is not None: params['max_tokens'] = n_predict
+        if presence_penalty is not None: params['presence_penalty'] = presence_penalty
+        if frequency_penalty is not None: params['frequency_penalty'] = frequency_penalty
+        return params
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             temperature: float = 0.7,
+             top_k: int = 50, # Not supported by Novita API
+             top_p: float = 0.9,
+             repeat_penalty: float = 1.1, # maps to frequency_penalty
+             presence_penalty: Optional[float] = 0.0,
+             seed: Optional[int] = None, # Not supported
+             n_threads: Optional[int] = None, # Not applicable
+             ctx_size: Optional[int] = None, # Determined by model
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with a Novita AI model using a LollmsDiscussion object.
+        """
+        system_prompt = discussion.system_prompt
+        messages = discussion.get_messages(branch_tip_id)
+
+        history = []
+        if system_prompt and system_prompt.strip():
+            history.append({"role": "system", "content": system_prompt})
+
+        for msg in messages:
+            role = 'user' if msg.sender_type == "user" else 'assistant'
+            
+            if msg.images:
+                ASCIIColors.warning("Novita AI API does not support images. They will be ignored.")
+
+            if msg.content and msg.content.strip():
+                history.append({"role": role, "content": msg.content})
+
+        if not history:
+            return {"status": "error", "message": "Cannot start chat with an empty discussion."}
+
+        api_params = self._construct_parameters(
+            temperature, top_p, n_predict, presence_penalty, repeat_penalty
+        )
+        
+        payload = {
+            "model": self.model_name,
+            "messages": history,
+            "stream": stream,
+            **api_params
+        }
+        
+        url = f"{API_BASE_URL}/v1/chat/completions"
+        full_response_text = ""
+
+        try:
+            if stream:
+                with requests.post(url, headers=self.headers, json=payload, stream=True) as response:
+                    response.raise_for_status()
+                    for line in response.iter_lines():
+                        if line:
+                            decoded_line = line.decode('utf-8')
+                            if decoded_line.startswith("data:"):
+                                content = decoded_line[len("data: "):].strip()
+                                if content == "[DONE]":
+                                    break
+                                try:
+                                    chunk = json.loads(content)
+                                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                                    text_chunk = delta.get("content", "")
+                                    if text_chunk:
+                                        full_response_text += text_chunk
+                                        if streaming_callback:
+                                            if not streaming_callback(text_chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+                                                break
+                                except json.JSONDecodeError:
+                                    ASCIIColors.error(f"Failed to decode JSON chunk: {content}")
+                                    continue
+                return full_response_text
+            else:
+                response = requests.post(url, headers=self.headers, json=payload)
+                response.raise_for_status()
+                data = response.json()
+                return data["choices"][0]["message"]["content"]
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_details = e.response.json()
+                error_message = error_details.get("error", {}).get("message", e.response.text)
+            except json.JSONDecodeError:
+                error_message = e.response.text
+            ASCIIColors.error(f"HTTP Error received from Novita AI API: {e.response.status_code} - {error_message}")
+            return {"status": "error", "message": f"HTTP Error: {e.response.status_code} - {error_message}"}
+        except requests.exceptions.RequestException as e:
+            error_message = f"An error occurred with the Novita AI API: {e}"
+            trace_exception(e)
+            return {"status": "error", "message": str(e)}
+
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text. Novita uses an OpenAI-compatible API,
+        so we use the same tokenizer as GPT-4.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple encoding: {e}")
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except Exception as e:
+            ASCIIColors.error(f"Could not use tiktoken, falling back to simple decoding: {e}")
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text.
+        """
+        return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text.
+        """
+        ASCIIColors.warning("Novita AI does not offer a public embedding API via this binding. This method is not implemented.")
+        raise NotImplementedError("Novita AI binding does not support embeddings.")
+
+    def get_model_info(self) -> dict:
+        """Return information about the current model setup."""
+        return {
+            "name": self.binding_name,
+            "host_address": API_BASE_URL,
+            "model_name": self.model_name,
+            "supports_vision": False
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models. Novita AI API does not have a models endpoint,
+        so a hardcoded list from their documentation is returned.
+        """
+        return sorted(_FALLBACK_MODELS, key=lambda x: x['display_name'])
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Novita AI model set to: {model_name}.")
+        return True
+
+if __name__ == '__main__':
+    if 'NOVITA_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: NOVITA_API_KEY environment variable not set.")
+        print("Please get your key from novita.ai and set it.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing NovitaAIBinding ---")
+    
+    test_model_name = "meta-llama/Llama-3-8B-Instruct"
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = NovitaAIBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models (static list) ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models.")
+            for m in models:
+                print(f"- {m['model_name']} ({m['display_name']})")
+        else:
+            ASCIIColors.error("Failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Chat (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Non-Streaming) ---")
+        discussion_non_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "What is the largest planet in our solar system?"}
+            ],
+            system_prompt="You are a helpful and concise astronomical assistant."
+        )
+        ASCIIColors.info(f"Prompt: What is the largest planet in our solar system?")
+        generated_text = binding.chat(discussion_non_stream, n_predict=50, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Chat (Streaming) ---
+        ASCIIColors.cyan("\n--- Chat (Streaming) ---")
+        
+        captured_chunks = []
+        def stream_callback(chunk: str, msg_type: int):
+            ASCIIColors.green(chunk, end="", flush=True)
+            captured_chunks.append(chunk)
+            return True
+        
+        discussion_stream = LollmsDiscussion.from_messages(
+            messages=[
+                {"sender":"user", "content": "Explain the concept of photosynthesis in one short paragraph."}
+            ]
+        )
+        ASCIIColors.info(f"Prompt: Explain the concept of photosynthesis in one short paragraph.")
+        result = binding.chat(
+            discussion_stream, 
+            n_predict=150, 
+            stream=True, 
+            streaming_callback=stream_callback
+        )
+        print("\n--- End of Stream ---")
+        full_streamed_text = "".join(captured_chunks)
+        assert result == full_streamed_text
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nNovitaAIBinding test finished.")