edsl 0.1.50__py3-none-any.whl → 0.1.51__py3-none-any.whl

edsl/dataset/dataset.py

@@ -1,5 +1,3 @@
-
-
 from __future__ import annotations
 import sys
 import json
@@ -10,7 +8,8 @@ from typing import Any, Union, Optional, TYPE_CHECKING, Callable
 from ..base import PersistenceMixin, HashingMixin
 
 from .dataset_tree import Tree
-from .exceptions import DatasetKeyError, DatasetValueError
+from .exceptions import DatasetKeyError, DatasetValueError, DatasetTypeError
+
 
 from .display.table_display import TableDisplay
 #from .smart_objects import FirstObject
@@ -121,19 +120,9 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
             new_data.append({key: values[:n]})
         return Dataset(new_data)
 
-    def expand(self, field):
-        return self.to_scenario_list().expand(field)
-
-    # def view(self):
-    #     from perspective.widget import PerspectiveWidget
+    # def expand(self, field):
+    #     return self.to_scenario_list().expand(field)
 
-    #     w = PerspectiveWidget(
-    #         self.to_pandas(),
-    #         plugin="Datagrid",
-    #         aggregates={"datetime": "any"},
-    #         sort=[["date", "desc"]],
-    #     )
-    #     return w
 
     def keys(self) -> list[str]:
         """Return the keys of the dataset.
@@ -287,12 +276,12 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         if len(potential_matches) == 1:
             return potential_matches[0][1]
         elif len(potential_matches) > 1:
-            from edsl.dataset.exceptions import DatasetKeyError
+            from .exceptions import DatasetKeyError
             raise DatasetKeyError(
                 f"Key '{key}' found in more than one location: {[m[0] for m in potential_matches]}"
             )
 
-        from edsl.dataset.exceptions import DatasetKeyError
+        from .exceptions import DatasetKeyError
         raise DatasetKeyError(f"Key '{key}' not found in any of the dictionaries.")
 
     def first(self) -> dict[str, Any]:
@@ -376,11 +365,12 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         >>> d = Dataset([{'person_name':["John"]}])
         >>> from edsl import QuestionFreeText 
         >>> q = QuestionFreeText(question_text = "How are you, {{ person_name ?}}?", question_name = "how_feeling")
-        >>> d.to(q)
-        Jobs(...)
+        >>> jobs = d.to(q)
+        >>> isinstance(jobs, object)
+        True
         """
-        from edsl.surveys import Survey
-        from edsl.questions import QuestionBase
+        from ..surveys import Survey
+        from ..questions import QuestionBase
 
         if isinstance(survey_or_question, Survey):
             return survey_or_question.by(self.to_scenario_list())
@@ -402,7 +392,7 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         """
         for key in keys:
             if key not in self.keys():
-                from edsl.dataset.exceptions import DatasetValueError
+                from .exceptions import DatasetValueError
                 raise DatasetValueError(f"Key '{key}' not found in the dataset. "
                                         f"Available keys: {self.keys()}"
                                        )
@@ -479,11 +469,11 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
 
         # Validate the input for sampling parameters
         if n is None and frac is None:
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError("Either 'n' or 'frac' must be provided for sampling.")
 
         if n is not None and frac is not None:
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError("Only one of 'n' or 'frac' should be specified.")
 
         # Get the length of the lists from the first entry
@@ -495,7 +485,7 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
             n = int(total_length * frac)
 
         if not with_replacement and n > total_length:
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError(
                 "Sample size cannot be greater than the number of available elements when sampling without replacement."
             )
@@ -513,47 +503,61 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
 
         return self
 
-    def order_by(self, sort_key: str, reverse: bool = False) -> Dataset:
-        """Return a new dataset with the observations sorted by the given key.
-
-        :param sort_key: The key to sort the observations by.
-        :param reverse: Whether to sort in reverse order.
-
-        >>> d = Dataset([{'a':[1,2,3,4]}, {'b':[4,3,2,1]}])
-        >>> d.order_by('a')
-        Dataset([{'a': [1, 2, 3, 4]}, {'b': [4, 3, 2, 1]}])
-
-        >>> d.order_by('a', reverse=True)
-        Dataset([{'a': [4, 3, 2, 1]}, {'b': [1, 2, 3, 4]}])
-
-        >>> d = Dataset([{'X.a':[1,2,3,4]}, {'X.b':[4,3,2,1]}])
-        >>> d.order_by('a')
-        Dataset([{'X.a': [1, 2, 3, 4]}, {'X.b': [4, 3, 2, 1]}])
-
-
+    def get_sort_indices(self, lst: list[Any], reverse: bool = False, use_numpy: bool = True) -> list[int]:
         """
-        import numpy as np
+        Return the indices that would sort the list, using either numpy or pure Python.
+        None values are placed at the end of the sorted list.
 
-        def sort_indices(lst: list[Any]) -> list[int]:
-            """
-            Return the indices that would sort the list.
+        Args:
+            lst: The list to be sorted
+            reverse: Whether to sort in descending order
+            use_numpy: Whether to use numpy implementation (falls back to pure Python if numpy is unavailable)
 
