def test_two(self):
store = Store("./test.json")
key, value = "1", {"a": 1}
store.create(key, value)
with pytest.raises(KeyError):
store.create(key, value)
store.delete(key)
def test_three(self):
store = Store("./test.json")
key, value, ttl = "k", {"a": 1}, 5
store.create(key, value, ttl)
time.sleep(ttl + 1)
with pytest.raises(KeyError):
store.read(key)
def test_four(self):
store = Store("./test.json")
key, value, ttl = "k", {"a": 1}, 5
store.create(key, value, ttl)
time.sleep(ttl - 1)
assert json.loads(store.read(key)) == value
store.delete(key)
def create_domain():
domain = request.forms.domain
if domain:
store = Store()
store.create(domain)
flash("%s added" % domain)
fanout.update()
return redirect(url("domains"))
def creation():
""" create all the tables by calling static method from these tables
six tables including two association tables:
- CategoryProduct and StoreProduct ."""
with Connection.get_instance() as cursor:
sql = """ CREATE DATABASE IF NOT EXISTS openfoodbase CHARACTER SET utf8; """
cursor.execute(sql)
Category.create()
Product.create()
Store.create()
CategoryProduct.create()
StoreProduct.create()
Historic.create()
class Oath(Stack):
def __init__(self, id=ID, size=4, instance_type='p2.xlarge'):
self.id = id
with Session() as session:
# Get stack
if self.id in session:
self.stack = session[self.id]
else:
self.stack = {}
session[self.id] = self.stack
# Get Store
if 'store' in self.stack:
self.store = self.stack['store']
else:
self.store = Store(id=self.id,
profile_name='federate',
tags=OATH_TAGS)
self.stack['store'] = self.store
# Get Cluster
if 'cluster' in self.stack:
self.cluster = self.stack['cluster']
else:
self.cluster = Cluster(id=self.id,
size=size,
profile_name='federate',
region_name='eu-west-1',
image_id=OATH_EU_WEST_1_AMI,
subnet_id='subnet-ea60c68e',
instance_type=instance_type,
instance_role=OATH_INSTANCE_ROLE,
tags=OATH_TAGS,
ip_mask=OATH_NETWORK)
self.stack['cluster'] = self.cluster
def create(self):
self.store.create()
self.cluster.create()
return self
def terminate(self):
# We clean the bucket
# self.store.bucket.Object('.s3keep')
# We may want to delete bucket
# self.store.terminate()
self.cluster.terminate()
with Session() as session:
del session[self.id]
self.stack = None
# self.store = None
self.cluster = None
return self
class Home(Stack):
def __init__(self, id=ID, size=4, instance_type='m5.large'):
self.id = id
with Session() as session:
# Get stack
if self.id in session:
self.stack = session[self.id]
else:
self.stack = {}
session[self.id] = self.stack
# Get Store
if 'store' in self.stack:
self.store = self.stack['store']
else:
self.store = Store(id=self.id)
self.stack['store'] = self.store
# Get Cluster
if 'cluster' in self.stack:
self.cluster = self.stack['cluster']
else:
self.cluster = Cluster(id=self.id,
size=size,
region_name='eu-west-1',
instance_type=instance_type,
instance_role=HOME_INSTANCE_ROLE)
self.stack['cluster'] = self.cluster
def create(self):
self.store.create()
self.cluster.create()
return self
def terminate(self):
# We clean the bucket
# self.store.bucket.Object('.s3keep')
# We may want to delete bucket
# self.store.terminate()
self.cluster.terminate()
with Session() as session:
del session[self.id]
self.stack = None
# self.store = None
self.cluster = None
return self
class App:
def __init__(self):
self.store = Store()
def signup(self, username, password, name):
id = username
try:
self.store.create(id, {"name": name, "password": password})
return 1
except KeyError:
return 0
def login(self, username, password):
try:
user = json.loads(self.store.read(username))
if user["password"] == password:
return 1
except KeyError:
return 0
def test_one(self):
store = Store("./test.json")
key, value = "k", {"a": 1}
store.create(key, value)
assert json.loads(store.read(key)) == value
store.delete(key)
def test_one(self):
store = Store("./test.json")
key, value = "1", {"a": 1}
assert store.create(key, value) == None
store.delete(key)
def test_nine(self):
store = Store("./test.json")
key, value, ttl = "1", {"a": 1}, "10"
with pytest.raises(TypeError):
store.create(key, value, ttl)
def test_nine(self):
store = Store("./test.json")
key, value, ttl = "1", {"a": 1}, 10
assert store.create(key, value, ttl) == None
store.delete("1")
def test_eight(self):
store = Store("./test.json")
key, value = "a" * 33, {"a": 1}
with pytest.raises(KeyError):
store.create(key, value)
def test_seven(self):
store = Store("./test.json")
key, value = "1", []
with pytest.raises(TypeError):
store.create(key, value)
def test_five(self):
store = Store("./test.json")
key, value = "1", 1
with pytest.raises(TypeError):
store.create()
def test_four(self):
store = Store("./test.json")
key, value = "1", {"1"}
with pytest.raises(TypeError):
store.create(key, value)
class Local(Stack):
def __init__(self, id=ID, size=4, profile_name='default', tags=()):
self.id = id
self.size = size
self.profile_name = profile_name
self.tags = tags
# self.path = os.path.join(tempfile.gettempdir(), self.id)
self.path = os.path.join('/tmp', self.id)
self.subprocesses = []
with Session() as session:
# Get stack
if self.id in session:
self.stack = session[self.id]
else:
self.stack = {}
session[self.id] = self.stack
# Get Store
if 'store' in self.stack:
self.store = self.stack['store']
else:
self.store = Store(id=self.id,
profile_name=self.profile_name,
tags=self.tags)
self.stack['store'] = self.store
def create(self):
self.store.create()
return self
def terminate(self):
with Session() as session:
del session[self.id]
self.stack = None
return self
def setup(self):
logging.info("Setup the cluster for IPyParallel")
try:
os.mkdir(self.path)
except FileExistsError as e:
logging.info("{} already exists".format(self.path))
subprocess.run('pip3 install ipyparallel', shell=True)
subprocess.run(
'pip3 install https://github.com/danielfrg/s3contents/archive/master.zip',
shell=True)
self.subprocesses.append(subprocess.Popen('ipcontroller &',
shell=True))
subprocess.run('''echo 'from s3contents import S3ContentsManager
c = get_config()
# Set working dir
c.NotebookApp.notebook_dir = "{path}"
# Tell Jupyter to use S3ContentsManager for all storage.
c.NotebookApp.contents_manager_class = S3ContentsManager
c.S3ContentsManager.bucket = "{bucket}"' > {path}/jupyter_notebook_config.py
'''.format(bucket=self.store.name, path=self.path),
shell=True)
for host in range(self.size):
self.subprocesses.append(
subprocess.Popen(
'cd {path}; ipengine &'.format(path=self.path),
shell=True))
self.subprocesses.append(
subprocess.Popen(
'jupyter notebook --ip="*" --NotebookApp.token="" --config {path}/jupyter_notebook_config.py'
.format(path=self.path),
shell=True))
logging.info(
colored("You can now connect to http://localhost:8888", 'yellow'))
logging.info(
colored("Test ipyparallel (for tensorflow_p36 env) with",
'yellow'))
logging.info(
colored("""
import ipyparallel as ipp
rc = ipp.Client()
rc.ids
""", 'white'))
logging.info(colored("then", 'yellow'))
logging.info(
colored(
"""
v = rc[:]
def ls(i):
import socket
return (i, socket.gethostname())
r = v.map(ls, range(100))
for l in r.get():
print(l)
""", 'white'))
return self
class GUI(object):
def __init__(self, filename):
self.filename = filename
self.store = Store()
self.root = tkinter.Tk()
self.passphrase = None
self.selected = None
self.value_changing = False
left_frame = tkinter.Frame(self.root)
left_frame.pack(side=tkinter.LEFT, fill=tkinter.Y)
left_frame.rowconfigure(0, weight=1)
scroll = tkinter.Scrollbar(left_frame)
self.keys = tkinter.Listbox(left_frame, exportselection=0)
scroll.grid(row=0, column=1, sticky=tkinter.N+tkinter.S)
self.keys.grid(row=0, column=0, sticky=tkinter.N+tkinter.S)
scroll.config(command=self.keys.yview)
self.keys.config(yscrollcommand=scroll.set)
self.keys.bind("<ButtonRelease>", self.on_key_selected)
self.keys.bind("<KeyRelease>", self.on_key_selected)
add = tkinter.Button(
left_frame,
text="Add",
command=self.on_add_entry,
)
add.grid(row=1, columnspan=2, sticky=tkinter.E+tkinter.W)
self.value_box = tkinter.Text(self.root)
self.value_box.pack(side=tkinter.LEFT, fill=tkinter.BOTH)
self.value_box.bind('<<Modified>>', self.on_value_changed)
self.root.bind('<Control-s>', self.on_save)
def run(self):
if os.path.exists(self.filename):
dialog = PassphraseDialog(self.root, title='Passphrase')
if not dialog.run():
return
self.passphrase = dialog.passphrase
self.store.load(self.passphrase, self.filename)
self.show_keys()
else:
dialog = PassphraseDialog(self.root, title='Passphrase', confirm=True)
if not dialog.run():
return
self.passphrase = dialog.passphrase
self.store.create(self.passphrase)
self.update_modified()
self.root.mainloop()
def on_key_selected(self, *_args):
selected = self.keys.curselection()
if not selected:
self.selected = None
return
idx = int(selected[0])
self.selected = self.keys.get(idx)
value = self.store.entries[self.selected]
self.value_changing = True
self.value_box.delete(1.0, tkinter.END)
self.value_box.insert(1.0, value)
self.value_changing = False
def on_add_entry(self, *_args):
dialog = Dialog(self.root, title='Add', label='name')
if not dialog.run():
return
key = dialog.value
self.store.entries[key] = ''
self.store.modified = True
self.update_modified()
keys = self.show_keys()
self.keys.select_clear(0, tkinter.END)
self.keys.select_set(keys.index(key))
self.on_key_selected()
def on_value_changed(self, *_args):
# guard against getting called during key selection changes
# and also when the modified flag is reset to False.
if self.value_changing:
self.root.call(self.value_box, 'edit', 'modified', 0)
return
self.value_changing = True
self.root.call(self.value_box, 'edit', 'modified', 0)
self.value_changing = False
if self.selected:
value = self.value_box.get(1.0, tkinter.END)[:-1]
if self.store.entries[self.selected] != value:
self.store.entries[self.selected] = value
self.store.modified = True
self.update_modified()
def on_save(self, *_args):
self.store.save(self.filename)
self.update_modified()
def show_keys(self):
self.keys.delete(0, tkinter.END)
keys = self.store.entries.keys()
keys.sort()
for key in keys:
self.keys.insert(tkinter.END, key)
return keys
def update_modified(self):
title = 'Password Store - %s' % self.filename
if self.store.modified:
title += ' (*)'
self.root.title(title)
def test_three(self):
store = Store("./test.json")
key, value, ttl = "k", {"a": 1}, 5
store.create(key, value, ttl)
time.sleep(ttl - 1)
assert store.delete(key) == None
def test_one(self):
store = Store("./test.json")
key, value, ttl = "k", {"a": 1}, 5
store.create(key, value, ttl)
assert store.delete(key) == None
def create():
Purchase.create()
Product.create()
Purchase_product.create()
Store.create()
def test_three(self):
store = Store("./test.json")
key, value = 1, {"a": 1}
with pytest.raises(TypeError):
store.create(key, value)
class CLI(object):
def __init__(self, filename):
self.filename = filename
self.store = Store()
if os.path.exists(filename):
self.passphrase = self.get_passphrase()
self.store.load(self.passphrase, filename)
else:
self.passphrase = self.get_passphrase(confirm=True)
self.store.create(self.passphrase)
self.commands = {
'ls' : (self.cmd_list, 'l'),
'cat' : (self.cmd_cat, 'c:'),
'set' : (self.cmd_set, 's:'),
'rm' : (self.cmd_remove, 'r:'),
'save' : (self.cmd_save, ' '),
'change_passphrase': (self.cmd_change_passphrase, ' '),
}
def cmd_list(self):
print '\n'.join(sorted(self.store.entries.iterkeys()))
def cmd_cat(self, label):
entry = self.store.entries.get(label)
if entry is not None:
print entry
else:
print 'ERROR: label not found'
def cmd_set(self, label):
value = ''
while True:
line = sys.stdin.readline()
if line[0] == '\r' or line[0] == '\n':
break
value += line
self.store.entries[label] = value.strip()
self.store.modified = True
def cmd_remove(self, label):
try:
del self.store.entries[label]
self.store.modified = True
except KeyError:
print 'ERROR: label not found'
def cmd_save(self):
self.store.save(self.filename)
def cmd_change_passphrase(self):
current = self.get_passphrase(prompt="Current passphrase: ")
if current != self.passphrase:
print 'Incorrect, passphrase not changed.'
return
new_passphrase = self.get_passphrase(confirm=True, allow_blank=True)
if not new_passphrase:
print 'Passphrase not changed.'
else:
self.passphrase = new_passphrase
self.store.change_passphrase(new_passphrase)
def completer(self, text, state):
parts = readline.get_line_buffer().split(' ')
idx = len(parts)
if idx == 1:
matches = 0
for command, attrs in self.commands.items():
if command.startswith(text):
matches += 1
if matches > state:
if attrs[-1][-1] == ':':
command += ' '
return command
elif idx == 2:
matches = 0
for label in self.store.entries.iterkeys():
if label.startswith(text):
matches += 1
if matches > state:
return label
def get_passphrase(self, prompt=None, confirm=False, allow_blank=False):
while True:
passphrase = getpass(prompt or "Passphrase: ")
if not passphrase:
if allow_blank:
return
continue
if confirm:
again = getpass("Confirm passphrase: ")
if passphrase != again:
print 'Passphrases did not match, please try again.'
continue
break
return passphrase
def run(self):
readline.set_completer(self.completer)
while True:
try:
command = raw_input('*> ' if self.store.modified else '> ')
except EOFError:
print
break
parts = command.split(' ')
if len(parts):
proc, _ = self.commands.get(parts[0], (None, None))
if proc:
proc(*parts[1:])
