edsl 0.1.59__py3-none-any.whl → 0.1.61__py3-none-any.whl

edsl/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.59"
+__version__ = "0.1.61"

edsl/agents/agent.py

@@ -58,6 +58,7 @@ from typing import (
     TypeVar,
     Type,
 )
+from collections.abc import MutableMapping
 
 if TYPE_CHECKING:
     from ..caching import Cache
@@ -106,24 +107,69 @@ class DirectAnswerMethod(Protocol):
     def __call__(self, self_: A, question: QuestionBase, scenario: Scenario) -> Any: ...
 
 
-class AgentTraits(Scenario):
-    """A class representing the traits of an agent.
-    
-    AgentTraits inherits from Scenario to provide a structured way to store and
-    access agent characteristics. This allows agent traits to be handled consistently
-    throughout the EDSL framework, including for presentation in prompts.
-    
-    Attributes:
-        data: Dictionary containing the agent's traits as key-value pairs
+class AgentTraits(MutableMapping):
     """
+    A proxy around the real trait dict.
+    All writes go through _guard(), which delegates to the parent Agent
+    to enforce whatever rules it wants (no dynamic-traits override, etc.).
+    """
+    def __init__(self, data: dict, parent: "Agent"):
+        self._store = Scenario(data)
+        self._parent = parent
+
+    # ---- internal helper -------------------------------------------------
+    def _guard(self):
+        self._parent._check_before_modifying_traits()        # raise if not allowed
+
+    # ---- MutableMapping interface ----------------------------------------
+    def __getitem__(self, key):
+        return self._store[key]
+
+    def __setitem__(self, key, value):
+        self._guard()
+        self._store[key] = value
+
+    def __delitem__(self, key):
+        self._guard()
+        del self._store[key]
 
+    def __iter__(self):
+        return iter(self._store)
+
+    def __len__(self):
+        return len(self._store)
+
+    # nice repr for debugging
     def __repr__(self):
-        """Generate a string representation of the agent traits.
-        
-        Returns:
-            str: String representation of the agent traits dictionary
+        return dict(self._store).__repr__()
+
+    # allow dict | union syntax to work like normal dicts
+    def __or__(self, other):
+        """Return a regular dictionary that is the union of this mapping and *other*.
+
+        Mirrors the behaviour of ``dict.__or__`` introduced in Python 3.9 so that
+        ``AgentTraits | AgentTraits`` (or ``|`` with any mapping) behaves the
+        same as with plain ``dict`` objects.  The result is a **new** *dict*
+        (not an ``AgentTraits`` instance) which matches the semantics of the
+        built-in type.
         """
-        return f"{self.data}"
+        if isinstance(other, MutableMapping):
+            return {**dict(self), **dict(other)}
+        return NotImplemented
+
+    # support reversed operand order (e.g. ``dict | AgentTraits``)
+    def __ror__(self, other):
+        if isinstance(other, MutableMapping):
+            return {**dict(other), **dict(self)}
+        return NotImplemented
+
+    # in-place union ``|=`` – delegates to __setitem__ so guards still fire
+    def __ior__(self, other):
+        if isinstance(other, MutableMapping):
+            for k, v in other.items():
+                self[k] = v  # will trigger _guard()
+            return self
+        return NotImplemented
 
 
 class Agent(Base):
