0.1.1 (#27)

* Cuckoo Filter
    * enforce unique inserts
    * import / export 
    * self expanding cuckoo filter implementation

CHANGELOG.md

@@ -1,5 +1,11 @@
 # PyProbables Changelog
 
+### Version 0.1.1:
+* CuckooFilter
+    * Import / Export functionality
+    * Enforce single insertion per key
+    * Auto expand when insertion failure OR when called to do so (settable)
+
 ### Version 0.1.0:
 * Cuckoo Filter
     * Added basic Cuckoo Filter code

probables/__init__.py

@@ -11,7 +11,7 @@
 __maintainer__ = 'Tyler Barrus'
 __email__ = 'barrust@gmail.com'
 __license__ = 'MIT'
-__version__ = '0.1.0'
+__version__ = '0.1.1'
 __credits__ = []
 __url__ = 'https://github.com/barrust/pyprobables'
 __bugtrack_url__ = 'https://github.com/barrust/pyprobables/issues'

probables/blooms/countingbloom.py

@@ -6,6 +6,7 @@
 from __future__ import (unicode_literals, absolute_import, print_function,
                         division)
 from . basebloom import (BaseBloom)
+from .. constants import (UINT32_T_MAX, UINT64_T_MAX)
 
 MISMATCH_MSG = ('The parameter second must be of type CountingBloomFilter')
 
@@ -44,8 +45,6 @@ def __init__(self, est_elements=None, false_positive_rate=None,
                                                   false_positive_rate,
                                                   filepath, hex_string,
                                                   hash_function)
-        self.__uint32_t_max = 2**32 - 1
-        self.__uint64_t_max = 2**64 - 1
 
     def __str__(self):
         ''' correctly handle python 3 vs python2 encoding if necessary '''
@@ -110,20 +109,20 @@ def add_alt(self, hashes, num_els=1):
             Returns:
                 int: Maximum number of insertions
         '''
-        res = self.__uint32_t_max
+        res = UINT32_T_MAX
         for i in list(range(0, self.number_hashes)):
             k = int(hashes[i]) % self.number_bits
             j = self._get_element(k)
             tmp = j + num_els
-            if tmp <= self.__uint32_t_max:
+            if tmp <= UINT32_T_MAX:
                 self._bloom[k] = self._get_set_element(j + num_els)
             else:
-                self._bloom[k] = self.__uint32_t_max
+                self._bloom[k] = UINT32_T_MAX
             if self._bloom[k] < res:
                 res = self._bloom[k]
         self.elements_added += num_els
-        if self.elements_added > self.__uint64_t_max:
-            self.elements_added = self.__uint64_t_max
+        if self.elements_added > UINT64_T_MAX:
+            self.elements_added = UINT64_T_MAX
         return res
 
     def check(self, key):
@@ -147,7 +146,7 @@ def check_alt(self, hashes):
             Returns:
                 int: Maximum number of insertions
         '''
-        res = self.__uint32_t_max
+        res = UINT32_T_MAX
         for i in list(range(0, self.number_hashes)):
             k = int(hashes[i]) % self.number_bits
             tmp = self._get_element(k)
@@ -179,8 +178,8 @@ def remove_alt(self, hashes, num_els=1):
                 int: Maximum number of insertions after the removal
         '''
         tmp = self.check_alt(hashes)
-        if tmp == self.__uint32_t_max:  # cannot remove if we have hit the max
-            return self.__uint32_t_max
+        if tmp == UINT32_T_MAX:  # cannot remove if we have hit the max
+            return UINT32_T_MAX
         elif tmp == 0:
             return 0
 

probables/constants.py

@@ -0,0 +1,7 @@
+''' Project Constants (or basic numerical constants...) '''
+INT32_T_MIN = -2147483648
+INT32_T_MAX = 2147483647
+INT64_T_MIN = -9223372036854775808
+INT64_T_MAX = 9223372036854775807
+UINT32_T_MAX = 2**32 - 1
+UINT64_T_MAX = 2**64 - 1

probables/countminsketch/countminsketch.py

@@ -11,6 +11,7 @@
 from .. exceptions import (InitializationError, NotSupportedError)
 from .. hashes import (default_fnv_1a)
 from .. utilities import (is_valid_file)
+from .. constants import (INT32_T_MIN, INT32_T_MAX, INT64_T_MIN, INT64_T_MAX)
 
 
 class CountMinSketch(object):
@@ -50,11 +51,6 @@ def __init__(self, width=None, depth=None, confidence=None,
         self.__error_rate = 0.0
         self.__elements_added = 0
         self.__query_method = self.__min_query
-        # for python2 and python3 support
-        self.__int32_t_min = -2147483648
-        self.__int32_t_max = 2147483647
-        self.__int64_t_min = -9223372036854775808
-        self.__int64_t_max = 9223372036854775807
 
         if is_valid_file(filepath):
             self.__load(filepath)
@@ -216,13 +212,13 @@ def add_alt(self, hashes, num_els=1):
         for i, val in enumerate(hashes):
             t_bin = (val % self.__width) + (i * self.__width)
             self._bins[t_bin] += num_els
-            if self._bins[t_bin] > self.__int32_t_max:
-                self._bins[t_bin] = self.__int32_t_max
+            if self._bins[t_bin] > INT32_T_MAX:
+                self._bins[t_bin] = INT32_T_MAX
             res.append(self._bins[t_bin])
         self.__elements_added += num_els
 
-        if self.__elements_added > self.__int64_t_max:
-            self.__elements_added = self.__int64_t_max
+        if self.__elements_added > INT64_T_MAX:
+            self.__elements_added = INT64_T_MAX
         return self.__query_method(sorted(res))
 
     def remove(self, key, num_els=1):
@@ -252,12 +248,12 @@ def remove_alt(self, hashes, num_els=1):
         for i, val in enumerate(hashes):
             t_bin = (val % self.__width) + (i * self.__width)
             self._bins[t_bin] -= num_els
-            if self._bins[t_bin] < self.__int32_t_min:
-                self._bins[t_bin] = self.__int32_t_min
+            if self._bins[t_bin] < INT32_T_MIN:
+                self._bins[t_bin] = INT32_T_MIN
             res.append(self._bins[t_bin])
         self.__elements_added -= num_els
-        if self.__elements_added < self.__int64_t_min:
-            self.__elements_added = self.__int64_t_min
+        if self.__elements_added < INT64_T_MIN:
+            self.__elements_added = INT64_T_MIN
 
         return self.__query_method(sorted(res))