def test_flata_external_cache_json_storage():
_cache = CachingMiddleware(JSONStorage)('db.json')
with Flata('db.json', cache=_cache) as db:
assert isinstance(db._storage, (CachingMiddleware, JSONStorage))
db.close()
def setup(table_name: str, id_field: str):
"""Creates the specified table if not yet exists in the db.json and returns its reference either way"""
db = Flata('db.json', storage=JSONStorage)
db.table(table_name, id_field=id_field)
return db.get(table_name)
def test_flata_json_storage():
with Flata('db.json', storage=JSONStorage) as db:
assert isinstance(db._storage, JSONStorage)
db.close()
def test_flata_caching_json_storage():
with Flata('db.json', storage=CachingMiddleware(JSONStorage)) as db:
assert isinstance(db._storage, (CachingMiddleware, JSONStorage))
db.close()
import os
from flata import Flata, Query
from flata.storages import JSONStorage
from flask import Flask, request, render_template, url_for, redirect
from random import choice, randint
from string import ascii_letters
app_storage_file = os.getenv('APP_STORAGE_FILE', '/tmp/db.json')
app_tiny_baseurl = os.getenv('APP_BASEURL', 'localhost:5000/t')
app_protocol = os.getenv('APP_PROTOCOL', 'https')
app_name = os.getenv('APP_NAME', 'My')
body_text = app_name + ' URL Shortener'
db_init = Flata(app_storage_file, storage=JSONStorage)
db_init.table('collection1', id_field = 'counter_id')
db = db_init.get('collection1')
q = Query()
tiny_appurl = app_protocol + '://' + app_tiny_baseurl + '/t'
def generate_tiny():
tiny_key = ''.join(choice(ascii_letters) + str(randint(0,9)) for x in range(randint(8, 8))).lower()
return tiny_key
def put_url(destination_url):
tiny_id = generate_tiny()
tiny_url = '{}/{}'.format(tiny_appurl, tiny_id)
db.insert({'id': tiny_id, 'name': tiny_url, 'value': destination_url})
return tiny_url
def get_url(tiny_url):
def test_flata_external_cache_memory_storage():
_cache = CachingMiddleware(MemoryStorage)()
with Flata('db.json', cache=_cache) as db:
assert isinstance(db._storage, (CachingMiddleware, MemoryStorage))
db.close()
def db():
db_ = Flata(storage=MemoryStorage)
db_.purge_tables()
db_.table('t').insert_multiple({'int': 1, 'char': c} for c in 'abc')
return db_
def test_caching_read():
db = Flata(storage=CachingMiddleware(MemoryStorage))
assert not db.all()
def test_json_invalid_directory():
with pytest.raises(IOError):
with Flata('/this/is/an/invalid/path/db.json', storage=JSONStorage):
pass
def test_in_memory_close():
with Flata('', storage=MemoryStorage) as db:
db.table('t').insert({})
## Made by Samuel Pratt
## Victoria, BC, Canada
import os
import json
from flask_cors import CORS
from flask import Flask, jsonify, render_template
from flata import Flata, where
from flata.storages import JSONStorage
from apscheduler.scheduler import Scheduler
from scraper import get_data
# Initialize db
db = Flata('./db.json', storage=JSONStorage)
db.table('table1')
db.get('table1')
app = Flask(__name__)
CORS(app)
# Scheduler object
sched = Scheduler(daemon=True)
sched.start()
# Valid departure terminals
departure_terminals = [
"tsawwassen", "swartz-bay", "nanaimo-(duke-pt)", "nanaimo-(dep.bay)",
"horseshoe-bay", "langdale"
]
# Valid destination terminals
def readJson(path_db):
db = Flata(path_db, storage=JSONStorage)
dic = db.all()
return dic
def readFromJson(path_db, table_name):
tb = Flata(path_db, storage=JSONStorage).table(table_name).all()[0]
return tb
Small document databases
https://tinydb.readthedocs.io/en/latest/
https://github.com/harryho/flata
https://blog.ruanbekker.com/blog/2018/04/15/experimenting-with-python-and-flata-the-lightweight-document-orientated-database/
"""
metadata_file = 'metadata.json'
data_file = 'public/data.js'
database_file = 'database.json'
DATETIME_FORMAT = '%Y.%m.%dT%H:%M:%S%z'
# FlataDB
from flata import Flata, Query, where
from flata.storages import JSONStorage
db = Flata(database_file, storage=JSONStorage)
q = Query()
# Init
metadata_uid = 1
metadataTable = db.table('metadata', id_field='uid')
recordsTable = db.table('records', id_field='uid')
def get_db():
return db
# So we don't need to write strings
category = 'category'
sub_category = 'sub_category'
def test_flata_memory_storage():
with Flata('db.json', storage=MemoryStorage) as db:
assert isinstance(db._storage, MemoryStorage)
db.close()
import platform
from flata import Flata, where, Query
from flata.storages import JSONStorage
import json
import threading
import time
t = None
logger = logging.getLogger('discord')
logger.setLevel(logging.DEBUG)
handler = logging.FileHandler(filename='discord.log', encoding='utf-8', mode='w')
handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s'))
logger.addHandler(handler)
db = Flata('db.json', storage=JSONStorage)
db.table('stats')
tb = db.get('stats')
# Start if script
client = Bot(description="Discord BOT that collects info about people being in voice channel", command_prefix="$", pm_help = False)
@client.event
async def on_ready():
print('Logged in as '+client.user.name+' (ID:'+client.user.id+') | Connected to '+str(len(client.servers))+' servers | Connected to '+str(len(set(client.get_all_members())))+' users')
print('--------')
print('Current Discord.py Version: {} | Current Python Version: {}'.format(discord.__version__, platform.python_version()))
print('--------')
print('Use this link to invite {}:'.format(client.user.name))
print('https://discordapp.com/oauth2/authorize?client_id={}&scope=bot&permissions=8'.format(client.user.id))
print('--------')
def test_flata_caching_memory_storage():
with Flata('db.json', storage=CachingMiddleware(MemoryStorage)) as db:
assert isinstance(db._storage, (CachingMiddleware, MemoryStorage))
db.close()
def test_multiple_dbs():
db1 = Flata(storage=MemoryStorage)
db2 = Flata(storage=MemoryStorage)
db1.table('t').insert({'int': 1, 'char': 'a'})
db1.table('t').insert({'int': 1, 'char': 'b'})
db1.table('t').insert({'int': 1, 'value': 5.0})
db2.table('t').insert({'color': 'blue', 'animal': 'turtle'})
assert len(db1.table('t').all()) == 3
assert len(db2.table('t').all()) == 1
#!/usr/bin/env pipenv run python
import sys
from pyfancy.pyfancy import pyfancy
from flata import Flata, where
from flata.storages import JSONStorage
db = Flata('db.json', storage=JSONStorage)
db.table('todos')
args = sys.argv
# usage represents the help guide
def usage():
usageText = """
todo helps you manage your todo tasks
usage:
todo <command>
commands can be:
new: used to create a new todo
get: used to retrieve your todos
complete: used to mark a todo as complete
help: used to print the usage guide
"""
print(usageText)
