edsl 0.1.30__py3-none-any.whl → 0.1.30.dev1__py3-none-any.whl

edsl/jobs/interviews/InterviewTaskBuildingMixin.py

@@ -25,7 +25,7 @@ TIMEOUT = float(CONFIG.get("EDSL_API_TIMEOUT"))
 class InterviewTaskBuildingMixin:
     def _build_invigilators(
         self, debug: bool
-    ) -> Generator["InvigilatorBase", None, None]:
+    ) -> Generator[InvigilatorBase, None, None]:
         """Create an invigilator for each question.
 
         :param debug: whether to use debug mode, in which case `InvigilatorDebug` is used.
@@ -35,7 +35,7 @@ class InterviewTaskBuildingMixin:
         for question in self.survey.questions:
             yield self._get_invigilator(question=question, debug=debug)
 
-    def _get_invigilator(self, question: "QuestionBase", debug: bool) -> "Invigilator":
+    def _get_invigilator(self, question: QuestionBase, debug: bool) -> "Invigilator":
         """Return an invigilator for the given question.
 
         :param question: the question to be answered
@@ -84,7 +84,7 @@ class InterviewTaskBuildingMixin:
         return tuple(tasks)  # , invigilators
 
     def _get_tasks_that_must_be_completed_before(
-        self, *, tasks: list[asyncio.Task], question: "QuestionBase"
+        self, *, tasks: list[asyncio.Task], question: QuestionBase
     ) -> Generator[asyncio.Task, None, None]:
         """Return the tasks that must be completed before the given question can be answered.
 
@@ -100,7 +100,7 @@ class InterviewTaskBuildingMixin:
     def _create_question_task(
         self,
         *,
-        question: "QuestionBase",
+        question: QuestionBase,
         tasks_that_must_be_completed_before: list[asyncio.Task],
         model_buckets: ModelBuckets,
         debug: bool,
@@ -175,14 +175,24 @@ class InterviewTaskBuildingMixin:
 
             self._add_answer(response=response, question=question)
 
+            # With the answer to the question, we can now cancel any skipped questions
             self._cancel_skipped_questions(question)
             return AgentResponseDict(**response)
         except Exception as e:
             raise e
-
-    def _add_answer(
-        self, response: "AgentResponseDict", question: "QuestionBase"
-    ) -> None:
+            # import traceback
+            # print("Exception caught:")
+            # traceback.print_exc()
+
+            # # Extract and print the traceback info
+            # tb = e.__traceback__
+            # while tb is not None:
+            #     print(f"File {tb.tb_frame.f_code.co_filename}, line {tb.tb_lineno}, in {tb.tb_frame.f_code.co_name}")
+            #     tb = tb.tb_next
+            #     breakpoint()
+            #     raise e
+
+    def _add_answer(self, response: AgentResponseDict, question: QuestionBase) -> None:
         """Add the answer to the answers dictionary.
 
         :param response: the response to the question.
@@ -190,7 +200,7 @@ class InterviewTaskBuildingMixin:
         """
         self.answers.add_answer(response=response, question=question)
 
-    def _skip_this_question(self, current_question: "QuestionBase") -> bool:
+    def _skip_this_question(self, current_question: QuestionBase) -> bool:
         """Determine if the current question should be skipped.
 
         :param current_question: the question to be answered.

edsl/jobs/runners/JobsRunnerAsyncio.py

@@ -88,8 +88,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
                     self.total_interviews.append(interview)
 
     async def run_async(self, cache=None) -> Results:
-        from edsl.results.Results import Results
-
         if cache is None:
             self.cache = Cache()
         else:
@@ -100,8 +98,6 @@ class JobsRunnerAsyncio(JobsRunnerStatusMixin):
         return Results(survey=self.jobs.survey, data=data)
 
     def simple_run(self):
-        from edsl.results.Results import Results
-
         data = asyncio.run(self.run_async())
         return Results(survey=self.jobs.survey, data=data)
 

edsl/jobs/tasks/QuestionTaskCreator.py

@@ -144,16 +144,12 @@ class QuestionTaskCreator(UserList):
             self.task_status = TaskStatus.FAILED
             raise e
 
