def device(req, resp):
gc.collect()
if req.method == 'POST':
yield from req.read_form_data()
#TODO: field validation
f = open("datastore/config.db", "r+b")
db = btree.open(f)
db[b"eci1_crc1"] = req.form.get("eci1_crc1")[0]
db[b"eci1_crc2"] = req.form.get("eci1_crc2")[0]
db[b"eci1_gain"] = req.form.get("eci1_gain")[0]
db[b"eci1_ugain"] = req.form.get("eci1_ugain")[0]
db[b"eci2_crc1"] = req.form.get("eci2_crc1")[0]
db[b"eci2_crc2"] = req.form.get("eci2_crc2")[0]
db[b"eci2_gain"] = req.form.get("eci2_gain")[0]
db[b"eci2_ugain"] = req.form.get("eci2_ugain")[0]
db.close()
f.close()
# TODO: Redirect not working?, memory problem?
yield from resp.awrite("HTTP/1.0 308 Redirect \r\n")
yield from resp.awrite("Location: http://192.168.4.1:8081/\r\n")
else:
f = open("datastore/config.db", "r+b")
db = btree.open(f)
# TODO: Check if passing db saves any *real* memory - is this a weird way to pass variables to template?
yield from picoweb.start_response(resp)
yield from app.render_template(resp, "hardware.html", (db, ))
db.close()
f.close()
def __init__(self):
try:
self.file = open("tiny.db", "r+b")
self.db = btree.open(self.file)
except OSError:
self.file = open("tiny.db", "w+b")
self.db = btree.open(self.file)
self.db[b"key"] = ""
def networks(req, resp):
if req.method == 'POST':
# Process form
yield from req.read_form_data()
ssid = req.form.get('ssid')[0]
pwd = req.form.get('pwd')[0]
f = open("network.db", "r+b")
db = btree.open(f)
if req.form.get('connect'):
try:
network = ujson.loads(db[ssid])
network['pwd'] = pwd
except KeyError:
network = {
"ssid": ssid,
"pwd": pwd,
"strength": None,
"connected": False
}
db[ssid] = ujson.dumps(network)
# TODO attempt to connect to network
print('connect to network: %s / pwd:%s' % (ssid, pwd))
elif req.form.get('forget'):
del db[ssid]
print('Forget network: %s ' % ssid)
db.close()
f.close()
# Load networks from db
# Open db (assumes it exists at this point)
f = open("network.db", "r+b")
db = btree.open(f)
# Retrieve all network, convert to list of dicts
networks = []
for key in db:
data = ujson.loads(db[key])
networks.append(
Network(key.decode("utf-8"), data['strength'], data['pwd'],
data['connected']))
db.close()
f.close()
#TODO: sort network list
# networks.sort(key=lambda n:(str(n['connected']), n['pwd'], n['strength'], n['ssid']), reverse=True)
yield from picoweb.start_response(resp)
yield from app.render_template(resp, "networks.html", (networks, ))
def c():
M = b'todo'
L = '.db'
G = 'modulelist'
import machine as N, btree
try:
C = K(G + L, 'r+b')
E = O
except D:
C = K(G + L, 'w+b')
E = F
stubber = Stubber(path=read_path())
if not E: stubber.clean()
A = btree.open(C)
if not E or I(list(A.keys())) == 0:
for P in K(G + '.txt'):
B = P.strip()
if I(B) and B[0] != '#': A[B] = M
A.flush()
for B in A.keys():
if A[B] != M: continue
H = F
try:
H = stubber.create_one_stub(B.decode(a))
except MemoryError:
A.close()
C.close()
N.reset()
if H: J = 'good, I guess'
else: J = b'skipped'
A[B] = J
A.flush()
A.close()
C.close()
def get(cfg_name):
"""
get: get config setting from btree ui.cfg file if one exists
Args:
cfg_name ([str, bytes]): name of setting to load
Returns:
(string): value of setting
"""
name = cfg_name.encode() if isinstance(cfg_name, str) else cfg_name
try:
cfg_file = open("ui.cfg", "r+b")
except OSError:
cfg_file = open("ui.cfg", "w+b")
cfg_db = btree.open(cfg_file)
try:
cfg_value = cfg_db[name]
except KeyError:
cfg_value = b''
cfg_db.close()
cfg_file.close()
return cfg_value.decode('ascii')
def open(self, path):
try:
self._fd = open(path, "r+b")
except OSError:
self._fd = open(path, "w+b")
self._db = btree.open(self._fd)
def _initialize(self):
try:
self._stream = open("{}/{}".format(DB_FOLDER, self._name), "r+b")
except OSError:
self._stream = open("{}/{}".format(DB_FOLDER, self._name), "w+b")
self._db = btree.open(self._stream)
def delete(self, document_id: int, drop_all: bool = False) -> str:
'''
This method can delete a single document with doc_id(int) param or can
delete all documents in database with drop_all(bool) param.
Returns str of how many documents deleted.
'''
document_id = str(document_id)
if document_id and not drop_all:
try:
del self.db[document_id]
self.db.flush()
self.db_len -= 1
documents_deleted = 1
except KeyError:
return 'document_id not found'
elif drop_all and not document_id:
documents_deleted = self.db_len
self.db_len = 0
self.db.close()
load_db(self.db_filepath, write_mode='wb')
self.db = btree.open(load_db(self.db_filepath, 'r+b'),
pagesize=1024)
return '{} documents deleted'.format(documents_deleted)
def connect(self):
try:
self.f = open("espdb", "r+b")
except OSError:
self.f = open("espdb", "w+b")
self.db = btree.open(self.f)
self.log.info("Database initiated with success")
def __init__(self, pulse_per_kwh):
"""Setup, including initialsing the database if it doesnt exist."""
self._kwh_per_pulse = 1 / pulse_per_kwh
self._persist_counter = 0
self._debounce_time = time.ticks_ms()
# Setup DB
try:
self._dbfile = open("db", "r+b")
print("Opened DB")
except OSError:
self._dbfile = open("db", "w+b")
print("Created DB")
self._db = btree.open(self._dbfile)
if b"kwh" not in self._db:
self._db["kwh"] = str(0)
self._db.flush()
print("Initialised DB")
self._kwh = float(self._db[b"kwh"])
# Setup averages
self.timestamp = "NaN"
self._timer = Timer(-1)
self._timer.init(
period=MS_IN_MINUTE, mode=Timer.PERIODIC, callback=self.timer_handler
)
self._pulses_per_minute = 0
self.kw_history = []
self.joules = 0
def webReplOff():
import btree
f = open("mydb", "w+b")
db = btree.open(f)
db[b"wr"] = b"0"
db.flush()
machine.reset()
def _initialize(self):
try:
self._stream = open("/".join((self.path, self.name)), "r+b")
except OSError:
self._stream = open("/".join((self.path, self.name)), "w+b")
self._db = btree.open(self._stream)
def put(cfg_name, cfg_value):
"""
put: put config setting into btree ui.cfg file
Args:
cfg_name ([str, bytes, bytearray]): name of setting to store
cfg_value ([str, bytes, bytearray]): value of setting to store
"""
if isinstance(cfg_name, str):
name = cfg_name.encode()
else:
name = cfg_name
if isinstance(cfg_value, str):
value = cfg_value.encode()
else:
value = cfg_value
try:
cfg_file = open("ui.cfg", "r+b")
except OSError:
cfg_file = open("ui.cfg", "w+b")
cfg_db = btree.open(cfg_file)
cfg_db[name] = value
cfg_db.close()
cfg_file.close()
def network_db():
try:
f = open("network.db", "r+b")
except OSError:
f = open("network.db", "w+b")
# Now open a database itself
db = btree.open(f)
# The keys you add will be sorted internally in the database
db[b"blam"] = ujson.dumps({
"strength": -84,
"pwd": "",
"connected": True
})
db[b"Telstra2EC8"] = ujson.dumps({
"strength": -78,
"pwd": "",
"connected": False
})
db[b"Hal-North"] = ujson.dumps({
"strength": -84,
"pwd": "",
"connected": False
})
db[b"myHiddenNetwork"] = ujson.dumps({
"strength": -91,
"pwd": "shhhh!",
"connected": False
})
db.close()
f.close()
def scan_networks():
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
nets = sta_if.scan()
# Note: Networks may appear multiple times. raw list is reduced to single instance of each network
networks = {}
for n in nets:
ssid = n[0].decode("utf-8")
if ssid not in networks:
networks[ssid] = {
"ssid": ssid,
"str":n[3],
"pwd":''
}
elif n[3] > networks[ssid]['str']:
networks[n[0].decode("utf-8")]['str'] = n[3]
# Incorporate saved passwords
f = open("datastore/network.db", "r+b")
db = btree.open(f)
for key in db:
if key.decode("utf-8") in networks:
networks[key.decode("utf-8")]['pwd'] = db[key].decode("utf-8")
db.close()
f.close()
networks = list(networks.values())
# TODO: include 'connected' in sort order)
networks.sort(key=lambda n:(n['pwd'], n['str']), reverse=True)
return networks
def get(key):
f = open(file, 'r+b')
db = btree.open(f)
try:
return db[key].decode('utf-8')
except KeyError:
return None
db.close()
def __init__(self):
try:
self.fichero = open(
"juegodb",
"r+b") # si hay un fichero de base de datos existente lo abre
except OSError:
self.fichero = open("juegodb", "w+b") # sino crea uno nuevo
self.db = btree.open(self.fichero)
def __init__(self, dbfile="salatimes.db"):
try:
self.f = open(dbfile, "r+b")
except OSError:
print("Salat db '", dbfile,
"' seems not to exist ? creating a new one")
self.f = open(dbfile, "w+b")
self.db = btree.open(self.f)
def _db_init(self):
'''
This function intitializes the database file. If the specified
database file does not exist it creates it. If file is not located
in root directory, parent directories must already exist.
'''
try:
if (self.db_filepath.split('/')[-1] not in listdir('/'.join(
[file for file in self.db_filepath.split('/')[0:-1]]))):
return btree.open(load_db(self.db_filepath, write_mode='w+b'),
pagesize=1024)
return btree.open(load_db(self.db_filepath, write_mode='r+b'),
pagesize=1024)
except OSError:
print('Please create db_filepath parent directories')
return None
def _db_action(self, action):
with self._access(self._filename) as f:
db = btree.open(f) # Btree doesn't support `with`.
try:
return action(db)
finally:
# Note that closing the DB does a flush.
db.close()
def open(self):
if self.is_open():
return
try:
self._file = open(DBNAME, 'r+b')
except OSError:
self._file = open(DBNAME, 'w+b')
self._db = btree.open(self._file)
self._db_exists = True
def dumpfile():
f = open(file, 'r+b')
db = btree.open(f)
with open('key_store.txt', 'wt') as text:
for key in db:
pair = "{}:{}\n".format(key.decode('utf-8'),
db[key].decode('utf-8'))
text.write(pair)
db.close()
print('key_store.txt created')
def __init__(self, name="octopus"):
self.file = name + ".db"
# simple test: root > todo sub directory
try:
f = open(self.file, "r+b")
except OSError:
f = open(self.file, "w+b")
self.data = btree.open(f)
def write_to_db(dbname, key, data):
try:
fp = open(dbname, 'r+b')
except OSError:
fp = open(dbname, 'w+b')
db = btree.open(fp)
db[key] = data
db.flush()
db.close()
fp.close()
def reopen(self):
if self.db != None:
self.save()
self.close()
try:
self.f = open(self.dbfile, "r+b")
except OSError:
print("Salat db '", self.dbfile,
"' seems not to exist ? creating a new one")
self.f = open(self.dbfile, "w+b")
self.db = btree.open(self.f)
def network_db():
try:
f = open("datastore/network.db", "r+b")
except OSError:
f = open("datastore/network.db", "w+b")
db = btree.open(f)
db[b"network1"] = b"didit"
db[b"network2"] = b""
db[b"network3"] = b""
db[b"HiddenNetwork"] = b"shhhh!"
db.close()
f.close()
def write(key, value):
try:
f = open('system.db', 'r+b')
except OSError:
f = open('system.db', 'w+b')
db = btree.open(f)
db[key] = value
db.flush()
assert key in db
assert db[key] == value
db.close()
f.close()
def index(req, resp):
gc.collect()
f = open("datastore/logger.db", "r+b")
db = btree.open(f)
logger = db['service'].decode('utf-8')
db.close()
f.close()
# TODO: Load dynamic content from datastore
yield from picoweb.start_response(resp)
yield from app.render_template(
resp, "index.html",
("[connected ssid here]", logger, "[version no. here]"))
def init():
try:
f = open(file, 'r+b')
except OSError:
f = open(file, 'w+b')
db = btree.open(f, pagesize=512)
db[b'ssid_name'] = input('Enter WiFi SSID - ')
db[b'ssid_pass'] = input('Enter WiFi password - ')
db[b'ntp_host'] = 'time.cloudflare.com'
db.flush()
#print("%s, %s, and %s added to %s file" % (db[b'ssid_name'].decode('utf-8'), db[b'ssid_pass'].decode('utf-8'), db[b'mqtt_broker'].decode('utf-8'), file))
db.close()
def dump():
try:
f = open("iotdb.db", "r+b")
except OSError:
print("Failed to open db.")
sys.exit(0)
db = btree.open(f)
for key in db:
print("Key : ", key)
print("Value: ", db[key])
try:
import btree
except ImportError:
print("SKIP")
import sys
sys.exit()
db = btree.open(None)
db[b"foo3"] = b"bar3"
db[b"foo1"] = b"bar1"
db[b"foo2"] = b"bar2"
db[b"bar1"] = b"foo1"
print(db[b"foo2"])
try:
print(db[b"foo"])
except KeyError:
print("KeyError")
print(db.get(b"foo"))
print(db.get(b"foo", b"dflt"))
del db[b"foo2"]
try:
del db[b"foo"]
except KeyError:
print("KeyError")
for k, v in db.items():
print((k, v))
print("---")
try:
import btree
import uio
except ImportError:
print("SKIP")
import sys
sys.exit()
#f = open("_test.db", "w+b")
f = uio.BytesIO()
db = btree.open(f)
db[b"foo3"] = b"bar3"
db[b"foo1"] = b"bar1"
db[b"foo2"] = b"bar2"
db[b"bar1"] = b"foo1"
print(db[b"foo2"])
try:
print(db[b"foo"])
except KeyError:
print("KeyError")
print(db.get(b"foo"))
print(db.get(b"foo", b"dflt"))
del db[b"foo2"]
try:
del db[b"foo"]
except KeyError:
print("KeyError")
try:
import btree
import uio
import uerrno
except ImportError:
print("SKIP")
import sys
sys.exit()
#f = open("_test.db", "w+b")
f = uio.BytesIO()
db = btree.open(f, pagesize=512)
db[b"foo3"] = b"bar3"
db[b"foo1"] = b"bar1"
db[b"foo2"] = b"bar2"
db[b"bar1"] = b"foo1"
dbstr = str(db)
print(dbstr[:7], dbstr[-1:])
print(db[b"foo2"])
try:
print(db[b"foo"])
except KeyError:
print("KeyError")
print(db.get(b"foo"))
print(db.get(b"foo", b"dflt"))
del db[b"foo2"]
try:
