edsl 0.1.27.dev2__py3-none-any.whl → 0.1.28__py3-none-any.whl

edsl/results/Results.py

@@ -5,9 +5,10 @@ It is not typically instantiated directly, but is returned by the run method of
 
 from __future__ import annotations
 import json
+import hashlib
 import random
 from collections import UserList, defaultdict
-from typing import Optional, Callable, Any, Type, Union
+from typing import Optional, Callable, Any, Type, Union, List
 
 from pygments import highlight
 from pygments.lexers import JsonLexer
@@ -29,7 +30,8 @@ from edsl.results.Dataset import Dataset
 from edsl.results.Result import Result
 from edsl.results.ResultsExportMixin import ResultsExportMixin
 from edsl.scenarios import Scenario
-from edsl.scenarios.ScenarioList import ScenarioList
+
+# from edsl.scenarios.ScenarioList import ScenarioList
 from edsl.surveys import Survey
 from edsl.data.Cache import Cache
 from edsl.utilities import (
@@ -37,7 +39,7 @@ from edsl.utilities import (
     shorten_string,
 )
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
-
+from edsl.utilities.utilities import dict_hash
 from edsl.results.ResultsToolsMixin import ResultsToolsMixin
 
 from edsl.results.ResultsDBMixin import ResultsDBMixin
@@ -163,7 +165,13 @@ class Results(UserList, Mixins, Base):
         )
 
     def __repr__(self) -> str:
-        return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        # return f"Results(data = {self.data}, survey = {repr(self.survey)}, created_columns = {self.created_columns})"
+        return f"""Results object 
+                Size: {len(self.data)}. 
+                Survey questions: {[q.question_name for q in self.survey.questions]}. 
+                Created columns: {self.created_columns}
+                Hash: {hash(self)}
+            """
 
     def _repr_html_(self) -> str:
         json_str = json.dumps(self.to_dict()["data"], indent=4)
@@ -174,6 +182,35 @@ class Results(UserList, Mixins, Base):
         )
         return HTML(formatted_json).data
 
+    def _to_dict(self, sort=False):
+        if sort:
+            data = sorted([result for result in self.data], key=lambda x: hash(x))
+        else:
+            data = [result for result in self.data]
+        return {
+            "data": [result.to_dict() for result in data],
+            "survey": self.survey.to_dict(),
+            "created_columns": self.created_columns,
+            "cache": Cache() if not hasattr(self, "cache") else self.cache.to_dict(),
+        }
+
+    def compare(self, other_results):
+        """
+        Compare two Results objects and return the differences.
+        """
+        hashes_0 = [hash(result) for result in self]
+        hashes_1 = [hash(result) for result in other_results]
+
+        in_self_but_not_other = set(hashes_0).difference(set(hashes_1))
+        in_other_but_not_self = set(hashes_1).difference(set(hashes_0))
+
+        indicies_self = [hashes_0.index(h) for h in in_self_but_not_other]
+        indices_other = [hashes_1.index(h) for h in in_other_but_not_self]
+        return {
+            "a_not_b": [self[i] for i in indicies_self],
+            "b_not_a": [other_results[i] for i in indices_other],
+        }
+
     @add_edsl_version
     def to_dict(self) -> dict[str, Any]:
         """Convert the Results object to a dictionary.
@@ -186,12 +223,14 @@ class Results(UserList, Mixins, Base):
         >>> r.to_dict().keys()
         dict_keys(['data', 'survey', 'created_columns', 'cache', 'edsl_version', 'edsl_class_name'])
         """
-        return {
-            "data": [result.to_dict() for result in self.data],
-            "survey": self.survey.to_dict(),
-            "created_columns": self.created_columns,
-            "cache": Cache() if not hasattr(self, "cache") else self.cache.to_dict(),
-        }
+        return self._to_dict()
+
+    def __hash__(self) -> int:
+        return dict_hash(self._to_dict(sort=True))
+
+    @property
+    def hashes(self) -> set:
+        return set(hash(result) for result in self.data)
 
     @classmethod
     @remove_edsl_version