@@ -267,7 +313,7 @@ class Agent(Base):
             codebook: Dictionary mapping trait keys to descriptions
         """
         self.name = name
-        self._traits = AgentTraits(traits or dict())
+        self._traits = AgentTraits(traits or {}, parent=self)
         self.codebook = codebook or dict()
 
     def _initialize_instruction(self, instruction) -> None:
@@ -711,7 +757,7 @@ class Agent(Base):
                 return self.dynamic_traits_function()
         else:
             # Return the stored traits
-            return dict(self._traits)
+            return self._traits
 
     @contextmanager
     def modify_traits_context(self):
@@ -719,7 +765,8 @@ class Agent(Base):
         try:
             yield
         finally:
-            self._traits = AgentTraits(self._traits)
+            # re-wrap the possibly mutated mapping so future writes remain guarded
+            self._traits = AgentTraits(dict(self._traits), parent=self)
 
     def _check_before_modifying_traits(self):
         """Check before modifying traits."""
@@ -732,6 +779,7 @@ class Agent(Base):
     @traits.setter
     def traits(self, traits: dict[str, str]):
         with self.modify_traits_context():
+            # store raw dict temporarily – it will be wrapped by the context manager
             self._traits = traits
 
     def rename(

edsl/agents/agent_list.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import csv
 import sys
 import random
+import warnings
 import logging
 from collections import defaultdict
 from itertools import product
@@ -38,6 +39,9 @@ class EmptyAgentList:
     def __repr__(self):
         return "Empty AgentList"
 
+    def __len__(self):
+        return 0
+
 
 # ResultsExportMixin,
 class AgentList(UserList, Base, AgentListOperationsMixin):
@@ -49,7 +53,7 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
 
     >>> AgentList.example().to_scenario_list().drop('age')
     ScenarioList([Scenario({'hair': 'brown', 'height': 5.5}), Scenario({'hair': 'brown', 'height': 5.5})])
-    
+
     >>> AgentList.example().to_dataset()
     Dataset([{'age': [22, 22]}, {'hair': ['brown', 'brown']}, {'height': [5.5, 5.5]}])
 
@@ -65,7 +69,11 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         "https://docs.expectedparrot.com/en/latest/agents.html#agentlist-class"
     )
 
-    def __init__(self, data: Optional[list["Agent"]] = None, codebook: Optional[dict[str, str]] = None):
+    def __init__(
+        self,
+        data: Optional[list["Agent"]] = None,
+        codebook: Optional[dict[str, str]] = None,
+    ):
         """Initialize a new AgentList.
 
         >>> from edsl import Agent
@@ -79,14 +87,14 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
 
         Args:
             data: A list of Agent objects. If None, creates an empty AgentList.
-            codebook: Optional dictionary mapping trait names to descriptions. 
+            codebook: Optional dictionary mapping trait names to descriptions.
                       If provided, will be applied to all agents in the list.
         """
         if data is not None:
             super().__init__(data)
         else:
             super().__init__()
-            
+
         # Apply codebook to all agents if provided
         if codebook is not None:
             self.set_codebook(codebook)
@@ -99,10 +107,12 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         """
         for agent in self.data:
             agent.instruction = instruction
-        
+
         return None
-    
-    def set_traits_presentation_template(self, traits_presentation_template: str) -> None:
+
+    def set_traits_presentation_template(
+        self, traits_presentation_template: str
+    ) -> None:
         """Set the traits presentation template for all agents in the list.
 
         Args:
@@ -110,7 +120,7 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         """
         for agent in self.data:
             agent.traits_presentation_template = traits_presentation_template
-        
+
         return None
 
     def shuffle(self, seed: Optional[str] = None) -> AgentList:
@@ -141,7 +151,7 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         if seed:
             random.seed(seed)
         return AgentList(random.sample(self.data, n))
-    
+
     def drop(self, field_name: str) -> AgentList:
         """Drop a field from the AgentList.
 
@@ -166,6 +176,34 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         """
         return AgentList([a.duplicate() for a in self.data])
 
