[sdk-1710] update naming

Author: jsonbailey

ldclient/__init__.py

@@ -37,7 +37,7 @@ def set_config(config: Config):
     global __config
     global __client
     global __lock
-    with __lock.write_lock():
+    with __lock.write():
         try:
             if __client:
                 log.info("Reinitializing LaunchDarkly Client " + VERSION + " with new config")
@@ -62,13 +62,13 @@ def get() -> LDClient:
     global __config
     global __client
     global __lock
-    with __lock.read_lock():
+    with __lock.read():
         if __client:
             return __client
         if __config is None:
             raise Exception("set_config was not called")
 
-    with __lock.write_lock():
+    with __lock.write():
         if not __client:
             log.info("Initializing LaunchDarkly Client " + VERSION)
             __client = LDClient(config=__config, start_wait=start_wait)
@@ -80,7 +80,7 @@ def _reset_client():
     global __client
     global __lock
     c = None
-    with __lock.write_lock():
+    with __lock.write():
         c = __client
         __client = None
     if c:

ldclient/client.py

@@ -111,7 +111,7 @@ def __wrapper(self, fn: Callable):
             raise
 
     def __update_availability(self, available: bool):
-        with self.__lock.write_lock():
+        with self.__lock.write():
             if available == self.__last_available:
                 return
             self.__last_available = available
@@ -124,7 +124,7 @@ def __update_availability(self, available: bool):
         self.__store_update_sink.update_status(status)
 
         if available:
-            with self.__lock.write_lock():
+            with self.__lock.write():
                 if self.__poller is not None:
                     self.__poller.stop()
                     self.__poller = None
@@ -134,7 +134,7 @@ def __update_availability(self, available: bool):
         log.warn("Detected persistent store unavailability; updates will be cached until it recovers")
         task = RepeatingTask("ldclient.check-availability", 0.5, 0, self.__check_availability)
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             self.__poller = task
             self.__poller.start()
 
@@ -710,7 +710,7 @@ def add_hook(self, hook: Hook):
         if not isinstance(hook, Hook):
             return
 
-        with self.__hooks_lock.write_lock():
+        with self.__hooks_lock.write():
             self.__hooks.append(hook)
 
     def __evaluate_with_hooks(self, key: str, context: Context, default_value: Any, method: str, block: Callable[[], _EvaluationWithHookResult]) -> _EvaluationWithHookResult:
