Fix rebase conflicts

gpt4all-bindings/python/gpt4all/gpt4all.py

@@ -4,66 +4,37 @@
 from __future__ import annotations
 
 import hashlib
-import json
 import os
 import platform
 import re
 import sys
 import warnings
 from contextlib import contextmanager
-from datetime import datetime
 from pathlib import Path
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, NamedTuple, NoReturn, Protocol, TypedDict, overload
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Protocol, overload
 
-import jinja2
 import requests
-from jinja2.sandbox import ImmutableSandboxedEnvironment
 from requests.exceptions import ChunkedEncodingError
 from tqdm import tqdm
 from urllib3.exceptions import IncompleteRead, ProtocolError
 
 from ._pyllmodel import (CancellationError as CancellationError, EmbCancelCallbackType, EmbedResult as EmbedResult,
-                         LLModel, ResponseCallbackType, _operator_call, empty_response_callback)
+                         LLModel, ResponseCallbackType, empty_response_callback)
 
 if TYPE_CHECKING:
     from typing_extensions import Self, TypeAlias
 
-if sys.platform == "darwin":
+if sys.platform == 'darwin':
     import fcntl
 
 # TODO: move to config
 DEFAULT_MODEL_DIRECTORY = Path.home() / ".cache" / "gpt4all"
 
-ConfigType: TypeAlias = "dict[str, Any]"
+DEFAULT_PROMPT_TEMPLATE = "### Human:\n{0}\n\n### Assistant:\n"
 
-# Environment setup adapted from HF transformers
-@_operator_call
-def _jinja_env() -> ImmutableSandboxedEnvironment:
-    def raise_exception(message: str) -> NoReturn:
-        raise jinja2.exceptions.TemplateError(message)
-
-    def tojson(obj: Any, indent: int | None = None) -> str:
-        return json.dumps(obj, ensure_ascii=False, indent=indent)
-
-    def strftime_now(fmt: str) -> str:
-        return datetime.now().strftime(fmt)
-
-    env = ImmutableSandboxedEnvironment(trim_blocks=True, lstrip_blocks=True)
-    env.filters["tojson"         ] = tojson
-    env.globals["raise_exception"] = raise_exception
-    env.globals["strftime_now"   ] = strftime_now
-    return env
-
-
-class MessageType(TypedDict):
-    role: str
-    content: str
-
-
-class ChatSession(NamedTuple):
-    template: jinja2.Template
-    history: list[MessageType]
+ConfigType: TypeAlias = 'dict[str, Any]'
+MessageType: TypeAlias = 'dict[str, str]'
 
 
 class Embed4All:
