Module llmflex.Prompts.prompt_template

Classes

class PromptTemplate (template: str, eos_token: Optional[str], bos_token: Optional[str], stop: Optional[List[str]] = None, force_real_template: bool = False, **kwargs)

Class for storing prompt format presets.

Initialising the chat prompt class.

Args

template : str

Jinja2 template.

eos_token : Optional[str]

EOS token string.

bos_token : Optional[str]

BOS token string.

stop : Optional[List[str]], optional

List of stop strings for the llm. If None is given, the EOS token string will be used. Defaults to None.

force_real_template : bool, optional

Whether to render the given template. For most templates it has no effects. Only for some restrictive templates like llama2. Defaults to False.

Expand source code

class PromptTemplate:
    """Class for storing prompt format presets.
    """
    def __init__(
            self,
            template: str,
            eos_token: Optional[str],
            bos_token: Optional[str],
            stop: Optional[List[str]] = None,
            force_real_template: bool = False,
            **kwargs
    ) -> None:
        """Initialising the chat prompt class.

        Args:
            template (str): Jinja2 template.
            eos_token (Optional[str]): EOS token string.
            bos_token (Optional[str]): BOS token string.
            stop (Optional[List[str]], optional): List of stop strings for the llm. If None is given, the EOS token string will be used. Defaults to None.
            force_real_template (bool, optional): Whether to render the given template. For most templates it has no effects. Only for some restrictive templates like llama2. Defaults to False.
        """
        self._template = template
        self._eos_token = eos_token
        self._bos_token = bos_token
        self._stop = stop
        self._force_real_template = force_real_template
        self._keywords = kwargs.get('keywords', [])

    @property
    def template(self) -> str:
        """Jinja template string.

        Returns:
            str: Jinja template string.
        """
        return self._template
    
    @property
    def _hidden_template(self) -> str:
        """To fix issues with some default templates like llama 2.

        Returns:
            str: The actual template to be rendered.
        """
        config = hidden_presets.get(self.template_name)
        return self.template if config is None else config['template']
    
    @property
    def rendered_template(self) -> Environment:
        """Rendered Jinja template.

        Returns:
            Environment: Rendered Jinja template.
        """
        if not hasattr(self, '_rendered_template'):
            from jinja2 import BaseLoader
            template = self.template if self._force_real_template else self._hidden_template
            self._rendered_template = Environment(loader=BaseLoader).from_string(template)
        return self._rendered_template
    
    @property
    def keywords(self) -> List[str]:
        """List of keywords to search for in Jinja templates for template detection. Used for presets.

        Returns:
            List[str]: List of keywords to search for in Jinja templates for template detection.
        """
        if not hasattr(self, '_keywords'):
            self._keywords = []
        return self._keywords

    @property
    def eos_token(self) -> Optional[str]:
        return self._eos_token
    
    @property
    def bos_token(self) -> Optional[str]:
        return self._bos_token

    @property
    def stop(self) -> List[str]:
        return self._stop if isinstance(self._stop, list) else [self.eos_token] if self.eos_token is not None else []
    
    @property
    def template_name(self) -> str:
        """Name of the template.

        Returns:
            str: Name of the template.
        """
        if not hasattr(self, '_template_name'):
            self._template_name = 'Unititled template'
            for k, v in presets.items():
                if self.template == v['template']:
                    self._template_name = k
                    break
        return self._template_name
    
    @property
    def allow_custom_role(self) -> bool:
        """Check if custom role can be used with the prompt template.

        Returns:
            bool: Whether custom role can be used with the prompt template.
        """
        if not hasattr(self, '_allow_custom_role'):
            test = [dict(role='user', content='random message'), dict(role='customrole', content='exist')]
            try: 
                output = self.create_custom_prompt(test)
                self._allow_custom_role = 'customrole' in output.lower()
            except:
                self._allow_custom_role = False
        return self._allow_custom_role



    def format_history(self, history: Union[List[str], List[Tuple[str, str]]], return_list: bool = False) -> Union[str, List[Dict[str, str]]]:
        """Formatting a list of conversation history into a full string of conversation history or a list of messages for the Jinja template to render.

        Args:
            history (Union[List[str], List[Tuple[str, str]]]): List of conversation history. 
            return_list (bool, optional): Whether to return a list of messages for the Jinja template to render. Defaults to False.

        Returns:
            Union[str, List[Dict[str, str]]]: A full string of conversation history or a list of messages for the Jinja template to render.
        """
        if len(history) == 0:
            return [] if return_list else ''
        elif not isinstance(history[0], str):
            body = list(map(lambda x: [dict(role='user', content=x[0]), dict(role='assistant', content=x[1])], history))
            body = sum(body, [])
        else:
            length = len(history)
            is_even = length % 2 == 0
            half = int(length / 2) if is_even else int((length + 1) / 2)
            roles = ['user', 'assistant'] * half
            roles = roles if is_even else roles[1:]
            body = list(map(lambda x: dict(role=x[0], content=x[1]), list(zip(roles, history))))
        if return_list:
            return body
        return self.rendered_template.render(messages=body, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=False)

    def create_prompt(self, user: str, system: str = DEFAULT_SYSTEM_MESSAGE, history: Optional[Union[List[str], List[Tuple[str, str]]]] = None) -> str:
        """Creating the full chat prompt.

        Args:
            user (str): Latest user input.
            system (str, optional): System message. Defaults to DEFAULT_SYSTEM_MESSAGE.
            history (Optional[Union[List[str], List[Tuple[str, str]]]], optional): List of conversation history. Defaults to None.

        Returns:
            str: The full prompt.
        """
        head = [dict(role='system', content=system)] if system.strip() != '' else []
        history = [] if history is None else history
        body = self.format_history(history=history, return_list=True)
        tail = [dict(role='user', content=user)]
        prompt = head + body + tail
        return self.rendered_template.render(messages=prompt, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=True)
    
    def create_custom_prompt(self, messages: List[Dict[str, str]], add_generation_prompt: bool = True) -> str:
        """Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content".

        Args:
            messages (List[Dict[str, str]]): List of messages. Each message should contain a dictionary with the key "role" and "content".
            add_generation_prompt (bool, optional): Whether to add the assistant tokens at the end of the prompt. Defaults to True.

        Returns:
            str: The full prompt given your messages.
        """
        return self.rendered_template.render(messages=messages, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=add_generation_prompt)
    
    def create_custom_prompt_with_open_role(self, messages: List[Dict[str, str]], end_role: str = '', begin_text: str = '') -> str:
        """Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content". The prompt will end with starting prompt of the end_role instead of assistant.

        Args:
            messages (List[Dict[str, str]]): List of messages. Each message should contain a dictionary with the key "role" and "content".
            end_role (str, optional): The role for text generation instead of assistant. If an empty string is given, it means that the role can be anything the llm is going to generate. Defaults to ''.
            begin_text (str, optional): The beginning text of the last role. Defaults to ''.

        Returns:
            str: The full prompt with your custom role.
        """
        if self.allow_custom_role:
            role_ph = end_role if end_role.strip() != '' else 'place_holder_role'
            text_ph = '$$$PLACE_HOLDER_TEXT$$$'
            prompt = self.create_custom_prompt(messages=messages + [dict(role=role_ph, content=text_ph)], add_generation_prompt=False)
            prompt = text_ph.join(prompt.split(text_ph)[:-1])
            real = self.create_custom_prompt(messages=messages + [dict(role=end_role, content=text_ph)], add_generation_prompt=False)
            real = text_ph.join(real.split(text_ph)[:-1])
            if real == prompt:
                return real + begin_text
            elif begin_text.strip() != '':
                return real + begin_text
            else:
                import os
                return os.path.commonprefix([real, prompt])
        else:
            raise AssertionError(f'This prompt template "{self.template_name}" does not allow custom_roles.')

    
    @classmethod
    def from_dict(cls, format_dict: Dict[str, Any], template_name: Optional[str] = None) -> PromptTemplate:
        """Initialise the prompt template from a dictionary.

        Args:
            format_dict (Dict[str, Any]): Dictionary of the prompt format.
            template_name (Optional[str], optional): Name of the template. Defaults to None.

        Returns:
            PromptTemplate: The initialised PromptTemplate instance.
        """
        template = cls(**format_dict)
        if template_name is not None:
            template._template_name = template_name
        return template
    
    @classmethod
    def from_json(cls, file_dir: str) -> PromptTemplate:
        """Initialise the prompt template from a json file.

        Args:
            file_dir (str): json file path of the prompt format.

        Returns:
            PromptTemplatet: The initialised PromptTemplate instance.
        """
        from ..utils import read_json
        return cls.from_dict(read_json(file_dir=file_dir), template_name=file_dir)
    
    @classmethod
    def from_preset(cls, style: PRESET_FORMATS, force_real_template: bool = False) -> PromptTemplate:
        """Initialise the prompt template from a preset.

        Args:
            style (PRESET_FORMATS): Format of the prompt.
            force_real_template (bool, optional): Whether to render the given template. For most templates it has no effects. Only for some restrictive templates like llama2. Defaults to False.

        Returns:
            PromptTemplate: The initialised PromptTemplate instance.
        """
        from copy import deepcopy
        preset = deepcopy(presets[style])
        preset['force_real_template'] = force_real_template
        return cls.from_dict(preset, template_name=style)
    
    def to_dict(self) -> Dict[str, Any]:
        """Export the class as a dictionary.

        Returns:
            Dict[str, Any]: Prompt format as a dictionary.
        """
        return dict(
            template = self.template,
            eos_token = self.eos_token,
            bos_token = self.bos_token,
            stop = self.stop if self.stop is not None else [self.eos_token]
        )

