edsl 0.1.53__py3-none-any.whl → 0.1.54__py3-none-any.whl

edsl/questions/question_check_box.py

@@ -24,29 +24,29 @@ if TYPE_CHECKING:
 class CheckboxResponse(BaseModel):
     """
     Base Pydantic model for validating checkbox responses.
-    
+
     This model defines the structure and validation rules for responses to
     checkbox questions, ensuring that selected options are properly formatted
     as a list of choices.
-    
+
     Attributes:
         answer: List of selected choices
         comment: Optional comment provided with the answer
         generated_tokens: Optional raw LLM output for token tracking
-        
+
     Examples:
         >>> # Valid response with list of options
         >>> response = CheckboxResponse(answer=[0, 1])
         >>> response.answer
         [0, 1]
-        
+
         >>> # Valid response with comment
         >>> response = CheckboxResponse(answer=[1], comment="This is my choice")
         >>> response.answer
         [1]
         >>> response.comment
         'This is my choice'
-        
+
         >>> # Invalid non-list answer
         >>> try:
         ...     CheckboxResponse(answer=1)
@@ -54,6 +54,7 @@ class CheckboxResponse(BaseModel):
         ...     print("Validation error occurred")
         Validation error occurred
     """
+
     answer: List[Any]
     comment: Optional[str] = None
     generated_tokens: Optional[Any] = None