-            :param lst: The list to be sorted.
-            :return: A list of indices that would sort the list.
-            """
-            indices = np.argsort(lst).tolist()
-            if reverse:
-                indices.reverse()
-            return indices
+        Returns:
+            A list of indices that would sort the list
+        """
+        if use_numpy:
+            try:
+                import numpy as np
+                # Convert list to numpy array
+                arr = np.array(lst, dtype=object)
+                # Get mask of non-None values
+                mask = ~(arr is None)
+                # Get indices of non-None and None values
+                non_none_indices = np.where(mask)[0]
+                none_indices = np.where(~mask)[0]
+                # Sort non-None values
+                sorted_indices = non_none_indices[np.argsort(arr[mask])]
+                # Combine sorted non-None indices with None indices
+                indices = np.concatenate([sorted_indices, none_indices]).tolist()
+                if reverse:
+                    # When reversing, keep None values at end
+                    indices = sorted_indices[::-1].tolist() + none_indices.tolist()
+                return indices
+            except ImportError:
+                # Fallback to pure Python if numpy is not available
+                pass
+        
+        # Pure Python implementation
+        enumerated = list(enumerate(lst))
+        # Sort None values to end by using (is_none, value) as sort key
+        sorted_pairs = sorted(enumerated, 
+                            key=lambda x: (x[1] is None, x[1]), 
+                            reverse=reverse)
+        return [index for index, _ in sorted_pairs]
+
+    def order_by(self, sort_key: str, reverse: bool = False, use_numpy: bool = True) -> Dataset:
+        """Return a new dataset with the observations sorted by the given key.
 
+        Args:
+            sort_key: The key to sort the observations by
+            reverse: Whether to sort in reverse order
+            use_numpy: Whether to use numpy for sorting (faster for large lists)
+        """
         number_found = 0
         for obs in self.data:
             key, values = list(obs.items())[0]
-            # an obseration is {'a':[1,2,3,4]}
-            # key = list(obs.keys())[0]
-            if (
-                sort_key == key or sort_key == key.split(".")[-1]
-            ):  # e.g., "age" in "scenario.age"
+            if sort_key == key or sort_key == key.split(".")[-1]:
                 relevant_values = values
                 number_found += 1
 
@@ -562,11 +566,9 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         elif number_found > 1:
             raise DatasetKeyError(f"Key '{sort_key}' found in more than one dictionary.")
 
-        # relevant_values = self._key_to_value(sort_key)
-        sort_indices_list = sort_indices(relevant_values)
+        sort_indices_list = self.get_sort_indices(relevant_values, reverse=reverse, use_numpy=use_numpy)
         new_data = []
         for observation in self.data:
-            # print(observation)
             key, values = list(observation.items())[0]
             new_values = [values[i] for i in sort_indices_list]
             new_data.append({key: new_values})
@@ -646,7 +648,7 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
 
         if max_rows is not None:
             if max_rows > len(data):
-                from edsl.dataset.exceptions import DatasetValueError
+                from .exceptions import DatasetValueError
                 raise DatasetValueError(
                     "max_rows cannot be greater than the number of rows in the dataset."
                 )
@@ -685,6 +687,19 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
     def from_pandas_dataframe(cls, df):
         result = cls([{col: df[col].tolist()} for col in df.columns])
         return result
+    
+    def to_dict(self) -> dict:
+        """
+        Convert the dataset to a dictionary.
+        """
+        return {'data': self.data}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Dataset':
+        """
+        Convert a dictionary to a dataset.
+        """
+        return cls(data['data'])
 
     def to_docx(self, output_file: str, title: str = None) -> None:
         """
@@ -736,6 +751,72 @@ class Dataset(UserList, DatasetOperationsMixin, PersistenceMixin, HashingMixin):
         # Save the document
         doc.save(output_file)
 
+    def expand(self, field: str, number_field: bool = False) -> "Dataset":
+        """
+        Expand a field containing lists into multiple rows.
+        
+        Args:
+            field: The field containing lists to expand
+            number_field: If True, adds a number field indicating the position in the original list
+            
+        Returns:
+            A new Dataset with the expanded rows
+            
+        Example:
+            >>> from edsl.dataset import Dataset
+            >>> d = Dataset([{'a': [[1, 2, 3], [4, 5, 6]]}, {'b': ['x', 'y']}])
+            >>> d.expand('a')
+            Dataset([{'a': [1, 2, 3, 4, 5, 6]}, {'b': ['x', 'x', 'x', 'y', 'y', 'y']}])
+        """
+        from collections.abc import Iterable
+        
+        # Find the field in the dataset
+        field_data = None
+        for entry in self.data:
+            key = list(entry.keys())[0]
+            if key == field:
+                field_data = entry[key]
+                break
+            
+        if field_data is None:
+            raise DatasetKeyError(f"Field '{field}' not found in dataset. Available fields are: {self.keys()}")
+
+
+        # Validate that the field contains lists
+        if not all(isinstance(v, list) for v in field_data):
+            raise DatasetTypeError(f"Field '{field}' must contain lists in all entries")
+        
+        # Create new expanded data structure
+        new_data = []
+        
+        # Process each field
+        for entry in self.data:
+            key, values = list(entry.items())[0]
+            new_values = []
+            
+            if key == field:
+                # This is the field to expand - flatten all sublists
+                for row_values in values:
+                    if not isinstance(row_values, Iterable) or isinstance(row_values, str):
+                        row_values = [row_values]
+                    new_values.extend(row_values)
+            else:
+                # For other fields, repeat each value the appropriate number of times
+                for i, row_value in enumerate(values):
+                    expand_length = len(field_data[i]) if i < len(field_data) else 0
+                    new_values.extend([row_value] * expand_length)
+            
+            new_data.append({key: new_values})
+        
+        # Add number field if requested
+        if number_field:
+            number_values = []
+            for i, lst in enumerate(field_data):
+                number_values.extend(range(1, len(lst) + 1))
+            new_data.append({f"{field}_number": number_values})
+        
+        return Dataset(new_data)
+
 
 if __name__ == "__main__":
     import doctest

edsl/dataset/dataset_operations_mixin.py

@@ -184,6 +184,13 @@ class DataOperationsBase:
                     )
 
         return _num_observations
+    
+    def chart(self):
+        """
+        Create a chart from the results.
+        """
+        import altair as alt
+        return alt.Chart(self.to_pandas(remove_prefix=True))
 
     def make_tabular(
         self, remove_prefix: bool, pretty_labels: Optional[dict] = None
@@ -538,13 +545,14 @@ class DataOperationsBase:
         >>> r.select('how_feeling').to_scenario_list()
         ScenarioList([Scenario({'how_feeling': 'OK'}), Scenario({'how_feeling': 'Great'}), Scenario({'how_feeling': 'Terrible'}), Scenario({'how_feeling': 'OK'})])
         """
-        from edsl.scenarios import ScenarioList, Scenario
+        from ..scenarios import ScenarioList, Scenario
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
         scenarios = []
         for d in list_of_dicts:
             scenarios.append(Scenario(d))
         return ScenarioList(scenarios)
