rhayes777__pyautofit-888

Attempt 1

git ls-files -z

find /PyAutoFit -name "sensitivity.py" 2>/dev/null

find /PyAutoFit -path "*/grid/sensitivity.py" 2>/dev/null

ls -la /PyAutoFit/autofit/non_linear/grid/ 2>/dev/null || find /PyAutoFit -type d -name "grid" 2>/dev/null

ls -la /PyAutoFit/autofit/non_linear/grid/sensitivity/

find /PyAutoFit -name "sensitivity.py" -type f 2>/dev/null

ls -la /PyAutoFit/autofit/non_linear/grid/

ls -la /PyAutoFit/autofit/non_linear/grid/sensitivity/

find /PyAutoFit -name "*.py" | xargs grep -l "class Sensitivity" 2>/dev/null

head -100 /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

wc -l /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '280,310p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '200,280p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '1,100p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

grep -n "step_size" /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '170,200p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

find /PyAutoFit -path "*/test*sensitivity*" -name "*.py" 2>/dev/null

grep -n "tuple_steps\|test_models_with_tuple_steps\|test_jobs_with_tuple_steps" /PyAutoFit/test_autofit/non_linear/grid/test_sensitivity/test_functionality.py

sed -n '130,160p' /PyAutoFit/test_autofit/non_linear/grid/test_sensitivity/test_functionality.py

grep -n "def make_lists" /PyAutoFit/autofit/non_linear/grid/grid_search.py

find /PyAutoFit -name "grid_search.py" -type f

find /PyAutoFit -path "*/grid_search*" -name "*.py" type f

find /PyAutoFit -name "grid_search.py"

ls -la /PyAutoFit/autofit/non_linear/grid/grid_search/ 2>/dev/null

grep -n "def make_lists" /PyAutoFit/autofit/non_linear/grid/grid_search/__init__.py

sed -n '378,430p' /PyAutoFit/autofit/non_linear/grid/grid_search/__init__.py

sed -n '230,260p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '244,262p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '244,270p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '244,262p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py | cat -A

sed -i '253s/.*/        if isinstance(self.step_size, tuple):\n            half_step = tuple(\n                self.limit_scale * step / 2 for step in self.step_size\n        )\n        else:\n            half_step = self.limit_scale * self.step_size / 2/' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

python3 << 'EOF'
with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'r') as f:
    lines = f.readlines()

# Find the line with "half_step = self.limit_scale * self.step_size / 2"
# It should be around line 253 (0-indexed: 252)
for i, line in enumerate(lines):
    if 'half_step = self.limit_scale * self.step_size / 2' in line:
        print(f"Found at line {i+1}: {repr(line)}")
        # Replace this line and the next few lines
        # Original lines 253-261 (1-indexed):
        # 253:         half_step = self.limit_scale * self.step_size / 2
        # 254:         for list_ in self._lists:
        # 255:             limits = [
        # 256:                 (
        # 257:                     prior.value_for(max(0.0, centre - half_step)),
        # 258:                     prior.value_for(min(1.0, centre + half_step)),
        # 259:                 )
        # 260:                 for centre, prior in zip(list_, self.perturb_model.priors_ordered_by_id)
        # 261:             ]
        # 262:             yield self.perturb_model.with_limits(limits)
        
        new_code = '''        if isinstance(self.step_size, tuple):
            half_step = tuple(
                self.limit_scale * step / 2 for step in self.step_size
            )
        else:
            half_step = self.limit_scale * self.step_size / 2
        for list_ in self._lists:
            limits = [
                (
                    prior.value_for(max(0.0, centre - half_step[i])),
                    prior.value_for(min(1.0, centre + half_step[i])),
                )
                for i, (centre, prior) in enumerate(zip(list_, self.perturb_model.priors_ordered_by_id))
            ]
            yield self.perturb_model.with_limits(limits)'''
        
        # Replace lines 253-262 (0-indexed: 252-261)
        lines[252:262] = [new_code + '\n']
        break

with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'w') as f:
    f.writelines(lines)

print("Done!")
EOF

sed -n '250,275p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

sed -n '244,280p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

