def __init__(self):
b = bucket.Bucket(0, 2 ** 160)
self.nodes_dict = {}
self.bucket = None
self.buckets = {}
self.nodes_by_addr = {}
self.active_buckets = [b]
def __init__(self,
capacity,
fingerprint_size,
bucket_size=4,
max_kicks=500):
'''
Initialize Cuckoo filter parameters.
capacity : size of the filter
Defines how many buckets the filter contains.
fingerprint_size: size of the fingerprint in bytes
A larger fingerprint size results in a lower FPP.
bucket_size : nr. of entries a bucket can hold
A bucket can hold multiple entries.
Default size is 4, which closely approaches the best size for FPP between 0.00001 and 0.002 (see Fan et al.).
If your targeted FPP is greater than 0.002, a bucket size of 2 is more space efficient.
max_kicks : nr. of times entries are kicked around before deciding the filter is full
Defaults to 500. This is an arbitrary number also used by Fan et al. and seems reasonable enough.
'''
self.capacity = capacity
self.fingerprint_size = fingerprint_size
self.max_kicks = max_kicks
self.buckets = [
bucket.Bucket(size=bucket_size) for _ in range(self.capacity)
]
self.size = 0
self.bucket_size = bucket_size
def __init__(self, f, language='en', inter_links=True, enable_images=True):
global g_this_article_title, article_count
HTMLParser.HTMLParser.__init__(self)
self.wordwrap = WordWrap.WordWrap(get_utf8_cwidth)
self.local_init()
self.tag_stack = []
self.language = language
self.inter_links = inter_links
self.enable_images = enable_images
self.bucket = bucket.Bucket()
block = f.read(self.READ_BLOCK_SIZE)
while block:
self.feed(block)
block = f.read(self.READ_BLOCK_SIZE)
def __init__(self, rate, period, half_seconds, sample_count, step,
threshold_percentage):
"""
SlidingWindow
"""
self.rate = rate
self.period = period
self.half_seconds = half_seconds
self.sample_count = sample_count
self.tail = 0
self.buckets = []
self.step = step
self.status = CLOSE
self._semaphore = threading.Semaphore(1)
self._threshold_percentage = threshold_percentage
for _ in xrange(period / rate):
self.buckets.append(bucket.Bucket())
def __init__(self, capacity, bucket_size=4, fingerprint_size=7,
max_displacements=500):
"""
Initialize CuckooFilter object.
:param capacity: Size of the Cuckoo Filter
:param bucket_size: Number of entries in a bucket
:param fingerprint_size: Fingerprint size in bytes
:param max_displacements: Maximum number of evictions before filter is
considered full
"""
self.capacity = capacity
self.bucket_size = bucket_size
self.fingerprint_size = fingerprint_size
self.max_displacements = max_displacements
self.buckets = [bucket.Bucket(size=bucket_size)
for _ in range(self.capacity)]
self.size = 0
def increase_tail(self):
"""
slide the window and decide whether to create a new bucket
:return:
"""
while 1:
# decide whether to open the breaker
if self.status == CLOSE and self._total(
) > self.sample_count and self._calculate_failure_rate(
) > self._threshold_percentage:
self.set_open()
if self.tail + 1 >= self.period / self.rate:
tmp_buckets = self.buckets[1:self.tail + 1]
tmp_buckets.append(bucket.Bucket())
self.buckets = tmp_buckets
else:
self.tail += 1
time.sleep(self.rate / 1000)
def setUp(self):
self.bucket = bucket.Bucket('test')
os.environ['sae.kvdb.file'] = 'kvdb.file'
logger = logging.getLogger()
logger.debug('The service is starting.')
def get_env(key: str, message: str):
val = os.getenv(key)
if val is None:
logger.error(
f"Environment variable was not providd during deployment: {message}"
)
raise errors.ServerError("Invalid server configuration")
return val
permDB = db.PermDB(get_env("TABLE_NAME", "Permission table name"))
user_bucket = bucket.Bucket(get_env("BUCKET_NAME", "User data bucket"))
def create_file(path: FilePath):
object_exists = user_bucket.check_file_presence(path)
entry_existed = permDB.create_master_entry(path)
if object_exists and entry_existed:
raise errors.ConflictError("File already exists")
elif object_exists and not entry_existed:
# Delete the entry again
try:
permDB.delete_master_entry(path)
except Exception as e:
logger.error(
f"Failed to delete master entry after detecting existing s3 object, with error: {e}"
input('Insert bucket center point (x,y,z): '))),
dtype=float)
width = float(input('Insert bucket width: '))
height = float(input('Insert bucket height: '))
thickness = float(input('Insert bucket thickness: '))
maxEmptyArea = float(
input(
'Insert max empty area (for points distribution in obstacles): '))
fileName = input('Insert file name: ')
voronoi = voronizator.Voronizator()
print('Create bucket', flush=True)
voronoi.addPolyhedron(
bucket.Bucket(center,
width,
height,
thickness,
distributePoints=True,
maxEmptyArea=maxEmptyArea))
voronoi.addBoundingBox(minPoint, maxPoint, maxEmptyArea, verbose=True)
voronoi.setPolyhedronsSites(verbose=True)
voronoi.makeVoroGraph(verbose=True)
print('Write file', flush=True)
record = {}
record['voronoi'] = voronoi
with open(fileName, 'wb') as f:
pickle.dump(record, f)
def addBin(self,x, y, color):
self.binlist.append(bucket.Bucket(x, y, color))
