diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe08aa8523e840f04dbd2f7ce22c3f195eb4d081..516c3e9d6f9e88b8cdec31c86b319a7cb788460a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ The software
* added satella.instrumentation.cpu_time.get_own_cpu_time()
* better documentation for satella.time.sleep()
* fixed behaviour of PIDFileLock
+* multiple minor code changes to improve pylint statistics
Build process
-------------
diff --git a/satella/coding/structures/syncable_droppable.py b/satella/coding/structures/syncable_droppable.py
index df6241589bac9213bf5d750216627ceedf9c0134..9c05d684eadeca24c68016de4dffb3dbb644eb21 100644
--- a/satella/coding/structures/syncable_droppable.py
+++ b/satella/coding/structures/syncable_droppable.py
@@ -5,7 +5,6 @@ from abc import ABCMeta, abstractmethod
import typing as tp
from satella.coding.concurrent.monitor import RMonitor
-from satella.coding.recast_exceptions import silence_excs
from satella.coding.sequences import try_close
from satella.coding.typing import V, K, KVTuple
@@ -310,6 +309,60 @@ class SyncableDroppable(RMonitor, tp.Generic[K, V]):
if self.start_entry is None:
self.start_entry = key
+ def _assert_correctness(self, maximum_entries):
+ if not self.start_entry:
+ raise ValueError('Nothing to synchronize!')
+ if self.synced_up_to == self.data_in_memory[-1][0]:
+ raise ValueError('Nothing to synchronize!')
+
+ def _on_sync_request_synced_up_none(self, maximum_entries):
+ # Sync everything
+ iterator = self.db_storage.iterate(None)
+ try:
+ data = list(iterator)
+ if len(data) < maximum_entries:
+ entries_left = maximum_entries - len(data)
+ if entries_left == math.inf:
+ data = itertools.chain(data, self.data_in_memory)
+ else:
+ data = itertools.chain(data, self.data_in_memory[:entries_left])
+ return data
+ finally:
+ try_close(iterator)
+
+ def _on_sync_request_synced_up_is_not_none(self, maximum_entries):
+ if self.first_key_in_memory <= self.synced_up_to:
+ # Means we have to sync from memory
+ if self.synced_up_to is None:
+ v = self.data_in_memory
+ else:
+ index = bisect.bisect_right([y[0] for y in self.data_in_memory],
+ self.synced_up_to)
+ if maximum_entries == math.inf:
+ v = self.data_in_memory[index:]
+ else:
+ v = self.data_in_memory[index:index + maximum_entries]
+ else:
+ # We have to start off the disk
+ data = []
+ iterator = self.db_storage.iterate(self.start_entry)
+ try:
+ while len(data) < maximum_entries:
+ try:
+ data.append(next(iterator))
+ except StopIteration:
+ for index, tpl in enumerate(self.data_in_memory):
+ if len(data) >= maximum_entries:
+ break
+ if self.synced_up_to is not None:
+ if tpl[0] > self.synced_up_to:
+ break
+ v = itertools.chain(data, self.data_in_memory[:index])
+ break
+ finally:
+ try_close(iterator)
+ return v
+
def on_sync_request(self, maximum_entries: tp.Optional[int] = math.inf) -> tp.Iterator[KVTuple]:
"""
Return an iterator that will provide the source of the data for synchronization.
@@ -321,57 +374,12 @@ class SyncableDroppable(RMonitor, tp.Generic[K, V]):
:return: an iterator of (KVTuple) that should be synchronized against the server
:raise ValueError: nothing to synchronize!
"""
- if not self.start_entry:
- raise ValueError('Nothing to synchronize!')
- if self.synced_up_to == self.data_in_memory[-1][0]:
- raise ValueError('Nothing to synchronize!')
+ self._assert_correctness(maximum_entries)
+
if self.synced_up_to is None:
- # Sync everything
- iterator = self.db_storage.iterate(None)
- try:
- data = list(iterator)
- if len(data) < maximum_entries:
- entries_left = maximum_entries - len(data)
- if entries_left == math.inf:
- data = itertools.chain(data, self.data_in_memory)
- else:
- data = itertools.chain(data, self.data_in_memory[:entries_left])
- v = data
- finally:
- try_close(iterator)
+ v = self._on_sync_request_synced_up_none(maximum_entries)
else:
- if self.first_key_in_memory <= self.synced_up_to:
- # Means we have to sync from memory
- if self.synced_up_to is None:
- v = self.data_in_memory
- else:
- index = bisect.bisect_right([y[0] for y in self.data_in_memory],
- self.synced_up_to)
- if maximum_entries == math.inf:
- v = self.data_in_memory[index:]
- else:
- v = self.data_in_memory[index:index + maximum_entries]
- else:
- # We have to start off the disk
- data = []
- iterator = self.db_storage.iterate(self.start_entry)
- try:
- while len(data) < maximum_entries:
- try:
- data.append(next(iterator))
- except StopIteration:
- for index, tpl in enumerate(self.data_in_memory):
- if len(data) >= maximum_entries:
- break
- if self.synced_up_to is not None:
- if tpl[0] > self.synced_up_to:
- break
- v = itertools.chain(data, self.data_in_memory[:index])
- break
- else:
- v = data
- finally:
- try_close(iterator)
+ v = self._on_sync_request_synced_up_is_not_none(maximum_entries)
return v
def on_synced_up_to(self, key: K) -> None:
@@ -387,7 +395,4 @@ class SyncableDroppable(RMonitor, tp.Generic[K, V]):
"""
:return: key of the first element stored in memory
"""
- if not self.data_in_memory:
- return None
- else:
- return self.data_in_memory[0][0]
+ return None if not self.data_in_memory else self.data_in_memory[0][0]