@@ -83,7 +54,7 @@ def __init__(self, model_name: str | None = None, *, n_threads: int | None = Non
             kwargs: Remaining keyword arguments are passed to the `GPT4All` constructor.
         """
         if model_name is None:
-            model_name = "all-MiniLM-L6-v2.gguf2.f16.gguf"
+            model_name = 'all-MiniLM-L6-v2.gguf2.f16.gguf'
         self.gpt4all = GPT4All(model_name, n_threads=n_threads, device=device, **kwargs)
 
     def __enter__(self) -> Self:
@@ -174,18 +145,18 @@ def embed(
             dimensionality = -1
         else:
             if dimensionality <= 0:
-                raise ValueError(f"Dimensionality must be None or a positive integer, got {dimensionality}")
+                raise ValueError(f'Dimensionality must be None or a positive integer, got {dimensionality}')
             if dimensionality < self.MIN_DIMENSIONALITY:
                 warnings.warn(
-                    f"Dimensionality {dimensionality} is less than the suggested minimum of {self.MIN_DIMENSIONALITY}."
-                    " Performance may be degraded."
+                    f'Dimensionality {dimensionality} is less than the suggested minimum of {self.MIN_DIMENSIONALITY}.'
+                    ' Performance may be degraded.'
                 )
         try:
             do_mean = {"mean": True, "truncate": False}[long_text_mode]
         except KeyError:
             raise ValueError(f"Long text mode must be one of 'mean' or 'truncate', got {long_text_mode!r}")
         result = self.gpt4all.model.generate_embeddings(text, prefix, dimensionality, do_mean, atlas, cancel_cb)
-        return result if return_dict else result["embeddings"]
+        return result if return_dict else result['embeddings']
 
 
 class GPT4All:
@@ -239,7 +210,6 @@ def __init__(
         if proxies is None:
             proxies = {}
         self.model_type = model_type
-        self._chat_session: ChatSession | None = None
         self._history: list[MessageType] | None = None
         self._current_prompt_template: str = "{0}"
         self._proxies = proxies
@@ -302,13 +272,7 @@ def device(self) -> str | None:
 
     @property
     def current_chat_session(self) -> list[MessageType] | None:
-        return None if self._chat_session is None else self._chat_session.history
-
-    @current_chat_session.setter
-    def current_chat_session(self, history: list[MessageType]) -> None:
-        if self._chat_session is None:
-            raise ValueError("current_chat_session may only be set when there is an active chat session")
-        self._chat_session.history[:] = history
+        return None if self._history is None else list(self._history)
 
     @staticmethod
     def list_models(
@@ -330,7 +294,7 @@ def list_models(
 
         resp = requests.get("https://gpt4all.io/models/models3.json", proxies=proxies, verify=verify_ssl)
         if resp.status_code != 200:
-            raise ValueError(f"Request failed: HTTP {resp.status_code} {resp.reason}")
+            raise ValueError(f'Request failed: HTTP {resp.status_code} {resp.reason}')
         return resp.json()
 
     @classmethod
@@ -366,7 +330,7 @@ def retrieve_model(
         # get the config for the model
         config: ConfigType = {}
         if allow_download:
-            models = cls.list_models()
+            models = cls.list_models(proxies=proxies, verify_ssl=verify_ssl)
             if (model := next((m for m in models if m["filename"] == model_filename), None)) is not None:
                 config.update(model)
 
@@ -437,13 +401,13 @@ def make_request(offset=None):
             headers = {}
             if offset:
                 print(f"\nDownload interrupted, resuming from byte position {offset}", file=sys.stderr)
-                headers["Range"] = f"bytes={offset}-"  # resume incomplete response
+                headers['Range'] = f'bytes={offset}-'  # resume incomplete response
                 headers["Accept-Encoding"] = "identity"  # Content-Encoding changes meaning of ranges
             response = requests.get(url, stream=True, headers=headers, proxies=proxies, verify=verify_ssl)
             if response.status_code not in (200, 206):
-                raise ValueError(f"Request failed: HTTP {response.status_code} {response.reason}")
-            if offset and (response.status_code != 206 or str(offset) not in response.headers.get("Content-Range", "")):
-                raise ValueError("Connection was interrupted and server does not support range requests")
+                raise ValueError(f'Request failed: HTTP {response.status_code} {response.reason}')
+            if offset and (response.status_code != 206 or str(offset) not in response.headers.get('Content-Range', '')):
+                raise ValueError('Connection was interrupted and server does not support range requests')
             if (enc := response.headers.get("Content-Encoding")) is not None:
                 raise ValueError(f"Expected identity Content-Encoding, got {enc}")
             return response
@@ -542,19 +506,19 @@ def generate(
 
     def generate(
         self,
-        prompt         : str,
+        prompt: str,
         *,
-        max_tokens     : int                  = 200,
-        temp           : float                = 0.7,
-        top_k          : int                  = 40,
-        top_p          : float                = 0.4,
-        min_p          : float                = 0.0,
-        repeat_penalty : float                = 1.18,
-        repeat_last_n  : int                  = 64,
-        n_batch        : int                  = 8,
-        n_predict      : int | None           = None,
-        streaming      : bool                 = False,
-        callback       : ResponseCallbackType = empty_response_callback,
+        max_tokens: int = 200,
+        temp: float = 0.7,
+        top_k: int = 40,
+        top_p: float = 0.4,
+        min_p: float = 0.0,
+        repeat_penalty: float = 1.18,
+        repeat_last_n: int = 64,
+        n_batch: int = 8,
+        n_predict: int | None = None,
+        streaming: bool = False,
+        callback: ResponseCallbackType = empty_response_callback,
     ) -> Any:
         """
         Generate outputs from any GPT4All model.
@@ -579,94 +543,122 @@ def generate(
 
         # Preparing the model request
         generate_kwargs: dict[str, Any] = dict(
-            temp           = temp,
-            top_k          = top_k,
-            top_p          = top_p,
-            min_p          = min_p,
-            repeat_penalty = repeat_penalty,
-            repeat_last_n  = repeat_last_n,
-            n_batch        = n_batch,
-            n_predict      = n_predict if n_predict is not None else max_tokens,
+            temp=temp,
+            top_k=top_k,
+            top_p=top_p,
+            min_p=min_p,
+            repeat_penalty=repeat_penalty,
+            repeat_last_n=repeat_last_n,
+            n_batch=n_batch,
+            n_predict=n_predict if n_predict is not None else max_tokens,
         )
 
-        # Prepare the callback, process the model response
-        full_response = ""
-
-        def _callback_wrapper(token_id: int, response: str) -> bool:
-            nonlocal full_response
-            full_response += response
-            return callback(token_id, response)
-
-        last_msg_rendered = prompt
-        if self._chat_session is not None:
-            session = self._chat_session
-            def render(messages: list[MessageType]) -> str:
-                return session.template.render(
-                    messages=messages,
-                    add_generation_prompt=True,
-                    **self.model.special_tokens_map,
+        if self._history is not None:
+            # check if there is only one message, i.e. system prompt:
+            reset = len(self._history) == 1
+            self._history.append({"role": "user", "content": prompt})
+
+            fct_func = self._format_chat_prompt_template.__func__  # type: ignore[attr-defined]
+            if fct_func is GPT4All._format_chat_prompt_template:
+                if reset:
+                    # ingest system prompt
+                    # use "%1%2" and not "%1" to avoid implicit whitespace
+                    self.model.prompt_model(self._history[0]["content"], "%1%2",
+                                            empty_response_callback,
+                                            n_batch=n_batch, n_predict=0, reset_context=True, special=True)
+                prompt_template = self._current_prompt_template.format("%1", "%2")
+            else:
+                warnings.warn(
+                    "_format_chat_prompt_template is deprecated. Please use a chat session with a prompt template.",
+                    DeprecationWarning,
+                )
+                # special tokens won't be processed
+                prompt = self._format_chat_prompt_template(
+                    self._history[-1:],
+                    self._history[0]["content"] if reset else "",
                 )
-            session.history.append(MessageType(role="user", content=prompt))
-            prompt = render(session.history)
-            if len(session.history) > 1:
-                last_msg_rendered = render(session.history[-1:])
+                prompt_template = "%1"
+                generate_kwargs["reset_context"] = reset
+        else:
+            prompt_template = "%1"
+            generate_kwargs["reset_context"] = True
+
+        # Prepare the callback, process the model response
+        output_collector: list[MessageType]
+        output_collector = [
+            {"content": ""}
+        ]  # placeholder for the self._history if chat session is not activated
+
+        if self._history is not None:
+            self._history.append({"role": "assistant", "content": ""})
+            output_collector = self._history
+
+        def _callback_wrapper(
+            callback: ResponseCallbackType,
+            output_collector: list[MessageType],
+        ) -> ResponseCallbackType:
+            def _callback(token_id: int, response: str) -> bool:
+                nonlocal callback, output_collector
+
+                output_collector[-1]["content"] += response
+
+                return callback(token_id, response)
 
-        # Check request length
-        last_msg_len = self.model.count_prompt_tokens(last_msg_rendered)
-        if last_msg_len > (limit := self.model.n_ctx - 4):
-            raise ValueError(f"Your message was too long and could not be processed ({last_msg_len} > {limit}).")
+            return _callback
 
         # Send the request to the model
         if streaming:
-            def stream() -> Iterator[str]:
-                yield from self.model.prompt_model_streaming(prompt, _callback_wrapper, **generate_kwargs)
-                if self._chat_session is not None:
-                    self._chat_session.history.append(MessageType(role="assistant", content=full_response))
-            return stream()
+            return self.model.prompt_model_streaming(
+                prompt,
+                prompt_template,
+                _callback_wrapper(callback, output_collector),
+                **generate_kwargs,
+            )
+
+        self.model.prompt_model(
+            prompt,
+            prompt_template,
+            _callback_wrapper(callback, output_collector),
+            **generate_kwargs,
+        )
 
-        self.model.prompt_model(prompt, _callback_wrapper, **generate_kwargs)
-        if self._chat_session is not None:
-            self._chat_session.history.append(MessageType(role="assistant", content=full_response))
-        return full_response
+        return output_collector[-1]["content"]
 
     @contextmanager
     def chat_session(
         self,
-        system_message: str | Literal[False] | None = None,
-        chat_template: str | None = None,
+        system_prompt: str | None = None,
+        prompt_template: str | None = None,
     ):
         """
         Context manager to hold an inference optimized chat session with a GPT4All model.
 
         Args:
-            system_message: An initial instruction for the model, None to use the model default, or False to disable. Defaults to None.
-            chat_template: Jinja template for the conversation, or None to use the model default. Defaults to None.
+            system_prompt: An initial instruction for the model.
+            prompt_template: Template for the prompts with {0} being replaced by the user message.
         """
 
-        if system_message is None:
-            system_message = self.config.get("systemMessage", False)
-
-        if chat_template is None:
-            if "name" not in self.config:
-                raise ValueError("For sideloaded models or with allow_download=False, you must specify a chat template.")
-            if "chatTemplate" not in self.config:
-                raise NotImplementedError("This model appears to have a built-in chat template, but loading it is not "
-                                          "currently implemented. Please pass a template to chat_session() directly.")
-            if (tmpl := self.config["chatTemplate"]) is None:
-                raise ValueError(f"The model {self.config['name']!r} does not support chat.")
-            chat_template = tmpl
-
-        history = []
-        if system_message is not False:
-            history.append(MessageType(role="system", content=system_message))
-        self._chat_session = ChatSession(
-            template=_jinja_env.from_string(chat_template),
-            history=history,
-        )
+        if system_prompt is None:
+            system_prompt = self.config.get("systemPrompt", "")
+
+        if prompt_template is None:
+            if (tmpl := self.config.get("promptTemplate")) is None:
+                warnings.warn("Use of a sideloaded model or allow_download=False without specifying a prompt template "
+                              "is deprecated. Defaulting to Alpaca.", DeprecationWarning)
+                tmpl = DEFAULT_PROMPT_TEMPLATE
+            prompt_template = tmpl
+
+        if re.search(r"%1(?![0-9])", prompt_template):
+            raise ValueError("Prompt template containing a literal '%1' is not supported. For a prompt "
+                             "placeholder, please use '{0}' instead.")
+
+        self._history = [{"role": "system", "content": system_prompt}]
+        self._current_prompt_template = prompt_template
         try:
             yield self
         finally:
-            self._chat_session = None
+            self._history = None
+            self._current_prompt_template = "{0}"
 
     @staticmethod
     def list_gpus() -> list[str]:
@@ -678,6 +670,43 @@ def list_gpus() -> list[str]:
         """
         return LLModel.list_gpus()
 
+    def _format_chat_prompt_template(
+        self,
+        messages: list[MessageType],
+        default_prompt_header: str = "",
+        default_prompt_footer: str = "",
+    ) -> str:
+        """
+        Helper method for building a prompt from list of messages using the self._current_prompt_template as a template for each message.
+
+        Warning:
+            This function was deprecated in version 2.3.0, and will be removed in a future release.
+
+        Args:
+            messages:  List of dictionaries. Each dictionary should have a "role" key
+                with value of "system", "assistant", or "user" and a "content" key with a
+                string value. Messages are organized such that "system" messages are at top of prompt,
+                and "user" and "assistant" messages are displayed in order. Assistant messages get formatted as
+                "Response: {content}".
+
+        Returns:
+            Formatted prompt.
+        """
+
+        full_prompt = default_prompt_header + "\n\n" if default_prompt_header != "" else ""
+
+        for message in messages:
+            if message["role"] == "user":
+                user_message = self._current_prompt_template.format(message["content"])
+                full_prompt += user_message
+            if message["role"] == "assistant":
+                assistant_message = message["content"] + "\n"
+                full_prompt += assistant_message
+
+        full_prompt += "\n\n" + default_prompt_footer if default_prompt_footer != "" else ""
+
+        return full_prompt
+
 
 def append_extension_if_missing(model_name):
     if not model_name.endswith((".bin", ".gguf")):
@@ -690,7 +719,7 @@ def fileno(self) -> int: ...
 
 
 def _fsync(fd: int | _HasFileno) -> None:
-    if sys.platform == "darwin":
+    if sys.platform == 'darwin':
         # Apple's fsync does not flush the drive write cache
         try:
             fcntl.fcntl(fd, fcntl.F_FULLFSYNC)