-        if results.get("cache_used", False):
-            self.tokens_bucket.add_tokens(requested_tokens)
-            self.requests_bucket.add_tokens(1)
-            self.from_cache = True
-            # Turbo mode means that we don't wait for tokens or requests.
-            self.tokens_bucket.turbo_mode_on()
-            self.requests_bucket.turbo_mode_on()
-        else:
-            self.tokens_bucket.turbo_mode_off()
-            self.requests_bucket.turbo_mode_off()
+        if "cached_response" in results:
+            if results["cached_response"]:
+                # Gives back the tokens b/c the API was not called.
+                self.tokens_bucket.add_tokens(requested_tokens)
+                self.requests_bucket.add_tokens(1)
+                self.from_cache = True
 
         _ = results.pop("cached_response", None)
 

edsl/language_models/LanguageModel.py

@@ -323,10 +323,12 @@ class LanguageModel(
             image_hash = hashlib.md5(encoded_image.encode()).hexdigest()
             cache_call_params["user_prompt"] = f"{user_prompt} {image_hash}"
 
-        cached_response, cache_key = cache.fetch(**cache_call_params)
+        cached_response = cache.fetch(**cache_call_params)
+
         if cached_response:
             response = json.loads(cached_response)
             cache_used = True
+            cache_key = None
         else:
             remote_call = hasattr(self, "remote") and self.remote
             f = (
@@ -338,7 +340,7 @@ class LanguageModel(
             if encoded_image:
                 params["encoded_image"] = encoded_image
             response = await f(**params)
-            new_cache_key = cache.store(
+            cache_key = cache.store(
                 user_prompt=user_prompt,
                 model=str(self.model),
                 parameters=self.parameters,
@@ -346,7 +348,6 @@ class LanguageModel(
                 response=response,
                 iteration=iteration,
             )
-            assert new_cache_key == cache_key
             cache_used = False
 
         return response, cache_used, cache_key
@@ -411,7 +412,7 @@ class LanguageModel(
 
         dict_response.update(
             {
-                "cache_used": cache_used,
+                "cached_used": cache_used,
                 "cache_key": cache_key,
                 "usage": raw_response.get("usage", {}),
                 "raw_model_response": raw_response,
@@ -494,12 +495,7 @@ class LanguageModel(
         return table
 
     @classmethod
-    def example(
-        cls,
-        test_model: bool = False,
-        canned_response: str = "Hello world",
-        throw_exception: bool = False,
-    ):
+    def example(cls, test_model: bool = False, canned_response: str = "Hello world"):
         """Return a default instance of the class.
 
         >>> from edsl.language_models import LanguageModel
@@ -524,8 +520,6 @@ class LanguageModel(
             ) -> dict[str, Any]:
                 await asyncio.sleep(0.1)
                 # return {"message": """{"answer": "Hello, world"}"""}
-                if throw_exception:
-                    raise Exception("This is a test error")
                 return {"message": f'{{"answer": "{canned_response}"}}'}
 
             def parse_response(self, raw_response: dict[str, Any]) -> str:

edsl/notebooks/Notebook.py

@@ -1,11 +1,14 @@
 """A Notebook is a utility class that allows you to easily share/pull ipynbs from Coop."""
 
-from __future__ import annotations
 import json
 from typing import Dict, List, Optional
-from uuid import uuid4
+
+
 from edsl.Base import Base
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
+from edsl.utilities.decorators import (
+    add_edsl_version,
+    remove_edsl_version,
+)
 
 
 class Notebook(Base):
@@ -189,13 +192,10 @@ class Notebook(Base):
         return table
 
     @classmethod
-    def example(cls, randomize: bool = False) -> Notebook:
+    def example(cls) -> "Notebook":
         """
-        Returns an example Notebook instance.
-
-        :param randomize: If True, adds a random string one of the cells' output.
+        Return an example Notebook.
         """
-        addition = "" if not randomize else str(uuid4())
         cells = [
             {
                 "cell_type": "markdown",
@@ -210,7 +210,7 @@ class Notebook(Base):
                     {
                         "name": "stdout",
                         "output_type": "stream",
-                        "text": f"Hello world!\n{addition}",
+                        "text": "Hello world!\n",
                     }
                 ],
                 "source": 'print("Hello world!")',

edsl/questions/QuestionFreeText.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import textwrap
 from typing import Any, Optional
-from uuid import uuid4
 from edsl.questions.QuestionBase import QuestionBase
 
 
@@ -66,10 +65,9 @@ class QuestionFreeText(QuestionBase):
         return question_html_content
 
     @classmethod
-    def example(cls, randomize: bool = False) -> QuestionFreeText:
+    def example(cls) -> QuestionFreeText:
         """Return an example instance of a free text question."""
-        addition = "" if not randomize else str(uuid4())
-        return cls(question_name="how_are_you", question_text=f"How are you?{addition}")
+        return cls(question_name="how_are_you", question_text="How are you?")
 
 
 def main():

edsl/questions/QuestionFunctional.py

@@ -4,34 +4,10 @@ import inspect
 from edsl.questions.QuestionBase import QuestionBase
 
 from edsl.utilities.restricted_python import create_restricted_function
-from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 
 
 class QuestionFunctional(QuestionBase):
-    """A special type of question that is *not* answered by an LLM.
-
-    >>> from edsl import Scenario, Agent
-
-    # Create an instance of QuestionFunctional with the new function
-    >>> question = QuestionFunctional.example()
-
-    # Activate and test the function
-    >>> question.activate()
-    >>> scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
-    >>> agent = Agent(traits={"multiplier": 10})
-    >>> results = question.by(scenario).by(agent).run()
-    >>> results.select("answer.*").to_list()[0] == 150
-    True
-
-    # Serialize the question to a dictionary
-
-    >>> from edsl.questions.QuestionBase import QuestionBase
-    >>> new_question = QuestionBase.from_dict(question.to_dict())
-    >>> results = new_question.by(scenario).by(agent).run()
-    >>> results.select("answer.*").to_list()[0] == 150
-    True
-
-    """
+    """A special type of question that is *not* answered by an LLM."""
 
     question_type = "functional"
     default_instructions = ""
@@ -97,7 +73,6 @@ class QuestionFunctional(QuestionBase):
         """Required by Question, but not used by QuestionFunctional."""
         raise NotImplementedError
 
-    @add_edsl_version
     def to_dict(self):
         return {
             "question_name": self.question_name,
@@ -138,11 +113,4 @@ def main():
     scenario = Scenario({"numbers": [1, 2, 3, 4, 5]})
     agent = Agent(traits={"multiplier": 10})
     results = question.by(scenario).by(agent).run()
-    assert results.select("answer.*").to_list()[0] == 150
-
-
-if __name__ == "__main__":
-    # main()
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    print(results)

edsl/questions/QuestionMultipleChoice.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import time
 from typing import Union
 import random
-from typing import Optional
+
 from jinja2 import Template
 
 from edsl.questions.QuestionBase import QuestionBase
@@ -10,11 +10,7 @@ from edsl.questions.descriptors import QuestionOptionsDescriptor
 
 
 class QuestionMultipleChoice(QuestionBase):
-    """This question prompts the agent to select one option from a list of options.
-
-    https://docs.expectedparrot.com/en/latest/questions.html#questionmultiplechoice-class
-
-    """
+    """This question prompts the agent to select one option from a list of options."""
 
     question_type = "multiple_choice"
     purpose = "When options are known and limited"
@@ -39,71 +35,27 @@ class QuestionMultipleChoice(QuestionBase):
         self.question_text = question_text
         self.question_options = question_options
 
-    # @property
-    # def question_options(self) -> Union[list[str], list[list], list[float], list[int]]:
-    #     """Return the question options."""
-    #     return self._question_options
-
     ################
     # Answer methods
     ################
     def _validate_answer(
         self, answer: dict[str, Union[str, int]]
     ) -> dict[str, Union[str, int]]:
-        """Validate the answer.
-
-        >>> q = QuestionMultipleChoice.example()
-        >>> q._validate_answer({"answer": 0, "comment": "I like custard"})
-        {'answer': 0, 'comment': 'I like custard'}
-
-        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["Good", "Great", "OK", "Bad"])
-        >>> q._validate_answer({"answer": -1, "comment": "I like custard"})
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionAnswerValidationError: Answer code must be a non-negative integer (got -1).
-        """
+        """Validate the answer."""
         self._validate_answer_template_basic(answer)
         self._validate_answer_multiple_choice(answer)
         return answer
 
     def _translate_answer_code_to_answer(
-        self, answer_code: int, scenario: Optional["Scenario"] = None
+        self, answer_code, scenario: "Scenario" = None
     ):
-        """Translate the answer code to the actual answer.
-
-        It is used to translate the answer code to the actual answer.
-        The question options might be templates, so they need to be rendered with the scenario.
-
-        >>> q = QuestionMultipleChoice.example()
-        >>> q._translate_answer_code_to_answer(0, {})
-        'Good'
-
-        >>> q = QuestionMultipleChoice(question_name="how_feeling", question_text="How are you?", question_options=["{{emotion[0]}}", "emotion[1]"])
-        >>> q._translate_answer_code_to_answer(0, {"emotion": ["Happy", "Sad"]})
-        'Happy'
-
-        """
+        """Translate the answer code to the actual answer."""
         from edsl.scenarios.Scenario import Scenario
 
         scenario = scenario or Scenario()
-
-        if isinstance(self.question_options, str):
-            # If dynamic options are provided like {{ options }}, render them with the scenario
-            from jinja2 import Environment, meta
-
-            env = Environment()
-            parsed_content = env.parse(self.question_options)
-            question_option_key = list(meta.find_undeclared_variables(parsed_content))[
-                0
-            ]
-            translated_options = scenario.get(question_option_key)
-        else:
-            translated_options = [
-                Template(str(option)).render(scenario)
-                for option in self.question_options
-            ]
-        # print("Translated options:", translated_options)
-        # breakpoint()
+        translated_options = [
+            Template(str(option)).render(scenario) for option in self.question_options
+        ]
         return translated_options[int(answer_code)]
 
     def _simulate_answer(
@@ -123,7 +75,6 @@ class QuestionMultipleChoice(QuestionBase):
 
     @property
     def question_html_content(self) -> str:
-        """Return the HTML version of the question."""
         if hasattr(self, "option_labels"):
             option_labels = self.option_labels
         else:

edsl/questions/descriptors.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 import re
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable
 from edsl.exceptions import (
     QuestionCreationValidationError,
     QuestionAnswerValidationError,
@@ -242,16 +242,6 @@ class QuestionNameDescriptor(BaseDescriptor):
 class QuestionOptionsDescriptor(BaseDescriptor):
     """Validate that `question_options` is a list, does not exceed the min/max lengths, and has unique items."""
 
-    @classmethod
-    def example(cls):
-        class TestQuestion:
-            question_options = QuestionOptionsDescriptor()
-
-            def __init__(self, question_options: List[str]):
-                self.question_options = question_options
-
-        return TestQuestion
-
     def __init__(
         self,
         num_choices: int = None,
@@ -264,31 +254,7 @@ class QuestionOptionsDescriptor(BaseDescriptor):
         self.q_budget = q_budget
 
     def validate(self, value: Any, instance) -> None:
-        """Validate the question options.
-
-        >>> q_class = QuestionOptionsDescriptor.example()
-        >>> _ = q_class(["a", "b", "c"])
-        >>> _ = q_class(["a", "b", "c", "d", "d"])
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionCreationValidationError: Question options must be unique (got ['a', 'b', 'c', 'd', 'd']).
-
-        We allow dynamic question options, which are strings of the form '{{ question_options }}'.
-
-        >>> _ = q_class("{{dynamic_options}}")
-        >>> _ = q_class("dynamic_options")
-        Traceback (most recent call last):
-        ...
-        edsl.exceptions.questions.QuestionCreationValidationError: Dynamic question options must be of the form: '{{ question_options }}'.
-        """
-        if isinstance(value, str):
-            # Check if the string is a dynamic question option
-            if "{{" in value and "}}" in value:
-                return None
-            else:
-                raise QuestionCreationValidationError(
-                    "Dynamic question options must be of the form: '{{ question_options }}'."
-                )
+        """Validate the question options."""
         if not isinstance(value, list):
             raise QuestionCreationValidationError(
                 f"Question options must be a list (got {value})."
@@ -373,9 +339,3 @@ class QuestionTextDescriptor(BaseDescriptor):
                 f"WARNING: Question text contains a single-braced substring: If you intended to parameterize the question with a Scenario this should be changed to a double-braced substring, e.g. {{variable}}.\nSee details on constructing Scenarios in the docs: https://docs.expectedparrot.com/en/latest/scenarios.html",
                 UserWarning,
             )
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod(optionflags=doctest.ELLIPSIS)

edsl/results/DatasetExportMixin.py

@@ -15,9 +15,6 @@ class DatasetExportMixin:
     ) -> list:
         """Return the set of keys that are present in the dataset.
 
-        :param data_type: The data type to filter by.
-        :param remove_prefix: Whether to remove the prefix from the column names.
-
         >>> from edsl.results.Dataset import Dataset
         >>> d = Dataset([{'a.b':[1,2,3,4]}])
         >>> d.relevant_columns()
@@ -30,6 +27,7 @@ class DatasetExportMixin:
         ['answer.how_feeling', 'answer.how_feeling_yesterday']
         """
         columns = [list(x.keys())[0] for x in self]
+        # columns = set([list(result.keys())[0] for result in self.data])
         if remove_prefix:
             columns = [column.split(".")[-1] for column in columns]
 
@@ -73,15 +71,7 @@ class DatasetExportMixin:
         return header, rows
 
     def print_long(self):
-        """Print the results in a long format.
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.select('how_feeling').print_long()
-        answer.how_feeling: OK
-        answer.how_feeling: Great
-        answer.how_feeling: Terrible
-        answer.how_feeling: OK
-        """
+        """Print the results in a long format."""
         for entry in self:
             key, list_of_values = list(entry.items())[0]
             for value in list_of_values:
@@ -127,42 +117,6 @@ class DatasetExportMixin:
         │ OK           │
         └──────────────┘
 
-        >>> r = Results.example()
-        >>> r2 = r.select("how_feeling").print(format = "rich", tee = True, max_rows = 2)
-        ┏━━━━━━━━━━━━━━┓
-        ┃ answer       ┃
-        ┃ .how_feeling ┃
-        ┡━━━━━━━━━━━━━━┩
-        │ OK           │
-        ├──────────────┤
-        │ Great        │
-        └──────────────┘
-        >>> r2
-        Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}])
-
-        >>> r.select('how_feeling').print(format = "rich", max_rows = 2)
-        ┏━━━━━━━━━━━━━━┓
-        ┃ answer       ┃
-        ┃ .how_feeling ┃
-        ┡━━━━━━━━━━━━━━┩
-        │ OK           │
-        ├──────────────┤
-        │ Great        │
-        └──────────────┘
-
-        >>> r.select('how_feeling').print(format = "rich", split_at_dot = False)
-        ┏━━━━━━━━━━━━━━━━━━━━┓
-        ┃ answer.how_feeling ┃
-        ┡━━━━━━━━━━━━━━━━━━━━┩
-        │ OK                 │
-        ├────────────────────┤
-        │ Great              │
-        ├────────────────────┤
-        │ Terrible           │
-        ├────────────────────┤
-        │ OK                 │
-        └────────────────────┘
-
         Example: using the pretty_labels parameter
 
         >>> r.select('how_feeling').print(format="rich", pretty_labels = {'answer.how_feeling': "How are you feeling"})
@@ -200,9 +154,6 @@ class DatasetExportMixin:
 
         if pretty_labels is None:
             pretty_labels = {}
-        else:
-            # if the user passes in pretty_labels, we don't want to split at the dot
-            split_at_dot = False
 
         if format not in ["rich", "html", "markdown", "latex"]:
             raise ValueError("format must be one of 'rich', 'html', or 'markdown'.")
@@ -217,6 +168,7 @@ class DatasetExportMixin:
                 for key in entry:
                     actual_rows = len(entry[key])
                     entry[key] = entry[key][:max_rows]
+            # print(f"Showing only the first {max_rows} rows of {actual_rows} rows.")
 
         if format == "rich":
             from edsl.utilities.interface import print_dataset_with_rich
@@ -293,10 +245,6 @@ class DatasetExportMixin:
         >>> r = Results.example()
         >>> r.select('how_feeling').to_csv()
         'answer.how_feeling\\r\\nOK\\r\\nGreat\\r\\nTerrible\\r\\nOK\\r\\n'
-
-        >>> r.select('how_feeling').to_csv(pretty_labels = {'answer.how_feeling': "How are you feeling"})
-        'How are you feeling\\r\\nOK\\r\\nGreat\\r\\nTerrible\\r\\nOK\\r\\n'
-
         """
         if pretty_labels is None:
             pretty_labels = {}
@@ -361,15 +309,6 @@ class DatasetExportMixin:
         return ScenarioList([Scenario(d) for d in list_of_dicts])
 
     def to_agent_list(self, remove_prefix: bool = True):
-        """Convert the results to a list of dictionaries, one per agent.
-
-        :param remove_prefix: Whether to remove the prefix from the column names.
-
-        >>> from edsl.results import Results
-        >>> r = Results.example()
-        >>> r.select('how_feeling').to_agent_list()
-        AgentList([Agent(traits = {'how_feeling': 'OK'}), Agent(traits = {'how_feeling': 'Great'}), Agent(traits = {'how_feeling': 'Terrible'}), Agent(traits = {'how_feeling': 'OK'})])
-        """
         from edsl import AgentList, Agent
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
@@ -405,9 +344,6 @@ class DatasetExportMixin:
     def to_list(self, flatten=False, remove_none=False) -> list[list]:
         """Convert the results to a list of lists.
 
-        :param flatten: Whether to flatten the list of lists.
-        :param remove_none: Whether to remove None values from the list.
-
         >>> from edsl.results import Results
         >>> Results.example().select('how_feeling', 'how_feeling_yesterday')
         Dataset([{'answer.how_feeling': ['OK', 'Great', 'Terrible', 'OK']}, {'answer.how_feeling_yesterday': ['Great', 'Good', 'OK', 'Terrible']}])
@@ -418,18 +354,6 @@ class DatasetExportMixin:
         >>> r = Results.example()
         >>> r.select('how_feeling').to_list()
         ['OK', 'Great', 'Terrible', 'OK']
-
-        >>> from edsl.results.Dataset import Dataset
-        >>> Dataset([{'a.b': [[1, 9], 2, 3, 4]}]).select('a.b').to_list(flatten = True)
-        [1, 9, 2, 3, 4]
-
-        >>> from edsl.results.Dataset import Dataset
-        >>> Dataset([{'a.b': [[1, 9], 2, 3, 4]}, {'c': [6, 2, 3, 4]}]).select('a.b', 'c').to_list(flatten = True)
-        Traceback (most recent call last):
-        ...
-        ValueError: Cannot flatten a list of lists when there are multiple columns selected.
-
-
         """
         if len(self.relevant_columns()) > 1 and flatten:
             raise ValueError(
@@ -461,10 +385,7 @@ class DatasetExportMixin:
         return list_to_return
 
     def html(
-        self,
-        filename: Optional[str] = None,
-        cta: str = "Open in browser",
-        return_link: bool = False,
+        self, filename: str = None, cta: str = "Open in browser", return_link=False
     ):
         import os
         import tempfile
@@ -498,7 +419,7 @@ class DatasetExportMixin:
             return filename
 
     def tally(
-        self, *fields: Optional[str], top_n: Optional[int] = None, output="dict"
+        self, *fields: Optional[str], top_n=None, output="dict"
     ) -> Union[dict, "Dataset"]:
         """Tally the values of a field or perform a cross-tab of multiple fields.