@@ -725,7 +725,7 @@ def __evaluate_with_hooks(self, key: str, context: Context, default_value: Any,
         # :return:
         """
         hooks = []  # type: List[Hook]
-        with self.__hooks_lock.read_lock():
+        with self.__hooks_lock.read():
             if len(self.__hooks) == 0:
                 return block()
 

ldclient/feature_store.py

@@ -77,7 +77,7 @@ def is_available(self) -> bool:
 
     def get(self, kind: VersionedDataKind, key: str, callback: Callable[[Any], Any] = lambda x: x) -> Any:
         """ """
-        with self._lock.read_lock():
+        with self._lock.read():
             itemsOfKind = self._items[kind]
             item = itemsOfKind.get(key)
             if item is None:
@@ -90,7 +90,7 @@ def get(self, kind: VersionedDataKind, key: str, callback: Callable[[Any], Any]
 
     def all(self, kind, callback):
         """ """
-        with self._lock.read_lock():
+        with self._lock.read():
             itemsOfKind = self._items[kind]
             return callback(dict((k, i) for k, i in itemsOfKind.items() if ('deleted' not in i) or not i['deleted']))
 
@@ -102,7 +102,7 @@ def init(self, all_data):
             for key, item in items.items():
                 items_decoded[key] = kind.decode(item)
             all_decoded[kind] = items_decoded
-        with self._lock.write_lock():
+        with self._lock.write():
             self._items.clear()
             self._items.update(all_decoded)
             self._initialized = True
@@ -112,7 +112,7 @@ def init(self, all_data):
     # noinspection PyShadowingNames
     def delete(self, kind, key: str, version: int):
         """ """
-        with self._lock.write_lock():
+        with self._lock.write():
             itemsOfKind = self._items[kind]
             i = itemsOfKind.get(key)
             if i is None or i['version'] < version:
@@ -123,7 +123,7 @@ def upsert(self, kind, item):
         """ """
         decoded_item = kind.decode(item)
         key = item['key']
-        with self._lock.write_lock():
+        with self._lock.write():
             itemsOfKind = self._items[kind]
             i = itemsOfKind.get(key)
             if i is None or i['version'] < item['version']:
@@ -133,7 +133,7 @@ def upsert(self, kind, item):
     @property
     def initialized(self) -> bool:
         """ """
-        with self._lock.read_lock():
+        with self._lock.read():
             return self._initialized
 
     def describe_configuration(self, config):

ldclient/impl/datasource/status.py

@@ -29,7 +29,7 @@ def __init__(self, store: FeatureStore, status_listeners: Listeners, flag_change
 
     @property
     def status(self) -> DataSourceStatus:
-        with self.__lock.read_lock():
+        with self.__lock.read():
             return self.__status
 
     def init(self, all_data: Mapping[VersionedDataKind, Mapping[str, dict]]):
@@ -67,7 +67,7 @@ def delete(self, kind: VersionedDataKind, key: str, version: int):
     def update_status(self, new_state: DataSourceState, new_error: Optional[DataSourceErrorInfo]):
         status_to_broadcast = None
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             old_status = self.__status
 
             if new_state == DataSourceState.INTERRUPTED and old_status.state == DataSourceState.INITIALIZING:

ldclient/impl/datastore/status.py

@@ -27,11 +27,11 @@ def listeners(self) -> Listeners:
         return self.__listeners
 
     def status(self) -> DataStoreStatus:
-        with self.__lock.read_lock():
+        with self.__lock.read():
             return copy(self.__status)
 
     def update_status(self, status: DataStoreStatus):
-        with self.__lock.write_lock():
+        with self.__lock.write():
             old_value, self.__status = self.__status, status
 
         if old_value != status:

ldclient/impl/datasystem/fdv2.py

@@ -42,13 +42,13 @@ def __init__(self, listeners: Listeners):
 
     @property
     def status(self) -> DataSourceStatus:
-        with self.__lock.read_lock():
+        with self.__lock.read():
             return self.__status
 
     def update_status(self, new_state: DataSourceState, new_error: Optional[DataSourceErrorInfo]):
         status_to_broadcast = None
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             old_status = self.__status
 
             if new_state == DataSourceState.INTERRUPTED and old_status.state == DataSourceState.INITIALIZING:
@@ -88,7 +88,7 @@ def update_status(self, status: DataStoreStatus):
         """
         modified = False
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             if self.__status != status:
                 self.__status = status
                 modified = True
@@ -98,7 +98,7 @@ def update_status(self, status: DataStoreStatus):
 
     @property
     def status(self) -> DataStoreStatus:
-        with self.__lock.read_lock():
+        with self.__lock.read():
             return copy(self.__status)
 
     def is_monitoring_enabled(self) -> bool:
@@ -163,7 +163,7 @@ def __update_availability(self, available: bool):
         poller_to_stop = None
         task_to_start = None
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             if available == self.__last_available:
                 return
 
@@ -322,7 +322,7 @@ def stop(self):
         """Stop the FDv2 data system and all associated threads."""
         self._stop_event.set()
 
-        with self._lock.write_lock():
+        with self._lock.write():
             if self._active_synchronizer is not None:
                 try:
                     self._active_synchronizer.stop()
@@ -411,7 +411,7 @@ def synchronizer_loop(self: 'FDv2'):
                 while not self._stop_event.is_set() and self._primary_synchronizer_builder is not None:
                     # Try primary synchronizer
                     try:
-                        with self._lock.write_lock():
+                        with self._lock.write():
                             primary_sync = self._primary_synchronizer_builder(self._config)
                             if isinstance(primary_sync, DiagnosticSource) and self._diagnostic_accumulator is not None:
                                 primary_sync.set_diagnostic_accumulator(self._diagnostic_accumulator)
@@ -446,7 +446,7 @@ def synchronizer_loop(self: 'FDv2'):
                         if self._secondary_synchronizer_builder is None:
                             continue
 
-                        with self._lock.write_lock():
+                        with self._lock.write():
                             secondary_sync = self._secondary_synchronizer_builder(self._config)
                             if isinstance(secondary_sync, DiagnosticSource) and self._diagnostic_accumulator is not None:
                                 secondary_sync.set_diagnostic_accumulator(self._diagnostic_accumulator)
@@ -480,7 +480,7 @@ def synchronizer_loop(self: 'FDv2'):
             finally:
                 # Ensure we always set the ready event when exiting
                 set_on_ready.set()
-                with self._lock.write_lock():
+                with self._lock.write():
                     if self._active_synchronizer is not None:
                         self._active_synchronizer.stop()
                     self._active_synchronizer = None

ldclient/impl/datasystem/store.py

@@ -49,7 +49,7 @@ def get(
         key: str,
         callback: Callable[[Any], Any] = lambda x: x,
     ) -> Any:
-        with self._lock.read_lock():
+        with self._lock.read():
             items_of_kind = self._items[kind]
             item = items_of_kind.get(key)
             if item is None:
@@ -69,7 +69,7 @@ def get(
             return callback(item)
 
     def all(self, kind: VersionedDataKind, callback: Callable[[Any], Any] = lambda x: x) -> Any:
-        with self._lock.read_lock():
+        with self._lock.read():
             items_of_kind = self._items[kind]
             return callback(
                 dict(
@@ -88,7 +88,7 @@ def set_basis(self, collections: Collections) -> bool:
             return False
 
         try:
-            with self._lock.write_lock():
+            with self._lock.write():
                 self._items.clear()
                 self._items.update(all_decoded)
                 self._initialized = True
@@ -107,7 +107,7 @@ def apply_delta(self, collections: Collections) -> bool:
             return False
 
         try:
-            with self._lock.write_lock():
+            with self._lock.write():
                 for kind, kind_data in all_decoded.items():
                     items_of_kind = self._items[kind]
                     kind_data = all_decoded[kind]
@@ -142,7 +142,7 @@ def initialized(self) -> bool:
         """
         Indicates whether the store has been initialized with data.
         """
-        with self._lock.read_lock():
+        with self._lock.read():
             return self._initialized
 
 
@@ -212,7 +212,7 @@ def with_persistence(
         Returns:
             Self for method chaining
         """
-        with self._lock.write_lock():
+        with self._lock.write():
             self._persistent_store = persistent_store
             self._persistent_store_writable = writable
             self._persistent_store_status_provider = status_provider
@@ -224,12 +224,12 @@ def with_persistence(
 
     def selector(self) -> Selector:
         """Returns the current selector."""
-        with self._lock.read_lock():
+        with self._lock.read():
             return self._selector
 
     def close(self) -> Optional[Exception]:
         """Close the store and any persistent store if configured."""
-        with self._lock.write_lock():
+        with self._lock.write():
             if self._persistent_store is not None:
                 try:
                     # Most FeatureStore implementations don't have close methods
@@ -250,7 +250,7 @@ def apply(self, change_set: ChangeSet, persist: bool) -> None:
         """
         collections = self._changes_to_store_data(change_set.changes)
 
-        with self._lock.write_lock():
+        with self._lock.write():
             try:
                 if change_set.intent_code == IntentCode.TRANSFER_FULL:
                     self._set_basis(collections, change_set.selector, persist)
@@ -442,7 +442,7 @@ def __mapping(data: Dict[str, ModelEntity]) -> Dict[str, Dict[str, Any]]:
 
             return __mapping
 
-        with self._lock.write_lock():
+        with self._lock.write():
             if self._should_persist():
                 try:
                     # Get all data from memory store and write to persistent store
@@ -456,7 +456,7 @@ def __mapping(data: Dict[str, ModelEntity]) -> Dict[str, Dict[str, Any]]:
 
     def get_active_store(self) -> ReadOnlyStore:
         """Get the currently active store for reading data."""
-        with self._lock.read_lock():
+        with self._lock.read():
             return self._active_store
 
     def is_initialized(self) -> bool:
@@ -465,5 +465,5 @@ def is_initialized(self) -> bool:
 
     def get_data_store_status_provider(self) -> Optional[DataStoreStatusProvider]:
         """Get the data store status provider for the persistent store, if configured."""
-        with self._lock.read_lock():
+        with self._lock.read():
             return self._persistent_store_status_provider

ldclient/impl/flag_tracker.py

@@ -22,7 +22,7 @@ def __call__(self, flag_change: FlagChange):
 
         new_value = self.__eval_fn(self.__key, self.__context)
 
-        with self.__lock.write_lock():
+        with self.__lock.write():
             old_value, self.__value = self.__value, new_value
 
         if new_value == old_value:

ldclient/impl/listeners.py

@@ -15,22 +15,22 @@ def __init__(self):
         self.__lock = ReadWriteLock()
 
     def has_listeners(self) -> bool:
-        with self.__lock.read_lock():
+        with self.__lock.read():
             return len(self.__listeners) > 0
 
     def add(self, listener: Callable):
-        with self.__lock.write_lock():
+        with self.__lock.write():
             self.__listeners.append(listener)
 
     def remove(self, listener: Callable):
-        with self.__lock.write_lock():
+        with self.__lock.write():
             try:
                 self.__listeners.remove(listener)
             except ValueError:
                 pass  # removing a listener that wasn't in the list is a no-op
 
     def notify(self, value: Any):
-        with self.__lock.read_lock():
+        with self.__lock.read():
             listeners_copy = self.__listeners.copy()
         for listener in listeners_copy:
             try: