CHANGELOG

@@ -1,17 +1,3 @@
-- 0.2.10
-	* Add count active states method
-	* Enable complete replace of NEW state on state instantiation
-- 0.2.9
-	* Enable access to is_pure method
-	* Numeric option for elements return value
-- 0.2.8
-	* Remove sync on persist set
-- 0.2.7
-	* Handle missing files in fs readdir list
-- 0.2.6
-	* Ensure atomic state lock in fs
-- 0.2.5
-	* Correct handling of persistent sync when no not-state filter has been set
 - 0.2.4
 	* Add optional concurrency lock for persistence store, implemented for file store
 - 0.2.3

setup.cfg

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

shep/persist.py

@@ -20,8 +20,8 @@ class PersistedState(State):
     :type logger: object
     """
 
-    def __init__(self, factory, bits, logger=None, verifier=None, check_alias=True, event_callback=None, default_state=None):
-        super(PersistedState, self).__init__(bits, logger=logger, verifier=verifier, check_alias=check_alias, event_callback=event_callback, default_state=default_state)
+    def __init__(self, factory, bits, logger=None, verifier=None, check_alias=True, event_callback=None):
+        super(PersistedState, self).__init__(bits, logger=logger, verifier=verifier, check_alias=check_alias, event_callback=event_callback)
         self.__store_factory = factory
         self.__stores = {}
 
@@ -69,7 +69,7 @@ class PersistedState(State):
             super(PersistedState, self).unset(key, or_state, allow_base=True)
             raise e
        
-        #self.sync(to_state)
+        self.sync(to_state)
 
         return to_state
 

shep/state.py

@@ -30,22 +30,16 @@ class State:
 
     base_state_name = 'NEW'
 
-    def __init__(self, bits, logger=None, verifier=None, check_alias=True, event_callback=None, default_state=None):
+    def __init__(self, bits, logger=None, verifier=None, check_alias=True, event_callback=None):
         self.__initial_bits = bits
         self.__bits = bits
         self.__limit = (1 << bits) - 1
         self.__c = 0
+        setattr(self, self.base_state_name, 0)
 
-        if default_state == None:
-            default_state = self.base_state_name
-
-        setattr(self, default_state, 0)
-
-        self.__reverse = {0: getattr(self, default_state)}
-        self.__keys = {getattr(self, default_state): []}
+        self.__reverse = {0: getattr(self, self.base_state_name)}
+        self.__keys = {getattr(self, self.base_state_name): []}
         self.__keys_reverse = {}
-        if default_state != self.base_state_name:
-            self.__keys_reverse[default_state] = 0
         self.__contents = {}
         self.modified_last = {}
         self.verifier = verifier
@@ -59,7 +53,7 @@ class State:
 
 
     # return true if v is a single-bit state
-    def is_pure(self, v):
+    def __is_pure(self, v):
         if v == 0:
             return True
         c = 1
@@ -145,7 +139,7 @@ class State:
     def __add_state_list(self, state, item):
         if self.__keys.get(state) == None:
             self.__keys[state] = []
-        if not self.is_pure(state) or state == 0:
+        if not self.__is_pure(state) or state == 0:
             self.__keys[state].append(item)
         c = 1
         for i in range(self.__bits):
@@ -202,7 +196,7 @@ class State:
         for a in args:
             a = self.__check_value_cursor(a)
             v = self.__check_limit(v | a, pure=False)
-        if self.is_pure(v):
+        if self.__is_pure(v):
             raise ValueError('use add to add pure values')
         return self.__set(k, v)
 
@@ -238,7 +232,7 @@ class State:
                 continue
             if pure:
                 state = self.from_name(k)
-                if not self.is_pure(state):
+                if not self.__is_pure(state):
                     continue
             if numeric:
                 if state == None:
@@ -250,22 +244,15 @@ class State:
         return l
 
 
-    def elements(self, v, numeric=False, as_string=True):
+    def elements(self, v):
         r = []
         if v == None or v == 0:
             return self.base_state_name
         c = 1
         for i in range(self.__bits):
             if v & c > 0:
-                if numeric:
-                    r.append(c)
-                else:
-                    r.append(self.name(c))
+                r.append(self.name(c))
             c <<= 1
-
-        if numeric or not as_string:
-            return r
-
         return '_' + '.'.join(r)
 
 
@@ -446,7 +433,7 @@ class State:
         :rtype: int
         :returns: Resulting state
         """
