camel-ai 0.1.1__py3-none-any.whl

camel/functions/weather_functions.py

@@ -0,0 +1,136 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import List
+
+from camel.functions import OpenAIFunction
+
+
+def get_openweathermap_api_key() -> str:
+    r"""Retrieve the OpenWeatherMap API key from environment variables.
+
+    Returns:
+        str: The OpenWeatherMap API key.
+
+    Raises:
+        ValueError: If the API key is not found in the environment variables.
+    """
+    # Get `OPENWEATHERMAP_API_KEY` here: https://openweathermap.org
+    OPENWEATHERMAP_API_KEY = os.environ.get('OPENWEATHERMAP_API_KEY')
+    if not OPENWEATHERMAP_API_KEY:
+        raise ValueError("`OPENWEATHERMAP_API_KEY` not found in environment "
+                         "variables. Get `OPENWEATHERMAP_API_KEY` here: "
+                         "`https://openweathermap.org`.")
+    return OPENWEATHERMAP_API_KEY
+
+
+def get_weather_data(city: str, temp_units: str = 'kelvin',
+                     wind_units: str = 'meters_sec',
+                     visibility_units: str = 'meters',
+                     time_units: str = 'unix') -> str:
+    r"""Fetch and return a comprehensive weather report for a given city as a
+    string. The report includes current weather conditions, temperature,
+    wind details, visibility, and sunrise/sunset times, all formatted as
+
+    The function interacts with the OpenWeatherMap API to retrieve the data.
+
+    Args:
+        city (string): The name of the city for which the weather information
+            is desired. Format "City, CountryCode" (e.g., "Paris, FR"
+            for Paris, France). If the country code is not provided,
+            the API will search for the city in all countries, which
+            may yield incorrect results if multiple cities with the
+            same name exist.
+        temp_units (string): Units for temperature. Options: 'kelvin',
+            'celsius', 'fahrenheit'. (default: :obj:`kelvin`)
+        wind_units (string): Units for wind speed. Options: 'meters_sec',
+            'miles_hour', 'knots', 'beaufort'. (default: :obj:`meters_sec`)
+        visibility_units (string): Units for visibility distance. Options:
+            'meters', 'miles'. (default: :obj:`meters`)
+        time_units (string): Format for sunrise and sunset times. Options:
+            'unix', 'iso', 'date'. (default: :obj:`unix`)
+
+    Returns:
+        str: A string containing the fetched weather data, formatted in a
+            readable manner. If an error occurs, a message indicating the
+            error will be returned instead.
+
+    Example of return string:
+        "Weather in Paris, FR: 15°C, feels like 13°C. Max temp: 17°C, Min temp
+            : 12°C.
+        Wind: 5 m/s at 270 degrees. Visibility: 10 kilometers.
+        Sunrise at 05:46:05 (UTC), Sunset at 18:42:20 (UTC)."
+
+    Note:
+        Please ensure that the API key is valid and has permissions to access
+            the weather data.
+    """
+    # NOTE: This tool may not work as expected since the input arguments like
+    # `time_units` should be enum types which are not supported yet.
+
+    try:
+        import pyowm
+    except ImportError:
+        raise ImportError(
+            "Please install `pyowm` first. You can install it by running "
+            "`pip install pyowm`.")
+
+    OPENWEATHERMAP_API_KEY = get_openweathermap_api_key()
+    owm = pyowm.OWM(OPENWEATHERMAP_API_KEY)
+    mgr = owm.weather_manager()
+
+    try:
+        observation = mgr.weather_at_place(city)
+        weather = observation.weather
+
+        # Temperature
+        temperature = weather.temperature(temp_units)
+
+        # Wind
+        wind_data = observation.weather.wind(unit=wind_units)
+        wind_speed = wind_data.get('speed')
+        # 'N/A' if the degree is not available
+        wind_deg = wind_data.get('deg', 'N/A')
+
+        # Visibility
+        visibility_distance = observation.weather.visibility_distance
+        visibility = (str(visibility_distance) if visibility_units == 'meters'
+                      else str(observation.weather.visibility(unit='miles')))
+
+        # Sunrise and Sunset
+        sunrise_time = str(weather.sunrise_time(timeformat=time_units))
+        sunset_time = str(weather.sunset_time(timeformat=time_units))
+
+        # Compile all the weather details into a report string
+        weather_report = (
+            f"Weather in {city}: {temperature['temp']}°{temp_units.title()}, "
+            f"feels like {temperature['feels_like']}°{temp_units.title()}. "
+            f"Max temp: {temperature['temp_max']}°{temp_units.title()}, "
+            f"Min temp: {temperature['temp_min']}°{temp_units.title()}. "
+            f"Wind: {wind_speed} {wind_units} at {wind_deg} degrees. "
+            f"Visibility: {visibility} {visibility_units}. "
+            f"Sunrise at {sunrise_time}, Sunset at {sunset_time}.")
+
+        return weather_report
+
+    except Exception as e:
+        error_message = (
+            f"An error occurred while fetching weather data for {city}: "
+            f"{str(e)}.")
+        return error_message
+
+
+WEATHER_FUNCS: List[OpenAIFunction] = [
+    OpenAIFunction(func) for func in [get_weather_data]
+]