@@ -67,59 +68,59 @@ def create_checkbox_response_model(
 ):
     """
     Dynamically create a CheckboxResponse model with a predefined list of choices.
-    
+
     This function creates a customized Pydantic model for checkbox questions that
     validates both the format of the response and any constraints on selection count.
-    
+
     Args:
         choices: A list of allowed values for the answer field
         min_selections: Optional minimum number of selections required
         max_selections: Optional maximum number of selections allowed
         permissive: If True, constraints are not enforced
-        
+
     Returns:
         A new Pydantic model class with appropriate validation
-        
+
     Examples:
         >>> # Create model with constraints
         >>> choices = [0, 1, 2, 3]
         >>> ConstrainedModel = create_checkbox_response_model(
-        ...     choices=choices, 
-        ...     min_selections=1, 
+        ...     choices=choices,
+        ...     min_selections=1,
         ...     max_selections=2
         ... )
-        
+
         >>> # Valid response within constraints
         >>> response = ConstrainedModel(answer=[0, 1])
         >>> response.answer
         [0, 1]
-        
+
         >>> # Too few selections fails validation
         >>> try:
         ...     ConstrainedModel(answer=[])
         ... except Exception as e:
         ...     "at least 1" in str(e)
         True
-        
+
         >>> # Too many selections fails validation
         >>> try:
         ...     ConstrainedModel(answer=[0, 1, 2])
         ... except Exception as e:
         ...     "at most 2" in str(e)
         True
-        
+
         >>> # Invalid choice fails validation
         >>> try:
         ...     ConstrainedModel(answer=[4])
         ... except Exception as e:
         ...     any(x in str(e) for x in ["Invalid choice", "not a valid enumeration member", "validation error"])
         True
-        
+
         >>> # Permissive model ignores constraints
         >>> PermissiveModel = create_checkbox_response_model(
-        ...     choices=choices, 
-        ...     min_selections=1, 
-        ...     max_selections=2, 
+        ...     choices=choices,
+        ...     min_selections=1,
+        ...     max_selections=2,
         ...     permissive=True
         ... )
         >>> response = PermissiveModel(answer=[0, 1, 2])
@@ -133,152 +134,161 @@ def create_checkbox_response_model(
         # For permissive mode, we still validate the choice values but ignore count constraints
         class PermissiveCheckboxResponse(CheckboxResponse):
             """Checkbox response model with choices validation but no count constraints."""
-            
+
             answer: Annotated[
                 List[Literal[choice_tuple]],
                 Field(description="List of selected choices"),
             ]
-            
-            @model_validator(mode='after')
+
+            @model_validator(mode="after")
             def validate_choices(self):
                 """Validate that each selected choice is valid."""
                 for choice in self.answer:
                     if choice not in choices:
                         validation_error = ValidationError.from_exception_data(
-                            title='CheckboxResponse',
-                            line_errors=[{
-                                'type': 'value_error',
-                                'loc': ('answer',),
-                                'msg': f'Invalid choice: {choice}. Must be one of: {choices}',
-                                'input': choice,
-                                'ctx': {'error': 'Invalid choice'}
-                            }]
+                            title="CheckboxResponse",
+                            line_errors=[
+                                {
+                                    "type": "value_error",
+                                    "loc": ("answer",),
+                                    "msg": f"Invalid choice: {choice}. Must be one of: {choices}",
+                                    "input": choice,
+                                    "ctx": {"error": "Invalid choice"},
+                                }
+                            ],
                         )
                         raise QuestionAnswerValidationError(
                             message=f"Invalid choice: {choice}. Must be one of: {choices}",
                             data=self.model_dump(),
                             model=self.__class__,
-                            pydantic_error=validation_error
+                            pydantic_error=validation_error,
                         )
                 return self
-                
+
         return PermissiveCheckboxResponse
     else:
         # For non-permissive mode, enforce both choice values and count constraints
         class ConstrainedCheckboxResponse(CheckboxResponse):
             """Checkbox response model with both choice and count constraints."""
-            
+
             answer: Annotated[
                 List[Literal[choice_tuple]],
                 Field(description="List of selected choices"),
             ]
-            
-            @model_validator(mode='after')
+
+            @model_validator(mode="after")
             def validate_selection_count(self):
                 """Validate that the number of selections meets constraints."""
                 if min_selections is not None and len(self.answer) < min_selections:
                     validation_error = ValidationError.from_exception_data(
-                        title='CheckboxResponse',
-                        line_errors=[{
-                            'type': 'value_error',
-                            'loc': ('answer',),
-                            'msg': f'Must select at least {min_selections} option(s)',
-                            'input': self.answer,
-                            'ctx': {'error': 'Too few selections'}
-                        }]
+                        title="CheckboxResponse",
+                        line_errors=[
+                            {
+                                "type": "value_error",
+                                "loc": ("answer",),
+                                "msg": f"Must select at least {min_selections} option(s)",
+                                "input": self.answer,
+                                "ctx": {"error": "Too few selections"},
+                            }
+                        ],
                     )
                     raise QuestionAnswerValidationError(
                         message=f"Must select at least {min_selections} option(s), got {len(self.answer)}",
                         data=self.model_dump(),
                         model=self.__class__,
-                        pydantic_error=validation_error
+                        pydantic_error=validation_error,
                     )
-                
+
                 if max_selections is not None and len(self.answer) > max_selections:
                     validation_error = ValidationError.from_exception_data(
-                        title='CheckboxResponse',
-                        line_errors=[{
-                            'type': 'value_error',
-                            'loc': ('answer',),
-                            'msg': f'Must select at most {max_selections} option(s)',
-                            'input': self.answer,
-                            'ctx': {'error': 'Too many selections'}
-                        }]
+                        title="CheckboxResponse",
+                        line_errors=[
+                            {
+                                "type": "value_error",
+                                "loc": ("answer",),
+                                "msg": f"Must select at most {max_selections} option(s)",
+                                "input": self.answer,
+                                "ctx": {"error": "Too many selections"},
+                            }
+                        ],
                     )
                     raise QuestionAnswerValidationError(
                         message=f"Must select at most {max_selections} option(s), got {len(self.answer)}",
                         data=self.model_dump(),
                         model=self.__class__,
-                        pydantic_error=validation_error
+                        pydantic_error=validation_error,
                     )
-                
+
                 # Also validate that each choice is valid
                 for choice in self.answer:
                     if choice not in choices:
                         validation_error = ValidationError.from_exception_data(
-                            title='CheckboxResponse',
-                            line_errors=[{
-                                'type': 'value_error',
-                                'loc': ('answer',),
-                                'msg': f'Invalid choice: {choice}. Must be one of: {choices}',
-                                'input': choice,
-                                'ctx': {'error': 'Invalid choice'}
-                            }]
+                            title="CheckboxResponse",
+                            line_errors=[
+                                {
+                                    "type": "value_error",
+                                    "loc": ("answer",),
+                                    "msg": f"Invalid choice: {choice}. Must be one of: {choices}",
+                                    "input": choice,
+                                    "ctx": {"error": "Invalid choice"},
+                                }
+                            ],
                         )
                         raise QuestionAnswerValidationError(
                             message=f"Invalid choice: {choice}. Must be one of: {choices}",
                             data=self.model_dump(),
                             model=self.__class__,
-                            pydantic_error=validation_error
+                            pydantic_error=validation_error,
                         )
-                
+
                 return self
-                
+
         return ConstrainedCheckboxResponse
 
 
 class CheckBoxResponseValidator(ResponseValidatorABC):
     """
     Validator for checkbox question responses.
