langroid 0.1.234__tar.gz → 0.1.236__tar.gz

{langroid-0.1.234 → langroid-0.1.236}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.234
+Version: 0.1.236
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -35,6 +35,7 @@ Requires-Dist: fakeredis (>=2.12.1,<3.0.0)
 Requires-Dist: fire (>=0.5.0,<0.6.0)
 Requires-Dist: flake8 (>=6.0.0,<7.0.0)
 Requires-Dist: google-api-python-client (>=2.95.0,<3.0.0)
+Requires-Dist: groq (>=0.5.0,<0.6.0)
 Requires-Dist: grpcio (>=1.62.1,<2.0.0)
 Requires-Dist: halo (>=0.0.31,<0.0.32)
 Requires-Dist: huggingface-hub (>=0.21.2,<0.22.0) ; extra == "transformers"
@@ -230,6 +231,19 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Apr 2024:**
+  - **0.1.236**: Support for open LLMs hosted on Groq, e.g. specify 
+    `chat_model="groq/llama3-8b-8192"`.
+      See [tutorial](https://langroid.github.io/langroid/tutorials/local-llm-setup/).
+  - **0.1.235**: `Task.run(), Task.run_async(), run_batch_tasks` have `max_cost` 
+    and `max_tokens` params to exit when tokens or cost exceed a limit. The result 
+    `ChatDocument.metadata` now includes a `status` field which is a code indicating a 
+     task completion reason code. Also `task.run()` etc can be invoked with an explicit
+     `session_id` field which is used as a key to look up various settings in Redis cache.
+    Currently only used to look up "kill status" - this allows killing a running task, either by `task.kill()`
+    or by the classmethod `Task.kill_session(session_id)`.
+    For example usage, see the `test_task_kill` in [tests/main/test_task.py](https://github.com/langroid/langroid/blob/main/tests/main/test_task.py)
+  
 - **Mar 2024:**
   - **0.1.216:** Improvements to allow concurrent runs of `DocChatAgent`, see the
     [`test_doc_chat_agent.py`](https://github.com/langroid/langroid/blob/main/tests/main/test_doc_chat_agent.py)

{langroid-0.1.234 → langroid-0.1.236}/README.md

@@ -122,6 +122,19 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Apr 2024:**
+  - **0.1.236**: Support for open LLMs hosted on Groq, e.g. specify 
+    `chat_model="groq/llama3-8b-8192"`.
+      See [tutorial](https://langroid.github.io/langroid/tutorials/local-llm-setup/).
+  - **0.1.235**: `Task.run(), Task.run_async(), run_batch_tasks` have `max_cost` 
+    and `max_tokens` params to exit when tokens or cost exceed a limit. The result 
+    `ChatDocument.metadata` now includes a `status` field which is a code indicating a 
+     task completion reason code. Also `task.run()` etc can be invoked with an explicit
+     `session_id` field which is used as a key to look up various settings in Redis cache.
+    Currently only used to look up "kill status" - this allows killing a running task, either by `task.kill()`
+    or by the classmethod `Task.kill_session(session_id)`.
+    For example usage, see the `test_task_kill` in [tests/main/test_task.py](https://github.com/langroid/langroid/blob/main/tests/main/test_task.py)
+  
 - **Mar 2024:**
   - **0.1.216:** Improvements to allow concurrent runs of `DocChatAgent`, see the
     [`test_doc_chat_agent.py`](https://github.com/langroid/langroid/blob/main/tests/main/test_doc_chat_agent.py)

{langroid-0.1.234 → langroid-0.1.236}/langroid/__init__.py

@@ -27,6 +27,7 @@ from .agent.batch import (
 )
 
 from .agent.chat_document import (
+    StatusCode,
     ChatDocument,
     ChatDocMetaData,
 )
@@ -77,6 +78,7 @@ __all__ = [
     "AgentConfig",
     "ChatAgent",
     "ChatAgentConfig",
+    "StatusCode",
     "ChatDocument",
     "ChatDocMetaData",
     "Task",

{langroid-0.1.234 → langroid-0.1.236}/langroid/agent/batch.py

@@ -53,6 +53,7 @@ def run_batch_task_gen(
         message (Optional[str]): optionally overrides the console status messages
         handle_exceptions: bool: Whether to replace exceptions with outputs of None
         max_cost: float: maximum cost to run the task (default 0.0 for unlimited)
+        max_tokens: int: maximum token usage (in and out) (default 0 for unlimited)
 
 
     Returns:

{langroid-0.1.234 → langroid-0.1.236}/langroid/agent/chat_document.py

@@ -1,4 +1,5 @@
 import json
+from enum import Enum
 from typing import List, Optional, Union
 
 from pydantic import BaseModel, Extra
@@ -23,6 +24,23 @@ class ChatDocAttachment(BaseModel):
         extra = Extra.allow
 
 
+class StatusCode(str, Enum):
+    """Codes meant to be returned by task.run(). Some are not used yet."""
+
+    OK = "OK"
+    ERROR = "ERROR"
+    DONE = "DONE"
+    STALLED = "STALLED"
+    INF_LOOP = "INF_LOOP"
+    KILL = "KILL"
+    MAX_TURNS = "MAX_TURNS"
+    MAX_COST = "MAX_COST"
+    MAX_TOKENS = "MAX_TOKENS"
+    TIMEOUT = "TIMEOUT"
+    NO_ANSWER = "NO_ANSWER"
+    USER_QUIT = "USER_QUIT"
+
+
 class ChatDocMetaData(DocMetaData):
     parent: Optional["ChatDocument"] = None
     sender: Entity
@@ -35,6 +53,7 @@ class ChatDocMetaData(DocMetaData):
     usage: Optional[LLMTokenUsage]
     cached: bool = False
     displayed: bool = False
+    status: Optional[StatusCode] = None
 
 
 class ChatDocLoggerFields(BaseModel):

{langroid-0.1.234 → langroid-0.1.236}/langroid/agent/openai_assistant.py

@@ -7,6 +7,7 @@ import time
 from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Type, cast, no_type_check
 
+import openai
 from openai.types.beta import Assistant, Thread
 from openai.types.beta.assistant_update_params import (
     ToolResources,
@@ -99,12 +100,14 @@ class OpenAIAssistant(ChatAgent):
         super().__init__(config)
         self.config: OpenAIAssistantConfig = config
         self.llm: OpenAIGPT = OpenAIGPT(self.config.llm)
+        if not isinstance(self.llm.client, openai.OpenAI):
+            raise ValueError("Client must be OpenAI")
         # handles for various entities and methods
-        self.client = self.llm.client
-        self.runs = self.llm.client.beta.threads.runs
-        self.threads = self.llm.client.beta.threads
-        self.thread_messages = self.llm.client.beta.threads.messages
-        self.assistants = self.llm.client.beta.assistants
+        self.client: openai.OpenAI = self.llm.client
+        self.runs = self.client.beta.threads.runs
+        self.threads = self.client.beta.threads
+        self.thread_messages = self.client.beta.threads.messages
+        self.assistants = self.client.beta.assistants
         # which tool_ids are awaiting output submissions
         self.pending_tool_ids: List[str] = []
         self.cached_tool_ids: List[str] = []
@@ -208,14 +211,14 @@ class OpenAIAssistant(ChatAgent):
 
     def _cache_thread_key(self) -> str:
         """Key to use for caching or retrieving thread id"""
-        org = self.llm.client.organization or ""
+        org = self.client.organization or ""
         uid = generate_user_id(org)
         name = self.config.name
         return "Thread:" + name + ":" + uid
 
     def _cache_assistant_key(self) -> str:
         """Key to use for caching or retrieving assistant id"""
-        org = self.llm.client.organization or ""
+        org = self.client.organization or ""
         uid = generate_user_id(org)
         name = self.config.name
         return "Assistant:" + name + ":" + uid
@@ -317,7 +320,7 @@ class OpenAIAssistant(ChatAgent):
         cached = self._cache_thread_lookup()
         if cached is not None:
             if self.config.use_cached_thread:
-                self.thread = self.llm.client.beta.threads.retrieve(thread_id=cached)
+                self.thread = self.client.beta.threads.retrieve(thread_id=cached)
             else:
                 logger.warning(
                     f"""
@@ -326,7 +329,7 @@ class OpenAIAssistant(ChatAgent):
                     """
                 )
                 try:
-                    self.llm.client.beta.threads.delete(thread_id=cached)
+                    self.client.beta.threads.delete(thread_id=cached)
                 except Exception:
                     logger.warning(
                         f"""
@@ -337,7 +340,7 @@ class OpenAIAssistant(ChatAgent):
         if self.thread is None:
             if self.assistant is None:
                 raise ValueError("Assistant is None")
-            self.thread = self.llm.client.beta.threads.create()
+            self.thread = self.client.beta.threads.create()
             hash_key_str = (
                 (self.assistant.instructions or "")
                 + str(self.config.use_tools)
@@ -371,7 +374,7 @@ class OpenAIAssistant(ChatAgent):
         cached = self._cache_assistant_lookup()
         if cached is not None:
             if self.config.use_cached_assistant:
-                self.assistant = self.llm.client.beta.assistants.retrieve(
+                self.assistant = self.client.beta.assistants.retrieve(
                     assistant_id=cached
                 )
             else:
@@ -382,7 +385,7 @@ class OpenAIAssistant(ChatAgent):
                     """
                 )
                 try:
-                    self.llm.client.beta.assistants.delete(assistant_id=cached)
+                    self.client.beta.assistants.delete(assistant_id=cached)
                 except Exception:
                     logger.warning(
                         f"""
@@ -391,7 +394,7 @@ class OpenAIAssistant(ChatAgent):
                     )
                 self.llm.cache.delete_keys([self._cache_assistant_key()])
         if self.assistant is None:
-            self.assistant = self.llm.client.beta.assistants.create(
+            self.assistant = self.client.beta.assistants.create(
                 name=self.config.name,
                 instructions=self.config.system_message,
                 tools=[],

{langroid-0.1.234 → langroid-0.1.236}/langroid/agent/special/table_chat_agent.py

@@ -203,7 +203,6 @@ class TableChatAgent(ChatAgent):
         # Temporarily redirect standard output to our string-based I/O stream
         sys.stdout = code_out
 
-
         # Evaluate the last line and get the result
         try:
             eval_result = pd.eval(exprn, local_dict=local_vars)

{langroid-0.1.234 → langroid-0.1.236}/langroid/agent/task.py

@@ -27,11 +27,20 @@ from langroid.agent.chat_document import (
     ChatDocLoggerFields,
     ChatDocMetaData,
     ChatDocument,
+    StatusCode,
 )
+from langroid.cachedb.redis_cachedb import RedisCache, RedisCacheConfig
 from langroid.mytypes import Entity
 from langroid.parsing.parse_json import extract_top_level_json
 from langroid.utils.configuration import settings
-from langroid.utils.constants import DONE, NO_ANSWER, PASS, PASS_TO, SEND_TO, USER_QUIT
+from langroid.utils.constants import (
+    DONE,
+    NO_ANSWER,
+    PASS,
+    PASS_TO,
+    SEND_TO,
+    USER_QUIT_STRINGS,
+)
 from langroid.utils.logging import RichFileLogger, setup_file_logger
 
 logger = logging.getLogger(__name__)
@@ -73,6 +82,9 @@ class Task:
     the value of `result()`, which is the final result of the task.
     """
 
+    # class variable called `cache` that is a RedisCache object
+    cache: RedisCache = RedisCache(RedisCacheConfig(fake=False))
+
     def __init__(
         self,
         agent: Optional[Agent] = None,
@@ -141,7 +153,6 @@ class Task:
         """
         if agent is None:
             agent = ChatAgent()
-
         self.callbacks = SimpleNamespace(
             show_subtask_response=noop_fn,
             set_parent_agent=noop_fn,
@@ -172,6 +183,7 @@ class Task:
                 agent.set_user_message(user_message)
         self.max_cost: float = 0
         self.max_tokens: int = 0
+        self.session_id: str = ""
         self.logger: None | RichFileLogger = None
         self.tsv_logger: None | logging.Logger = None
         self.color_log: bool = False if settings.notebook else True
@@ -285,6 +297,54 @@ class Task:
     def __str__(self) -> str:
         return f"{self.name}"
 
+    def _cache_session_store(self, key: str, value: str) -> None:
+        """
+        Cache a key-value pair for the current session.
+        E.g. key = "kill", value = "1"
+        """
+        try:
+            self.cache.store(f"{self.session_id}:{key}", value)
+        except Exception as e:
+            logging.error(f"Error in Task._cache_session_store: {e}")
+
+    def _cache_session_lookup(self, key: str) -> Dict[str, Any] | str | None:
+        """
+        Retrieve a value from the cache for the current session.
+        """
+        session_id_key = f"{self.session_id}:{key}"
+        try:
+            cached_val = self.cache.retrieve(session_id_key)
+        except Exception as e:
+            logging.error(f"Error in Task._cache_session_lookup: {e}")
+            return None
+        return cached_val
+
+    def _is_kill(self) -> bool:
+        """
+        Check if the current session is killed.
+        """
+        return self._cache_session_lookup("kill") == "1"
+
+    def _set_alive(self) -> None:
+        """
+        Initialize the kill status of the current session.
+        """
+        self._cache_session_store("kill", "0")
+
+    @classmethod
+    def kill_session(cls, session_id: str = "") -> None:
+        """
+        Kill the session with the given session_id.
+        """
+        session_id_kill_key = f"{session_id}:kill"
+        cls.cache.store(session_id_kill_key, "1")
+
+    def kill(self) -> None:
+        """
+        Kill the task run associated with the current session.
+        """
+        self._cache_session_store("kill", "1")
+
     @property
     def _level(self) -> int:
         if self.caller is None:
@@ -378,6 +438,7 @@ class Task:
         caller: None | Task = None,
         max_cost: float = 0,
         max_tokens: int = 0,
+        session_id: str = "",
     ) -> Optional[ChatDocument]:
         """Synchronous version of `run_async()`.
         See `run_async()` for details."""
@@ -385,6 +446,9 @@ class Task:
         self.n_stalled_steps = 0
         self.max_cost = max_cost
         self.max_tokens = max_tokens
+        self.session_id = session_id
+        self._set_alive()
+
         assert (
             msg is None or isinstance(msg, str) or isinstance(msg, ChatDocument)
         ), f"msg arg in Task.run() must be None, str, or ChatDocument, not {type(msg)}"
@@ -406,15 +470,19 @@ class Task:
         i = 0
         while True:
             self.step()
-            if self.done():
+            done, status = self.done()
+            if done:
                 if self._level == 0 and not settings.quiet:
                     print("[magenta]Bye, hope this was useful!")
                 break
             i += 1
             if turns > 0 and i >= turns:
+                status = StatusCode.MAX_TURNS
                 break
 
         final_result = self.result()
+        if final_result is not None:
+            final_result.metadata.status = status
         self._post_run_loop()
         return final_result
 
@@ -425,6 +493,7 @@ class Task:
         caller: None | Task = None,
         max_cost: float = 0,
         max_tokens: int = 0,
+        session_id: str = "",
     ) -> Optional[ChatDocument]:
         """
         Loop over `step()` until task is considered done or `turns` is reached.
@@ -443,6 +512,7 @@ class Task:
             caller (Task|None): the calling task, if any
             max_cost (float): max cost allowed for the task (default 0 -> no limit)
             max_tokens (int): max tokens allowed for the task (default 0 -> no limit)
+            session_id (str): session id for the task
 
         Returns:
             Optional[ChatDocument]: valid result of the task.
@@ -456,6 +526,9 @@ class Task:
         self.n_stalled_steps = 0
         self.max_cost = max_cost
         self.max_tokens = max_tokens
+        self.session_id = session_id
+        self._set_alive()
+
         if (
             isinstance(msg, ChatDocument)
             and msg.metadata.recipient != ""
@@ -473,15 +546,19 @@ class Task:
         i = 0
         while True:
             await self.step_async()
-            if self.done():
+            done, status = self.done()
+            if done:
                 if self._level == 0 and not settings.quiet:
                     print("[magenta]Bye, hope this was useful!")
                 break
             i += 1
             if turns > 0 and i >= turns:
+                status = StatusCode.MAX_TURNS
                 break
 
         final_result = self.result()
+        if final_result is not None:
+            final_result.metadata.status = status
         self._post_run_loop()
         return final_result
 
@@ -942,6 +1019,7 @@ class Task:
         recipient = result_msg.metadata.recipient if result_msg else None
         responder = result_msg.metadata.parent_responder if result_msg else None
         tool_ids = result_msg.metadata.tool_ids if result_msg else []
+        status = result_msg.metadata.status if result_msg else None
 
         # regardless of which entity actually produced the result,
         # when we return the result, we set entity to USER
@@ -954,6 +1032,7 @@ class Task:
                 source=Entity.USER,
                 sender=Entity.USER,
                 block=block,
+                status=status,
                 parent_responder=responder,
                 sender_name=self.name,
                 recipient=recipient,
@@ -1036,7 +1115,7 @@ class Task:
 
     def done(
         self, result: ChatDocument | None = None, r: Responder | None = None
-    ) -> bool:
+    ) -> Tuple[bool, StatusCode]:
         """
         Check if task is done. This is the default behavior.
         Derived classes can override this.
@@ -1046,26 +1125,29 @@ class Task:
                 Not used here, but could be used by derived classes.
         Returns:
             bool: True if task is done, False otherwise
+            StatusCode: status code indicating why task is done
         """
+        if self._is_kill():
+            return (True, StatusCode.KILL)
         result = result or self.pending_message
         user_quit = (
             result is not None
-            and result.content in USER_QUIT
+            and result.content in USER_QUIT_STRINGS
             and result.metadata.sender == Entity.USER
         )
         if self._level == 0 and self.only_user_quits_root:
             # for top-level task, only user can quit out
-            return user_quit
+            return (user_quit, StatusCode.USER_QUIT if user_quit else StatusCode.OK)
 
         if self.is_done:
-            return True
+            return (True, StatusCode.DONE)
 
         if self.n_stalled_steps >= self.max_stalled_steps:
             # we are stuck, so bail to avoid infinite loop
             logger.warning(
                 f"Task {self.name} stuck for {self.max_stalled_steps} steps; exiting."
             )
-            return True
+            return (True, StatusCode.STALLED)
 
         if self.max_cost > 0 and self.agent.llm is not None:
             try:
@@ -1073,7 +1155,7 @@ class Task:
                     logger.warning(
                         f"Task {self.name} cost exceeded {self.max_cost}; exiting."
                     )
-                    return True
+                    return (True, StatusCode.MAX_COST)
             except Exception:
                 pass
 
@@ -1083,10 +1165,10 @@ class Task:
                     logger.warning(
                         f"Task {self.name} uses > {self.max_tokens} tokens; exiting."
                     )
-                    return True
+                    return (True, StatusCode.MAX_TOKENS)
             except Exception:
                 pass
-        return (
+        final = (
             # no valid response from any entity/agent in current turn
             result is None
             # An entity decided task is done
@@ -1103,6 +1185,7 @@ class Task:
             # )
             or user_quit
         )
+        return (final, StatusCode.OK)
 
     def valid(
         self,
@@ -1120,7 +1203,7 @@ class Task:
 
         # if task would be considered done given responder r's `result`,
         # then consider the result valid.
-        if result is not None and self.done(result, r):
+        if result is not None and self.done(result, r)[0]:
             return True
         return (
             result is not None

{langroid-0.1.234 → langroid-0.1.236}/langroid/cachedb/redis_cachedb.py

@@ -109,7 +109,7 @@ class RedisCache(CacheDB):
             key (str): The key to retrieve the value for.
 
         Returns:
-            dict: The value associated with the key.
+            dict|str|None: The value associated with the key.
         """
         with self.redis_client() as client:  # type: ignore
             try:

{langroid-0.1.234 → langroid-0.1.236}/langroid/language_models/openai_gpt.py

@@ -21,6 +21,7 @@ from typing import (
 )
 
 import openai
+from groq import AsyncGroq, Groq
 from httpx import Timeout
 from openai import AsyncOpenAI, OpenAI
 from pydantic import BaseModel
@@ -347,6 +348,9 @@ class OpenAIGPT(LanguageModel):
     Class for OpenAI LLMs
     """
 
+    client: OpenAI | Groq
+    async_client: AsyncOpenAI | AsyncGroq
+
     def __init__(self, config: OpenAIGPTConfig = OpenAIGPTConfig()):
         """
         Args:
@@ -448,18 +452,31 @@ class OpenAIGPT(LanguageModel):
                 self.api_key = os.getenv("OPENAI_API_KEY", DUMMY_API_KEY)
         else:
             self.api_key = DUMMY_API_KEY
-        self.client = OpenAI(
-            api_key=self.api_key,
-            base_url=self.api_base,
-            organization=self.config.organization,
-            timeout=Timeout(self.config.timeout),
-        )
-        self.async_client = AsyncOpenAI(
-            api_key=self.api_key,
-            organization=self.config.organization,
-            base_url=self.api_base,
-            timeout=Timeout(self.config.timeout),
-        )
+
+        self.is_groq = self.config.chat_model.startswith("groq/")
+
+        if self.is_groq:
+            self.config.chat_model = self.config.chat_model.replace("groq/", "")
+            self.api_key = os.getenv("GROQ_API_KEY", DUMMY_API_KEY)
+            self.client = Groq(
+                api_key=self.api_key,
+            )
+            self.async_client = AsyncGroq(
+                api_key=self.api_key,
+            )
+        else:
+            self.client = OpenAI(
+                api_key=self.api_key,
+                base_url=self.api_base,
+                organization=self.config.organization,
+                timeout=Timeout(self.config.timeout),
+            )
+            self.async_client = AsyncOpenAI(
+                api_key=self.api_key,
+                organization=self.config.organization,
+                base_url=self.api_base,
+                timeout=Timeout(self.config.timeout),
+            )
 
         self.cache: MomentoCache | RedisCache
         if settings.cache_type == "momento":
@@ -855,6 +872,9 @@ class OpenAIGPT(LanguageModel):
         if self.config.use_chat_for_completion:
             return self.chat(messages=prompt, max_tokens=max_tokens)
 
+        if self.is_groq:
+            raise ValueError("Groq does not support pure completions")
+
         if settings.debug:
             print(f"[grey37]PROMPT: {escape(prompt)}[/grey37]")
 
@@ -869,6 +889,7 @@ class OpenAIGPT(LanguageModel):
             else:
                 if self.config.litellm:
                     from litellm import completion as litellm_completion
+                assert isinstance(self.client, OpenAI)
                 completion_call = (
                     litellm_completion
                     if self.config.litellm
@@ -929,6 +950,9 @@ class OpenAIGPT(LanguageModel):
         if self.config.use_chat_for_completion:
             return await self.achat(messages=prompt, max_tokens=max_tokens)
 
+        if self.is_groq:
+            raise ValueError("Groq does not support pure completions")
+
         if settings.debug:
             print(f"[grey37]PROMPT: {escape(prompt)}[/grey37]")
 
@@ -948,6 +972,7 @@ class OpenAIGPT(LanguageModel):
                     from litellm import acompletion as litellm_acompletion
                 # TODO this may not work: text_completion is not async,
                 # and we didn't find an async version in litellm
+                assert isinstance(self.async_client, AsyncOpenAI)
                 acompletion_call = (
                     litellm_acompletion
                     if self.config.litellm

{langroid-0.1.234 → langroid-0.1.236}/langroid/utils/constants.py

@@ -13,7 +13,7 @@ class Colors(BaseModel):
     RESET: str = "\033[0m"
 
 
-USER_QUIT = ["q", "x", "quit", "exit", "bye"]
+USER_QUIT_STRINGS = ["q", "x", "quit", "exit", "bye"]
 NO_ANSWER = "DO-NOT-KNOW"
 DONE = "DONE"
 PASS = "__PASS__"

{langroid-0.1.234 → langroid-0.1.236}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.1.234"
+version = "0.1.236"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -96,6 +96,7 @@ pdf2image = "^1.17.0"
 pytesseract = "^0.3.10"
 types-pyyaml = "^6.0.12.20240311"
 types-pillow = "^10.2.0.20240406"
+groq = "^0.5.0"
 
 [tool.poetry.extras]
 # install these using `poetry install -E [...]` where [...] is one of the extras below