git -C /PyAutoFit checkout -- autofit/non_linear/grid/sensitivity/__init__.py 2>/dev/null || echo "Not a git repo or file not tracked"

git -C /PyAutoFit status 2>&1 | head -20

git -C /PyAutoFit log --oneline -5

git -C /PyAutoFit restore autofit/non_linear/grid/sensitivity/__init__.py

sed -n '244,265p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

python3 << 'PYEOF'
with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'r') as f:
    content = f.read()

# The old code to replace
old_code = '''        half_step = self.limit_scale * self.step_size / 2
        for list_ in self._lists:
            limits = [
                (
                    prior.value_for(max(0.0, centre - half_step)),
                    prior.value_for(min(1.0, centre + half_step)),
                )
                for centre, prior in zip(list_, self.perturb_model.priors_ordered_by_id)
            ]
            yield self.perturb_model.with_limits(limits)'''

# The new code
new_code = '''        if isinstance(self.step_size, tuple):
            half_step = tuple(
                self.limit_scale * step / 2 for step in self.step_size
            )
        else:
            half_step = self.limit_scale * self.step_size / 2
        for list_ in self._lists:
            limits = [
                (
                    prior.value_for(max(0.0, centre - half_step[i])),
                    prior.value_for(min(1.0, centre + half_step[i])),
                )
                for i, (centre, prior) in enumerate(zip(list_, self.perturb_model.priors_ordered_by_id))
            ]
            yield self.perturb_model.with_limits(limits)'''

if old_code in content:
    new_content = content.replace(old_code, new_code)
    with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'w') as f:
        f.write(new_content)
    print("Successfully replaced the code")
else:
    print("Could not find the old code pattern")
    # Let's debug what's actually there
    idx = content.find('half_step = self.limit_scale * self.step_size / 2')
    if idx != -1:
        print(f"Found at index {idx}")
        print(repr(content[idx:idx+200]))
PYEOF

sed -n '244,275p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

cd /PyAutoFit && python -m pytest test_autofit/non_linear/grid/test_sensitivity/test_functionality.py::test_models_with_tuple_steps test_autofit/non_linear/grid/test_sensitivity/test_functionality.py::test_jobs_with_tuple_steps -v 2>&1

cd /PyAutoFit && python -m pytest test_autofit/non_linear/grid/test_sensitivity/ -v 2>&1

python3 << 'PYEOF'
with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'r') as f:
    content = f.read()

# The current code to replace
old_code = '''        if isinstance(self.step_size, tuple):
            half_step = tuple(
                self.limit_scale * step / 2 for step in self.step_size
            )
        else:
            half_step = self.limit_scale * self.step_size / 2
        for list_ in self._lists:
            limits = [
                (
                    prior.value_for(max(0.0, centre - half_step[i])),
                    prior.value_for(min(1.0, centre + half_step[i])),
                )
                for i, (centre, prior) in enumerate(zip(list_, self.perturb_model.priors_ordered_by_id))
            ]
            yield self.perturb_model.with_limits(limits)'''

# New code that handles both cases
new_code = '''        if isinstance(self.step_size, tuple):
            half_step = tuple(
                self.limit_scale * step / 2 for step in self.step_size
            )
        else:
            half_step = self.limit_scale * self.step_size / 2
        for list_ in self._lists:
            if isinstance(half_step, tuple):
                limits = [
                    (
                        prior.value_for(max(0.0, centre - half_step[i])),
                        prior.value_for(min(1.0, centre + half_step[i])),
                    )
                    for i, (centre, prior) in enumerate(zip(list_, self.perturb_model.priors_ordered_by_id))
                ]
            else:
                limits = [
                    (
                        prior.value_for(max(0.0, centre - half_step)),
                        prior.value_for(min(1.0, centre + half_step)),
                    )
                    for centre, prior in zip(list_, self.perturb_model.priors_ordered_by_id)
                ]
            yield self.perturb_model.with_limits(limits)'''

if old_code in content:
    new_content = content.replace(old_code, new_code)
    with open('/PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py', 'w') as f:
        f.write(new_content)
    print("Successfully replaced the code")
