dandy 0.0.3__py3-none-any.whl

dandy/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.3"

dandy/bot/__init__.py

@@ -0,0 +1,2 @@
+from .bot import Bot
+from .llm_bot import LlmBot

dandy/bot/bot.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from dandy.handler.handler import Handler
+
+
+class Bot(Handler, ABC):
+    ...

dandy/bot/exceptions.py

@@ -0,0 +1,2 @@
+class BotException(Exception):
+    pass

dandy/bot/llm_bot.py

@@ -0,0 +1,30 @@
+from abc import ABC
+from typing import Type
+
+from dandy.bot.bot import Bot
+from dandy.core.type_vars import ModelType
+from dandy.llm.config import LlmConfig
+from dandy.llm.prompt import Prompt
+
+
+class LlmBot(Bot, ABC):
+    role_prompt: Prompt
+    instructions_prompt: Prompt
+    llm_config: LlmConfig
+
+    @classmethod
+    def process_prompt_to_model_object(
+            cls,
+            prompt: Prompt,
+            model: Type[ModelType],
+    ) -> ModelType:
+
+        return cls.llm_config.service.process_prompt_to_model_object(
+            prompt=prompt,
+            model=model,
+            prefix_system_prompt=(
+                Prompt()
+                .prompt(cls.role_prompt)
+                .prompt(cls.instructions_prompt)
+            )
+        )

dandy/contrib/bots/__init__.py

@@ -0,0 +1 @@
+from dandy.contrib.bots.choice_llm_bot import SingleChoiceLlmBot, MultipleChoiceLlmBot

dandy/contrib/bots/choice_llm_bot.py