@@ -318,7 +357,7 @@ class Results(UserList, Mixins, Base):
         return [r.model for r in self.data]
 
     @property
-    def scenarios(self) -> ScenarioList:
+    def scenarios(self) -> "ScenarioList":
         """Return a list of all of the scenarios in the Results.
 
         Example:
@@ -327,6 +366,8 @@ class Results(UserList, Mixins, Base):
         >>> r.scenarios
         ScenarioList([Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'}), Scenario({'period': 'morning'}), Scenario({'period': 'afternoon'})])
         """
+        from edsl import ScenarioList
+
         return ScenarioList([r.scenario for r in self.data])
 
     @property
@@ -487,6 +528,39 @@ class Results(UserList, Mixins, Base):
             created_columns=self.created_columns + [new_var_name],
         )
 
+    def add_column(self, column_name: str, values: list) -> Results:
+        """Adds columns to Results
+
+        >>> r = Results.example()
+        >>> r.add_column('a', [1,2,3, 4]).select('a')
+        Dataset([{'answer.a': [1, 2, 3, 4]}])
+        """
+
+        assert len(values) == len(
+            self.data
+        ), "The number of values must match the number of results."
+        new_results = self.data.copy()
+        for i, result in enumerate(new_results):
+            result["answer"][column_name] = values[i]
+        return Results(
+            survey=self.survey,
+            data=new_results,
+            created_columns=self.created_columns + [column_name],
+        )
+
+    def add_columns_from_dict(self, columns: List[dict]) -> Results:
+        """Adds columns to Results from a list of dictionaries.
+
+        >>> r = Results.example()
+        >>> r.add_columns_from_dict([{'a': 1, 'b': 2}, {'a': 3, 'b': 4}, {'a':3, 'b':2}, {'a':3, 'b':2}]).select('a', 'b')
+        Dataset([{'answer.a': [1, 3, 3, 3]}, {'answer.b': [2, 4, 2, 2]}])
+        """
+        keys = list(columns[0].keys())
+        for key in keys:
+            values = [d[key] for d in columns]
+            self = self.add_column(key, values)
+        return self
+
     def mutate(
         self, new_var_string: str, functions_dict: Optional[dict] = None
     ) -> Results:

edsl/results/ResultsDBMixin.py

@@ -136,12 +136,9 @@ class ResultsDBMixin:
 
         >>> from edsl.results import Results
         >>> r = Results.example()
-        >>> r.sql("select data_type, key, value from self where data_type = 'answer' limit 3", shape="long")
-          data_type                    key                                         value
-        0    answer            how_feeling                                            OK
-        1    answer    how_feeling_comment  This is a real survey response from a human.
-        2    answer  how_feeling_yesterday                                         Great
-
+        >>> d = r.sql("select data_type, key, value from self where data_type = 'answer' limit 3", shape="long")
+        >>> list(d['value'])
+        ['OK', 'This is a real survey response from a human.', 'Great']
 
         We can also return the data in wide format.
         Note the use of single quotes to escape the column names, as required by sql.

edsl/results/ResultsExportMixin.py

@@ -6,7 +6,7 @@ import io
 import random
 from functools import wraps
 
-from typing import Literal, Optional
+from typing import Literal, Optional, Union
 
 from edsl.utilities.utilities import is_notebook
 
@@ -33,6 +33,8 @@ class ResultsExportMixin:
                 return func(self.select(), *args, **kwargs)
             elif self.__class__.__name__ == "Dataset":
                 return func(self, *args, **kwargs)