-    
+
     This class implements the validation and fixing logic for checkbox responses.
     It ensures that responses contain valid selections from the available options
     and that the number of selections meets any constraints.
-    
+
     Attributes:
         required_params: List of required parameters for validation.
         valid_examples: Examples of valid responses for testing.
         invalid_examples: Examples of invalid responses for testing.
-        
+
     Examples:
         >>> from edsl import QuestionCheckBox
-        >>> q = QuestionCheckBox.example()
+        >>> q = QuestionCheckBox.example(use_code=True)
         >>> validator = q.response_validator
-        
+
         >>> # Fix string to list
         >>> response = {"answer": 1}
         >>> fixed = validator.fix(response)
         >>> isinstance(fixed["answer"], list)
         True
-        
+
         >>> # Extract selections from text
         >>> response = {"generated_tokens": "I choose options 0 and 2"}
         >>> fixed = validator.fix(response)
         >>> sorted(fixed["answer"])
         [0, 2]
-        
+
         >>> # Fix comma-separated list
         >>> response = {"generated_tokens": "0, 1, 3"}
         >>> fixed = validator.fix(response)
         >>> sorted(fixed["answer"])
         [0, 1, 3]
-        
+
         >>> # Preserve comments when fixing
         >>> response = {"answer": 1, "comment": "My explanation"}
         >>> fixed = validator.fix(response)
         >>> "comment" in fixed and fixed["comment"] == "My explanation"
         True
     """
+
     required_params = [
         "question_options",
         "min_selections",
@@ -316,20 +326,20 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
     def fix(self, response, verbose=False):
         """
         Fix common issues in checkbox responses.
-        
+
         This method attempts to extract valid selections from responses with
         format issues. It can handle:
         1. Single values that should be lists
         2. Comma-separated strings in answer field or generated_tokens
         3. Finding option indices mentioned in text
-        
+
         Args:
             response: The response dictionary to fix
             verbose: If True, print information about the fixing process
-            
+
         Returns:
             A fixed version of the response dictionary with a valid list of selections
-            
+
         Notes:
             - First tries to convert to a list if the answer is not already a list
             - Then tries to parse comma-separated values from answer or generated_tokens