@@ -0,0 +1,148 @@
+from abc import ABC
+from enum import Enum
+from typing import Tuple, List, Union, overload, Type
+
+from pydantic import BaseModel
+
+from dandy.bot import LlmBot
+from dandy.bot.exceptions import BotException
+from dandy.llm.prompt import Prompt
+
+
+NO_CHOICE_FOUND_RESPONSE = 'no-choice-match-found'
+
+
+class SingleChoiceResponse(BaseModel):
+    selected_choice: str
+
+
+class MultipleChoiceResponse(BaseModel):
+    selected_choices: List[str]
+
+
+class _ChoiceLlmBot(LlmBot, ABC):
+    role_prompt = (
+        Prompt()
+        .text('You are an choice bot.')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            choice_response_model: Union[Type[SingleChoiceResponse], Type[MultipleChoiceResponse]]
+    ) -> Union[SingleChoiceResponse, MultipleChoiceResponse]:
+
+        prompt = (
+            Prompt()
+            .text('This is the user input:')
+            .text(user_input, triple_quote=True)
+            .text('These are the choices:')
+        )
+
+        if isinstance(choices, type) and issubclass(choices, Enum):
+            prompt.unordered_random_list([choice.value for choice in choices], triple_quote=True)
+        elif isinstance(choices, (list, tuple)):
+            prompt.unordered_random_list(choices, triple_quote=True)
+        else:
+            raise BotException('Choices must be an Enum, a list or a tuple.')
+
+        return cls.process_prompt_to_model_object(
+            prompt=prompt,
+            model=choice_response_model
+        )
+
+
+class _ChoiceOverloadMixin:
+    @classmethod
+    @overload
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[List[str], Tuple[str]],
+            choice_response_model: Type[BaseModel]
+    ) -> Union[str, List[str], None]:
+        ...
+
+    @classmethod
+    @overload
+    def process(
+            cls,
+            user_input: str,
+            choices: Type[Enum],
+            choice_response_model: Type[BaseModel]
+    ) -> Union[Enum, List[Enum], None]:
+        ...
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[Enum, List[Enum], str, List[str], None]:
+        ...
+
+
+class SingleChoiceLlmBot(_ChoiceLlmBot, _ChoiceOverloadMixin):
+    instructions_prompt = (
+        Prompt()
+        .text('Your job is to identify the intent of the user input and match it to the provided choices.')
+        .text(f'If there is no good matches in the choices reply with value "{NO_CHOICE_FOUND_RESPONSE}".')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[Enum, str, None]:
+
+        choice_response = super().process(
+            user_input=user_input,
+            choices=choices,
+            choice_response_model=SingleChoiceResponse,
+        )
+
+        selected_choice = choice_response.selected_choice
+        if selected_choice == NO_CHOICE_FOUND_RESPONSE:
+            return None
+        else:
+            if isinstance(choices, type) and issubclass(choices, Enum):
+                return choices(selected_choice)
+            else:
+                return selected_choice
+
+
+class MultipleChoiceLlmBot(_ChoiceLlmBot, _ChoiceOverloadMixin):
+    instructions_prompt = (
+        Prompt()
+        .text('Your job is to identify the intent of the user input and match it to the provided choices.')
+        .text('Return as many choices as you see relevant to the user input.')
+        .text(f'If there is no good matches in the choices reply with value "{NO_CHOICE_FOUND_RESPONSE}".')
+    )
+
+    @classmethod
+    def process(
+            cls,
+            user_input: str,
+            choices: Union[Type[Enum], List[str], Tuple[str]],
+            **kwargs
+    ) -> Union[List[Enum], List[str], None]:
+
+        choice_response = super().process(
+            user_input=user_input,
+            choices=choices,
+            choice_response_model=MultipleChoiceResponse
+        )
+
+        select_choices = choice_response.selected_choices
+        if NO_CHOICE_FOUND_RESPONSE in select_choices:
+            return None
+        else:
+            if isinstance(choices, type) and issubclass(choices, Enum):
+                return [choices(choice) for choice in select_choices]
+            else:
+                return select_choices

dandy/core/exceptions.py

@@ -0,0 +1,2 @@
+class DandyException(Exception):
+    pass

dandy/core/singleton.py

@@ -0,0 +1,7 @@
+class Singleton:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
+        return cls._instance

dandy/core/type_vars.py

@@ -0,0 +1,6 @@
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+
+ModelType = TypeVar('ModelType', bound=BaseModel)

dandy/core/url.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import List, Dict
+from urllib.parse import urlencode, urlparse, ParseResult, quote
+
+
+@dataclass(kw_only=True)
+class Url:
+    host: str
+    path_parameters: List[str] = list
+    query_parameters: Dict[str, str] = dict
+
+
+    @property
+    def parsed_url(self) -> ParseResult:
+        return urlparse(self.host)
+
+    @property
+    def path(self) -> str:
+        return self.path_parameters_to_str + self.query_parameters_to_str
+
+    @property
+    def is_https(self) -> bool:
+        return self.parsed_url.scheme == 'https'
+
+    @property
+    def path_parameters_to_str(self) -> str:
+        if self.path_parameters:
+            return '/' + '/'.join([quote(parameter) for parameter in self.path_parameters])
+
+        return ''
+
+    @property
+    def query_parameters_to_str(self) -> str:
+        if self.query_parameters:
+            query = urlencode(self.query_parameters)
+            return '?' + query
+
+        return ''

dandy/handler/handler.py

@@ -0,0 +1,9 @@
+from abc import abstractmethod, ABC
+from typing import Any
+
+
+class Handler(ABC):
+    @classmethod
+    @abstractmethod
+    def process(cls, **kwargs: Any) -> Any:
+        ...

dandy/llm/config.py

@@ -0,0 +1,95 @@
+from abc import abstractmethod
+from typing import Optional, List
+
+from dandy.core.url import Url
+from dandy.llm.service import Service
+
+
+class LlmConfig:
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            path_parameters: Optional[List[str]] = None,
+            query_parameters: Optional[dict] = None,
+            headers: Optional[dict] = None,
+            api_key: Optional[str] = None,
+            retry_count: int = 10,
+    ):
+        if headers is None:
+            headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            }
+
+        if api_key is not None:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        self.url=Url(
+            host=host,
+            path_parameters=path_parameters,
+            query_parameters=query_parameters,
+        )
+        self.port=port
+        self.model=model
+        self.headers=headers
+
+        self.retry_count = retry_count
+
+    @property
+    def service(self):
+        return Service(self)
+
+    @abstractmethod
+    def get_response_content(self, response) -> str:
+        ...
+
+
+class OllamaLlmConfig(LlmConfig):
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            api_key: Optional[str] = None,
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            model=model,
+            path_parameters=[
+                'api',
+                'chat',
+            ],
+            api_key=api_key,
+        )
+
+    def get_response_content(self, response) -> str:
+        return response['message']['content']
+
+
+class OpenaiLlmConfig(LlmConfig):
+    def __init__(
+            self,
+            host: str,
+            port: int,
+            model: str,
+            api_key: Optional[str] = None,
+    ):
+        super().__init__(
+            host=host,
+            port=port,
+            model=model,
+            path_parameters=[
+                'v1',
+                'chat',
+                'completions',
+            ],
+            api_key=api_key,
+        )
+
+    def get_response_content(self, response) -> str:
+        return response['choices'][0]['message']['content']
+
+