else:
    print("Could not find the old code pattern")
PYEOF

sed -n '244,280p' /PyAutoFit/autofit/non_linear/grid/sensitivity/__init__.py

cd /PyAutoFit && python -m pytest test_autofit/non_linear/grid/test_sensitivity/ -v 2>&1

cd /PyAutoFit && python -m pytest test_autofit/non_linear/grid/test_sensitivity/test_functionality.py::test_models_with_tuple_steps test_autofit/non_linear/grid/test_sensitivity/test_functionality.py::test_jobs_with_tuple_steps -v 2>&1

cd /PyAutoFit && git diff --stat

compute patch in executor staging agent1-8ba1646cd7134af4a49867a107dea542: /opt/homebrew/Cellar/git/2.53.0/bin/git -c core.hooksPath=/dev/null -c core.attributesFile=/dev/null -c diff.external= -c core.quotePath=false add -A && /opt/homebrew/Cellar/git/2.53.0/bin/git -c core.hooksPath=/dev/null -c core.attributesFile=/dev/null -c diff.external= -c core.quotePath=false diff --cached --binary --no-ext-diff --no-textconv --no-renames d564f29a393b75747f1ec3da7c51070d2e12cda1

git update-index -q --refresh; git apply -v --3way --recount --ignore-space-change --whitespace=nowarn /opt/receipts-63dec0c50b47409cb0a4d48c63d9df94/incoming/8cb6aa53dc452db2b185d041f98790c0570a38ff8a1cdff674a82e2209791a25.diff

/opt/receipts-f96a81a4ec4749a2857e93ecbb04c8ed/bin/busybox mkdir -p /opt/receipts/reports && python -I /opt/receipts-f96a81a4ec4749a2857e93ecbb04c8ed/receipts_pytest.py --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning test_autofit/non_linear/grid/test_sensitivity/test_functionality.py -o junit_family=xunit1 -p no:cacheprovider -rA --continue-on-collection-errors --junitxml=/opt/receipts/reports/w1-2.xml

Shipped patch