@@ -338,16 +348,20 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
         """
         if verbose:
             print("Invalid response of QuestionCheckBox was: ", response)
-        
+
         # Check if answer exists and is a comma-separated string (common LLM output format)
-        if "answer" in response and isinstance(response["answer"], str) and "," in response["answer"]:
+        if (
+            "answer" in response
+            and isinstance(response["answer"], str)
+            and "," in response["answer"]
+        ):
             if verbose:
                 print(f"Parsing comma-separated answer string: {response['answer']}")
-            
+
             # Split by commas and strip whitespace
             proposed_list = response["answer"].split(",")
             proposed_list = [item.strip() for item in proposed_list]
-            
+
             # Try to convert to integers if use_code is True
             if self.use_code:
                 try:
@@ -355,31 +369,33 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
                 except ValueError:
                     # If we can't convert to integers, try to match values to indices
                     if verbose:
-                        print("Could not convert comma-separated values to integers, trying to match options")
-                    
+                        print(
+                            "Could not convert comma-separated values to integers, trying to match options"
+                        )
+
                     # Try to match option text values to their indices
                     index_map = {}
                     for i, option in enumerate(self.question_options):
                         index_map[option.lower().strip()] = i
-                    
+
                     converted_list = []
                     for item in proposed_list:
                         item_lower = item.lower().strip()
                         if item_lower in index_map:
                             converted_list.append(index_map[item_lower])
-                            
+
                     if converted_list:
                         proposed_list = converted_list
-                    
+
             if verbose:
                 print("Proposed solution from comma separation is: ", proposed_list)
-            
+
             proposed_data = {
                 "answer": proposed_list,
                 "comment": response.get("comment"),
                 "generated_tokens": response.get("generated_tokens"),
             }
-            
+
             # Try validating with the proposed solution
             try:
                 validated = self._base_validate(proposed_data)
@@ -387,14 +403,14 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
             except Exception as e:
                 if verbose:
                     print(f"Comma-separated solution invalid: {e}")
-            
+
         # If answer exists but is not a list, convert it to a list
         elif "answer" in response and not isinstance(response["answer"], list):
             if verbose:
                 print(f"Converting non-list answer {response['answer']} to a list")
             answer_value = response["answer"]
             response = {**response, "answer": [answer_value]}
-            
+
             # Try validating the fixed response
             try:
                 validated = self._base_validate(response)
@@ -402,7 +418,7 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
             except Exception:
                 if verbose:
                     print("Converting to list didn't fix the issue")
-        
+
         # Try parsing from generated_tokens if present
         response_text = response.get("generated_tokens")
         if response_text and isinstance(response_text, str):
@@ -410,38 +426,40 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
             if "," in response_text:
                 proposed_list = response_text.split(",")
                 proposed_list = [item.strip() for item in proposed_list]
-                
+
                 if self.use_code:
                     try:
                         proposed_list = [int(i) for i in proposed_list]
                     except ValueError:
                         # If we can't convert to integers, try to match values to indices
                         if verbose:
-                            print("Could not convert comma-separated values to integers, trying to match options")
-                        
+                            print(
+                                "Could not convert comma-separated values to integers, trying to match options"
+                            )
+
                         # Try to match option text values to their indices
                         index_map = {}
                         for i, option in enumerate(self.question_options):
                             index_map[option.lower().strip()] = i
-                        
+
                         converted_list = []
                         for item in proposed_list:
                             item_lower = item.lower().strip()
                             if item_lower in index_map:
                                 converted_list.append(index_map[item_lower])
-                                
+
                         if converted_list:
                             proposed_list = converted_list
-                
+
                 if verbose:
                     print("Proposed solution from comma separation is: ", proposed_list)
-                
+
                 proposed_data = {
                     "answer": proposed_list,
                     "comment": response.get("comment"),
                     "generated_tokens": response.get("generated_tokens"),
                 }
-                
+
                 # Try validating with the proposed solution
                 try:
                     validated = self._base_validate(proposed_data)
@@ -449,7 +467,7 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
                 except Exception as e:
                     if verbose:
                         print(f"Comma-separated solution invalid: {e}")
-            
+
             # Try finding option indices mentioned in the text
             matches = []
             for index, option in enumerate(self.question_options):
@@ -459,17 +477,17 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
                 else:
                     if option in response_text:
                         matches.append(option)
-                        
+
             if matches:
                 if verbose:
                     print(f"Found options mentioned in text: {matches}")
-                    
+
                 proposed_data = {
                     "answer": matches,
                     "comment": response.get("comment"),
                     "generated_tokens": response.get("generated_tokens"),
                 }
-                
+
                 # Try validating with the proposed solution
                 try:
                     validated = self._base_validate(proposed_data)
@@ -477,7 +495,7 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
                 except Exception as e:
                     if verbose:
                         print(f"Text matching solution invalid: {e}")
-        
+
         # If nothing worked, return the original response
         return response
 
@@ -485,11 +503,11 @@ class CheckBoxResponseValidator(ResponseValidatorABC):
 class QuestionCheckBox(QuestionBase):
     """
     A question that prompts the agent to select multiple options from a list.
-    
+
     QuestionCheckBox allows agents to select one or more items from a predefined
     list of options. It's useful for "select all that apply" scenarios, multi-select
     preferences, or any question where multiple valid selections are possible.
-    
+
     Attributes:
         question_type (str): Identifier for this question type, set to "checkbox".
         purpose (str): Brief description of when to use this question type.
@@ -498,16 +516,16 @@ class QuestionCheckBox(QuestionBase):
         max_selections: Optional maximum number of selections allowed.
         _response_model: Initially None, set by create_response_model().
         response_validator_class: Class used to validate and fix responses.
