CHANGELOG

@@ -1,10 +1,3 @@
-- 0.3.0
-	* Clean up lingering keys in lists when moving from alias state
-	* Properly set default state when set through instantiation
-	* Pass key to verifier (breaking change)
-	* Ensure all states and aliases persisted even if empty
-	* Allow auto-generated aliases when listing all states
-	* Reformat auto-generated aliases, double underscore instead of dot (breaking change)
 - 0.2.10
 	* Add count active states method
 	* Enable complete replace of NEW state on state instantiation

README.rocksdb

@@ -1 +0,0 @@
-Rocksdb extension requires python 3.9, as it uses lbry-rocksdb which at the time of writing (13.10.2022) does not have a package available for python 3.10.

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = shep
-version = 0.3.0
+version = 0.2.10
 description = Multi-state key stores using bit masks
 author = Louis Holbrook
 author_email = dev@holbrook.no

shep/persist.py

@@ -2,9 +2,7 @@
 import datetime
 
 # local imports
-from .state import (
+from .state import State
-        State,
-        )
 from .error import (
         StateItemExists,
         StateLockedKey,
@@ -26,12 +24,10 @@ class PersistedState(State):
         super(PersistedState, self).__init__(bits, logger=logger, verifier=verifier, check_alias=check_alias, event_callback=event_callback, default_state=default_state)
         self.__store_factory = factory
         self.__stores = {}
-        self.__ensure_store(self.base_state_name)
 
 
     # Create state store container if missing.
     def __ensure_store(self, k):
-        k = k.upper()
         if self.__stores.get(k) == None:
             self.__stores[k] = self.__store_factory(k)
 
@@ -78,7 +74,7 @@ class PersistedState(State):
         return to_state
 
 
-    def unset(self, key, not_state, allow_base=False):
+    def unset(self, key, not_state):
         """Persist a new state for a key or key/content.
 
         See shep.state.State.unset
@@ -86,7 +82,7 @@ class PersistedState(State):
         from_state = self.state(key)
         k_from = self.name(from_state)
 
-        to_state = super(PersistedState, self).unset(key, not_state, allow_base=allow_base)
+        to_state = super(PersistedState, self).unset(key, not_state)
 
         k_to = self.name(to_state)
         self.__ensure_store(k_to)
@@ -148,7 +144,7 @@ class PersistedState(State):
         return to_state
 
 
-    def sync(self, state=None, not_state=None, ignore_auto=True):
+    def sync(self, state=None, not_state=None):
         """Reload resources for a single state in memory from the persisted state store.
 
         :param state: State to load
@@ -159,7 +155,7 @@ class PersistedState(State):
 
         states_numeric = []
         if state == None:
-            states_numeric = list(self.all(numeric=True, ignore_auto=ignore_auto))
+            states_numeric = list(self.all(numeric=True))
         else:
             states_numeric = [state]
        
@@ -241,13 +237,3 @@ class PersistedState(State):
         state = self.state(key)
         k = self.name(state)
         return self.__stores[k].modified(key)
-
-
-    def add(self, key):
-        self.__ensure_store(key)
-        super(PersistedState, self).add(key)
-
-
-    def alias(self, key, *args):
-        self.__ensure_store(key)
-        super(PersistedState, self).alias(key, *args)

shep/state.py

@@ -15,18 +15,6 @@ from shep.error import (
 
 re_name = r'^[a-zA-Z_\.]+$'
 
-def join_elements(states):
-    return '_' + '__'.join(states)
-
-
-def split_elements(s):
-    if len(s) == 0:
-        return []
-    if s[0] == '_':
-        s = s[1:]
-    return s.split('__')
-
-
 class State:
     """State is an in-memory bitmasked state store for key-value pairs, or even just keys alone.
 
@@ -48,20 +36,16 @@ class State:
         self.__limit = (1 << bits) - 1
         self.__c = 0
 
-        self.__keys_reverse = {}
-
         if default_state == None:
             default_state = self.base_state_name
-        else:
-            default_state = self.__check_name_valid(default_state)
-            self.base_state_name = default_state
-            self.__keys_reverse[default_state] = 0
 
         setattr(self, default_state, 0)
 
-        self.__reverse = {0: default_state}
+        self.__reverse = {0: getattr(self, default_state)}
-        self.__keys = {0: []}
+        self.__keys = {getattr(self, default_state): []}
-
+        self.__keys_reverse = {}
+        if default_state != self.base_state_name:
+            self.__keys_reverse[default_state] = 0
         self.__contents = {}
         self.modified_last = {}
         self.verifier = verifier
@@ -220,7 +204,6 @@ class State:
             v = self.__check_limit(v | a, pure=False)
         if self.is_pure(v):
             raise ValueError('use add to add pure values')
-        k = k.replace('.', '__')
         return self.__set(k, v)
 
 
@@ -240,31 +223,16 @@ class State:
         return self.__alias(k, *args)    
 
 
-    def __all_bit(self):
+    def all(self, pure=False, numeric=False):
-        r = []
-        r.append(self.name(0))
-        v = 1
-        while v < self.__limit:
-            r.append(self.name(v))
-            v <<= 1
-        return r
-
-
-    def all(self, pure=False, numeric=False, ignore_auto=True, bit_order=False):
         """Return list of all unique atomic and alias state strings.
         
         :rtype: list of ints
         :return: states
         """
         l = []
-        v = None
+        for k in dir(self):
-        if bit_order:
-            v = self.__all_bit()
-        else:
-            v = dir(self)
-        for k in v:
             state = None
-            if k[0] == '_' and ignore_auto:
+            if k[0] == '_':
                 continue
             if k.upper() != k:
                 continue
@@ -278,8 +246,7 @@ class State:
                 l.append(state)
             else:
                 l.append(k)
-        if not bit_order:
+        l.sort()
-            l.sort()
         return l
 
 
@@ -289,7 +256,7 @@ class State:
             return self.base_state_name
         c = 1
         for i in range(self.__bits):
-            if (v & c) > 0:
+            if v & c > 0:
                 if numeric:
                     r.append(c)
                 else:
@@ -299,17 +266,14 @@ class State:
         if numeric or not as_string:
             return r
 
-        if len(r) == 1:
+        return '_' + '.'.join(r)
-            return self.name(v)
-
-        return join_elements(r) #'_' + '.'.join(r)
 
 
     def from_elements(self, k):
         r = 0
         if k[0] != '_':
             raise ValueError('elements string must start with underscore (_), got {}'.format(k))
-        for v in k[1:].split('__'):
+        for v in k[1:].split('.'):
             r |= self.from_name(v) 
         return r
 
@@ -345,8 +309,6 @@ class State:
         :return: Numeric state value
         """
         k = self.__check_name_valid(k)
-        if k == self.base_state_name:
-            return 0
         return getattr(self, k)
 
 
@@ -454,19 +416,16 @@ class State:
             raise StateCorruptionError(to_state)
 
         if self.verifier != None:
-            r = self.verifier(self, key, from_state, to_state)
+            r = self.verifier(self, from_state, to_state)
             if r != None:
                 raise StateTransitionInvalid(r)
 
-        old_state = self.__keys_reverse.get(key)
+        current_state_list.pop(idx) 
+
         if self.event_callback != None:
+            old_state = self.__keys_reverse.get(key)
             self.event_callback(key, self.name(old_state), self.name(to_state))
 
-        if old_state == 0:
-            current_state_list.pop(idx)
-        else:
-            for k in self.elements(from_state, numeric=True):
-                self.__keys[k].remove(key)
         self.__add_state_list(to_state, key)
 
         self.register_modify(key)
@@ -505,14 +464,12 @@ class State:
     def unset(self, key, not_state, allow_base=False):
         """Unset a single bit, moving to a pure or alias state.
         
-        If allow_base is set to False, The resulting state cannot be State.base_state_name (0).
+        The resulting state cannot be State.base_state_name (0).
          
         :param key: Content key to modify state for
         :type key: str
         :param or_state: Atomic stat to add
         :type or_state: int
-        :paran allow_base: Allow state to be reset to 0
-        :type allow_base: bool
         :raises ValueError: State is not a single bit state, or attempts to revert to State.base_state_name
         :raises StateItemNotFound: Content key is not registered
         :raises StateInvalid: Resulting state after addition of atomic state is unknown
@@ -602,7 +559,7 @@ class State:
             return []
 
 
-    def sync(self, state=None, not_state=None, ignore_auto=True):
+    def sync(self, state=None):
         """Noop method for interface implementation providing sync to backend.
         
         :param state: State to sync.

shep/store/file.py

@@ -1,7 +1,6 @@
 # standard imports
 import os
 import re
-import stat
 
 # local imports
 from .base import (
@@ -205,26 +204,9 @@ class SimpleFileStoreFactory(StoreFactory):
         r = []
         for v in os.listdir(self.__path):
             if re.match(re_processedname, v):
-                fp = os.path.join(self.__path, v)
+                r.append(v)
-                st = os.stat(fp)
-                if stat.S_ISDIR(st.st_mode):
-                    r.append(v)
         return r
 
 
-    def have(self, k):
-        lock_path = None
-        if self.__use_lock:
-            lock_path = os.path.join(self.__path, '.lock')
-        for d in self.ls():
-            p = os.path.join(self.__path, d)
-            s = SimpleFileStore(p, binary=self.__binary, lock_path=lock_path)
-            try:
-                s.get(k)
-            except:
-                return False
-            return True
-
-
     def close(self):
         pass

tests/test_file.py

@@ -244,21 +244,18 @@ class TestFileStore(unittest.TestCase):
 
 
     def test_factory_ls(self):
-        r = self.factory.ls()
-        self.assertEqual(len(r), 4)
-
         self.states.put('abcd')
         self.states.put('xxxx', state=self.states.BAZ)
         r = self.factory.ls()
-        self.assertEqual(len(r), 4)
+        self.assertEqual(len(r), 2)
 
         self.states.put('yyyy', state=self.states.BAZ)
         r = self.factory.ls()
-        self.assertEqual(len(r), 4)
+        self.assertEqual(len(r), 2)
 
         self.states.put('zzzz', state=self.states.BAR)
         r = self.factory.ls()
-        self.assertEqual(len(r), 4)
+        self.assertEqual(len(r), 3)
 
 
     def test_lock(self):

tests/test_state.py

@@ -124,7 +124,7 @@ class TestState(unittest.TestCase):
         states.set('abcd', states.BAZ)
         v = states.state('abcd')
         s = states.name(v)
-        self.assertEqual(s, '_FOO__BAZ')
+        self.assertEqual(s, '_FOO.BAZ')
 
 
     def test_peek(self):
@@ -318,41 +318,8 @@ class TestState(unittest.TestCase):
         states = State(2, default_state='FOO')
         with self.assertRaises(StateItemNotFound):
             states.state('NEW')
-        r = getattr(states, 'FOO')
+        getattr(states, 'FOO')
-        self.assertEqual(r, 0)
         states.state('FOO')
-        states.put('bar')
-        r = states.list(states.FOO)
-        self.assertEqual(len(r), 1)
-
-
-    def test_unset(self):
-        states = State(2)
-        states.add('one')
-        states.add('two')
-        states.alias('three', states.ONE, states.TWO)
-        states.put('foo', state=states.ONE)
-        states.set('foo', states.TWO)
-        r = states.list(states.ONE)
-        self.assertEqual(len(r), 1)
-        r = states.list(states.TWO)
-        self.assertEqual(len(r), 1)
-        r = states.unset('foo', states.ONE)
-        r = states.list(states.ONE)
-        self.assertEqual(len(r), 0)
-        r = states.list(states.TWO)
-        self.assertEqual(len(r), 1)
-
-
-    def test_move(self):
-        states = State(1)
-        states.add('one')
-        states.put('foo')
-        r = states.list(states.NEW)
-        self.assertEqual(len(r), 1)
-        states.move('foo', states.ONE)
-        r = states.list(states.NEW)
-        self.assertEqual(len(r), 0)
 
 
 if __name__ == '__main__':

tests/test_store.py

@@ -43,7 +43,7 @@ class TestStateItems(unittest.TestCase):
         self.mockstore = MockStore()
 
         def mockstore_factory(v):
-            #self.mockstore.for_state = v
+            self.mockstore.for_state = v
             return self.mockstore
 
         self.states = PersistedState(mockstore_factory, 4)
@@ -71,7 +71,7 @@ class TestStateItems(unittest.TestCase):
         item = b'foo'
         self.states.put(item, self.states.FOO, True)
         self.states.move(item, self.states.XYZZY) 
-        #self.assertEqual(self.mockstore.for_state, self.states.name(self.states.XYZZY))
+        self.assertEqual(self.mockstore.for_state, self.states.name(self.states.XYZZY))
         # TODO: cant check the add because remove happens after remove, need better mock
         self.assertIsNone(self.mockstore.v.get(item)) 
 
@@ -80,7 +80,7 @@ class TestStateItems(unittest.TestCase):
         item = b'foo'
         self.states.put(item)
         self.states.move(item, self.states.BAZ)
-        #self.assertEqual(self.mockstore.for_state, self.states.name(self.states.BAZ))
+        self.assertEqual(self.mockstore.for_state, self.states.name(self.states.BAZ))
         self.assertIsNone(self.mockstore.v.get(item))
 
 

tests/test_verify.py

@@ -8,7 +8,7 @@ from shep.error import (
         )
 
 
-def mock_verify(state, key, from_state, to_state):
+def mock_verify(state, from_state, to_state):
     if from_state == state.FOO:
         if to_state == state.BAR:
             return 'bar cannot follow foo'