prompt: We are currently solving the following issue within our repository. Here is the issue text:
  --- BEGIN ISSUE ---
  Use cleaner solution for non-truncating division in python 2
  Prefer `from __future__ import division` to `1.*x/y`
  
  --- END ISSUE ---
  
  Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
  --- BEGIN FILES ---
  Path: `great_expectations/rule_based_profiler/rule_state.py`
  Content:
  ```
  1 from __future__ import annotations
  2 
  3 from typing import TYPE_CHECKING, Dict, List, Optional
  4 
  5 import great_expectations.exceptions as ge_exceptions
  6 from great_expectations.rule_based_profiler.domain import Domain
  7 from great_expectations.rule_based_profiler.parameter_container import (
  8     ParameterContainer,
  9 )
  10 
  11 if TYPE_CHECKING:
  12     from great_expectations.rule_based_profiler.rule.rule import Rule
  13 
  14 
  15 class RuleState:
  16     """
  17     RuleState maintains state information, resulting from executing "Rule.run()" method by combining passed "Batch" data
  18     with currently loaded configuration of "Rule" components ("DomainBuilder" object, "ParameterBuilder" objects, and
  19     "ExpectationConfigurationBuilder" objects).  Using "RuleState" with correponding flags is sufficient for generating
  20     outputs for different purposes (in raw and aggregated form) from available "Domain" objects and computed parameters.
  21     """
  22 
  23     def __init__(
  24         self,
  25         rule: Optional[Rule] = None,
  26         variables: Optional[ParameterContainer] = None,
  27         domains: Optional[List[Domain]] = None,
  28         parameters: Optional[Dict[str, ParameterContainer]] = None,
  29     ) -> None:
  30         """
  31         Args:
  32             rule: Rule object for which present RuleState object corresponds (needed for various Rule properties).
  33             variables: attribute name/value pairs (part of state, relevant for associated Rule).
  34             domains: List of Domain objects, which DomainBuilder of associated Rule generated.
  35             parameters: Dictionary of ParameterContainer objects corresponding to all Domain objects in memory.
  36         """
  37         self._rule = rule
  38 
  39         self._variables = variables
  40 
  41         if domains is None:
  42             domains = []
  43 
  44         self._domains = domains
  45 
  46         if parameters is None:
  47             parameters = {}
  48 
  49         self._parameters = parameters
  50 
  51         self._rule_domain_builder_execution_time = 0.0
  52         self._rule_execution_time = 0.0
  53 
  54     @property
  55     def rule(self) -> Optional[Rule]:
  56         return self._rule
  57 
  58     @rule.setter
  59     def rule(self, value: Rule) -> None:
  60         self._rule = value
  61 
  62     @property
  63     def variables(self) -> Optional[ParameterContainer]:
  64         return self._variables
  65 
  66     @variables.setter
  67     def variables(self, value: Optional[ParameterContainer]) -> None:
  68         self._variables = value
  69 
  70     @property
  71     def domains(self) -> List[Domain]:
  72         return self._domains
  73 
  74     @domains.setter
  75     def domains(self, value: Optional[List[Domain]]) -> None:
  76         self._domains = value
  77 
  78     @property
  79     def parameters(self) -> Dict[str, ParameterContainer]:
  80         return self._parameters
  81 
  82     @parameters.setter
  83     def parameters(self, value: Optional[Dict[str, ParameterContainer]]) -> None:
  84         self._parameters = value
  85 
  86     @property
  87     def rule_domain_builder_execution_time(self) -> float:
  88         return self._rule_domain_builder_execution_time
  89 
  90     @rule_domain_builder_execution_time.setter
  91     def rule_domain_builder_execution_time(self, value: float) -> None:
  92         self._rule_domain_builder_execution_time = value
  93 
  94     @property
  95     def rule_execution_time(self) -> float:
  96         return self._rule_execution_time
  97 
  98     @rule_execution_time.setter
  99     def rule_execution_time(self, value: float) -> None:
  100         self._rule_execution_time = value
  101 
  102     def reset(self) -> None:
  103         self.reset_domains()
  104         self.reset_parameter_containers()
  105 
  106     def reset_domains(self) -> None:
  107         self.domains = []
  108 
  109     def reset_parameter_containers(self) -> None:
  110         self.parameters = {}
  111 
  112     def add_domain(
  113         self,
  114         domain: Domain,
  115         allow_duplicates: bool = False,
  116     ) -> None:
  117         domain_cursor: Domain
  118         if not allow_duplicates and domain.id in [
  119             domain_cursor.id for domain_cursor in self.domains
  120         ]:
  121             raise ge_exceptions.ProfilerConfigurationError(
  122                 f"""Error: Domain\n{domain}\nalready exists.  In order to add it, either pass "allow_duplicates=True" \
  123 or call "RuleState.remove_domain_if_exists()" with Domain having ID equal to "{domain.id}" as argument first.
  124 """
  125             )
  126         self.domains.append(domain)
  127 
  128     def remove_domain_if_exists(self, domain: Domain) -> None:
  129         domain_cursor: Domain
  130         if domain.id in [domain_cursor.id for domain_cursor in self.domains]:
  131             self.domains.remove(domain)
  132             self.remove_domain_if_exists(domain=domain)
  133 
  134     def get_domains_as_dict(self) -> Dict[str, Domain]:
  135         domain: Domain
  136         return {domain.id: domain for domain in self.domains}
  137 
  138     def initialize_parameter_container_for_domain(
  139         self,
  140         domain: Domain,
  141         overwrite: bool = True,
  142     ) -> None:
  143         if not overwrite and domain.id in self.parameters:
  144             raise ge_exceptions.ProfilerConfigurationError(
  145                 f"""Error: ParameterContainer for Domain\n{domain}\nalready exists.  In order to overwrite it, either \
  146 pass "overwrite=True" or call "RuleState.remove_parameter_container_from_domain()" with Domain having ID equal to \
  147 "{domain.id}" as argument first.
  148 """
  149             )
  150 
  151         parameter_container = ParameterContainer(parameter_nodes=None)
  152         self._parameters[domain.id] = parameter_container
  153 
  154     def remove_parameter_container_from_domain_if_exists(self, domain: Domain) -> None:
  155         self.parameters.pop(domain.id, None)
  156
  ```
  --- END FILES ---
  
  Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.
  
  Here is an example:
  
  ```diff
  diff --git a/examples/server_async.py b/examples/server_async.py
  --- a/examples/server_async.py
  +++ b/examples/server_async.py
  @@ -313,4 +313,4 @@
   
   
   if __name__ == "__main__":
  -    asyncio.run(run_async_server("."), debug=True)
  +    asyncio.run(run_async_server(), debug=True)
  diff --git a/examples/server_sync.py b/examples/server_sync.py
  --- a/examples/server_sync.py
  +++ b/examples/server_sync.py
  @@ -313,5 +313,5 @@
   
   
   if __name__ == "__main__":
  -    server = run_sync_server(".")
  +    server = run_sync_server()
       server.shutdown()
  
  ```
  