+    
 
     def to_agent_list(self, remove_prefix: bool = True):
         """Convert the results to a list of dictionaries, one per agent.
@@ -556,7 +564,7 @@ class DataOperationsBase:
         >>> 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.agents import Agent, AgentList
+        from ..agents import Agent, AgentList
 
         list_of_dicts = self.to_dicts(remove_prefix=remove_prefix)
         agents = []
@@ -665,7 +673,7 @@ class DataOperationsBase:
     ):
         import os
         import tempfile
-        from edsl.utilities.utilities import is_notebook
+        from ..utilities.utilities import is_notebook
         from IPython.display import HTML, display
 
         df = self.to_pandas()
@@ -799,7 +807,7 @@ class DataOperationsBase:
             from docx.shared import Pt
             import json
         except ImportError:
-            from edsl.dataset.exceptions import DatasetImportError
+            from .exceptions import DatasetImportError
             raise DatasetImportError("The python-docx package is required for DOCX export. Install it with 'pip install python-docx'.")
         
         doc = Document()
@@ -871,7 +879,7 @@ class DataOperationsBase:
             >>> isinstance(doc, object)
             True
         """
-        from edsl.utilities.utilities import is_notebook
+        from ..utilities.utilities import is_notebook
         
         # Prepare the data for the report
         field_data, num_obs, fields, header_fields = self._prepare_report_data(
@@ -1076,7 +1084,7 @@ class DataOperationsBase:
         # Check if the field is ambiguous
         if len(matching_entries) > 1:
             matching_cols = [next(iter(entry.keys())) for entry in matching_entries]
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError(
                 f"Ambiguous field name '{field}'. It matches multiple columns: {matching_cols}. "
                 f"Please specify the full column name to flatten."

edsl/dataset/dataset_tree.py

@@ -51,7 +51,7 @@ class Tree:
         else:
             if not set(node_order).issubset(set(self.data.keys())):
                 invalid_keys = set(node_order) - set(self.data.keys())
-                from edsl.dataset.exceptions import DatasetValueError
+                from .exceptions import DatasetValueError
                 raise DatasetValueError(f"Invalid keys in node_order: {invalid_keys}")
 
         self.root = TreeNode()
@@ -130,7 +130,7 @@ class Tree:
         doc_buffer.seek(0)
 
         base64_string = base64.b64encode(doc_buffer.getvalue()).decode("utf-8")
-        from edsl.scenarios.FileStore import FileStore
+        from ..scenarios.file_store import FileStore
 
         # Create and return FileStore instance
         return FileStore(
@@ -335,7 +335,7 @@ class Tree:
         Returns:
             A string containing the markdown document, or renders markdown in notebooks.            
         """
-        from edsl.utilities.utilities import is_notebook
+        from ..utilities.utilities import is_notebook
         from IPython.display import Markdown, display
         
         if node is None:

edsl/dataset/display/table_renderers.py

@@ -103,9 +103,12 @@ class PandasStyleRenderer(DataTablesRendererABC):
             else:
                 df = pd.DataFrame(self.table_data.data, columns=self.table_data.headers)
 
-            styled_df = df.style.set_properties(
-                **{"text-align": "left"}
-            ).background_gradient()
+            styled_df = df.style.set_properties(**{
+                "text-align": "left",
+                "white-space": "pre-wrap",  # Allows text wrapping
+                "max-width": "300px",       # Maximum width before wrapping
+                "word-wrap": "break-word"   # Breaks words that exceed max-width
+            }).background_gradient()
 
             return f"""
             <div style="max-height: 500px; overflow-y: auto;">

edsl/dataset/file_exports.py

@@ -40,7 +40,7 @@ class FileExport(ABC):
 
     def _create_filestore(self, data: Union[str, bytes]):
         """Create a FileStore instance with encoded data."""
-        from ..scenarios import FileStore
+        from ..scenarios.file_store import FileStore
         if isinstance(data, str):
             base64_string = base64.b64encode(data.encode()).decode()
         else:
@@ -203,7 +203,7 @@ class SQLiteExport(TabularExport):
                 (self.table_name,),
             )
             if cursor.fetchone():
-                from edsl.dataset.exceptions import DatasetValueError
+                from .exceptions import DatasetValueError
                 raise DatasetValueError(f"Table {self.table_name} already exists")
 
         # Create table
@@ -245,14 +245,14 @@ class SQLiteExport(TabularExport):
         """Validate initialization parameters."""
         valid_if_exists = {"fail", "replace", "append"}
         if self.if_exists not in valid_if_exists:
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError(
                 f"if_exists must be one of {valid_if_exists}, got {self.if_exists}"
             )
 
         # Validate table name (basic SQLite identifier validation)
         if not self.table_name.isalnum() and not all(c in "_" for c in self.table_name):
-            from edsl.dataset.exceptions import DatasetValueError
+            from .exceptions import DatasetValueError
             raise DatasetValueError(
                 f"Invalid table name: {self.table_name}. Must contain only alphanumeric characters and underscores."
             )

edsl/dataset/r/ggplot.py

@@ -30,12 +30,12 @@ class GGPlot:
 
         if result.returncode != 0:
             if result.returncode == 127:
-                from edsl.dataset.exceptions import DatasetRuntimeError
+                from ..exceptions import DatasetRuntimeError
                 raise DatasetRuntimeError(
                     "Rscript is probably not installed. Please install R from https://cran.r-project.org/"
                 )
             else:
-                from edsl.dataset.exceptions import DatasetRuntimeError
+                from ..exceptions import DatasetRuntimeError
                 raise DatasetRuntimeError(
                     f"An error occurred while running Rscript: {result.stderr}"
                 )
@@ -49,7 +49,7 @@ class GGPlot:
         """Save the plot to a file."""
         format = filename.split('.')[-1].lower()
         if format not in ['svg', 'png']:
-            from edsl.dataset.exceptions import DatasetValueError
+            from ..exceptions import DatasetValueError
             raise DatasetValueError("Only 'svg' and 'png' formats are supported")
             
         save_command = f'\nggsave("{filename}", plot = last_plot(), width = {self.width}, height = {self.height}, device = "{format}")'

edsl/inference_services/available_model_fetcher.py

@@ -55,7 +55,7 @@ class AvailableModelFetcher:
 
         :param service: Optional[InferenceServiceABC] - If specified, only fetch models for this service.
 
-        >>> from edsl.inference_services.services.open_ai_service import OpenAIService
+        >>> from .services.open_ai_service import OpenAIService
         >>> af = AvailableModelFetcher([OpenAIService()], {})
         >>> af.available(service="openai")
         [LanguageModelInfo(model_name='...', service_name='openai'), ...]
@@ -155,7 +155,7 @@ class AvailableModelFetcher:
         """The service name is the _inference_service_ attribute of the service."""
         if service_name in self._service_map:
             return self._service_map[service_name]
-        from edsl.inference_services.exceptions import InferenceServiceValueError
+        from .exceptions import InferenceServiceValueError
         raise InferenceServiceValueError(f"Service {service_name} not found")
 
     def _get_all_models(self, force_refresh=False) -> List[LanguageModelInfo]:

edsl/inference_services/data_structures.py

@@ -43,7 +43,7 @@ class LanguageModelInfo:
         elif key == 1:
             return self.service_name
         else:
-            from edsl.inference_services.exceptions import InferenceServiceIndexError
+            from .exceptions import InferenceServiceIndexError
             raise InferenceServiceIndexError("Index out of range")
 
     @classmethod
@@ -70,7 +70,7 @@ class AvailableModels(UserList):
         return self.to_dataset().print()
 
     def to_dataset(self):
-        from edsl.scenarios.ScenarioList import ScenarioList
+        from ..scenarios.scenario_list import ScenarioList
 
         models, services = zip(
             *[(model.model_name, model.service_name) for model in self]
@@ -106,14 +106,14 @@ class AvailableModels(UserList):
                 ]
             )
             if len(avm) == 0:
-                from edsl.inference_services.exceptions import InferenceServiceValueError
+                from .exceptions import InferenceServiceValueError
                 raise InferenceServiceValueError(
                     "No models found matching the search pattern: " + pattern
                 )
             else:
                 return avm
         except re.error as e:
-            from edsl.inference_services.exceptions import InferenceServiceValueError
+            from .exceptions import InferenceServiceValueError
             raise InferenceServiceValueError(f"Invalid regular expression pattern: {e}")
 
 
@@ -128,7 +128,7 @@ class ServiceToModelsMapping(UserDict):
     def _validate_service_names(self):
         for service in self.service_names:
             if service not in InferenceServiceLiteral:
-                from edsl.inference_services.exceptions import InferenceServiceValueError
+                from .exceptions import InferenceServiceValueError
                 raise InferenceServiceValueError(f"Invalid service name: {service}")
 
     def model_to_services(self) -> dict:

edsl/inference_services/inference_service_abc.py

@@ -26,7 +26,7 @@ class InferenceServiceABC(ABC):
         ]
         for attr in must_have_attributes:
             if not hasattr(cls, attr):