diff --git a/autofit/non_linear/grid/sensitivity/__init__.py b/autofit/non_linear/grid/sensitivity/__init__.pyindex fa19768c..01d20592 100644--- a/autofit/non_linear/grid/sensitivity/__init__.py+++ b/autofit/non_linear/grid/sensitivity/__init__.py@@ -1,301 +1,315 @@-import csv-import logging-import os-from copy import copy-from pathlib import Path-from typing import List, Generator, Callable, ClassVar, Optional, Union, Tuple--from autoconf.dictable import to_dict-from autofit.mapper.model import ModelInstance-from autofit.mapper.prior_model.abstract import AbstractPriorModel-from autofit.non_linear.grid.grid_search import make_lists, Sequential-from autofit.non_linear.grid.sensitivity.job import Job-from autofit.non_linear.grid.sensitivity.job import JobResult-from autofit.non_linear.grid.sensitivity.result import SensitivityResult-from autofit.non_linear.parallel import Process-from autofit.text.text_util import padding--class Sensitivity:-    def __init__(-        self,-        base_model: AbstractPriorModel,-        perturb_model: AbstractPriorModel,-        simulation_instance,-        paths,-        simulate_cls: Callable,-        base_fit_cls: Callable,-        perturb_fit_cls: Callable,-        job_cls: ClassVar = Job,-        perturb_model_prior_func : Optional[Callable] = None,-        number_of_steps: Union[Tuple[int, ...], int] = 4,-        number_of_cores: int = 2,-        limit_scale: int = 1,-    ):-        """-        Perform sensitivity mapping to evaluate whether a perturbation-        can be detected if it occurs in different parts of an image.--        For a range from 0 to 1 with step_size, for each dimension of the-        perturb_model, a perturbation is created and used in conjunction-        with the instance to create an image.--        For each of these images, a fit is run with just the model and with both-        the model and perturb_model to compare how much better the image-        can be fit if the perturbation is included.--        Parameters-        -----------        base_model-            A model that fits the instance well-        perturb_model-            A model which provides a perturbations to be applied to the instance-            before creating images-        simulation_instance-            An instance of a model to which perturbations are applied prior to-            images being generated-        simulate_cls-            A class which simulates images from each perturb instance that sensitivity mapping is performed on.-        base_fit_cls-            The class which fits the base model to each simulated dataset of the sensitivity map.-        perturb_fit_cls-            The class which fits the perturb model to each simulated dataset of the sensitivity map.-        number_of_steps-            The number of steps for each dimension of the sensitivity grid. If input as a float the dimensions are-            all that value. If input as a tuple of length the number of dimensions, each tuple value is the number of-            steps in that dimension.-        number_of_cores-            How many cores does this computer have?-        limit_scale-            Scales the priors for each perturbation model.-                A scale of 1 means priors have limits the same size as the grid square.-                A scale of 2 means priors have limits larger than the grid square with-                    width twice a grid square.-                A scale of 0.5 means priors have limits smaller than the grid square-                    with width half a grid square.-        """-        self.logger = logging.getLogger(f"Sensitivity ({paths.name})")--        self.logger.info("Creating")--        self.instance = simulation_instance-        self.model = base_model-        self.perturb_model = perturb_model--        self.paths = paths--        self.simulate_cls = simulate_cls-        self.base_fit_cls = base_fit_cls-        self.perturb_fit_cls = perturb_fit_cls--        self.perturb_model_prior_func = perturb_model_prior_func--        self.job_cls = job_cls--        self.number_of_steps = number_of_steps-        self.number_of_cores = number_of_cores--        self.limit_scale = limit_scale--    def run(self) -> SensitivityResult:-        """-        Run fits and comparisons for all perturbations, returning-        a list of results.-        """-        self.logger.info("Running")--        self.paths.save_unique_tag(is_grid_search=True)--        headers = [-            "index",-            *self._headers,-            "log_evidence_increase",-            "log_likelihood_increase",-        ]-        physical_values = list(self._physical_values)--        process_class = Process if self.number_of_cores > 1 else Sequential--        results = list()-        for result in process_class.run_jobs(-            self._make_jobs(), number_of_cores=self.number_of_cores-        ):-            if isinstance(result, Exception):-                raise result--            results.append(result)-            results = sorted(results)--            os.makedirs(self.paths.output_path, exist_ok=True)-            with open(self.results_path, "w+") as f:-                writer = csv.writer(f)-                writer.writerow(headers)-                for result_ in results:--                    values = physical_values[result_.number]-                    writer.writerow(-                        padding(item)-                        for item in [-                            result_.number,-                            *values,-                            result_.log_evidence_increase,-                            result_.log_likelihood_increase,-                        ]-                    )--        result = SensitivityResult(-            samples=[result.result.samples.summary() for result in results],-            perturb_samples=[result.perturb_result.samples.summary() for result in results],-            shape=self.shape-        )--        self.paths.save_json("result", to_dict(result))--        return result--    @property-    def shape(self) -> Tuple[int, ...]:-        """-        Returns the shape of the sensitivity grid.--        The shape is the number of steps performed for each dimension of the `perturb_model`. If sensitivity mapping-        is performed in 3D, the shape will therefore be a tuple of length 3.--        The `shape` can vary across dimensions if the `number_of_steps` parameter is input as a tuple.--        Returns-        --------        The shape of the sensitivity grid.-        """--        if isinstance(self.number_of_steps, tuple):-            return self.number_of_steps--        return tuple(self.number_of_steps for _ in range(self.perturb_model.prior_count))--    @property-    def step_size(self) -> Union[float, Tuple]:-        """-        Returns-        --------        step_size-            The size of a step in any given dimension in hyper space.-        """-        if isinstance(self.number_of_steps, tuple):-            return tuple(1 / number_of_steps for number_of_steps in self.number_of_steps)-        return 1 / self.number_of_steps--    @property-    def results_path(self) -> Path:-        return self.paths.output_path / "results.csv"--    @property-    def _lists(self) -> List[List[float]]:-        """-        A list of hypercube vectors, used to instantiate-        the perturb_model and create the individual-        perturbations.-        """-        return make_lists(self.perturb_model.prior_count, step_size=self.step_size)--    @property-    def _physical_values(self) -> List[List[float]]:-        """-        Lists of physical values for each grid square-        """-        return [-            [-                prior.value_for(unit_value)-                for prior, unit_value in zip(-                    self.perturb_model.priors_ordered_by_id, unit_values-                )-            ]-            for unit_values in self._lists-        ]--    @property-    def _headers(self) -> Generator[str, None, None]:-        """-        A name for each of the perturb priors-        """-        for path, _ in self.perturb_model.prior_tuples:-            yield path--    @property-    def _labels(self) -> Generator[str, None, None]:-        """-        One label for each perturbation, used to distinguish-        fits for each perturbation by placing them in separate-        directories.-        """-        for list_ in self._lists:-            strings = list()-            for value, prior_tuple in zip(list_, self.perturb_model.prior_tuples):-                path, prior = prior_tuple-                value = prior.value_for(value)-                strings.append(f"{path}_{value}")-            yield "_".join(strings)--    @property-    def _perturb_instances(self) -> Generator[ModelInstance, None, None]:-        """-        A list of instances each of which defines a perturbation to-        be applied to the image.-        """-        for list_ in self._lists:-            yield self.perturb_model.instance_from_unit_vector(list_)--    @property-    def _perturb_models(self) -> Generator[AbstractPriorModel, None, None]:-        """-        A list of models representing a perturbation at each grid square.--        By default models have priors with limits at the edges of a grid square.-        These limits can be scaled using the limit_scale variable. If the variable-        is 2 then the priors will have width twice the step size.-        """-        half_step = self.limit_scale * self.step_size / 2-        for list_ in self._lists:-            limits = [-                (-                    prior.value_for(max(0.0, centre - half_step)),-                    prior.value_for(min(1.0, centre + half_step)),-                )-                for centre, prior in zip(list_, self.perturb_model.priors_ordered_by_id)-            ]-            yield self.perturb_model.with_limits(limits)--    def _make_jobs(self) -> Generator[Job, None, None]:-        """-        Create a list of jobs to be run on separate processes.--        Each job fits a perturb image with the original model-        and a model which includes a perturbation.-        """-        for number, (perturb_instance, perturb_model, label) in enumerate(-            zip(self._perturb_instances, self._perturb_models, self._labels)-        ):--            if self.perturb_model_prior_func is not None:-                perturb_model = self.perturb_model_prior_func(-                    perturb_instance=perturb_instance,-                    perturb_model=perturb_model-                )--            simulate_instance = copy(self.instance)-            simulate_instance.perturb = perturb_instance--            paths = self.paths.for_sub_analysis(-                label,-            )--            yield self.job_cls(-                simulate_instance=simulate_instance,-                model=self.model,-                perturb_model=perturb_model,-                base_instance=self.instance,-                simulate_cls=self.simulate_cls,-                base_fit_cls=self.base_fit_cls,-                perturb_fit_cls=self.perturb_fit_cls,-                paths=paths,-                number=number,+import csv+import logging+import os+from copy import copy+from pathlib import Path+from typing import List, Generator, Callable, ClassVar, Optional, Union, Tuple++from autoconf.dictable import to_dict+from autofit.mapper.model import ModelInstance+from autofit.mapper.prior_model.abstract import AbstractPriorModel+from autofit.non_linear.grid.grid_search import make_lists, Sequential+from autofit.non_linear.grid.sensitivity.job import Job+from autofit.non_linear.grid.sensitivity.job import JobResult+from autofit.non_linear.grid.sensitivity.result import SensitivityResult+from autofit.non_linear.parallel import Process+from autofit.text.text_util import padding++class Sensitivity:+    def __init__(+        self,+        base_model: AbstractPriorModel,+        perturb_model: AbstractPriorModel,+        simulation_instance,+        paths,+        simulate_cls: Callable,+        base_fit_cls: Callable,+        perturb_fit_cls: Callable,+        job_cls: ClassVar = Job,+        perturb_model_prior_func : Optional[Callable] = None,+        number_of_steps: Union[Tuple[int, ...], int] = 4,+        number_of_cores: int = 2,+        limit_scale: int = 1,+    ):+        """+        Perform sensitivity mapping to evaluate whether a perturbation+        can be detected if it occurs in different parts of an image.++        For a range from 0 to 1 with step_size, for each dimension of the+        perturb_model, a perturbation is created and used in conjunction+        with the instance to create an image.++        For each of these images, a fit is run with just the model and with both+        the model and perturb_model to compare how much better the image+        can be fit if the perturbation is included.++        Parameters+        ----------+        base_model+            A model that fits the instance well+        perturb_model+            A model which provides a perturbations to be applied to the instance+            before creating images+        simulation_instance+            An instance of a model to which perturbations are applied prior to+            images being generated+        simulate_cls+            A class which simulates images from each perturb instance that sensitivity mapping is performed on.+        base_fit_cls+            The class which fits the base model to each simulated dataset of the sensitivity map.+        perturb_fit_cls+            The class which fits the perturb model to each simulated dataset of the sensitivity map.+        number_of_steps+            The number of steps for each dimension of the sensitivity grid. If input as a float the dimensions are+            all that value. If input as a tuple of length the number of dimensions, each tuple value is the number of+            steps in that dimension.+        number_of_cores+            How many cores does this computer have?+        limit_scale+            Scales the priors for each perturbation model.+                A scale of 1 means priors have limits the same size as the grid square.+                A scale of 2 means priors have limits larger than the grid square with+                    width twice a grid square.+                A scale of 0.5 means priors have limits smaller than the grid square+                    with width half a grid square.+        """+        self.logger = logging.getLogger(f"Sensitivity ({paths.name})")++        self.logger.info("Creating")++        self.instance = simulation_instance+        self.model = base_model+        self.perturb_model = perturb_model++        self.paths = paths++        self.simulate_cls = simulate_cls+        self.base_fit_cls = base_fit_cls+        self.perturb_fit_cls = perturb_fit_cls++        self.perturb_model_prior_func = perturb_model_prior_func++        self.job_cls = job_cls++        self.number_of_steps = number_of_steps+        self.number_of_cores = number_of_cores++        self.limit_scale = limit_scale++    def run(self) -> SensitivityResult:+        """+        Run fits and comparisons for all perturbations, returning+        a list of results.+        """+        self.logger.info("Running")++        self.paths.save_unique_tag(is_grid_search=True)++        headers = [+            "index",+            *self._headers,+            "log_evidence_increase",+            "log_likelihood_increase",+        ]+        physical_values = list(self._physical_values)++        process_class = Process if self.number_of_cores > 1 else Sequential++        results = list()+        for result in process_class.run_jobs(+            self._make_jobs(), number_of_cores=self.number_of_cores+        ):+            if isinstance(result, Exception):+                raise result++            results.append(result)+            results = sorted(results)++            os.makedirs(self.paths.output_path, exist_ok=True)+            with open(self.results_path, "w+") as f:+                writer = csv.writer(f)+                writer.writerow(headers)+                for result_ in results:++                    values = physical_values[result_.number]+                    writer.writerow(+                        padding(item)+                        for item in [+                            result_.number,+                            *values,+                            result_.log_evidence_increase,+                            result_.log_likelihood_increase,+                        ]+                    )++        result = SensitivityResult(+            samples=[result.result.samples.summary() for result in results],+            perturb_samples=[result.perturb_result.samples.summary() for result in results],+            shape=self.shape+        )++        self.paths.save_json("result", to_dict(result))++        return result++    @property+    def shape(self) -> Tuple[int, ...]:+        """+        Returns the shape of the sensitivity grid.++        The shape is the number of steps performed for each dimension of the `perturb_model`. If sensitivity mapping+        is performed in 3D, the shape will therefore be a tuple of length 3.++        The `shape` can vary across dimensions if the `number_of_steps` parameter is input as a tuple.++        Returns+        -------+        The shape of the sensitivity grid.+        """++        if isinstance(self.number_of_steps, tuple):+            return self.number_of_steps++        return tuple(self.number_of_steps for _ in range(self.perturb_model.prior_count))++    @property+    def step_size(self) -> Union[float, Tuple]:+        """+        Returns+        -------+        step_size+            The size of a step in any given dimension in hyper space.+        """+        if isinstance(self.number_of_steps, tuple):+            return tuple(1 / number_of_steps for number_of_steps in self.number_of_steps)+        return 1 / self.number_of_steps++    @property+    def results_path(self) -> Path:+        return self.paths.output_path / "results.csv"++    @property+    def _lists(self) -> List[List[float]]:+        """+        A list of hypercube vectors, used to instantiate+        the perturb_model and create the individual+        perturbations.+        """+        return make_lists(self.perturb_model.prior_count, step_size=self.step_size)++    @property+    def _physical_values(self) -> List[List[float]]:+        """+        Lists of physical values for each grid square+        """+        return [+            [+                prior.value_for(unit_value)+                for prior, unit_value in zip(+                    self.perturb_model.priors_ordered_by_id, unit_values+                )+            ]+            for unit_values in self._lists+        ]++    @property+    def _headers(self) -> Generator[str, None, None]:+        """+        A name for each of the perturb priors+        """+        for path, _ in self.perturb_model.prior_tuples:+            yield path++    @property+    def _labels(self) -> Generator[str, None, None]:+        """+        One label for each perturbation, used to distinguish+        fits for each perturbation by placing them in separate+        directories.+        """+        for list_ in self._lists:+            strings = list()+            for value, prior_tuple in zip(list_, self.perturb_model.prior_tuples):+                path, prior = prior_tuple+                value = prior.value_for(value)+                strings.append(f"{path}_{value}")+            yield "_".join(strings)++    @property+    def _perturb_instances(self) -> Generator[ModelInstance, None, None]:+        """+        A list of instances each of which defines a perturbation to+        be applied to the image.+        """+        for list_ in self._lists:+            yield self.perturb_model.instance_from_unit_vector(list_)++    @property+    def _perturb_models(self) -> Generator[AbstractPriorModel, None, None]:+        """+        A list of models representing a perturbation at each grid square.++        By default models have priors with limits at the edges of a grid square.+        These limits can be scaled using the limit_scale variable. If the variable+        is 2 then the priors will have width twice the step size.+        """+        if isinstance(self.step_size, tuple):+            half_step = tuple(+                self.limit_scale * step / 2 for step in self.step_size+            )+        else:+            half_step = self.limit_scale * self.step_size / 2+        for list_ in self._lists:+            if isinstance(half_step, tuple):+                limits = [+                    (+                        prior.value_for(max(0.0, centre - half_step[i])),+                        prior.value_for(min(1.0, centre + half_step[i])),+                    )+                    for i, (centre, prior) in enumerate(zip(list_, self.perturb_model.priors_ordered_by_id))+                ]+            else:+                limits = [+                    (+                        prior.value_for(max(0.0, centre - half_step)),+                        prior.value_for(min(1.0, centre + half_step)),+                    )+                    for centre, prior in zip(list_, self.perturb_model.priors_ordered_by_id)+                ]+            yield self.perturb_model.with_limits(limits)++    def _make_jobs(self) -> Generator[Job, None, None]:+        """+        Create a list of jobs to be run on separate processes.++        Each job fits a perturb image with the original model+        and a model which includes a perturbation.+        """+        for number, (perturb_instance, perturb_model, label) in enumerate(+            zip(self._perturb_instances, self._perturb_models, self._labels)+        ):++            if self.perturb_model_prior_func is not None:+                perturb_model = self.perturb_model_prior_func(+                    perturb_instance=perturb_instance,+                    perturb_model=perturb_model+                )++            simulate_instance = copy(self.instance)+            simulate_instance.perturb = perturb_instance++            paths = self.paths.for_sub_analysis(+                label,+            )++            yield self.job_cls(+                simulate_instance=simulate_instance,+                model=self.model,+                perturb_model=perturb_model,+                base_instance=self.instance,+                simulate_cls=self.simulate_cls,+                base_fit_cls=self.base_fit_cls,+                perturb_fit_cls=self.perturb_fit_cls,+                paths=paths,+                number=number,             )\ No newline at end of file