+    def collapse(self, warn_about_none_name: bool = True) -> "AgentList":
+        """All agents with the same name have their traits combined.
+
+        >>> al = AgentList([Agent(name = 'steve'), Agent(name = 'roxanne')])
+        >>> al.collapse()
+        AgentList([Agent(name = \"\"\"steve\"\"\", traits = {}), Agent(name = \"\"\"roxanne\"\"\", traits = {})])
+        >>> al = AgentList([Agent(name = 'steve', traits = {'age': 22}), Agent(name = 'steve', traits = {'hair': 'brown'})])
+        >>> al.collapse()
+        AgentList([Agent(name = \"\"\"steve\"\"\", traits = {'age': 22, 'hair': 'brown'})])
+        >>> AgentList.example().collapse(warn_about_none_name = False)
+        AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})])
+        """
+        new_agent_list = AgentList()
+        warned_about_none_name = False
+        d = {}
+        for agent in self:
+            if agent.name is None:
+                if not warned_about_none_name and warn_about_none_name:
+                    warnings.warn("Agent has no name, so it will be ignored.")
+                    warned_about_none_name = True
+            if agent.name not in d:
+                d[agent.name] = agent
+            else:
+                d[agent.name].traits.update(agent.traits)
+        for name, agent in d.items():
+            new_agent_list.append(agent)
+        return new_agent_list
+
     def rename(self, old_name: str, new_name: str) -> AgentList:
         """Rename a trait across all agents in the list.
 
@@ -212,7 +250,20 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
             traits_to_select = list(traits)
 
         return AgentList([agent.select(*traits_to_select) for agent in self.data])
-
+    
+    # @classmethod
+    # def from_results(self, results: "Results") -> "AgentList": 
+    #     """Create an AgentList from a Results object.
+        
+    #     >>> from edsl import Results
+    #     >>> results = Results.example()
+    #     >>> al = AgentList.from_results(results)
+    #     >>> al
+    #     AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5}), Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})])
+    #     """ 
+    #     al = results.agent_list 
+    #     return al 
+     
     def filter(self, expression: str) -> AgentList:
         """Filter agents based on a boolean expression.
 
@@ -229,11 +280,23 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
             ...                Agent(traits = {'a': 1, 'b': 2})])
             >>> al.filter("b == 2")
             AgentList([Agent(traits = {'a': 1, 'b': 2})])
+            >>> al = AgentList([Agent(traits = {'a': 1, 'b': 1}, name = 'steve'),
+            ...                Agent(traits = {'a': 1, 'b': 2}, name = 'roxanne')])
+            >>> len(al.filter("name == 'steve'"))
+            1
+            >>> len(al.filter("name == 'roxanne'"))
+            1
+            >>> len(al.filter("name == 'steve' and a == 1"))
+            1
+            >>> len(al.filter("name == 'steve' and a == 2"))
+            0
+            >>> len(al.filter("name == 'steve' and a == 1 and b == 2"))
+            0
         """
 
         def create_evaluator(agent: "Agent"):
             """Create an evaluator for the given agent."""