+            elif self.__class__.__name__ == "ScenarioList":
+                return func(self.to_dataset(), *args, **kwargs)
             else:
                 raise Exception(
                     f"Class {self.__class__.__name__} not recognized as a Results or Dataset object."
@@ -46,6 +48,7 @@ class ResultsExportMixin:
     ) -> list:
         """Return the set of keys that are present in the dataset.
 
+        >>> from edsl.results.Dataset import Dataset
         >>> d = Dataset([{'a.b':[1,2,3,4]}])
         >>> d.relevant_columns()
         ['a.b']
@@ -155,6 +158,9 @@ class ResultsExportMixin:
         max_rows=None,
         tee=False,
         iframe=False,
+        iframe_height: int = 200,
+        iframe_width: int = 600,
+        web=False,
     ) -> None:
         """Print the results in a pretty format.
 
@@ -239,21 +245,26 @@ class ResultsExportMixin:
         elif format == "html":
             notebook = is_notebook()
             html_source = print_list_of_dicts_as_html_table(
-                new_data, filename=None, interactive=interactive, notebook=notebook
+                new_data, interactive=interactive
             )
             if iframe:
                 import html
 
-                height = 200
-                width = 600
+                height = iframe_height
+                width = iframe_width
                 escaped_output = html.escape(html_source)
                 # escaped_output = html_source
                 iframe = f""""
                 <iframe srcdoc="{ escaped_output }" style="width: {width}px; height: {height}px;"></iframe>
                 """
                 display(HTML(iframe))
-            else:
+            elif notebook:
                 display(HTML(html_source))
+            else:
+                from edsl.utilities.interface import view_html
+
+                view_html(html_source)
+
         elif format == "markdown":
             print_list_of_dicts_as_markdown_table(new_data, filename=filename)
         elif format == "latex":
@@ -474,16 +485,19 @@ class ResultsExportMixin:
             return filename
 
     @_convert_decorator