Static methods

def from_dict(format_dict: Dict[str, Any], template_name: Optional[str] = None) ‑> PromptTemplate

Initialise the prompt template from a dictionary.

Args

format_dict : Dict[str, Any]

Dictionary of the prompt format.

template_name : Optional[str], optional

Name of the template. Defaults to None.

Returns

PromptTemplate

The initialised PromptTemplate instance.

Expand source code

@classmethod
def from_dict(cls, format_dict: Dict[str, Any], template_name: Optional[str] = None) -> PromptTemplate:
    """Initialise the prompt template from a dictionary.

    Args:
        format_dict (Dict[str, Any]): Dictionary of the prompt format.
        template_name (Optional[str], optional): Name of the template. Defaults to None.

    Returns:
        PromptTemplate: The initialised PromptTemplate instance.
    """
    template = cls(**format_dict)
    if template_name is not None:
        template._template_name = template_name
    return template

def from_json(file_dir: str) ‑> PromptTemplate

Initialise the prompt template from a json file.

Args

file_dir : str

json file path of the prompt format.

Returns

PromptTemplatet

The initialised PromptTemplate instance.

Expand source code

@classmethod
def from_json(cls, file_dir: str) -> PromptTemplate:
    """Initialise the prompt template from a json file.

    Args:
        file_dir (str): json file path of the prompt format.

    Returns:
        PromptTemplatet: The initialised PromptTemplate instance.
    """
    from ..utils import read_json
    return cls.from_dict(read_json(file_dir=file_dir), template_name=file_dir)