-            return EvalWithCompoundTypes(names=agent.traits)
+            return EvalWithCompoundTypes(names={**agent.traits, "name": agent.name})
 
         try:
             new_data = [
@@ -269,7 +332,12 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         return list(d.keys())
 
     @classmethod
-    def from_csv(cls, file_path: str, name_field: Optional[str] = None, codebook: Optional[dict[str, str]] = None):
+    def from_csv(
+        cls,
+        file_path: str,
+        name_field: Optional[str] = None,
+        codebook: Optional[dict[str, str]] = None,
+    ):
         """Load AgentList from a CSV file.
 
         >>> import csv
@@ -306,7 +374,9 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
                     name_field = "name"
                 if name_field is not None:
                     agent_name = row.pop(name_field)
-                    agent_list.append(Agent(traits=row, name=agent_name, codebook=codebook))
+                    agent_list.append(
+                        Agent(traits=row, name=agent_name, codebook=codebook)
+                    )
                 else:
                     agent_list.append(Agent(traits=row, codebook=codebook))
         return cls(agent_list)
@@ -420,19 +490,19 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
                 agent.to_dict(add_edsl_version=add_edsl_version) for agent in data
             ]
         }
-        
+
         # Add codebook if all agents have the same codebook
         if len(self.data) > 0:
             # Get the first agent's codebook
             first_codebook = self.data[0].codebook
-            
+
             # Check if all agents have the same codebook
             all_same = all(agent.codebook == first_codebook for agent in self.data)
-            
+
             # Only include codebook if it's non-empty and consistent across all agents
             if all_same and first_codebook:
                 d["codebook"] = first_codebook
-                
+
         if add_edsl_version:
             from edsl import __version__
 
@@ -453,7 +523,7 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         return {
             "agents": len(self),
         }
-    
+
     def set_codebook(self, codebook: dict[str, str]) -> AgentList:
         """Set the codebook for the AgentList.
 
@@ -472,7 +542,6 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
 
         return self
 
-
     def table(
         self,
         *fields,
@@ -525,7 +594,11 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
                 data[trait_key].append(agent.traits.get(trait_key, None))
             if not traits_only:
                 data["agent_parameters"].append(
-                    {"instruction": agent.instruction, "agent_name": agent.name, "traits_presentation_template": agent.traits_presentation_template}
+                    {
+                        "instruction": agent.instruction,
+                        "agent_name": agent.name,
+                        "traits_presentation_template": agent.traits_presentation_template,
+                    }
                 )
         return Dataset([{key: entry} for key, entry in data.items()])
 
@@ -551,21 +624,23 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
 
         agents = [Agent.from_dict(agent_dict) for agent_dict in data["agent_list"]]
         agent_list = cls(agents)
-        
+
         # Apply codebook if present in the dictionary
         if "codebook" in data and data["codebook"]:
             agent_list.set_codebook(data["codebook"])
-            
+
         return agent_list
 
     @classmethod
-    def example(cls, randomize: bool = False, codebook: Optional[dict[str, str]] = None) -> AgentList:
+    def example(
+        cls, randomize: bool = False, codebook: Optional[dict[str, str]] = None
+    ) -> AgentList:
         """
         Returns an example AgentList instance.
 
         :param randomize: If True, uses Agent's randomize method.
         :param codebook: Optional dictionary mapping trait names to descriptions.
-        
+
         >>> al = AgentList.example()
         >>> al
         AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5}), Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})])
@@ -576,14 +651,19 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         from .agent import Agent
 
         agent_list = cls([Agent.example(randomize), Agent.example(randomize)])
-        
+
         if codebook:
             agent_list.set_codebook(codebook)
-            
+
         return agent_list
 
     @classmethod
-    def from_list(self, trait_name: str, values: List[Any], codebook: Optional[dict[str, str]] = None) -> "AgentList":
+    def from_list(
+        self,
+        trait_name: str,
+        values: List[Any],
+        codebook: Optional[dict[str, str]] = None,
+    ) -> "AgentList":
         """Create an AgentList from a list of values.
 
         :param trait_name: The name of the trait.
@@ -599,10 +679,10 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
         from .agent import Agent
 
         agent_list = AgentList([Agent({trait_name: value}) for value in values])
-        
+
         if codebook:
             agent_list.set_codebook(codebook)
-            
+
         return agent_list
 
     def __mul__(self, other: AgentList) -> AgentList:
@@ -649,7 +729,7 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
             AgentList([Agent(traits = {'age': 22, 'hair': 'brown', 'height': 5.5})])
         """
         from .agent import Agent  # Use direct relative import
-        
+
         agents = []
         for scenario in scenario_list:
             # Simple implementation to handle the basic test case
@@ -659,13 +739,17 @@ class AgentList(UserList, Base, AgentListOperationsMixin):
 
         # Add a debug check to verify we've processed the scenarios correctly
         if len(agents) != len(scenario_list):
-            raise ValueError(f"Expected {len(scenario_list)} agents, but created {len(agents)}")
+            raise ValueError(
+                f"Expected {len(scenario_list)} agents, but created {len(agents)}"
+            )
 
         return cls(agents)
 
 
 if __name__ == "__main__":
     import doctest
-    
+
     # Just run the standard doctests with verbose flag
-    doctest.testmod(verbose=True, optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
+    doctest.testmod(
+        verbose=True, optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE
+    )

edsl/base/base_class.py

@@ -146,31 +146,62 @@ class PersistenceMixin:
         """
         print(cls.__doc__)
 
+    # def push(
+    #     self,
+    #     description: Optional[str] = None,
+    #     alias: Optional[str] = None,
+    #     visibility: Optional[str] = "unlisted",
+    #     expected_parrot_url: Optional[str] = None,
+    # ):
+    #     """Upload this object to the EDSL cooperative platform.
+
+    #     This method serializes the object and posts it to the EDSL coop service,
+    #     making it accessible to others or for your own use across sessions.
+
+    #     Args:
+    #         description: Optional text description of the object
+    #         alias: Optional human-readable identifier for the object
+    #         visibility: Access level setting ("private", "unlisted", or "public")
+    #         expected_parrot_url: Optional custom URL for the coop service
+
+    #     Returns:
+    #         The response from the coop service containing the object's unique identifier
+    #     """
+    #     from edsl.coop import Coop
+
+    #     c = Coop(url=expected_parrot_url)
+    #     return c.create(self, description, alias, visibility)
+
     def push(
         self,
         description: Optional[str] = None,
         alias: Optional[str] = None,
         visibility: Optional[str] = "unlisted",
         expected_parrot_url: Optional[str] = None,
-    ):
-        """Upload this object to the EDSL cooperative platform.
+    ) -> dict:
+        """
+        Get a signed URL for directly uploading an object to Google Cloud Storage.
 
-        This method serializes the object and posts it to the EDSL coop service,
-        making it accessible to others or for your own use across sessions.
+        This method provides a more efficient way to upload objects compared to the push() method,
+        especially for large files, by generating a direct signed URL to the storage bucket.
 
         Args:
-            description: Optional text description of the object
-            alias: Optional human-readable identifier for the object
-            visibility: Access level setting ("private", "unlisted", or "public")
-            expected_parrot_url: Optional custom URL for the coop service
+            expected_parrot_url (str, optional): Optional custom URL for the coop service
 
         Returns:
-            The response from the coop service containing the object's unique identifier
+            dict: A response containing the signed_url for direct upload and optionally a job_id
+
+        Example:
+            >>> from edsl.surveys import Survey
+            >>> survey = Survey(...)
+            >>> response = survey.push()
+            >>> print(f"Upload URL: {response['signed_url']}")
+            >>> # Use the signed_url to upload the object directly
         """
         from edsl.coop import Coop
 
         c = Coop(url=expected_parrot_url)
-        return c.create(self, description, alias, visibility)
+        return c.push(self, description, alias, visibility)
 
     def to_yaml(self, add_edsl_version=False, filename: str = None) -> Union[str, None]:
         """Convert the object to YAML format.
@@ -243,7 +274,7 @@ class PersistenceMixin:
         return fs.create_link()
 
     @classmethod
-    def pull(
+    def old_pull(
         cls,
         url_or_uuid: Optional[Union[str, UUID]] = None,
     ):
@@ -269,6 +300,44 @@ class PersistenceMixin:
 
         return coop.get(url_or_uuid, expected_object_type=object_type)
 
+    @classmethod
+    def pull(
+        cls,
+        url_or_uuid: Optional[Union[str, UUID]] = None,
+        expected_parrot_url: Optional[str] = None,
+    ) -> dict:
+        """
+        Get a signed URL for directly downloading an object from Google Cloud Storage.
+
+        This method provides a more efficient way to download objects compared to the old pull() method,
+        especially for large files, by generating a direct signed URL to the storage bucket.
+
+        Args:
+            url_or_uuid (Union[str, UUID], optional): Identifier for the object to retrieve.
+                Can be one of:
+                - UUID string (e.g., "123e4567-e89b-12d3-a456-426614174000")
+                - Full URL (e.g., "https://expectedparrot.com/content/123e4567...")
+                - Alias URL (e.g., "https://expectedparrot.com/content/username/my-survey")
+            expected_parrot_url (str, optional): Optional custom URL for the coop service
+
+        Returns:
+            dict: A response containing the signed_url for direct download
+
+        Example:
+            >>> response = SurveyClass.pull("123e4567-e89b-12d3-a456-426614174000")
+            >>> response = SurveyClass.pull("https://expectedparrot.com/content/username/my-survey")
+            >>> print(f"Download URL: {response['signed_url']}")
+            >>> # Use the signed_url to download the object directly
+        """
+        from edsl.coop import Coop
+        from edsl.coop import ObjectRegistry
+
+        coop = Coop(url=expected_parrot_url)
+
+        object_type = ObjectRegistry.get_object_type_by_edsl_class(cls)
+
+        return coop.pull(url_or_uuid, object_type)
+
     @classmethod
     def list(
         cls,

edsl/base/data_transfer_models.py

@@ -17,6 +17,7 @@ class EDSLOutput(NamedTuple):
     answer: Any
     generated_tokens: str
     comment: Optional[str] = None
+    reasoning_summary: Optional[Any] = None
 
 
 class ModelResponse(NamedTuple):
@@ -49,6 +50,7 @@ class EDSLResultObjectInput(NamedTuple):
     cache_key: str
     answer: Any
     comment: str
+    reasoning_summary: Optional[Any] = None
     validated: bool = False
     exception_occurred: Exception = None
     input_tokens: Optional[int] = None
@@ -96,12 +98,15 @@ class Answers(UserDict):
         answer = response.answer
         comment = response.comment
         generated_tokens = response.generated_tokens
+        reasoning_summary = response.reasoning_summary
         # record the answer
         if generated_tokens:
             self[question.question_name + "_generated_tokens"] = generated_tokens
         self[question.question_name] = answer
         if comment:
             self[question.question_name + "_comment"] = comment
+        if reasoning_summary:
+            self[question.question_name + "_reasoning_summary"] = reasoning_summary
 
     def replace_missing_answers_with_none(self, survey: "Survey") -> None:
         """Replace missing answers with None. Answers can be missing if the agent skips a question."""

edsl/base/enums.py

@@ -57,6 +57,7 @@ class InferenceServiceType(EnumWithChecks):
     DEEP_INFRA = "deep_infra"
     REPLICATE = "replicate"
     OPENAI = "openai"
+    OPENAI_V2 = "openai_v2"
     GOOGLE = "google"
     TEST = "test"
     ANTHROPIC = "anthropic"
@@ -77,6 +78,7 @@ InferenceServiceLiteral = Literal[
     "deep_infra",
     "replicate",
     "openai",
+    "openai_v2",
     "google",
     "test",
     "anthropic",
@@ -93,6 +95,7 @@ InferenceServiceLiteral = Literal[
 available_models_urls = {
     "anthropic": "https://docs.anthropic.com/en/docs/about-claude/models",
     "openai": "https://platform.openai.com/docs/models/gp",
+    "openai_v2": "https://platform.openai.com/docs/models/gp",
     "groq": "https://console.groq.com/docs/models",
     "google": "https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models",
 }
@@ -102,6 +105,7 @@ service_to_api_keyname = {
     InferenceServiceType.DEEP_INFRA.value: "DEEP_INFRA_API_KEY",
     InferenceServiceType.REPLICATE.value: "TBD",
     InferenceServiceType.OPENAI.value: "OPENAI_API_KEY",
+    InferenceServiceType.OPENAI_V2.value: "OPENAI_API_KEY",
     InferenceServiceType.GOOGLE.value: "GOOGLE_API_KEY",
     InferenceServiceType.TEST.value: "TBD",
     InferenceServiceType.ANTHROPIC.value: "ANTHROPIC_API_KEY",
@@ -135,7 +139,7 @@ class TokenPricing:
             and self.prompt_token_price == other.prompt_token_price
             and self.completion_token_price == other.completion_token_price
         )
-    
+
     @classmethod
     def example(cls) -> "TokenPricing":
         """Return an example TokenPricing object."""
@@ -145,6 +149,7 @@ class TokenPricing:
             completion_token_price_per_k=0.03,
         )
 
+
 pricing = {
     "dbrx-instruct": TokenPricing(
         model_name="dbrx-instruct",
@@ -212,4 +217,4 @@ def get_token_pricing(model_name):
             model_name=model_name,
             prompt_token_price_per_k=0.0,
             completion_token_price_per_k=0.0,
-        )
+        )