def test_pickleshare(tmpdir):
db = PickleShareDB(tmpdir)
db.clear()
print("Should be empty:",db.items())
assert len(db) == 0
db['hello'] = 15
assert db['hello'] == 15
db['aku ankka'] = [1,2,313]
assert db['aku ankka'] == [1,2,313]
db['paths/nest/ok/keyname'] = [1,(5,46)]
assert db['paths/nest/ok/keyname'] == [1,(5,46)]
db.hset('hash', 'aku', 12)
db.hset('hash', 'ankka', 313)
assert db.hget('hash', 'aku') == 12
assert db.hget('hash', 'ankka') == 313
print("all hashed",db.hdict('hash'))
print(db.keys())
print(db.keys('paths/nest/ok/k*'))
print(dict(db)) # snapsot of whole db
db.uncache() # frees memory, causes re-reads later
# shorthand for accessing deeply nested files
lnk = db.getlink('myobjects/test')
lnk.foo = 2
lnk.bar = lnk.foo + 5
assert lnk.bar == 7
def test_pickleshare(tmpdir):
db = PickleShareDB(tmpdir)
db.clear()
print("Should be empty:", db.items())
assert len(db) == 0
db['hello'] = 15
assert db['hello'] == 15
db['aku ankka'] = [1, 2, 313]
assert db['aku ankka'] == [1, 2, 313]
db['paths/nest/ok/keyname'] = [1, (5, 46)]
assert db['paths/nest/ok/keyname'] == [1, (5, 46)]
db.hset('hash', 'aku', 12)
db.hset('hash', 'ankka', 313)
assert db.hget('hash', 'aku') == 12
assert db.hget('hash', 'ankka') == 313
print("all hashed", db.hdict('hash'))
print(db.keys())
print(db.keys('paths/nest/ok/k*'))
print(dict(db)) # snapsot of whole db
db.uncache() # frees memory, causes re-reads later
# shorthand for accessing deeply nested files
lnk = db.getlink('myobjects/test')
lnk.foo = 2
lnk.bar = lnk.foo + 5
assert lnk.bar == 7
def registrar_BD(username, password):
db = PickleShareDB('miBD')
if username in db.keys():
return "Incorrecto"
else:
session['logged'] = True
session['username'] = username
db[username] = {'pass': password}
return "Correcto"
def registBD(username, password):
db = PickleShareDB('miBD')
if username in db.keys():
return False
else:
session['logged'] = True
session['username'] = username
db[username] = {'pass': password}
return True
def login_BD(username, password):
db = PickleShareDB('miBD')
if username in db.keys(
) and db[username] and password == db[username]["pass"]:
session['logged'] = True
session['username'] = username
return "Credenciales correctas"
else:
return "Credenciales incorrectas"
def login():
form = LoginForm()
if form.validate_on_submit():
db = PickleShareDB('miBD')
try:
if db.keys().index(f'{form.username.data}') != ValueError and form.password.data == db[f'{form.username.data}']['pass']:
flash(f'Hi {form.username.data}!', 'success')
session['username'] = f'{form.username.data}'
return redirect(url_for('home'))
else:
raise ValueError
except ValueError:
flash('Login Unsuccessful. Please check username and password', 'danger')
return render_template('login.html', title='Login', form = form)
def register():
form = RegistrationForm()
if form.validate_on_submit():
db = PickleShareDB('miBD')
try:
if db.keys().index(f'{form.username.data}') != ValueError:
flash('User already exist', 'danger')
else:
raise ValueError
except ValueError:
flash(f'Account created for {form.username.data}!', 'success')
db[f'{form.username.data}'] = { 'pass' : f'{form.password.data}' }
return redirect(url_for('home'))
return render_template('register.html', title='Register', form = form)
class Task(object):
""" A Task is a Pipe-like function that also propagates job information
note: a task is pickleable
TODO:
* add memoization / conditional work
This should not run the function if not necessary
"""
def __init__(self, func, args=(), name=None, memoized=False, logger=None, **kwargs):
if type(memoized) not in [ bool, str ]:
raise ValueError('memoized value "{}" not understood. Expecting Boolean or str')
self.memoized = memoized
self.func = func
self.name = name or func.__name__
self.args = args
self.kwargs = kwargs
update_wrapper(self, func)
self.__set_memoize_backend__()
self.set_logger(logger)
def set_logger(self, logger, **kwargs):
""" set the logger backend """
if isinstance(logger, Logger):
self.logger = logger
else:
self.logger = Logger(out=logger, **kwargs)
def memoize(self, val=None):
if val is None:
return self.memoized
else:
self.memoized = val
self.__set_memoize_backend__()
def clear_memoized(self):
if self._cache is not None:
self._cache.clear()
def get_job_status(self, job_id, strict=True):
""" Check if previous results are available
if strict, unkown jobs will raise KeyError exceptions, otherwise
return False
"""
key = '{}/{}'.format(job_id, self.name)
if self.memoized is False:
return False
elif (key in self._cache):
return True
else:
if strict:
raise KeyError('Job "{}" not found'.format(job_id))
else:
return False
def get(self, job_id, strict=True):
""" get the result from a previous memoized job
See also get_job_status
"""
if self.get_job_status(job_id, strict=strict):
key = '{}/{}'.format(job_id, self.name)
return self._cache[key]
def __set_memoize_backend__(self):
""" Defines the backend for memoization of the results """
if self.memoized is False:
self._cache = None
elif self.memoized is True:
self._cache = {}
elif isinstance(self.memoized, str):
self._cache = PickleShareDB(self.memoized)
def run(self, key, val, *args, **kwargs):
if hasattr(val, '__iter__'):
_args = tuple(val) + args + self.args
else:
_args = (val, ) + args + self.args
_kwargs = self.kwargs.copy()
_kwargs.update(kwargs)
if self.memoized is False:
self.logger.write('Job {} -- started\n'.format(key))
ret = self.func(*_args, **_kwargs)
self.logger.write('Job {} -- ended\n'.format(key))
return ret
else:
if (key not in self._cache.keys()):
self.logger.write('Job {} -- started\n'.format(key))
self._cache[key] = self.func(*_args, **_kwargs)
self.logger.write('Job {} -- ended\n'.format(key))
return self._cache[key]
else:
self.logger.write('Job {} -- existing result, skipped\n'.format(key))
return self._cache[key]
def __ror__(self, other):
""" Used for the | operator """
job_id = other[0]
key = '{}/{}'.format(job_id, self.name)
return job_id, self.run(key, other[1])
def __call__(self, *args, **kwargs):
if len(args) > 0:
self.args = args
if len(kwargs) > 0:
self.memoized = kwargs.pop('memoized', self.memoized)
self.logger = kwargs.pop('memoized', self.logger)
self.kwargs = kwargs
return self
def __repr__(self):
txt = 'Task: {}'.format(self.func.__repr__())
if self.memoized:
txt += '\n memoized {}'.format(object.__repr__(self._cache))
if self.logger is not None:
txt += '\n Logger {}'.format(self.logger.__repr__())
return txt
def __getitem__(self, job_id):
return self.get(job_id)
def editar_BD(username, password):
db = PickleShareDB('miBD')
if username in db.keys():
del db[username]
registrar_BD(username, password)