-    def tally(self, *fields: Optional[str], top_n=None, format=None):
+    def tally(
+        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.
 
         :param fields: The field(s) to tally, multiple fields for cross-tabulation.
 
+        >>> from edsl.results import Results
         >>> r = Results.example()
         >>> r.select('how_feeling').tally('answer.how_feeling')
         {'OK': 2, 'Great': 1, 'Terrible': 1}
-        >>> r.tally('field1', 'field2')
-        {('X', 'A'): 1, ('X', 'B'): 1, ('Y', 'A'): 1}
+        >>> r.select('how_feeling', 'period').tally('how_feeling', 'period')
+        {('OK', 'morning'): 1, ('Great', 'afternoon'): 1, ('Terrible', 'morning'): 1, ('OK', 'afternoon'): 1}
         """
         from collections import Counter
 
@@ -506,19 +520,36 @@ class ResultsExportMixin:
         else:
             values = list(zip(*(self._key_to_value(field) for field in fields)))
 
+        for value in values:
+            if isinstance(value, list):
+                value = tuple(value)
+
         tally = dict(Counter(values))
         sorted_tally = dict(sorted(tally.items(), key=lambda item: -item[1]))
         if top_n is not None:
             sorted_tally = dict(list(sorted_tally.items())[:top_n])
 
-        if format is not None:
-            if format == "rich":
-                from edsl.utilities.interface import print_tally_with_rich
-
-                print_tally_with_rich(sorted_tally)
-                return None
-
-        return sorted_tally
+        import warnings
+        import textwrap
+        from edsl.results.Dataset import Dataset
+
+        if output == "dict":
+            warnings.warn(
+                textwrap.dedent(
+                    """\
+                        The default output from tally will change to Dataset in the future.
+                        Use output='Dataset' to get the Dataset object for now.
+                        """
+                )
+            )
+            return sorted_tally
+        elif output == "Dataset":
+            return Dataset(
+                [
+                    {"value": list(sorted_tally.keys())},
+                    {"count": list(sorted_tally.values())},
+                ]
+            )
 
 
 if __name__ == "__main__":

edsl/results/ResultsToolsMixin.py

@@ -1,4 +1,4 @@
-from edsl import ScenarioList
+# from edsl import ScenarioList
 from edsl.questions import QuestionList, QuestionCheckBox
 
 
@@ -14,6 +14,7 @@ class ResultsToolsMixin:
         print_exceptions=False,
     ) -> list:
         values = self.shuffle(seed=seed).select(field).to_list()[:max_values]
+        from edsl import ScenarioList
 
         q = QuestionList(
             question_text=f"""
@@ -24,10 +25,7 @@ class ResultsToolsMixin:
         """,
             question_name="themes",
         )
-        s = ScenarioList.from_list(field, values)
-        results = q.by(s).run(
-            print_exceptions=print_exceptions, progress_bar=progress_bar
-        )
+        results = q.run(print_exceptions=print_exceptions, progress_bar=progress_bar)
         return results.select("themes").first()
 
     def answers_to_themes(
@@ -38,6 +36,8 @@ class ResultsToolsMixin:
         progress_bar=False,
         print_exceptions=False,
     ) -> dict:
+        from edsl import ScenarioList
+
         values = self.select(field).to_list()
         scenarios = ScenarioList.from_list("field", values).add_value(
             "context", context

edsl/scenarios/Scenario.py

@@ -5,10 +5,15 @@ from collections import UserDict
 from typing import Union, List, Optional, Generator
 import base64
 import hashlib
+import json
+
+import fitz  # PyMuPDF
+import os
+import subprocess
+
 from rich.table import Table
 
 from edsl.Base import Base
-
 from edsl.scenarios.ScenarioImageMixin import ScenarioImageMixin
 from edsl.scenarios.ScenarioHtmlMixin import ScenarioHtmlMixin
 
@@ -19,7 +24,9 @@ from edsl.utilities.decorators import (
 
 
 class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
-    """A Scenario is a dictionary of keys/values for parameterizing questions."""
+    """A Scenario is a dictionary of keys/values.
+
+    They can be used parameterize edsl questions."""
 
     def __init__(self, data: Union[dict, None] = None, name: str = None):
         """Initialize a new Scenario.
@@ -32,7 +39,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         self.name = name
 
     def replicate(self, n: int) -> "ScenarioList":
-        """Replicate a scenario n times.
+        """Replicate a scenario n times to return a ScenarioList.
 
         :param n: The number of times to replicate the scenario.
 
@@ -58,7 +65,7 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         self._has_image = value
 
     def __add__(self, other_scenario: "Scenario") -> "Scenario":
-        """Combine two scenarios.
+        """Combine two scenarios by taking the union of their keys
 
         If the other scenario is None, then just return self.
 
@@ -102,6 +109,17 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
                 new_scenario[key] = value
         return new_scenario
 
+    def _to_dict(self) -> dict:
+        """Convert a scenario to a dictionary.
+
+        Example:
+
+        >>> s = Scenario({"food": "wood chips"})
+        >>> s.to_dict()
+        {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
+        """
+        return self.data.copy()
+
     @add_edsl_version
     def to_dict(self) -> dict:
         """Convert a scenario to a dictionary.
@@ -112,7 +130,21 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
         >>> s.to_dict()
         {'food': 'wood chips', 'edsl_version': '...', 'edsl_class_name': 'Scenario'}
         """
-        return self.data.copy()
+        return self._to_dict()
+
+    def __hash__(self) -> int:
+        """
+        Return a hash of the scenario.
+
+        Example:
+
+        >>> s = Scenario({"food": "wood chips"})
+        >>> hash(s)
+        1153210385458344214
+        """
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict())
 
     def print(self):
         from rich import print_json
@@ -183,6 +215,28 @@ class Scenario(Base, UserDict, ScenarioImageMixin, ScenarioHtmlMixin):
             s.has_image = True
             return s
 