def from_preset(style: PRESET_FORMATS, force_real_template: bool = False) ‑> PromptTemplate

Initialise the prompt template from a preset.

Args

style : PRESET_FORMATS

Format of the prompt.

force_real_template : bool, optional

Whether to render the given template. For most templates it has no effects. Only for some restrictive templates like llama2. Defaults to False.

Returns

PromptTemplate

The initialised PromptTemplate instance.

Expand source code

@classmethod
def from_preset(cls, style: PRESET_FORMATS, force_real_template: bool = False) -> PromptTemplate:
    """Initialise the prompt template from a preset.

    Args:
        style (PRESET_FORMATS): Format of the prompt.
        force_real_template (bool, optional): Whether to render the given template. For most templates it has no effects. Only for some restrictive templates like llama2. Defaults to False.

    Returns:
        PromptTemplate: The initialised PromptTemplate instance.
    """
    from copy import deepcopy
    preset = deepcopy(presets[style])
    preset['force_real_template'] = force_real_template
    return cls.from_dict(preset, template_name=style)

Instance variables

var allow_custom_role : bool

Check if custom role can be used with the prompt template.

Returns

bool

Whether custom role can be used with the prompt template.

Expand source code

@property
def allow_custom_role(self) -> bool:
    """Check if custom role can be used with the prompt template.

    Returns:
        bool: Whether custom role can be used with the prompt template.
    """
    if not hasattr(self, '_allow_custom_role'):
        test = [dict(role='user', content='random message'), dict(role='customrole', content='exist')]
        try: 
            output = self.create_custom_prompt(test)
            self._allow_custom_role = 'customrole' in output.lower()
        except:
            self._allow_custom_role = False
    return self._allow_custom_role

var bos_token : Optional[str]