-                from edsl.inference_services.exceptions import InferenceServiceNotImplementedError
+                from .exceptions import InferenceServiceNotImplementedError
                 raise InferenceServiceNotImplementedError(
                     f"Class {cls.__name__} must have a '{attr}' attribute."
                 )

edsl/inference_services/inference_services_collection.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Optional, Protocol, Dict, List, Tuple, TYPE_CHECKING
 
-from edsl.enums import InferenceServiceLiteral
+from ..enums import InferenceServiceLiteral
 from .inference_service_abc import InferenceServiceABC
 from .available_model_fetcher import AvailableModelFetcher
 from .exceptions import InferenceServiceError

edsl/inference_services/service_availability.py

@@ -42,7 +42,7 @@ class ServiceAvailability:
     @classmethod
     def models_from_coop(cls) -> AvailableModels:
         if not cls._coop_model_list:
-            from edsl.coop.coop import Coop
+            from ..coop.coop import Coop
 
             c = Coop()
             coop_model_list = c.fetch_models()
@@ -74,7 +74,7 @@ class ServiceAvailability:
                 continue
 
         # If we get here, all sources failed
-        from edsl.inference_services.exceptions import InferenceServiceRuntimeError
+        from .exceptions import InferenceServiceRuntimeError
         raise InferenceServiceRuntimeError(
             f"All sources failed to fetch models. Last error: {last_error}"
         )