-        
+
     Examples:
         >>> # Basic creation works
         >>> q = QuestionCheckBox.example()
         >>> q.question_type
         'checkbox'
-        
+
         >>> # Create preferences question with selection constraints
         >>> q = QuestionCheckBox(
-        ...     question_name="favorite_fruits", 
+        ...     question_name="favorite_fruits",
         ...     question_text="Which fruits do you like?",
         ...     question_options=["Apple", "Banana", "Cherry", "Durian", "Elderberry"],
         ...     min_selections=1,
@@ -538,14 +556,14 @@ class QuestionCheckBox(QuestionBase):
         min_selections: Optional[int] = None,
         max_selections: Optional[int] = None,
         include_comment: bool = True,
-        use_code: bool = True,
+        use_code: bool = False,
         question_presentation: Optional[str] = None,
         answering_instructions: Optional[str] = None,
         permissive: bool = False,
     ):
         """
         Initialize a new checkbox question.
-        
+
         Args:
             question_name: Identifier for the question, used in results and templates.
                           Must be a valid Python variable name.
@@ -558,7 +576,7 @@ class QuestionCheckBox(QuestionBase):
             question_presentation: Optional custom presentation template.
             answering_instructions: Optional additional instructions.
             permissive: If True, ignore selection count constraints during validation.
-            
+
         Examples:
             >>> q = QuestionCheckBox(
             ...     question_name="symptoms",
@@ -568,12 +586,12 @@ class QuestionCheckBox(QuestionBase):
             ... )
             >>> q.question_name
             'symptoms'
-            
+
             >>> # Question with both min and max
             >>> q = QuestionCheckBox(
             ...     question_name="pizza_toppings",
             ...     question_text="Choose 2-4 toppings for your pizza:",
-            ...     question_options=["Cheese", "Pepperoni", "Mushroom", "Onion", 
+            ...     question_options=["Cheese", "Pepperoni", "Mushroom", "Onion",
             ...                       "Sausage", "Bacon", "Pineapple"],
             ...     min_selections=2,
             ...     max_selections=4
@@ -595,15 +613,15 @@ class QuestionCheckBox(QuestionBase):
     def create_response_model(self):
         """
         Create a response model with the appropriate constraints.
-        
+
         This method creates a Pydantic model customized with the options and
         selection count constraints specified for this question instance.
-        
+
         Returns:
             A Pydantic model class tailored to this question's constraints.
-            
+
         Examples:
-            >>> q = QuestionCheckBox.example()
+            >>> q = QuestionCheckBox.example(use_code=True)
             >>> model = q.create_response_model()
             >>> model(answer=[0, 2])  # Select first and third options
             ConstrainedCheckboxResponse(answer=[0, 2], comment=None, generated_tokens=None)
@@ -630,23 +648,23 @@ class QuestionCheckBox(QuestionBase):
     ):
         """
         Translate the answer codes to the actual answer text.
-        
+
         For checkbox questions with use_code=True, the agent responds with
         option indices (e.g., [0, 1]) which need to be translated to their
         corresponding option text values (e.g., ["Option A", "Option B"]).
-        
+
         Args:
             answer_codes: List of selected option indices or values
             scenario: Optional scenario with variables for template rendering
-            
+
         Returns:
             List of selected option texts
-            
+
         Examples:
             >>> q = QuestionCheckBox(
             ...     question_name="example",
             ...     question_text="Select options:",
-            ...     question_options=["A", "B", "C"]
+            ...     question_options=["A", "B", "C"],use_code=True
             ... )
             >>> q._translate_answer_code_to_answer([0, 2])
             ['A', 'C']
@@ -666,16 +684,16 @@ class QuestionCheckBox(QuestionBase):
     def _simulate_answer(self, human_readable=True):
         """
         Simulate a valid answer for debugging purposes.
-        
+
         This method generates a random valid answer for the checkbox question,
         useful for testing and demonstrations.
-        
+
         Args:
             human_readable: If True, return option text values; if False, return indices
-            
+
         Returns:
             A dictionary with a valid random answer
-            
+
         Examples:
             >>> q = QuestionCheckBox.example()
             >>> answer = q._simulate_answer(human_readable=False)
