camel-ai 0.2.3__py3-none-any.whl → 0.2.3a0__py3-none-any.whl

camel/toolkits/google_scholar_toolkit.py

@@ -1,146 +0,0 @@
-# =========== 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 re
-from typing import List, Optional
-
-from camel.toolkits import FunctionTool
-from camel.toolkits.base import BaseToolkit
-
-
-class GoogleScholarToolkit(BaseToolkit):
-    r"""A toolkit for retrieving information about authors and their
-    publications from Google Scholar.
-
-    Attributes:
-        author_identifier (Union[str, None]): The author's Google Scholar URL
-            or name of the author to search for.
-        is_author_name (bool): Flag to indicate if the identifier is a name.
-            (default: :obj:`False`)
-        scholarly (module): The scholarly module for querying Google Scholar.
-    """
-
-    def __init__(
-        self, author_identifier: str, is_author_name: bool = False
-    ) -> None:
-        r"""Initializes the GoogleScholarToolkit with the author's identifier.
-
-        Args:
-            author_identifier (str): The author's Google Scholar URL or name
-                of the author to search for.
-            is_author_name (bool): Flag to indicate if the identifier is a
-                name. (default: :obj:`False`)
-        """
-        from scholarly import scholarly
-
-        self.scholarly = scholarly
-        self.author_identifier = author_identifier
-        self.is_author_name = is_author_name
-
-    def _extract_author_id(self) -> Optional[str]:
-        r"""Extracts the author ID from a Google Scholar URL if provided.
-
-        Returns:
-            Optional[str]: The extracted author ID, or None if not found.
-        """
-        match = re.search(r'user=([A-Za-z0-9-]+)', self.author_identifier)
-        return match.group(1) if match else None
-
-    def get_author_detailed_info(
-        self,
-    ) -> dict:
-        r"""Retrieves detailed information about the author.
-
-        Returns:
-            dict: A dictionary containing detailed information about the
-                author.
-        """
-        if self.is_author_name:
-            search_query = self.scholarly.search_author(self.author_identifier)
-            # Retrieve the first result from the iterator
-            first_author_result = next(search_query)
-        else:
-            author_id = self._extract_author_id()
-            first_author_result = self.scholarly.search_author_id(id=author_id)
-
-        author = self.scholarly.fill(first_author_result)
-        return author
-
-    def get_author_publications(
-        self,
-    ) -> List[str]:
-        r"""Retrieves the titles of the author's publications.
-
-        Returns:
-            List[str]: A list of publication titles authored by the author.
-        """
-        author = self.get_author_detailed_info()
-        publication_titles = [
-            pub['bib']['title'] for pub in author['publications']
-        ]
-        return publication_titles
-
-    def get_publication_by_title(
-        self, publication_title: str
-    ) -> Optional[dict]:
-        r"""Retrieves detailed information about a specific publication by its
-        title. Note that this method cannot retrieve the full content of the
-        paper.
-
-        Args:
-            publication_title (str): The title of the publication to search
-                for.
-
-        Returns:
-            Optional[dict]: A dictionary containing detailed information about
-                the publication if found; otherwise, `None`.
-        """
-        author = self.get_author_detailed_info()
-        publications = author['publications']
-        for publication in publications:
-            if publication['bib']['title'] == publication_title:
-                return self.scholarly.fill(publication)
-        return None  # Return None if not found
-
-    def get_full_paper_content_by_link(self, pdf_url: str) -> Optional[str]:
-        r"""Retrieves the full paper content from a given PDF URL using the
-        arxiv2text tool.
-
-        Args:
-            pdf_url (str): The URL of the PDF file.
-
-        Returns:
-            Optional[str]: The full text extracted from the PDF, or `None` if
-                an error occurs.
-        """
-        from arxiv2text import arxiv_to_text
-
-        try:
-            return arxiv_to_text(pdf_url)
-        except Exception:
-            return None  # Return None in case of any error
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of FunctionTool objects representing the
-        functions in the toolkit.
-
-        Returns:
-            List[FunctionTool]: A list of FunctionTool objects
-                representing the functions in the toolkit.
-        """
-        return [
-            FunctionTool(self.get_author_detailed_info),
-            FunctionTool(self.get_author_publications),
-            FunctionTool(self.get_publication_by_title),
-            FunctionTool(self.get_full_paper_content_by_link),
-        ]

camel/toolkits/whatsapp_toolkit.py

@@ -1,177 +0,0 @@
-# =========== 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 Any, Dict, List, Union
-
-import requests
-
-from camel.toolkits import FunctionTool
-from camel.toolkits.base import BaseToolkit
-from camel.utils.commons import retry_request
-
-
-class WhatsAppToolkit(BaseToolkit):
-    r"""A class representing a toolkit for WhatsApp operations.
-
-    This toolkit provides methods to interact with the WhatsApp Business API,
-    allowing users to send messages, retrieve message templates, and get
-    business profile information.
-
-    Attributes:
-        retries (int): Number of retries for API requests in case of failure.
-        delay (int): Delay between retries in seconds.
-        base_url (str): Base URL for the WhatsApp Business API.
-        version (str): API version.
-    """
-
-    def __init__(self, retries: int = 3, delay: int = 1):
-        r"""Initializes the WhatsAppToolkit with the specified number of
-        retries and delay.
-
-        Args:
-            retries (int): Number of times to retry the request in case of
-                failure. (default: :obj:`3`)
-            delay (int): Time in seconds to wait between retries.
-                (default: :obj:`1`)
-        """
-        self.retries = retries
-        self.delay = delay
-        self.base_url = "https://graph.facebook.com"
-        self.version = "v17.0"
-
-        self.access_token = os.environ.get("WHATSAPP_ACCESS_TOKEN", "")
-        self.phone_number_id = os.environ.get("WHATSAPP_PHONE_NUMBER_ID", "")
-
-        if not all([self.access_token, self.phone_number_id]):
-            raise ValueError(
-                "WhatsApp API credentials are not set. "
-                "Please set the WHATSAPP_ACCESS_TOKEN and "
-                "WHATSAPP_PHONE_NUMBER_ID environment variables."
-            )
-
-    def send_message(
-        self, to: str, message: str
-    ) -> Union[Dict[str, Any], str]:
-        r"""Sends a text message to a specified WhatsApp number.
-
-        Args:
-            to (str): The recipient's WhatsApp number in international format.
-            message (str): The text message to send.
-
-        Returns:
-            Union[Dict[str, Any], str]: A dictionary containing
-                the API response if successful, or an error message string if
-                failed.
-        """
-        url = f"{self.base_url}/{self.version}/{self.phone_number_id}/messages"
-        headers = {
-            "Authorization": f"Bearer {self.access_token}",
-            "Content-Type": "application/json",
-        }
-        data = {
-            "messaging_product": "whatsapp",
-            "to": to,
-            "type": "text",
-            "text": {"body": message},
-        }
-
-        try:
-            response = retry_request(
-                requests.post,
-                retries=self.retries,
-                delay=self.delay,
-                url=url,
-                headers=headers,
-                json=data,
-            )
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            return f"Failed to send message: {e!s}"
-
-    def get_message_templates(self) -> Union[List[Dict[str, Any]], str]:
-        r"""Retrieves all message templates for the WhatsApp Business account.
-
-        Returns:
-            Union[List[Dict[str, Any]], str]: A list of dictionaries containing
-                template information if successful, or an error message string
-                if failed.
-        """
-        url = (
-            f"{self.base_url}/{self.version}/{self.phone_number_id}"
-            "/message_templates"
-        )
-        headers = {"Authorization": f"Bearer {self.access_token}"}
-
-        try:
-            response = retry_request(
-                requests.get,
-                retries=self.retries,
-                delay=self.delay,
-                url=url,
-                headers=headers,
-            )
-            response.raise_for_status()
-            return response.json().get("data", [])
-        except Exception as e:
-            return f"Failed to retrieve message templates: {e!s}"
-
-    def get_business_profile(self) -> Union[Dict[str, Any], str]:
-        r"""Retrieves the WhatsApp Business profile information.
-
-        Returns:
-            Union[Dict[str, Any], str]: A dictionary containing the business
-                profile information if successful, or an error message string
-                if failed.
-        """
-        url = (
-            f"{self.base_url}/{self.version}/{self.phone_number_id}"
-            "/whatsapp_business_profile"
-        )
-        headers = {"Authorization": f"Bearer {self.access_token}"}
-        params = {
-            "fields": (
-                "about,address,description,email,profile_picture_url,"
-                "websites,vertical"
-            )
-        }
-
-        try:
-            response = retry_request(
-                requests.get,
-                retries=self.retries,
-                delay=self.delay,
-                url=url,
-                headers=headers,
-                params=params,
-            )
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            return f"Failed to retrieve business profile: {e!s}"
-
-    def get_tools(self) -> List[FunctionTool]:
-        r"""Returns a list of OpenAIFunction objects representing the
-        functions in the toolkit.
-
-        Returns:
-            List[OpenAIFunction]: A list of OpenAIFunction objects for the
-                toolkit methods.
-        """
-        return [
-            FunctionTool(self.send_message),
-            FunctionTool(self.get_message_templates),
-            FunctionTool(self.get_business_profile),
-        ]

camel/types/unified_model_type.py

@@ -1,104 +0,0 @@
-# =========== 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 logging
-from threading import Lock
-from typing import TYPE_CHECKING, ClassVar, Dict, Union, cast
-
-if TYPE_CHECKING:
-    from camel.types import ModelType
-
-
-class UnifiedModelType(str):
-    r"""Class used for support both :obj:`ModelType` and :obj:`str` to be used
-    to represent a model type in a unified way. This class is a subclass of
-    :obj:`str` so that it can be used as string seamlessly.
-
-    Args:
-        value (Union[ModelType, str]): The value of the model type.
-    """
-
-    _cache: ClassVar[Dict[str, "UnifiedModelType"]] = {}
-    _lock: ClassVar[Lock] = Lock()
-
-    def __new__(cls, value: Union["ModelType", str]) -> "UnifiedModelType":
-        with cls._lock:
-            if value not in cls._cache:
-                instance = super().__new__(cls, value)
-                cls._cache[value] = cast(UnifiedModelType, instance)
-            else:
-                instance = cls._cache[value]
-        return instance
-
-    def __init__(self, value: Union["ModelType", str]) -> None:
-        pass
-
-    @property
-    def value_for_tiktoken(self) -> str:
-        r"""Returns the model name for TikToken."""
-        return "gpt-4o-mini"
-
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the token limit for the model. Here we set the default
-        value as `999_999_999` if it's not provided from `model_config_dict`"""
-        logging.warning(
-            "Invalid or missing `max_tokens` in `model_config_dict`. "
-            "Defaulting to 999_999_999 tokens."
-        )
-        return 999_999_999
-
-    @property
-    def is_openai(self) -> bool:
-        r"""Returns whether the model is an OpenAI model."""
-        return True
-
-    @property
-    def is_anthropic(self) -> bool:
-        r"""Returns whether the model is an Anthropic model."""
-        return True
-
-    @property
-    def is_azure_openai(self) -> bool:
-        r"""Returns whether the model is an Azure OpenAI model."""
-        return True
-
-    @property
-    def is_groq(self) -> bool:
-        r"""Returns whether the model is a Groq served model."""
-        return True
-
-    @property
-    def is_zhipuai(self) -> bool:
-        r"""Returns whether the model is a Zhipuai model."""
-        return True
-
-    @property
-    def is_gemini(self) -> bool:
-        r"""Returns whether the model is a Gemini model."""
-        return True
-
-    @property
-    def is_mistral(self) -> bool:
-        r"""Returns whether the model is a Mistral model."""
-        return True
-
-    @property
-    def is_reka(self) -> bool:
-        r"""Returns whether the model is a Reka model."""
-        return True
-
-    @property
-    def support_native_tool_calling(self) -> bool:
-        r"""Returns whether the model supports native tool calling."""
-        return False

camel_ai-0.2.3.dist-info/LICENSE

@@ -1,201 +0,0 @@
-                                 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 2023 @ CAMEL-AI.org
-
-   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.