+    @classmethod
+    def from_pdf(cls, pdf_path):
+        # Ensure the file exists
+        if not os.path.exists(pdf_path):
+            raise FileNotFoundError(f"The file {pdf_path} does not exist.")
+
+        # Open the PDF file
+        document = fitz.open(pdf_path)
+
+        # Get the filename from the path
+        filename = os.path.basename(pdf_path)
+
+        # Iterate through each page and extract text
+        text = ""
+        for page_num in range(len(document)):
+            page = document.load_page(page_num)
+            text = text + page.get_text()
+
+        # Create a dictionary for the combined text
+        page_info = {"filename": filename, "text": text}
+        return Scenario(page_info)
+
     @classmethod
     def from_docx(cls, docx_path: str) -> "Scenario":
         """Creates a scenario from the text of a docx file.

edsl/scenarios/ScenarioList.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 import csv
-from collections import UserList
+import random
+from collections import UserList, Counter
 from collections.abc import Iterable
-from collections import Counter
 
 from typing import Any, Optional, Union, List
 
@@ -16,14 +16,14 @@ from edsl.Base import Base
 from edsl.utilities.decorators import add_edsl_version, remove_edsl_version
 from edsl.scenarios.ScenarioListPdfMixin import ScenarioListPdfMixin
 
-import pandas as pd
-
 from edsl.utilities.interface import print_scenario_list
 
 from edsl.utilities import is_valid_variable_name
 
+from edsl.results.ResultsExportMixin import ResultsExportMixin
+
 
-class ScenarioList(Base, UserList, ScenarioListPdfMixin):
+class ScenarioList(Base, UserList, ScenarioListPdfMixin, ResultsExportMixin):
     """Class for creating a list of scenarios to be used in a survey."""
 
     def __init__(self, data: Optional[list] = None):
@@ -33,11 +33,37 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         else:
             super().__init__([])
 
+    @property
+    def parameters(self) -> set:
+        """Return the set of parameters in the ScenarioList
+
+        Example:
+
+        >>> s = ScenarioList([Scenario({'a': 1}), Scenario({'b': 2})])
+        >>> s.parameters == {'a', 'b'}
+        True
+        """
+        if len(self) == 0:
+            return set()
+
+        return set.union(*[set(s.keys()) for s in self])
+
+    def __hash__(self) -> int:
+        """Return the hash of the ScenarioList.
+
+        >>> s = ScenarioList.example()
+        >>> hash(s)
+        1262252885757976162
+        """
+        from edsl.utilities.utilities import dict_hash
+
+        return dict_hash(self._to_dict(sort=True))
+
     def __repr__(self):
         return f"ScenarioList({self.data})"
 
     def __mul__(self, other: ScenarioList) -> ScenarioList:
-        """Return a ScenarioList with the scenarios repeated n times."""
+        """Takes the cross product of two ScenarioLists."""
         from itertools import product
 
         new_sl = []
@@ -45,6 +71,24 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
             new_sl.append(s1 + s2)
         return ScenarioList(new_sl)
 
+    def times(self, other: ScenarioList) -> ScenarioList:
+        """Takes the cross product of two ScenarioLists.
+
+        Example:
+
+        >>> s1 = ScenarioList([Scenario({'a': 1}), Scenario({'a': 2})])
+        >>> s2 = ScenarioList([Scenario({'b': 1}), Scenario({'b': 2})])
+        >>> s1.times(s2)
+        ScenarioList([Scenario({'a': 1, 'b': 1}), Scenario({'a': 1, 'b': 2}), Scenario({'a': 2, 'b': 1}), Scenario({'a': 2, 'b': 2})])
+        """
+        return self.__mul__(other)
+
+    def shuffle(self, seed: Optional[str] = "edsl") -> ScenarioList:
+        """Shuffle the ScenarioList."""
+        random.seed(seed)
+        random.shuffle(self.data)
+        return self
+
     def _repr_html_(self) -> str:
         from edsl.utilities.utilities import data_to_html
 
@@ -69,7 +113,6 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
     def sample(self, n: int, seed="edsl") -> ScenarioList:
         """Return a random sample from the ScenarioList"""
-        import random
 
         if seed != "edsl":
             random.seed(seed)
@@ -217,6 +260,13 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         """
         return cls([Scenario({name: value}) for value in values])
 