@@ -691,9 +709,9 @@ class QuestionCheckBox(QuestionBase):
         # Ensure we don't try to select more options than available
         max_sel = min(max_sel, len(self.question_options))
         min_sel = min(min_sel, max_sel)
-        
+
         num_selections = random.randint(min_sel, max_sel)
-        
+
         if human_readable:
             # Select a random number of options from self.question_options
             selected_options = random.sample(self.question_options, num_selections)
@@ -716,11 +734,11 @@ class QuestionCheckBox(QuestionBase):
     def question_html_content(self) -> str:
         """
         Generate HTML content for rendering the question in web interfaces.
-        
+
         This property generates HTML markup for the question when it needs to be
         displayed in web interfaces or HTML contexts. For a checkbox question,
         this is a set of checkbox input elements, one for each option.
-        
+
         Returns:
             str: HTML markup for rendering the question.
         """
@@ -729,7 +747,7 @@ class QuestionCheckBox(QuestionBase):
             instructions += f"Select at least {self.min_selections} option(s). "
         if self.max_selections is not None:
             instructions += f"Select at most {self.max_selections} option(s)."
-            
+
         question_html_content = Template(
             """
         <p>{{ instructions }}</p>
@@ -752,20 +770,20 @@ class QuestionCheckBox(QuestionBase):
     ################
     @classmethod
     @inject_exception
-    def example(cls, include_comment=False, use_code=True) -> QuestionCheckBox:
+    def example(cls, include_comment=False, use_code=False) -> QuestionCheckBox:
         """
         Create an example instance of a checkbox question.
-        
+
         This class method creates a predefined example of a checkbox question
         for demonstration, testing, and documentation purposes.
-        
+
         Args:
             include_comment: Whether to include a comment field with the answer.
             use_code: Whether to use indices (True) or values (False) for answer codes.
-                     
+
         Returns:
             QuestionCheckBox: An example checkbox question.
-            
+
         Examples:
             >>> q = QuestionCheckBox.example()
             >>> q.question_name
@@ -797,11 +815,11 @@ class QuestionCheckBox(QuestionBase):
 def main():
     """
     Demonstrate the functionality of the QuestionCheckBox class.
-    
+
     This function creates an example checkbox question and demonstrates its
     key features including validation, serialization, and answer simulation.
     It's primarily intended for testing and development purposes.
-    
+
     Note:
         This function will be executed when the module is run directly,
         but not when imported.
@@ -813,47 +831,51 @@ def main():
     print(f"Question options: {q.question_options}")
     print(f"Min selections: {q.min_selections}")
     print(f"Max selections: {q.max_selections}")
-    
+
     # Validate an answer
     print("\nValidating an answer...")
     valid_answer = {"answer": [1, 2], "comment": "I like these foods"}
     validated = q._validate_answer(valid_answer)
     print(f"Validated answer: {validated}")
-    
+
     # Translate answer codes
     print("\nTranslating answer codes...")
     translated = q._translate_answer_code_to_answer([1, 2])
     print(f"Translated answer: {translated}")
-    
+
     # Simulate answers
     print("\nSimulating answers...")
     simulated_human = q._simulate_answer(human_readable=True)
     print(f"Simulated human-readable answer: {simulated_human}")
-    
+
     simulated_codes = q._simulate_answer(human_readable=False)
     print(f"Simulated code answer: {simulated_codes}")
-    
+
     # Validate simulated answer
     validated_simulated = q._validate_answer(simulated_codes)
     print(f"Validated simulated answer: {validated_simulated}")
-    
+
     # Serialization demonstration
     print("\nTesting serialization...")
     serialized = q.to_dict()
     print(f"Serialized question (keys): {list(serialized.keys())}")
     deserialized = QuestionBase.from_dict(serialized)
-    print(f"Deserialization successful: {deserialized.question_text == q.question_text}")
-    
+    print(
+        f"Deserialization successful: {deserialized.question_text == q.question_text}"
+    )
+
     # Run doctests
     print("\nRunning doctests...")
     import doctest
+
     doctest.testmod(optionflags=doctest.ELLIPSIS)
     print("Doctests completed")
 
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod(optionflags=doctest.ELLIPSIS)
-    
+
     # Uncomment to run demonstration
     # main()