camel/generators.py

@@ -0,0 +1,263 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from typing import Dict, Generator, List, Optional, Set, Tuple
+
+from camel.messages import BaseMessage
+from camel.prompts import PromptTemplateGenerator, TextPrompt
+from camel.types import RoleType, TaskType
+
+
+class SystemMessageGenerator:
+    r"""System message generator for agents.
+
+    Args:
+        task_type (TaskType, optional): The task type.
+            (default: :obj:`TaskType.AI_SOCIETY`)
+        sys_prompts (Optional[Dict[RoleType, str]], optional): The prompts of
+            the system messages for each role type. (default: :obj:`None`)
+        sys_msg_meta_dict_keys (Optional[Set[str]], optional): The set of keys
+            of the meta dictionary used to fill the prompts.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        task_type: TaskType = TaskType.AI_SOCIETY,
+        sys_prompts: Optional[Dict[RoleType, str]] = None,
+        sys_msg_meta_dict_keys: Optional[Set[str]] = None,
+    ) -> None:
+        self.sys_prompts: Dict[RoleType, str]
+
+        if sys_prompts is not None:
+            self.sys_prompts = sys_prompts
+            self.sys_msg_meta_dict_keys = sys_msg_meta_dict_keys or set()
+        else:
+            assistant_prompt_template = PromptTemplateGenerator(
+            ).get_system_prompt(
+                task_type,
+                RoleType.ASSISTANT,
+            )
+            user_prompt_template = PromptTemplateGenerator().get_system_prompt(
+                task_type,
+                RoleType.USER,
+            )
+            critic_prompt_template = PromptTemplateGenerator(
+            ).get_system_prompt(
+                task_type,
+                RoleType.CRITIC,
+            )
+            embodiment_prompt_template = PromptTemplateGenerator(
+            ).get_system_prompt(
+                task_type,
+                RoleType.EMBODIMENT,
+            )
+
+            self.sys_prompts = dict()
+            self.sys_prompts[RoleType.ASSISTANT] = assistant_prompt_template
+            self.sys_prompts[RoleType.USER] = user_prompt_template
+            self.sys_prompts[RoleType.CRITIC] = critic_prompt_template
+            self.sys_prompts[RoleType.EMBODIMENT] = embodiment_prompt_template
+
+            self.sys_msg_meta_dict_keys = (
+                assistant_prompt_template.key_words
+                | user_prompt_template.key_words
+                | critic_prompt_template.key_words
+                | embodiment_prompt_template.key_words)
+
+        if RoleType.DEFAULT not in self.sys_prompts:
+            self.sys_prompts[RoleType.DEFAULT] = "You are a helpful assistant."
+
+    def validate_meta_dict_keys(self, meta_dict: Dict[str, str]) -> None:
+        r"""Validates the keys of the meta_dict.
+
+        Args:
+            meta_dict (Dict[str, str]): The dictionary to validate.
+        """
+        if not set(meta_dict.keys()).issubset(self.sys_msg_meta_dict_keys):
+            raise ValueError("The keys of the meta_dict should be in "
+                             f"{self.sys_msg_meta_dict_keys}. "
+                             f"Got {set(meta_dict.keys())} instead.")
+
+    def from_dict(
+        self,
+        meta_dict: Dict[str, str],
+        role_tuple: Tuple[str, RoleType] = ("", RoleType.DEFAULT),
+    ) -> BaseMessage:
+        r"""Generates a system message from a dictionary.
+
+        Args:
+            meta_dict (Dict[str, str]): The dictionary containing the
+                information to generate the system message.
+            role_tuple (Tuple[str, RoleType], optional): The tuple containing
+                the role name and role type. (default: ("", RoleType.DEFAULT))
+
+        Returns:
+            BaseMessage: The generated system message.
+        """
+        self.validate_meta_dict_keys(meta_dict)
+        role_name, role_type = role_tuple
+        sys_prompt = self.sys_prompts[role_type]
+        sys_prompt = sys_prompt.format(**meta_dict)
+        return BaseMessage(role_name=role_name, role_type=role_type,
+                           meta_dict=meta_dict, content=sys_prompt)
+
+    def from_dicts(
+        self,
+        meta_dicts: List[Dict[str, str]],
+        role_tuples: List[Tuple[str, RoleType]],
+    ) -> List[BaseMessage]:
+        r"""Generates a list of system messages from a list of dictionaries.
+
+        Args:
+            meta_dicts (List[Dict[str, str]]): A list of dictionaries
+                containing the information to generate the system messages.
+            role_tuples (List[Tuple[str, RoleType]]): A list of tuples
+                containing the role name and role type for each system message.
+
+        Returns:
+            List[BaseMessage]: A list of generated system messages.
+
+        Raises:
+            ValueError: If the number of meta_dicts and role_tuples are
+                different.
+        """
+        if len(meta_dicts) != len(role_tuples):
+            raise ValueError(
+                "The number of meta_dicts and role_types should be the same.")
+
+        return [
+            self.from_dict(meta_dict, role_tuple)
+            for meta_dict, role_tuple in zip(meta_dicts, role_tuples)
+        ]
+
+
+class RoleNameGenerator:
+
+    def __init__(self, assistant_role_names_path:
+                 str = "data/ai_society/assistant_roles.txt",
+                 user_role_names_path: str = "data/ai_society/user_roles.txt",
+                 assistant_role_names: Optional[List[str]] = None,
+                 user_role_names: Optional[List[str]] = None) -> None:
+
+        if assistant_role_names is None:
+            with open(assistant_role_names_path, "r") as f:
+                assistant_role_names_: List[str] = f.read().splitlines()
+                self.assistant_role_names = [
+                    " ".join(name.split(" ")[1:])
+                    for name in assistant_role_names_
+                ]
+        else:
+            self.assistant_role_names = assistant_role_names
+
+        if user_role_names is None:
+            with open(user_role_names_path, "r") as f:
+                user_role_names_: List[str] = f.read().splitlines()
+                self.user_role_names = [
+                    " ".join(name.split(" ")[1:]) for name in user_role_names_
+                ]
+        else:
+            self.user_role_names = user_role_names
+
+    def from_role_files(self) -> Generator[Tuple, None, None]:
+        for assistant_role_name in self.assistant_role_names:
+            for user_role_name in self.user_role_names:
+                yield (assistant_role_name, user_role_name)
+
+
+class AISocietyTaskPromptGenerator:
+
+    def __init__(
+        self,
+        num_tasks: int = 10,
+    ) -> None:
+        self.generate_tasks_prompt = PromptTemplateGenerator(
+        ).get_generate_tasks_prompt(TaskType.AI_SOCIETY)
+
+        self.num_tasks = num_tasks
+
+    # TODO: Return role names for user and assistant with the generator.
+    def from_role_files(
+        self,
+        assistant_role_names_path: str = "data/ai_society/assistant_roles.txt",
+        user_role_names_path: str = "data/ai_society/user_roles.txt"
+    ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
+        roles_generator = RoleNameGenerator(
+            assistant_role_names_path, user_role_names_path).from_role_files()
+        for role_1, role_2 in roles_generator:
+            generate_tasks_prompt = self.generate_tasks_prompt.format(
+                assistant_role=role_1, user_role=role_2,
+                num_tasks=self.num_tasks)
+
+            yield (generate_tasks_prompt, (role_1, role_2))
+
+    def from_role_generator(
+        self, role_generator: Generator[Tuple, None, None]
+    ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
+        for role_1, role_2 in role_generator:
+            generate_tasks_prompt = self.generate_tasks_prompt.format(
+                assistant_role=role_1, user_role=role_2,
+                num_tasks=self.num_tasks)
+
+            yield (generate_tasks_prompt, (role_1, role_2))
+
+
+class SingleTxtGenerator:
+
+    def __init__(
+        self,
+        text_file_path: str,
+    ) -> None:
+
+        with open(text_file_path, "r") as f:
+            data_list: List[str] = f.read().splitlines()
+            self.data_list = [
+                " ".join(name.split(" ")[1:]) for name in data_list
+            ]
+
+    def from_role_files(self) -> Generator[str, None, None]:
+        for data in self.data_list:
+            yield data
+
+
+class CodeTaskPromptGenerator:
+
+    def __init__(
+        self,
+        num_tasks: int = 50,
+    ) -> None:
+
+        self.generate_tasks_prompt = PromptTemplateGenerator(
+        ).get_generate_tasks_prompt(TaskType.CODE)
+
+        self.num_tasks = num_tasks
+
+    def from_role_files(
+        self, languages_path: str = "data/code/languages.txt",
+        domains_path: str = "data/code/domains.txt"
+    ) -> Generator[Tuple[TextPrompt, str, str], None, None]:
+        language_generator = SingleTxtGenerator(
+            languages_path).from_role_files()
+
+        for language in language_generator:
+            domains_generator = SingleTxtGenerator(
+                domains_path).from_role_files()
+            for domain in domains_generator:
+                generated_tasks_prompt = self.generate_tasks_prompt.format(
+                    language=language, domain=domain, num_tasks=self.num_tasks)
+                yield generated_tasks_prompt, language, domain
+
+    def from_role_generator(
+        self, role_generator: Generator[Tuple, None, None]
+    ) -> Generator[str, None, None]:
+        raise NotImplementedError

camel/human.py

@@ -0,0 +1,130 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from typing import Any, Dict, Sequence
+
+from colorama import Fore
+
+from camel.messages import BaseMessage
+from camel.responses import ChatAgentResponse
+from camel.utils import print_text_animated
+
+
+class Human:
+    r"""A class representing a human user.
+
+    Args:
+        name (str): The name of the human user.
+            (default: :obj:`"Kill Switch Engineer"`).
+        logger_color (Any): The color of the menu options displayed to the
+            user. (default: :obj:`Fore.MAGENTA`)
+
+    Attributes:
+        name (str): The name of the human user.
+        logger_color (Any): The color of the menu options displayed to the
+            user.
+        input_button (str): The text displayed for the input button.
+        kill_button (str): The text displayed for the kill button.
+        options_dict (Dict[str, str]): A dictionary containing the options
+            displayed to the user.
+    """
+
+    def __init__(self, name: str = "Kill Switch Engineer",
+                 logger_color: Any = Fore.MAGENTA) -> None:
+        self.name = name
+        self.logger_color = logger_color
+        self.input_button = f"Input by {self.name}."
+        self.kill_button = "Stop!!!"
+        self.options_dict: Dict[str, str] = dict()
+
+    def display_options(self, messages: Sequence[BaseMessage]) -> None:
+        r"""Displays the options to the user.
+
+        Args:
+            messages (Sequence[BaseMessage]): A list of `BaseMessage` objects.
+
+        Returns:
+            None
+        """
+        options = [message.content for message in messages]
+        options.append(self.input_button)
+        options.append(self.kill_button)
+        print_text_animated(
+            self.logger_color + "\n> Proposals from "
+            f"{messages[0].role_name} ({messages[0].role_type}). "
+            "Please choose an option:\n")
+        for index, option in enumerate(options):
+            print_text_animated(
+                self.logger_color +
+                f"\x1b[3mOption {index + 1}:\n{option}\x1b[0m\n")
+            self.options_dict[str(index + 1)] = option
+
+    def get_input(self) -> str:
+        r"""Gets the input from the user.
+
+        Returns:
+            str: The user's input.
+        """
+        while True:
+            human_input = input(
+                self.logger_color +
+                f"Please enter your choice ([1-{len(self.options_dict)}]): ")
+            print("\n")
+            if human_input in self.options_dict:
+                break
+            print_text_animated(self.logger_color +
+                                "\n> Invalid choice. Please try again.\n")
+
+        return human_input
+
+    def parse_input(self, human_input: str) -> str:
+        r"""Parses the user's input and returns a `BaseMessage` object.
+
+        Args:
+            human_input (str): The user's input.
+
+        Returns:
+            content: A `str` object representing the user's input.
+        """
+        if self.options_dict[human_input] == self.input_button:
+            content = input(self.logger_color + "Please enter your message: ")
+        elif self.options_dict[human_input] == self.kill_button:
+            exit(self.logger_color + f"Killed by {self.name}.")
+        else:
+            content = self.options_dict[human_input]
+
+        return content
+
+    def reduce_step(self,
+                    messages: Sequence[BaseMessage]) -> ChatAgentResponse:
+        r"""Performs one step of the conversation by displaying options to the
+        user, getting their input, and parsing their choice.
+
+        Args:
+            messages (Sequence[BaseMessage]): A list of BaseMessage objects.
+
+        Returns:
+            ChatAgentResponse: A `ChatAgentResponse` object representing the
+                user's choice.
+        """
+        meta_chat_message = BaseMessage(
+            role_name=messages[0].role_name,
+            role_type=messages[0].role_type,
+            meta_dict=messages[0].meta_dict,
+            content="",
+        )
+        self.display_options(messages)
+        human_input = self.get_input()
+        content = self.parse_input(human_input)
+        message = meta_chat_message.create_new_instance(content)
+        return ChatAgentResponse([message], terminated=False, info={})

camel/memories/__init__.py

@@ -0,0 +1,28 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from .records import MemoryRecord, ContextRecord
+from .base import BaseMemory
+from .context_creators.base import BaseContextCreator
+from .context_creators.score_based import ScoreBasedContextCreator
+from .chat_history_memory import ChatHistoryMemory
+
+__all__ = [
+    'MemoryRecord',
+    'ContextRecord',
+    'BaseMemory',
+    'ChatHistoryMemory',
+    "BaseContextCreator",
+    "ScoreBasedContextCreator",
+]

camel/memories/base.py

@@ -0,0 +1,75 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+
+from camel.memories import MemoryRecord
+from camel.messages import OpenAIMessage
+
+
+class BaseMemory(ABC):
+    r"""An abstract base class that defines the foundational operations for a
+    memory component within an agent's memory system.
+
+    The memory component is tasked with functions like saving chat histories,
+    fetching or storing information in vector databases, and other related
+    operations. Every memory system should incorporate at least one instance of
+    a subclass derived from :obj:`BaseMemory`.
+
+    These instances, known as "memories", typically communicate using the
+    :obj:`MemoryRecord` object. Usually, a memory has at least one "storage"
+    mechanism, allowing it to interface with various storage systems, such as
+    disks or vector databases. Additionally, some memories might embed other
+    memory instances, enabling them to function as a high-level controller
+    within the broader memory system.
+
+    By default, when executing the :obj:`step()` method, an agent retrieves
+    messages from its designated memory and combines them with an incoming
+    message for input to the agent. Subsequently, both the response message and
+    the incoming messages are archived back into the memory.
+    """
+
+    @abstractmethod
+    def get_context(self) -> Tuple[List[OpenAIMessage], int]:
+        r"""Gets chat context with a proper size for the agent.
+
+        Returns:
+            (List[OpenAIMessage], int): A tuple containing the constructed
+                context in OpenAIMessage format and the total token count.
+        """
+        pass
+
+    @abstractmethod
+    def write_records(self, records: List[MemoryRecord]) -> None:
+        r"""Writes records to the memory, appending them to existing ones.
+
+        Args:
+            records (List[MemoryRecord]): Records to be added to the memory.
+        """
+        pass
+
+    def write_record(self, record: MemoryRecord) -> None:
+        r"""Writes a record to the memory, appending it to existing ones.
+
+        Args:
+            record (MemoryRecord): Record to be added to the memory.
+        """
+        self.write_records([record])
+
+    @abstractmethod
+    def clear(self) -> None:
+        r"""Clears all messages from the memory.
+        """
+        pass