Expand source code

@property
def bos_token(self) -> Optional[str]:
    return self._bos_token

var eos_token : Optional[str]

Expand source code

@property
def eos_token(self) -> Optional[str]:
    return self._eos_token

var keywords : List[str]

List of keywords to search for in Jinja templates for template detection. Used for presets.

Returns

List[str]

List of keywords to search for in Jinja templates for template detection.

Expand source code

@property
def keywords(self) -> List[str]:
    """List of keywords to search for in Jinja templates for template detection. Used for presets.

    Returns:
        List[str]: List of keywords to search for in Jinja templates for template detection.
    """
    if not hasattr(self, '_keywords'):
        self._keywords = []
    return self._keywords

var rendered_template : jinja2.environment.Environment

Rendered Jinja template.

Returns

Environment

Rendered Jinja template.

Expand source code

@property
def rendered_template(self) -> Environment:
    """Rendered Jinja template.

    Returns:
        Environment: Rendered Jinja template.
    """
    if not hasattr(self, '_rendered_template'):
        from jinja2 import BaseLoader
        template = self.template if self._force_real_template else self._hidden_template
        self._rendered_template = Environment(loader=BaseLoader).from_string(template)
    return self._rendered_template

var stop : List[str]

Expand source code

@property
def stop(self) -> List[str]:
    return self._stop if isinstance(self._stop, list) else [self.eos_token] if self.eos_token is not None else []

var template : str

Jinja template string.

Returns

str

Jinja template string.

Expand source code

@property
def template(self) -> str:
    """Jinja template string.

    Returns:
        str: Jinja template string.
    """
    return self._template

var template_name : str

Name of the template.

Returns

str

Name of the template.

Expand source code

@property
def template_name(self) -> str:
    """Name of the template.

    Returns:
        str: Name of the template.
    """
    if not hasattr(self, '_template_name'):
        self._template_name = 'Unititled template'
        for k, v in presets.items():
            if self.template == v['template']:
                self._template_name = k
                break
    return self._template_name

Methods

def create_custom_prompt(self, messages: List[Dict[str, str]], add_generation_prompt: bool = True) ‑> str

Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content".

Args

messages : List[Dict[str, str]]

List of messages. Each message should contain a dictionary with the key "role" and "content".

add_generation_prompt : bool, optional

Whether to add the assistant tokens at the end of the prompt. Defaults to True.

Returns

str

The full prompt given your messages.

Expand source code

def create_custom_prompt(self, messages: List[Dict[str, str]], add_generation_prompt: bool = True) -> str:
    """Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content".

    Args:
        messages (List[Dict[str, str]]): List of messages. Each message should contain a dictionary with the key "role" and "content".
        add_generation_prompt (bool, optional): Whether to add the assistant tokens at the end of the prompt. Defaults to True.

    Returns:
        str: The full prompt given your messages.
    """
    return self.rendered_template.render(messages=messages, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=add_generation_prompt)

def create_custom_prompt_with_open_role(self, messages: List[Dict[str, str]], end_role: str = '', begin_text: str = '') ‑> str

Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content". The prompt will end with starting prompt of the end_role instead of assistant.

Args

messages : List[Dict[str, str]]

List of messages. Each message should contain a dictionary with the key "role" and "content".

end_role : str, optional

The role for text generation instead of assistant. If an empty string is given, it means that the role can be anything the llm is going to generate. Defaults to ''.

begin_text : str, optional

The beginning text of the last role. Defaults to ''.

Returns

str

The full prompt with your custom role.

Expand source code

def create_custom_prompt_with_open_role(self, messages: List[Dict[str, str]], end_role: str = '', begin_text: str = '') -> str:
    """Creating a custom prompt with your given list of messages. Each message should contain a dictionary with the key "role" and "content". The prompt will end with starting prompt of the end_role instead of assistant.

    Args:
        messages (List[Dict[str, str]]): List of messages. Each message should contain a dictionary with the key "role" and "content".
        end_role (str, optional): The role for text generation instead of assistant. If an empty string is given, it means that the role can be anything the llm is going to generate. Defaults to ''.
        begin_text (str, optional): The beginning text of the last role. Defaults to ''.

    Returns:
        str: The full prompt with your custom role.
    """
    if self.allow_custom_role:
        role_ph = end_role if end_role.strip() != '' else 'place_holder_role'
        text_ph = '$$$PLACE_HOLDER_TEXT$$$'
        prompt = self.create_custom_prompt(messages=messages + [dict(role=role_ph, content=text_ph)], add_generation_prompt=False)
        prompt = text_ph.join(prompt.split(text_ph)[:-1])
        real = self.create_custom_prompt(messages=messages + [dict(role=end_role, content=text_ph)], add_generation_prompt=False)
        real = text_ph.join(real.split(text_ph)[:-1])
        if real == prompt:
            return real + begin_text
        elif begin_text.strip() != '':
            return real + begin_text
        else:
            import os
            return os.path.commonprefix([real, prompt])
    else:
        raise AssertionError(f'This prompt template "{self.template_name}" does not allow custom_roles.')