+    def to_dataset(self) -> "Dataset":
+        from edsl.results.Dataset import Dataset
+
+        keys = self[0].keys()
+        data = {key: [scenario[key] for scenario in self.data] for key in keys}
+        return Dataset([data])
+
     def add_list(self, name, values) -> ScenarioList:
         """Add a list of values to a ScenarioList.
 
@@ -227,7 +277,10 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
         """
         for i, value in enumerate(values):
-            self[i][name] = value
+            if i < len(self):
+                self[i][name] = value
+            else:
+                self.append(Scenario({name: value}))
         return self
 
     def add_value(self, name, value):
@@ -244,6 +297,16 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         return self
 
     def rename(self, replacement_dict: dict) -> ScenarioList:
+        """Rename the fields in the scenarios.
+
+        Example:
+
+        >>> s = ScenarioList([Scenario({'name': 'Alice', 'age': 30}), Scenario({'name': 'Bob', 'age': 25})])
+        >>> s.rename({'name': 'first_name', 'age': 'years'})
+        ScenarioList([Scenario({'first_name': 'Alice', 'years': 30}), Scenario({'first_name': 'Bob', 'years': 25})])
+
+        """
+
         new_list = ScenarioList([])
         for obj in self:
             new_obj = obj.rename(replacement_dict)
@@ -301,6 +364,13 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
                 observations.append(Scenario(dict(zip(header, row))))
         return cls(observations)
 
+    def _to_dict(self, sort=False) -> dict:
+        if sort:
+            data = sorted(self, key=lambda x: hash(x))
+        else:
+            data = self
+        return {"scenarios": [s._to_dict() for s in data]}
+
     @add_edsl_version
     def to_dict(self) -> dict[str, Any]:
         """Return the `ScenarioList` as a dictionary.
@@ -315,7 +385,14 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
 
     @classmethod
     def gen(cls, scenario_dicts_list: List[dict]) -> ScenarioList:
-        """Create a `ScenarioList` from a list of dictionaries."""
+        """Create a `ScenarioList` from a list of dictionaries.
+
+        Example:
+
+        >>> ScenarioList.gen([{'name': 'Alice'}, {'name': 'Bob'}])
+        ScenarioList([Scenario({'name': 'Alice'}), Scenario({'name': 'Bob'})])
+
+        """
         return cls([Scenario(s) for s in scenario_dicts_list])
 
     @classmethod
@@ -361,39 +438,19 @@ class ScenarioList(Base, UserList, ScenarioListPdfMixin):
         filename: str = None,
     ):
         print_scenario_list(self)
-        # if format is None:
-        #     if is_notebook():
-        #         format = "html"
-        #     else:
-        #         format = "rich"
-
-        # if pretty_labels is None:
-        #     pretty_labels = {}
-
-        # if format not in ["rich", "html", "markdown"]:
-        #     raise ValueError("format must be one of 'rich', 'html', or 'markdown'.")
-
-        # if max_rows is not None:
-        #     new_data = self[:max_rows]
-        # else:
-        #     new_data = self
-
-        # if format == "rich":
-        #     print_list_of_dicts_with_rich(
-        #         new_data, filename=filename, split_at_dot=False
-        #     )
-        # elif format == "html":
-        #     notebook = is_notebook()
-        #     html = print_list_of_dicts_as_html_table(
-        #         new_data, filename=None, interactive=False, notebook=notebook
-        #     )
-        #     # print(html)
-        #     display(HTML(html))
-        # elif format == "markdown":
-        #     print_list_of_dicts_as_markdown_table(new_data, filename=filename)
 
     def __getitem__(self, key: Union[int, slice]) -> Any:
-        """Return the item at the given index."""
+        """Return the item at the given index.
+
+        Example:
+        >>> s = ScenarioList([Scenario({'age': 22, 'hair': 'brown', 'height': 5.5}), Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})])
+        >>> s[0]
+        Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})
+
+        >>> s[:1]
+        ScenarioList([Scenario({'age': 22, 'hair': 'brown', 'height': 5.5})])
+
+        """
         if isinstance(key, slice):
             return ScenarioList(super().__getitem__(key))
         elif isinstance(key, int):