tomwer 1.1.0rc7__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/core/process/reconstruction/test/test_utils.py

@@ -1,8 +1,9 @@
+import numpy
+
 from tomwer.core.process.reconstruction.utils.cor import (
-    relative_pos_to_absolute,
     absolute_pos_to_relative,
+    relative_pos_to_absolute,
 )
-import numpy
 
 
 def test_cor_conversion():

tomwer/core/process/script/python.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "03/08/2020"
 
 
+import code
+import logging
+
+import tomwer.version
 from tomwer.core.process.task import Task
+from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.volumeutils import volume_identifier_to_volume
-import tomwer.version
-import logging
-import code
-
 
 _logger = logging.getLogger(__name__)
 
@@ -53,9 +53,7 @@ class PythonScript(
         elif isinstance(scan, (TomwerScanBase, type(None))):
             scan = scan
         else:
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
         # load volume
         volume = volume_identifier_to_volume(self.inputs.volume)
 

tomwer/core/process/task.py

@@ -34,22 +34,21 @@ __license__ = "MIT"
 __date__ = "27/07/2021"
 
 
-import h5py
-import numpy
-from datetime import datetime
-from typing import Union
-from silx.io.dictdump import dicttoh5
-from collections import namedtuple
-from silx.io.dictdump import h5todict
-from tomoscan.io import HDF5File
-import typing
 import logging
-from silx.io.utils import h5py_read_dataset
 import multiprocessing
+import typing
+from collections import namedtuple
+from datetime import datetime
+from typing import Union
+
+import h5py
+import numpy
 import silx
-from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
 from ewokscore.task import Task as _EwoksTask
-
+from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
+from silx.io.dictdump import dicttoh5, h5todict
+from silx.io.utils import h5py_read_dataset
+from tomoscan.io import HDF5File
 
 mult_manager = multiprocessing.Manager()
 

tomwer/core/process/test/test_axis.py

@@ -28,21 +28,24 @@ __license__ = "MIT"
 __date__ = "05/04/2019"
 
 
+import os
 import shutil
 import tempfile
 import unittest
-import numpy
-import os
+
 import h5py
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.utils.scanutils import MockEDF, MockHDF5
-from ..reconstruction.axis.axis import AxisProcess
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.reconstruction.axis.params import AxisRP
+import numpy
+from silx.io.utils import h5py_read_dataset
+
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.process.reconstruction.axis.params import AxisRP
 from tomwer.core.process.task import Task
-from silx.io.utils import h5py_read_dataset
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF, MockHDF5
+from tomwer.tests.utils import UtilsTest
+
+from ..reconstruction.axis.axis import AxisProcess
 
 
 class TestAxisIO(unittest.TestCase):

tomwer/core/process/test/test_conditions.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "19/07/2018"
 
 
-import unittest
 import shutil
 import tempfile
+import unittest
 
-from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.process.conditions.filters import (
-    RegularExpressionFilter,
     FileNameFilter,
+    RegularExpressionFilter,
 )
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF
 
 
 class TestConditionalFilter(unittest.TestCase):
@@ -46,10 +46,10 @@ class TestConditionalFilter(unittest.TestCase):
     """
 
     def testPattern1(self):
-        filter = RegularExpressionFilter("name10")
-        self.assertTrue(filter.isFiltered("toto") is True)
-        self.assertTrue(filter.isFiltered("name10") is False)
-        self.assertTrue(filter.isFiltered("name100") is False)
+        filter_ = RegularExpressionFilter("name10")
+        self.assertTrue(filter_.isFiltered("toto") is True)
+        self.assertTrue(filter_.isFiltered("name10") is False)
+        self.assertTrue(filter_.isFiltered("name100") is False)
 
     def testInputOutput(self):
         pass

tomwer/core/process/test/test_dark_and_flat.py

@@ -32,18 +32,19 @@ import os
 import shutil
 import tempfile
 import unittest
+
 import numpy
-from tomwer.core.utils.scanutils import MockEDF, MockHDF5
-from tomwer.core.process.reconstruction.darkref.params import (
-    DKRFRP,
-    ReduceMethod as cMethod,
-)
+from tomoscan.esrf.scan.utils import get_data
+
+from tomwer.core.process.reconstruction.darkref.params import DKRFRP
+from tomwer.core.process.reconstruction.darkref.params import ReduceMethod as cMethod
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF, MockHDF5
+from tomwer.tests.utils import UtilsTest
+
 from ..reconstruction.darkref.darkrefs import DarkRefs
 from ..reconstruction.darkref.darkrefscopy import DarkRefsCopy
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.esrf.scan.utils import get_data
 
 
 class TestDarkRefIO(unittest.TestCase):

tomwer/core/process/test/test_data_listener.py

@@ -28,11 +28,13 @@ __license__ = "MIT"
 __date__ = "09/06/2020"
 
 
-import unittest
-import tempfile
-import shutil
 import os
+import shutil
+import tempfile
+import unittest
+
 import h5py
+
 from tomwer.core.process.control.datalistener.rpcserver import _BaseDataListenerThread
 
 

tomwer/core/process/test/test_data_transfer.py

@@ -30,25 +30,27 @@ __date__ = "05/04/2019"
 
 import gc
 import os
-import h5py
+import shutil
+import tempfile
 import time
+import unittest
+
+import h5py
 import numpy
 import pytest
-import shutil
-import unittest
-import tempfile
+from nxtomomill.converter import from_h5_to_nx
+from nxtomomill.io.config.hdf5config import TomoHDF5Config
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomoscan.io import HDF5File
+from tomoscan.validator import is_valid_for_reconstruction
+
+from tomwer.core.process.control.datalistener import DataListener
+from tomwer.core.process.control.scantransfer import ScanTransfer
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.control.scantransfer import ScanTransfer
-from tomwer.tests.utils import UtilsTest
+from tomwer.core.utils.scanutils import MockEDF
 from tomwer.synctools.rsyncmanager import RSyncManager
-from tomwer.core.process.control.datalistener import DataListener
-from nxtomomill.converter import from_h5_to_nx
-from nxtomomill.io.config.hdf5config import TomoHDF5Config
-from tomoscan.validator import is_valid_for_reconstruction
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from tomwer.tests.utils import UtilsTest
 
 
 class TestDataTransferIO(unittest.TestCase):

tomwer/core/process/test/test_data_watcher.py

@@ -30,10 +30,12 @@ __date__ = "05/04/2019"
 
 import os
 import time
+
 import pytest
+
+from tomwer.core.process.control.datawatcher import DataWatcher
 from tomwer.core.process.control.datawatcher.status import DET_END_XML, PARSE_INFO_FILE
 from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.process.control.datawatcher import DataWatcher
 from tomwer.core.utils.threads import LoopThread
 
 

tomwer/core/process/test/test_lamino.py

@@ -31,9 +31,11 @@ __date__ = "05/04/2019"
 import shutil
 import tempfile
 import unittest
+
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF
+
 from ..reconstruction.lamino import LaminoReconstruction
-from tomwer.core.scan.scanbase import TomwerScanBase
 
 
 class TestLaminoIO(unittest.TestCase):

tomwer/core/process/test/test_nabu.py

@@ -30,17 +30,18 @@ __date__ = "14/02/2020"
 import os
 import shutil
 import tempfile
-from glob import glob
 import unittest
-from tomwer.tests.utils import UtilsTest
+from glob import glob
+
+from tomwer.core.process.reconstruction.axis import AxisRP
 from tomwer.core.process.reconstruction.nabu import nabuslices as nabu
+from tomwer.core.process.reconstruction.nabu import settings as nabu_settings
 from tomwer.core.process.reconstruction.nabu import utils as nabuutils
-from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.process.reconstruction.nabu.nabuslices import NabuSliceMode
-from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.process.reconstruction.axis import AxisRP
-from tomwer.core.process.reconstruction.nabu import settings as nabu_settings
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import MockEDF
+from tomwer.tests.utils import UtilsTest
 
 
 class TestNabuDescUtils(unittest.TestCase):
@@ -300,9 +301,9 @@ class TestTomwerConfForNabu(unittest.TestCase):
 
     def testSlices(self):
         # check if single value
-        for slice in ("1", NabuSliceMode.MIDDLE):
-            with self.subTest(slice=slice):
-                self.conf["tomwer_slices"] = slice
+        for data_slice in ("1", NabuSliceMode.MIDDLE):
+            with self.subTest(data_slice=data_slice):
+                self.conf["tomwer_slices"] = data_slice
 
                 sub_confs = nabu.interpret_tomwer_configuration(
                     self.conf, scan=self.scan
@@ -312,9 +313,9 @@ class TestTomwerConfForNabu(unittest.TestCase):
                 self.assertEqual(len(sub_confs), 1 + 1)
 
         # check single values or list of values
-        for slice in ("[2, 3, 7]", "(6, 9,56)", "5;6; 9"):
-            with self.subTest(slice=slice):
-                self.conf["tomwer_slices"] = slice
+        for data_slice in ("[2, 3, 7]", "(6, 9,56)", "5;6; 9"):
+            with self.subTest(slice=data_slice):
+                self.conf["tomwer_slices"] = data_slice
 
                 sub_confs = nabu.interpret_tomwer_configuration(
                     self.conf, scan=self.scan

tomwer/core/process/test/test_normalization.py

@@ -27,14 +27,16 @@ __license__ = "MIT"
 __date__ = "11/07/2021"
 
 
-from tomwer.core.process.reconstruction.normalization import params, normalization
-from tomoscan.normalization import Method
-from tomwer.core.utils.scanutils import MockHDF5
-import unittest
-import tempfile
 import shutil
+import tempfile
+import unittest
+
 import h5py
 import numpy
+from tomoscan.normalization import Method
+
+from tomwer.core.process.reconstruction.normalization import normalization, params
+from tomwer.core.utils.scanutils import MockHDF5
 
 
 class TestNormalization(unittest.TestCase):

tomwer/core/process/test/test_timer.py

@@ -31,9 +31,10 @@ __date__ = "05/04/2019"
 import shutil
 import tempfile
 import unittest
-from tomwer.core.utils.scanutils import MockEDF
+
 from tomwer.core.process.control.timer import Timer
 from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF
 
 
 class TestTimerIO(unittest.TestCase):

tomwer/core/process/utils.py

@@ -28,16 +28,18 @@ __license__ = "MIT"
 __date__ = "04/03/2019"
 
 
-from collections import OrderedDict
 import datetime
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.blissscan import BlissScan
+import logging
+import typing
+from collections import OrderedDict
+
+import h5py
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
+
 from tomwer.core.process.reconstruction.scores import ComputedScore
-import h5py
-import typing
-import logging
+from tomwer.core.scan.blissscan import BlissScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
@@ -106,9 +108,7 @@ def get_scores(node: h5py.Group) -> typing.Union[None, dict]:
                 )
                 scores[float(res_item)] = (url, score)
             except Exception as e:
-                _logger.warning(
-                    "Unable to load {}. Reason is {}".format(score_node.name, str(e))
-                )
+                _logger.warning(f"Unable to load {score_node.name}. Reason is {e}")
         scores = dict(sorted(scores.items(), key=lambda item: item[0]))
 
         return scores

tomwer/core/progress.py

@@ -29,9 +29,9 @@ __license__ = "MIT"
 __date__ = "07/08/2019"
 
 
+import logging
 import sys
 from enum import Enum
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -82,9 +82,8 @@ class Progress(object):
     def setAdvancement(self, value):
         length = 20  # modify this to change the length
         block = int(round(length * value / 100))
-        msg = "\r{0}: [{1}] {2}%".format(
-            self._name, "#" * block + "-" * (length - block), round(value, 2)
-        )
+        blocks_str = "#" * block + "-" * (length - block)
+        msg = f"\r{self._name}: [{blocks_str}] {round(value, 2)}%"
         if value >= 100:
             msg += " DONE\r\n"
         sys.stdout.write(msg)

tomwer/core/scan/blissscan.py

@@ -29,6 +29,7 @@ __date__ = "09/08/2018"
 
 
 import os
+
 import h5py
 
 try:
@@ -48,11 +49,12 @@ except ImportError:
     from nxtomomill.settings import H5_INIT_TITLES
     from nxtomomill.settings import H5_ZSERIE_INIT_TITLES
     from nxtomomill.settings import H5_PCOTOMO_INIT_TITLES
-from silx.io.utils import h5py_read_dataset
+
 import logging
-from tomoscan.io import HDF5File
 from typing import Optional
 
+from silx.io.utils import h5py_read_dataset
+from tomoscan.io import HDF5File
 
 _logger = logging.getLogger(__name__)
 

tomwer/core/scan/edfscan.py

@@ -28,31 +28,34 @@ __license__ = "MIT"
 __date__ = "09/08/2018"
 
 
+import functools
+import logging
 import os
 import re
 from collections import OrderedDict
+from glob import glob
 from math import ceil
+from typing import Optional
+
 import fabio
 import numpy
-import functools
-import logging
+from processview.core.dataset import DatasetIdentifier
+from silx.io.url import DataUrl
+from tomoscan.esrf.identifier.edfidentifier import (
+    EDFTomoScanIdentifier as _EDFTomoScanIdentifier,
+)
+from tomoscan.esrf.scan.edfscan import EDFTomoScan as _tsEDFTomoScan
+from tomoscan.esrf.scan.utils import get_data
 from tomoscan.scanbase import FOV
+
 from tomwer.core.process.reconstruction.darkref.settings import (
-    REFHST_PREFIX,
     DARKHST_PREFIX,
+    REFHST_PREFIX,
 )
 from tomwer.core.progress import Progress
-from silx.io.url import DataUrl
-from tomoscan.esrf.scan.utils import get_data
-from glob import glob
-from .scanbase import TomwerScanBase
-from tomoscan.esrf.scan.edfscan import EDFTomoScan as _tsEDFTomoScan
-from tomoscan.esrf.identifier.edfidentifier import (
-    EDFTomoScanIdentifier as _EDFTomoScanIdentifier,
-)
 from tomwer.utils import docstring
-from processview.core.dataset import DatasetIdentifier
-from typing import Optional
+
+from .scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
@@ -223,8 +226,8 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             return a dict with the index of the slice reconstructed.
         """
 
-        def containsDigits(input):
-            return any(char.isdigit() for char in input)
+        def containsDigits(input_):
+            return any(char.isdigit() for char in input_)
 
         if (scanID is None) or (not os.path.isdir(scanID)):
             if withIndex is True:
@@ -308,8 +311,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
         :rtype: numpy.array
         """
         _logger.info(
-            "compute sinogram for line %s of %s (subsampling: %s)"
-            % (line, self.path, subsampling)
+            f"compute sinogram for line {line} of {self.path} (subsampling: {subsampling})"
         )
         assert isinstance(line, int)
         if self.tomo_n is not None and self.dim_2 is not None and line > self.dim_2:
@@ -323,8 +325,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             proj_sort = list(filter(lambda x: not isinstance(x, str), proj_sort))
             proj_sort.sort()
             advancement = Progress(
-                name="compute sinogram for %s, line=%s,"
-                "sampling=%s" % (os.path.basename(self.path), line, subsampling)
+                name=f"compute sinogram for {os.path.basename(self.path)}, line={line}, sampling={subsampling}"
             )
             advancement.setMaxAdvancement(len(proj_sort))
             for i_proj, proj in enumerate(proj_sort):
@@ -393,7 +394,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             return None
         path = os.path.join(self.path, f)
         if os.path.exists(path):
-            _logger.info("Getting %s from %s" % (what, f))
+            _logger.info(f"Getting {what} from {f}")
             try:
                 data = fabio.open(path).data
             except Exception:
@@ -456,8 +457,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
 
             if len(oProj) > 2:
                 _logger.info(
-                    "Only bordering projections (%s and %s) will "
-                    "be used for extracting %s" % (lowPI, uppPI, what)
+                    f"Only bordering projections ({lowPI} and {uppPI}) will be used for extracting {what}"
                 )
 
             uppPI = uppPI
@@ -468,15 +468,13 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             if (index >= lowPI) is False:
                 index = lowPI
                 _logger.warning(
-                    "ProjectionI not in the files indexes"
-                    "range (projectionI >= lowerProjIndex)"
+                    "ProjectionI not in the files indexes range (projectionI >= lowerProjIndex)"
                 )
 
             if (index <= uppPI) is False:
                 index = uppPI
                 _logger.warning(
-                    "ProjectionI not in the files indexes"
-                    "range upperProjIndex >= projectionI"
+                    "ProjectionI not in the files indexes range upperProjIndex >= projectionI"
                 )
 
             # simple interpolation
@@ -524,9 +522,8 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
     def _deduce_transfert_scan(self, output_dir):
         if os.path.basename(output_dir) != os.path.basename(self.path):
             raise ValueError(
-                "Transfert to a new EDFTomoScan requires an "
-                "equal basename. Current path is {}, requested "
-                "one is {}".format(self.path, output_dir)
+                "Transfert to a new EDFTomoScan requires an equal basename. "
+                f"Current path is {self.path}, requested one is {output_dir}"
             )
         # here: avoir reloading the metadata because not sure there will be some processing after the 'data transfert'. And can be long with EDF + GPFS at esrf
         return EDFTomoScan(scan=output_dir, update=False)

tomwer/core/scan/futurescan.py

@@ -1,6 +1,7 @@
-from tomwer.core.futureobject import TomwerScanBase
 from silx.utils.deprecation import deprecated
 
+from tomwer.core.futureobject import TomwerScanBase
+
 
 @deprecated(replacement="TomwerScanBase", since_version="1.0")
 class FutureTomwerScan(TomwerScanBase):

tomwer/core/scan/hdf5scan.py

@@ -28,35 +28,34 @@ __license__ = "MIT"
 __date__ = "09/08/2018"
 
 
-from .scanbase import TomwerScanBase
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _tsHDF5TomoScan
-from tomoscan.esrf.identifier.hdf5Identifier import (
-    HDF5TomoScanIdentifier as _HDF5TomoScanIdentifier,
-)
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.io import HDF5File
-from processview.core.dataset import DatasetIdentifier
 import functools
-import json
 import io
-import h5py
-import os
-from tomwer.utils import docstring
+import json
 import logging
+import os
 from typing import Optional
 from urllib.parse import urlparse
-from tomoscan.esrf.identifier.url_utils import (
-    UrlSettings,
-    split_path,
-    split_query,
+
+import h5py
+from processview.core.dataset import DatasetIdentifier
+from tomoscan.esrf.identifier.hdf5Identifier import (
+    HDF5TomoScanIdentifier as _HDF5TomoScanIdentifier,
 )
+from tomoscan.esrf.identifier.url_utils import UrlSettings, split_path, split_query
+from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _tsHDF5TomoScan
+from tomoscan.esrf.scan.hdf5scan import ImageKey
+from tomoscan.io import HDF5File
+
+from tomwer.utils import docstring
+
+from .scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
 
 class HDF5TomoScanIdentifier(_HDF5TomoScanIdentifier, DatasetIdentifier):
-    def __init__(self, object, hdf5_file, entry):
-        super().__init__(object, hdf5_file, entry)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         DatasetIdentifier.__init__(self, data_builder=HDF5TomoScan.from_identifier)
 
     @staticmethod
@@ -325,9 +324,7 @@ class HDF5TomoScan(_tsHDF5TomoScan, TomwerScanBase):
             for frame in frames:
                 if frame.image_key is ImageKey.PROJECTION:
                     if frame.is_control:
-                        self._cache_proj_urls[
-                            "{} (1)".format(frame.rotation_angle)
-                        ] = frame.url
+                        self._cache_proj_urls[f"{frame.rotation_angle} (1)"] = frame.url
                     else:
                         self._cache_proj_urls[str(frame.rotation_angle)] = frame.url
         return self._cache_proj_urls
@@ -460,16 +457,12 @@ class HDF5TomoScan(_tsHDF5TomoScan, TomwerScanBase):
     @docstring(TomwerScanBase)
     def get_nabu_dataset_info(self, binning=1, binning_z=1, proj_subsampling=1):
         if not isinstance(binning, int):
-            raise TypeError("binning should be an int. Not {}".format(type(binning)))
+            raise TypeError(f"binning should be an int. Not {type(binning)}")
         if not isinstance(binning_z, int):
-            raise TypeError(
-                "binning_z should be an int. Not {}".format(type(binning_z))
-            )
+            raise TypeError(f"binning_z should be an int. Not {type(binning_z)}")
         if not isinstance(proj_subsampling, int):
             raise TypeError(
-                "proj_subsampling should be an int. Not {}".format(
-                    type(proj_subsampling)
-                )
+                f"proj_subsampling should be an int. Not {type(proj_subsampling)}"
             )
         return {
             "hdf5_entry": self.entry,