def create_prompt(self, user: str, system: str = 'This is a conversation between a human user and a helpful AI assistant.', history: Optional[Union[List[str], List[Tuple[str, str]]]] = None) ‑> str

Creating the full chat prompt.

Args

user : str

Latest user input.

system : str, optional

System message. Defaults to DEFAULT_SYSTEM_MESSAGE.

history : Optional[Union[List[str], List[Tuple[str, str]]]], optional

List of conversation history. Defaults to None.

Returns

str

The full prompt.

Expand source code

def create_prompt(self, user: str, system: str = DEFAULT_SYSTEM_MESSAGE, history: Optional[Union[List[str], List[Tuple[str, str]]]] = None) -> str:
    """Creating the full chat prompt.

    Args:
        user (str): Latest user input.
        system (str, optional): System message. Defaults to DEFAULT_SYSTEM_MESSAGE.
        history (Optional[Union[List[str], List[Tuple[str, str]]]], optional): List of conversation history. Defaults to None.

    Returns:
        str: The full prompt.
    """
    head = [dict(role='system', content=system)] if system.strip() != '' else []
    history = [] if history is None else history
    body = self.format_history(history=history, return_list=True)
    tail = [dict(role='user', content=user)]
    prompt = head + body + tail
    return self.rendered_template.render(messages=prompt, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=True)

def format_history(self, history: Union[List[str], List[Tuple[str, str]]], return_list: bool = False) ‑> Union[str, List[Dict[str, str]]]

Formatting a list of conversation history into a full string of conversation history or a list of messages for the Jinja template to render.

Args

history : Union[List[str], List[Tuple[str, str]]]

List of conversation history.

return_list : bool, optional

Whether to return a list of messages for the Jinja template to render. Defaults to False.

Returns

Union[str, List[Dict[str, str]]]

A full string of conversation history or a list of messages for the Jinja template to render.

Expand source code

def format_history(self, history: Union[List[str], List[Tuple[str, str]]], return_list: bool = False) -> Union[str, List[Dict[str, str]]]:
    """Formatting a list of conversation history into a full string of conversation history or a list of messages for the Jinja template to render.

    Args:
        history (Union[List[str], List[Tuple[str, str]]]): List of conversation history. 
        return_list (bool, optional): Whether to return a list of messages for the Jinja template to render. Defaults to False.

    Returns:
        Union[str, List[Dict[str, str]]]: A full string of conversation history or a list of messages for the Jinja template to render.
    """
    if len(history) == 0:
        return [] if return_list else ''
    elif not isinstance(history[0], str):
        body = list(map(lambda x: [dict(role='user', content=x[0]), dict(role='assistant', content=x[1])], history))
        body = sum(body, [])
    else:
        length = len(history)
        is_even = length % 2 == 0
        half = int(length / 2) if is_even else int((length + 1) / 2)
        roles = ['user', 'assistant'] * half
        roles = roles if is_even else roles[1:]
        body = list(map(lambda x: dict(role=x[0], content=x[1]), list(zip(roles, history))))
    if return_list:
        return body
    return self.rendered_template.render(messages=body, bos_token=self.bos_token, eos_token=self.eos_token, add_generation_prompt=False)

def to_dict(self) ‑> Dict[str, Any]

Export the class as a dictionary.

Returns

Dict[str, Any]

Prompt format as a dictionary.

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Export the class as a dictionary.

    Returns:
        Dict[str, Any]: Prompt format as a dictionary.
    """
    return dict(
        template = self.template,
        eos_token = self.eos_token,
        bos_token = self.bos_token,
        stop = self.stop if self.stop is not None else [self.eos_token]
    )