dandy/llm/exceptions.py

@@ -0,0 +1,12 @@
+from typing import List
+
+from dandy.core.exceptions import DandyException
+
+
+class LlmException(DandyException):
+    pass
+
+
+class LlmValidationException(LlmException):
+    def __init__(self, name: str, choices: List[str]):
+        super().__init__(f'Did not get a valid response format from llm service')

dandy/llm/prompt/__init__.py

@@ -0,0 +1,2 @@
+from dandy.llm.prompt.prompt import Prompt
+from dandy.llm.prompt.snippet import Snippet

dandy/llm/prompt/prompt.py

@@ -0,0 +1,208 @@
+from typing import List, Type, Self, Dict
+
+from pydantic import BaseModel
+
+from dandy.llm.prompt import snippet
+
+
+CHARACTERS_PER_TOKEN = 4
+
+
+class Prompt:
+    def __init__(
+            self,
+            tag: str = None
+    ):
+        self.snippets: List[snippet.Snippet] = []
+        self.tag = tag
+
+    def __str__(self) -> str:
+        return self.to_str()
+
+    def to_str(self) -> str:
+        prompt_string = ''.join([_.to_str() for _ in self.snippets])
+
+        if isinstance(self.tag, str):
+            return f'<{self.tag}>\n{prompt_string}\n</{self.tag}>\n'
+        else:
+            return prompt_string
+
+    def dict(
+            self,
+            dictionary: Dict,
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.DictionarySnippet(
+                dictionary=dictionary,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def divider(self) -> Self:
+        self.snippets.append(snippet.DividerSnippet())
+
+        return self
+
+    @property
+    def estimated_token_count(self) -> int:
+        return int(len(self.to_str()) / CHARACTERS_PER_TOKEN)
+
+
+    def title(
+            self,
+            title: str,
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.TitleSnippet(
+                title=title,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def line_break(self) -> Self:
+        self.snippets.append(snippet.LineBreakSnippet())
+
+        return self
+
+    def list(
+            self,
+            items: List[str],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.unordered_list(
+            items=items,
+            triple_quote=triple_quote
+        )
+
+        return self
+
+    def model_object(
+            self,
+            model_object: BaseModel,
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.ModelObject(
+                model_object=model_object,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def model_schema(
+            self,
+            model: Type[BaseModel],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.ModelSchema(
+                model=model,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def ordered_list(
+            self,
+            items: List[str],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.OrderedListSnippet(
+                items=items,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def prompt(
+            self,
+            prompt: Self,
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.PromptSnippet(
+                prompt=prompt,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def random_choice(
+            self,
+            choices: List[str],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.RandomChoiceSnippet(
+                choices=choices,
+                triple_quote=triple_quote,
+            )
+        )
+
+        return self
+
+    def text(
+            self,
+            text: str,
+            label: str = '',
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.TextSnippet(
+                text=text,
+                label=label,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def unordered_list(
+            self,
+            items: List[str],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.UnorderedListSnippet(
+                items=items,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self
+
+    def unordered_random_list(
+            self,
+            items: List[str],
+            triple_quote: bool = False
+    ) -> Self:
+
+        self.snippets.append(
+            snippet.UnorderedRandomListSnippet(
+                items=items,
+                triple_quote=triple_quote
+            )
+        )
+
+        return self