golden_diff: diff --git a/great_expectations/rule_based_profiler/rule_state.py b/great_expectations/rule_based_profiler/rule_state.py
  --- a/great_expectations/rule_based_profiler/rule_state.py
  +++ b/great_expectations/rule_based_profiler/rule_state.py
  @@ -23,26 +23,26 @@
       def __init__(
           self,
           rule: Optional[Rule] = None,
  -        variables: Optional[ParameterContainer] = None,
           domains: Optional[List[Domain]] = None,
  +        variables: Optional[ParameterContainer] = None,
           parameters: Optional[Dict[str, ParameterContainer]] = None,
       ) -> None:
           """
           Args:
               rule: Rule object for which present RuleState object corresponds (needed for various Rule properties).
  -            variables: attribute name/value pairs (part of state, relevant for associated Rule).
               domains: List of Domain objects, which DomainBuilder of associated Rule generated.
  +            variables: attribute name/value pairs (part of state, relevant for associated Rule).
               parameters: Dictionary of ParameterContainer objects corresponding to all Domain objects in memory.
           """
           self._rule = rule
   
  -        self._variables = variables
  -
           if domains is None:
               domains = []
   
           self._domains = domains
   
  +        self._variables = variables
  +
           if parameters is None:
               parameters = {}
   
  @@ -59,14 +59,6 @@
       def rule(self, value: Rule) -> None:
           self._rule = value
   
  -    @property
  -    def variables(self) -> Optional[ParameterContainer]:
  -        return self._variables
  -
  -    @variables.setter
  -    def variables(self, value: Optional[ParameterContainer]) -> None:
  -        self._variables = value
  -
       @property
       def domains(self) -> List[Domain]:
           return self._domains
  @@ -75,6 +67,14 @@
       def domains(self, value: Optional[List[Domain]]) -> None:
           self._domains = value
   
  +    @property
  +    def variables(self) -> Optional[ParameterContainer]:
  +        return self._variables
  +
  +    @variables.setter
  +    def variables(self, value: Optional[ParameterContainer]) -> None:
  +        self._variables = value
  +
       @property
       def parameters(self) -> Dict[str, ParameterContainer]:
           return self._parameters
  @@ -123,6 +123,7 @@
   or call "RuleState.remove_domain_if_exists()" with Domain having ID equal to "{domain.id}" as argument first.
   """
               )
  +
           self.domains.append(domain)
   
       def remove_domain_if_exists(self, domain: Domain) -> None:
  
verification_info: {"golden_diff": "diff --git a/great_expectations/rule_based_profiler/rule_state.py b/great_expectations/rule_based_profiler/rule_state.py\n--- a/great_expectations/rule_based_profiler/rule_state.py\n+++ b/great_expectations/rule_based_profiler/rule_state.py\n@@ -23,26 +23,26 @@\n     def __init__(\n         self,\n         rule: Optional[Rule] = None,\n-        variables: Optional[ParameterContainer] = None,\n         domains: Optional[List[Domain]] = None,\n+        variables: Optional[ParameterContainer] = None,\n         parameters: Optional[Dict[str, ParameterContainer]] = None,\n     ) -> None:\n         \"\"\"\n         Args:\n             rule: Rule object for which present RuleState object corresponds (needed for various Rule properties).\n-            variables: attribute name/value pairs (part of state, relevant for associated Rule).\n             domains: List of Domain objects, which DomainBuilder of associated Rule generated.\n+            variables: attribute name/value pairs (part of state, relevant for associated Rule).\n             parameters: Dictionary of ParameterContainer objects corresponding to all Domain objects in memory.\n         \"\"\"\n         self._rule = rule\n \n-        self._variables = variables\n-\n         if domains is None:\n             domains = []\n \n         self._domains = domains\n \n+        self._variables = variables\n+\n         if parameters is None:\n             parameters = {}\n \n@@ -59,14 +59,6 @@\n     def rule(self, value: Rule) -> None:\n         self._rule = value\n \n-    @property\n-    def variables(self) -> Optional[ParameterContainer]:\n-        return self._variables\n-\n-    @variables.setter\n-    def variables(self, value: Optional[ParameterContainer]) -> None:\n-        self._variables = value\n-\n     @property\n     def domains(self) -> List[Domain]:\n         return self._domains\n@@ -75,6 +67,14 @@\n     def domains(self, value: Optional[List[Domain]]) -> None:\n         self._domains = value\n \n+    @property\n+    def variables(self) -> Optional[ParameterContainer]:\n+        return self._variables\n+\n+    @variables.setter\n+    def variables(self, value: Optional[ParameterContainer]) -> None:\n+        self._variables = value\n+\n     @property\n     def parameters(self) -> Dict[str, ParameterContainer]:\n         return self._parameters\n@@ -123,6 +123,7 @@\n or call \"RuleState.remove_domain_if_exists()\" with Domain having ID equal to \"{domain.id}\" as argument first.\n \"\"\"\n             )\n+\n         self.domains.append(domain)\n \n     def remove_domain_if_exists(self, domain: Domain) -> None:\n", "issue": "Use cleaner solution for non-truncating division in python 2\nPrefer `from __future__ import division` to `1.*x/y`\n", "before_files": [{"content": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, Dict, List, Optional\n\nimport great_expectations.exceptions as ge_exceptions\nfrom great_expectations.rule_based_profiler.domain import Domain\nfrom great_expectations.rule_based_profiler.parameter_container import (\n    ParameterContainer,\n)\n\nif TYPE_CHECKING:\n    from great_expectations.rule_based_profiler.rule.rule import Rule\n\n\nclass RuleState:\n    \"\"\"\n    RuleState maintains state information, resulting from executing \"Rule.run()\" method by combining passed \"Batch\" data\n    with currently loaded configuration of \"Rule\" components (\"DomainBuilder\" object, \"ParameterBuilder\" objects, and\n    \"ExpectationConfigurationBuilder\" objects).  Using \"RuleState\" with correponding flags is sufficient for generating\n    outputs for different purposes (in raw and aggregated form) from available \"Domain\" objects and computed parameters.\n    \"\"\"\n\n    def __init__(\n        self,\n        rule: Optional[Rule] = None,\n        variables: Optional[ParameterContainer] = None,\n        domains: Optional[List[Domain]] = None,\n        parameters: Optional[Dict[str, ParameterContainer]] = None,\n    ) -> None:\n        \"\"\"\n        Args:\n            rule: Rule object for which present RuleState object corresponds (needed for various Rule properties).\n            variables: attribute name/value pairs (part of state, relevant for associated Rule).\n            domains: List of Domain objects, which DomainBuilder of associated Rule generated.\n            parameters: Dictionary of ParameterContainer objects corresponding to all Domain objects in memory.\n        \"\"\"\n        self._rule = rule\n\n        self._variables = variables\n\n        if domains is None:\n            domains = []\n\n        self._domains = domains\n\n        if parameters is None:\n            parameters = {}\n\n        self._parameters = parameters\n\n        self._rule_domain_builder_execution_time = 0.0\n        self._rule_execution_time = 0.0\n\n    @property\n    def rule(self) -> Optional[Rule]:\n        return self._rule\n\n    @rule.setter\n    def rule(self, value: Rule) -> None:\n        self._rule = value\n\n    @property\n    def variables(self) -> Optional[ParameterContainer]:\n        return self._variables\n\n    @variables.setter\n    def variables(self, value: Optional[ParameterContainer]) -> None:\n        self._variables = value\n\n    @property\n    def domains(self) -> List[Domain]:\n        return self._domains\n\n    @domains.setter\n    def domains(self, value: Optional[List[Domain]]) -> None:\n        self._domains = value\n\n    @property\n    def parameters(self) -> Dict[str, ParameterContainer]:\n        return self._parameters\n\n    @parameters.setter\n    def parameters(self, value: Optional[Dict[str, ParameterContainer]]) -> None:\n        self._parameters = value\n\n    @property\n    def rule_domain_builder_execution_time(self) -> float:\n        return self._rule_domain_builder_execution_time\n\n    @rule_domain_builder_execution_time.setter\n    def rule_domain_builder_execution_time(self, value: float) -> None:\n        self._rule_domain_builder_execution_time = value\n\n    @property\n    def rule_execution_time(self) -> float:\n        return self._rule_execution_time\n\n    @rule_execution_time.setter\n    def rule_execution_time(self, value: float) -> None:\n        self._rule_execution_time = value\n\n    def reset(self) -> None:\n        self.reset_domains()\n        self.reset_parameter_containers()\n\n    def reset_domains(self) -> None:\n        self.domains = []\n\n    def reset_parameter_containers(self) -> None:\n        self.parameters = {}\n\n    def add_domain(\n        self,\n        domain: Domain,\n        allow_duplicates: bool = False,\n    ) -> None:\n        domain_cursor: Domain\n        if not allow_duplicates and domain.id in [\n            domain_cursor.id for domain_cursor in self.domains\n        ]:\n            raise ge_exceptions.ProfilerConfigurationError(\n                f\"\"\"Error: Domain\\n{domain}\\nalready exists.  In order to add it, either pass \"allow_duplicates=True\" \\\nor call \"RuleState.remove_domain_if_exists()\" with Domain having ID equal to \"{domain.id}\" as argument first.\n\"\"\"\n            )\n        self.domains.append(domain)\n\n    def remove_domain_if_exists(self, domain: Domain) -> None:\n        domain_cursor: Domain\n        if domain.id in [domain_cursor.id for domain_cursor in self.domains]:\n            self.domains.remove(domain)\n            self.remove_domain_if_exists(domain=domain)\n\n    def get_domains_as_dict(self) -> Dict[str, Domain]:\n        domain: Domain\n        return {domain.id: domain for domain in self.domains}\n\n    def initialize_parameter_container_for_domain(\n        self,\n        domain: Domain,\n        overwrite: bool = True,\n    ) -> None:\n        if not overwrite and domain.id in self.parameters:\n            raise ge_exceptions.ProfilerConfigurationError(\n                f\"\"\"Error: ParameterContainer for Domain\\n{domain}\\nalready exists.  In order to overwrite it, either \\\npass \"overwrite=True\" or call \"RuleState.remove_parameter_container_from_domain()\" with Domain having ID equal to \\\n\"{domain.id}\" as argument first.\n\"\"\"\n            )\n\n        parameter_container = ParameterContainer(parameter_nodes=None)\n        self._parameters[domain.id] = parameter_container\n\n    def remove_parameter_container_from_domain_if_exists(self, domain: Domain) -> None:\n        self.parameters.pop(domain.id, None)\n", "path": "great_expectations/rule_based_profiler/rule_state.py"}], "after_files": [{"content": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, Dict, List, Optional\n\nimport great_expectations.exceptions as ge_exceptions\nfrom great_expectations.rule_based_profiler.domain import Domain\nfrom great_expectations.rule_based_profiler.parameter_container import (\n    ParameterContainer,\n)\n\nif TYPE_CHECKING:\n    from great_expectations.rule_based_profiler.rule.rule import Rule\n\n\nclass RuleState:\n    \"\"\"\n    RuleState maintains state information, resulting from executing \"Rule.run()\" method by combining passed \"Batch\" data\n    with currently loaded configuration of \"Rule\" components (\"DomainBuilder\" object, \"ParameterBuilder\" objects, and\n    \"ExpectationConfigurationBuilder\" objects).  Using \"RuleState\" with correponding flags is sufficient for generating\n    outputs for different purposes (in raw and aggregated form) from available \"Domain\" objects and computed parameters.\n    \"\"\"\n\n    def __init__(\n        self,\n        rule: Optional[Rule] = None,\n        domains: Optional[List[Domain]] = None,\n        variables: Optional[ParameterContainer] = None,\n        parameters: Optional[Dict[str, ParameterContainer]] = None,\n    ) -> None:\n        \"\"\"\n        Args:\n            rule: Rule object for which present RuleState object corresponds (needed for various Rule properties).\n            domains: List of Domain objects, which DomainBuilder of associated Rule generated.\n            variables: attribute name/value pairs (part of state, relevant for associated Rule).\n            parameters: Dictionary of ParameterContainer objects corresponding to all Domain objects in memory.\n        \"\"\"\n        self._rule = rule\n\n        if domains is None:\n            domains = []\n\n        self._domains = domains\n\n        self._variables = variables\n\n        if parameters is None:\n            parameters = {}\n\n        self._parameters = parameters\n\n        self._rule_domain_builder_execution_time = 0.0\n        self._rule_execution_time = 0.0\n\n    @property\n    def rule(self) -> Optional[Rule]:\n        return self._rule\n\n    @rule.setter\n    def rule(self, value: Rule) -> None:\n        self._rule = value\n\n    @property\n    def domains(self) -> List[Domain]:\n        return self._domains\n\n    @domains.setter\n    def domains(self, value: Optional[List[Domain]]) -> None:\n        self._domains = value\n\n    @property\n    def variables(self) -> Optional[ParameterContainer]:\n        return self._variables\n\n    @variables.setter\n    def variables(self, value: Optional[ParameterContainer]) -> None:\n        self._variables = value\n\n    @property\n    def parameters(self) -> Dict[str, ParameterContainer]:\n        return self._parameters\n\n    @parameters.setter\n    def parameters(self, value: Optional[Dict[str, ParameterContainer]]) -> None:\n        self._parameters = value\n\n    @property\n    def rule_domain_builder_execution_time(self) -> float:\n        return self._rule_domain_builder_execution_time\n\n    @rule_domain_builder_execution_time.setter\n    def rule_domain_builder_execution_time(self, value: float) -> None:\n        self._rule_domain_builder_execution_time = value\n\n    @property\n    def rule_execution_time(self) -> float:\n        return self._rule_execution_time\n\n    @rule_execution_time.setter\n    def rule_execution_time(self, value: float) -> None:\n        self._rule_execution_time = value\n\n    def reset(self) -> None:\n        self.reset_domains()\n        self.reset_parameter_containers()\n\n    def reset_domains(self) -> None:\n        self.domains = []\n\n    def reset_parameter_containers(self) -> None:\n        self.parameters = {}\n\n    def add_domain(\n        self,\n        domain: Domain,\n        allow_duplicates: bool = False,\n    ) -> None:\n        domain_cursor: Domain\n        if not allow_duplicates and domain.id in [\n            domain_cursor.id for domain_cursor in self.domains\n        ]:\n            raise ge_exceptions.ProfilerConfigurationError(\n                f\"\"\"Error: Domain\\n{domain}\\nalready exists.  In order to add it, either pass \"allow_duplicates=True\" \\\nor call \"RuleState.remove_domain_if_exists()\" with Domain having ID equal to \"{domain.id}\" as argument first.\n\"\"\"\n            )\n\n        self.domains.append(domain)\n\n    def remove_domain_if_exists(self, domain: Domain) -> None:\n        domain_cursor: Domain\n        if domain.id in [domain_cursor.id for domain_cursor in self.domains]:\n            self.domains.remove(domain)\n            self.remove_domain_if_exists(domain=domain)\n\n    def get_domains_as_dict(self) -> Dict[str, Domain]:\n        domain: Domain\n        return {domain.id: domain for domain in self.domains}\n\n    def initialize_parameter_container_for_domain(\n        self,\n        domain: Domain,\n        overwrite: bool = True,\n    ) -> None:\n        if not overwrite and domain.id in self.parameters:\n            raise ge_exceptions.ProfilerConfigurationError(\n                f\"\"\"Error: ParameterContainer for Domain\\n{domain}\\nalready exists.  In order to overwrite it, either \\\npass \"overwrite=True\" or call \"RuleState.remove_parameter_container_from_domain()\" with Domain having ID equal to \\\n\"{domain.id}\" as argument first.\n\"\"\"\n            )\n\n        parameter_container = ParameterContainer(parameter_nodes=None)\n        self._parameters[domain.id] = parameter_container\n\n    def remove_parameter_container_from_domain_if_exists(self, domain: Domain) -> None:\n        self.parameters.pop(domain.id, None)\n", "path": "great_expectations/rule_based_profiler/rule_state.py"}]}