-        if not self.is_pure(or_state):
+        if not self.__is_pure(or_state):
             raise ValueError('can only apply using single bit states')
 
         current_state = self.__keys_reverse.get(key)
@@ -476,7 +463,7 @@ class State:
         :rtype: int
         :returns: Resulting state
         """
-        if not self.is_pure(not_state):
+        if not self.__is_pure(not_state):
             raise ValueError('can only apply using single bit states')
 
         current_state = self.__keys_reverse.get(key)
@@ -592,7 +579,7 @@ class State:
         state = self.__keys_reverse.get(key)
         if state == None:
             raise StateItemNotFound(key)
-        if not self.is_pure(state):
+        if not self.__is_pure(state):
             raise StateInvalid('cannot run next on an alias state')
        
         if state == 0:
@@ -667,7 +654,3 @@ class State:
             del self.modified_last[key]
         except KeyError:
             pass
-
-
-    def count(self):
-        return self.__c

shep/store/file.py

@@ -28,17 +28,22 @@ class SimpleFileStore:
             os.makedirs(lock_path, exist_ok=True)
 
 
+    def __is_locked(self, k):
+        if self.__lock_path == None:
+            return False
+        for v in os.listdir(self.__lock_path):
+            if k == v:
+                return True
+        return False
+       
+
     def __lock(self, k):
         if self.__lock_path == None:
             return
-        fp = os.path.join(self.__lock_path, k)
-        f = None
-        try:
-            f = open(fp, 'x')
-        except FileExistsError:
-            pass
-        if f == None:
+        if self.__is_locked(k):
             raise StateLockedKey(k)
+        fp = os.path.join(self.__lock_path, k)
+        f = open(fp, 'w')
         f.close()
 
 
@@ -115,11 +120,7 @@ class SimpleFileStore:
         files = []
         for p in os.listdir(self.__path):
             fp = os.path.join(self.__path, p)
-            f = None
-            try:
-                f = open(fp, self.__m[0])
-            except FileNotFoundError:
-                continue
+            f = open(fp, self.__m[0])
             r = f.read()
             f.close()
             if len(r) == 0:

tests/test_state.py

@@ -270,57 +270,5 @@ class TestState(unittest.TestCase):
             states.state('xyzzy')
 
 
-    def test_elements(self):
-        states = State(2)
-        states.add('foo')
-        states.add('bar')
-        states.alias('baz', states.FOO, states.BAR)
-
-        v = states.elements(states.BAZ)
-        self.assertIn('FOO', v)
-        self.assertIn('BAR', v)
-        self.assertIsInstance(v, str)
-
-        v = states.elements(states.BAZ, numeric=True)
-        self.assertIn(states.FOO, v)
-        self.assertIn(states.BAR, v)
-
-        v = states.elements(states.BAZ, as_string=False)
-        self.assertIn('FOO', v)
-        self.assertIn('BAR', v)
-        self.assertNotIsInstance(v, str)
-        self.assertIsInstance(v, list)
-
-
-    def test_count(self):
-        states = State(3)
-        states.add('foo')
-        states.add('bar')
-        self.assertEqual(states.count(), 2)
-        states.add('baz')
-        self.assertEqual(states.count(), 3)
-
-
-    def test_pure(self):
-        states = State(2)
-        states.add('foo')
-        states.add('bar')
-        states.alias('baz', states.FOO, states.BAR)
-
-        v = states.is_pure(states.BAZ)
-        self.assertFalse(v)
-
-        v = states.is_pure(states.FOO)
-        self.assertTrue(v)
-
-
-    def test_default(self):
-        states = State(2, default_state='FOO')
-        with self.assertRaises(StateItemNotFound):
-            states.state('NEW')
-        getattr(states, 'FOO')
-        states.state('FOO')
-
-
 if __name__ == '__main__':
     unittest.main()