@@ -93,7 +93,7 @@ class ServiceAvailability:
     @staticmethod
     def _fetch_from_cache(service: "InferenceServiceABC") -> ModelNamesList:
         """Fetch models from local cache."""
-        from edsl.inference_services.models_available_cache import models_available
+        from .models_available_cache import models_available
 
         return models_available.get(service._inference_service_, [])
 

edsl/inference_services/services/azure_ai.py

@@ -46,7 +46,7 @@ class AzureAIService(InferenceServiceABC):
         out = []
         azure_endpoints = os.getenv("AZURE_ENDPOINT_URL_AND_KEY", None)
         if not azure_endpoints:
-            from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+            from ..exceptions import InferenceServiceEnvironmentError
             raise InferenceServiceEnvironmentError("AZURE_ENDPOINT_URL_AND_KEY is not defined")
         azure_endpoints = azure_endpoints.split(",")
         for data in azure_endpoints:
@@ -135,7 +135,7 @@ class AzureAIService(InferenceServiceABC):
                     api_key = None
 
                 if not api_key:
-                    from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+                    from ..exceptions import InferenceServiceEnvironmentError
                     raise InferenceServiceEnvironmentError(
                         f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
                     )
@@ -146,7 +146,7 @@ class AzureAIService(InferenceServiceABC):
                     endpoint = None
 
                 if not endpoint:
-                    from edsl.inference_services.exceptions import InferenceServiceEnvironmentError
+                    from ..exceptions import InferenceServiceEnvironmentError
                     raise InferenceServiceEnvironmentError(
                         f"AZURE_ENDPOINT_URL_AND_KEY doesn't have the endpoint:key pair for your model: {model_name}"
                     )

edsl/inference_services/services/google_service.py

@@ -5,7 +5,7 @@ import google.generativeai as genai
 from google.generativeai.types import GenerationConfig
 from google.api_core.exceptions import InvalidArgument
 
-# from edsl.exceptions.general import MissingAPIKeyError
+# from ...exceptions.general import MissingAPIKeyError
 from ..inference_service_abc import InferenceServiceABC
 from ...language_models import LanguageModel
 

edsl/inference_services/services/test_service.py

@@ -74,7 +74,7 @@ class TestService(InferenceServiceABC):
                         p = 1
 
                     if random.random() < p:
-                        from edsl.inference_services.exceptions import InferenceServiceError
+                        from ..exceptions import InferenceServiceError
                         raise InferenceServiceError("This is a test error")
 
                 if hasattr(self, "func"):