def removeHexFromProcessingDB(hexnite, real):
if real:
backend = FileBackend("./realdb")
else:
backend = FileBackend("./testdb")
hex = backend.filter(hexes, {'hexnite': hexnite})
backend.delete(hex)
'Hexnite', hexnite, 'removed from database'
def vote(pk):
print(pk)
if not current_user:
return redirect("/login")
if request.method == 'GET':
if pk + '_vote' in request.cookies:
return redirect('/already_voted')
redirect_to_index = redirect("/thankyou")
response = current_app.make_response(redirect_to_index)
response.set_cookie(pk + '_vote', value='true')
waifu = current_app.dbbackend.get(Waifu, {"pk": pk})
ip = request.environ.get('HTTP_X_REAL_IP', request.remote_addr)
try:
if ip in waifu.votes_l:
return redirect("/already_voted")
waifu.votes_l.append(ip)
except:
waifu.votes_l = list()
waifu.votes_l.append(ip)
user_m = current_user._get_current_object()
if waifu in user_m.voted_waifus:
return redirect("/already_voted")
user_m.voted_waifus.append(waifu)
current_app.dbbackend.save(user_m)
waifu.votes = waifu.votes + 1
current_app.dbbackend.save(waifu)
current_app.dbbackend.commit()
current_app.dbbackend = FileBackend("./database")
return response
def get_project_and_backend(path):
try:
project_config = get_project_config(path+"/.checkmate")
except (IOError,):
sys.stderr.write("No project configuration found!\n")
exit(-1)
backend_config = project_config['backend']
project_class = project_config.get('project_class','DiskProject')
if not project_class in settings.models:
sys.stderr.write("Invalid project type: %s. Maybe the plugin is missing?" % project_class)
exit(-1)
ProjectClass = settings.models[project_class]
if backend_config['driver'] == 'mongo':
if not pymongo_support:
sys.stderr.write("Encountered pymongo backend, but pymongo is not installed!")
exit(-1)
pymongo_db = pymongo.MongoClient()[backend_config['db']]
backend = MongoBackend(pymongo_db,autoload_embedded = False,allow_documents_in_query = False)
elif backend_config['driver'] == 'file':
backend = FileBackend(path+"/.checkmate",autoload_embedded = False)
else:
sys.stdout.write("Unknown backend driver: %s" % backend_config['driver'])
try:
project = backend.get(ProjectClass,{'pk' : project_config['project_id']})
except ProjectClass.DoesNotExist:
project = ProjectClass({'pk' : project_config['project_id']})
backend.save(project)
project.path = path
backend.save(project)
backend.commit()
return project,backend
def open_database(self, dbpath): # (self, dbpath, attrs={}, **kwargs)
if os.path.basename(dbpath) == self.name:
self.dbpath = dbpath # opening existing Visinum database
elif os.path.isdir(os.path.join(dbpath, self.name)):
self.dbpath = os.path.join(dbpath,
self.name) # opening existing database
logger.info("Found Visinum database %s in directory %s" %
(self.name, dbpath))
elif os.path.isdir(dbpath):
self.dbpath = os.path.join(dbpath, self.name)
logger.info("Creating new Visinum database %s in directory %s" %
(self.name, dbpath))
else:
logger.error("Database path (dbpath) incorrectly specified %s" %
(dbpath, ))
raise ValueError(
"Database path (dbpath) incorrectly specified %s" % (dbpath, ))
self.db = FileBackend(self.dbpath, {'serializer_class': 'json'})
logger.info("Opening Visinum database %s" % (self.dbpath, ))
config_attrs = self.get_config()
"""try:
#config_attrs = self.db.get(self.DbDocClass, {'visinum_type' : 'db_config'})
config_attrs = self.get_config()
except self.DbDocClass.DoesNotExist:
self.set_config( {'visinum_type' : 'db_config',
'title' : os.path.basename( os.path.dirname(self.dbpath) ),
'path_orig' : self.dbpath,
'UUID': make_uuid(version=3, namespace='uuid.NAMESPACE_URL', name=self.dbpath)
} )
#config_attrs.update(attrs)
#self.create_new_item(config_attrs, config_attrs, **kwargs )"""
self.config_attrs = config_attrs
def _query(self, f, q):
try:
out = f(*q)
except KeyError:
self.db = FileBackend(expanduser("~/.omesa/db"))
f = self.db.filter
out = f(*q)
return out
def wrapped_f(bot, update, *args, **kwargs):
msg_entry = Message(json.loads(update.to_json()))
backend = FileBackend(settings.ACCESS_LOG_DB_PATH)
backend.save(msg_entry)
backend.commit()
return f(bot, update, *args, **kwargs)
def cleardb(real=False):
password = '******'
user_input = raw_input('Please Enter Password: '******'Incorrect Password, terminating... \n')
if real:
backend = FileBackend("./realdb")
else:
backend = FileBackend("./testdb")
images = backend.filter(preprocessing, {'status': 'Submitted'})
images.delete()
hexen = backend.filter(hexes, {'num_target_g': 0})
hexen.delete()
exposuren = backend.filter(exposures,
{'status': 'Awaiting additional exposures'})
exposuren.delete()
backend.commit()
def __init__(self, bot):
self.bot: 'PixlBot' = bot
self.config = bot.config['TwitchNotifier']
self.backend = FileBackend('db')
self.backend.autocommit = True
self.bot.logger.info("Twitch notifier plugin ready")
self.uuids = []
self.online_uuids = []
self.sslcontext = ssl.SSLContext()
self.sslcontext.load_cert_chain(self.config['cert_path'],
self.config['key_path'])
self._twitch_init_()
def __init__(self, driver_type, connection_string):
super(BlitzDBDALDriver, self).__init__()
self.database_name = 'datmo_db'
if driver_type == "file":
from blitzdb import FileBackend
self.backend = FileBackend(connection_string)
elif driver_type == "mongo":
from pymongo import MongoClient
from blitzdb.backends.mongo import Backend as MongoBackend
c = MongoClient(connection_string)
#create a new BlitzDB backend using a MongoDB database
self.backend = MongoBackend(c[self.database_name])
def __init__(self):
retry = 0
while retry < 3:
try:
self.jav_db = FileBackend('jav_manager.db')
break
except Exception as e:
print(f'read file db error {e}, gonna retry')
retry += 1
sleep(5)
if not self.jav_db:
raise Exception('read local db error')
from collections import Counter
# Xml FilePath
file_path = "dblp-2017-05-02.xml"
# Für BlitzDB
class Inproceedings(Document):
pass
class Proceedings(Document):
pass
backend = FileBackend("./dblp-db")
# Ende BlitzDb
# Hauptmenü zur einfachen Navigation. Teilaufgaben
def hauptmenu():
print("\nBitte wählen Sie aus folgenden Punkten:")
while True:
print("\n--Hauptmenü--")
print("\n1 - Teilaufgabe 1.1"
"\n2 - Teilaufgabe 1.2"
"\n3 - Teilaufgabe 1.3"
"\n4 - Teilaufgabe 2.1"
"\n5 - Teilaufgabe 2.2"
import json
import os
import sys
from blitzdb import Document, FileBackend
class ListEntry(Document):
pass
dirname, filename = os.path.split(os.path.abspath(sys.argv[0]))
DATABASE = dirname + "/db"
backend = FileBackend(DATABASE)
outputs = []
crontabs = []
def process_message(data):
channel = data["channel"]
text = data["text"]
if text.startswith("shelp"):
outputs.append([channel, "Shoppinglist! Yeah!\n" + "shop SACHE"])
if text.startswith("shop"):
item = text[5:]
if not item:
def __init__(self):
self.jav_db = FileBackend('jav_manager.db')
from blitzdb import Document, FileBackend
backend = FileBackend('./mob-db')
'''
A user shall have the following attributes: name, email, username/handle, twitter/facebook ID, auth token, karma points, as well
as future references to posts, comments and votes.
'''
class User(Document):
pass
'''
A post shall have the following attributes: title, content, a reference to the user who posted it, timestamp, a list containing
IDs of comments in chronological order, as well as a list of vote IDs.
'''
class Post(Document):
pass
'''
A comment shall have the following attributes: content, a reference to the author.
'''
class Comment(Document):
pass
from flask import Flask, redirect, session, json, url_for, render_template
from flask_oauth_c import OAuth
from blitzdb import FileBackend
from objects import Waifu, User
from vote import votes
from config import _cfg, _cfgi
from flask.ext.login import login_user, LoginManager, current_user, logout_user
import requests
import re
import random
app = Flask(__name__)
app.register_blueprint(votes)
app.dbbackend = FileBackend("./database")
app.config['UPLOAD_FOLDER'] = _cfg("content-folder")
app.config['ALLOWED_EXTENSIONS'] = set(
['png', 'jpg', 'jpeg', 'gif', 'JPEG', 'JPG', 'PNG', 'GIF'])
login_manager = LoginManager()
login_manager.init_app(app)
app.config['WAIFU_BGS'] = list(["0.png", "1.png"])
oauth = OAuth()
google = oauth.remote_app(
'google',
base_url='https://www.google.com/accounts/',
authorize_url='https://accounts.google.com/o/oauth2/auth',
request_token_url=None,
def __init__(self):
self.backend = FileBackend(settings['database_location'])
def create_app(configfile=None):
app = Flask(__name__)
AppConfig(app, configfile) # Flask-Appconfig is not necessary, but
# highly recommend =)
# https://github.com/mbr/flask-appconfig
Bootstrap(app)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
#NoSQL Backend
backend = FileBackend("/tmp/wakeonlan.db")
backend.create_index(Device, fields={'id': 1}, unique=True)
#TEST Devices
alldevices = backend.filter(Device, {})
if len(alldevices) == 0:
try:
pc1 = Device({
"id": "001122334411",
"name": "PC 1",
"mac": "00:11:22:33:44:11",
"ip": "192.168.222.111",
'status': ''
})
backend.save(pc1)
pc2 = Device({
"id": "001122334422",
"name": "PC 2",
"mac": "00:11:22:33:44:22",
"ip": "192.168.222.112",
'status': ''
})
backend.save(pc2)
pc3 = Device({
"id": "001122334433",
"name": "Router",
"mac": "00:11:22:33:44:33",
"ip": "192.168.222.1",
'status': ''
})
backend.save(pc3)
backend.commit()
except:
backend.revert()
pass
# in a real app, these should be configured through Flask-Appconfig
app.config['SECRET_KEY'] = 'devkey'
# app.config['RECAPTCHA_PUBLIC_KEY'] = \
# '6Lfol9cSAAAAADAkodaYl9wvQCwBMr3qGR_PPHcw'
def getDeviceById(id):
device = None
try:
device = backend.get(Device, {'id': id})
except:
pass
return device
def pingDeviceById(id):
#Get Device
device = backend.get(Device, {'id': id})
if device:
#Get Device's IP
ip = device['ip']
result = pingDeviceByIp(ip)
#Update Status UP/Down/''
if result == 0:
device['status'] = 'UP'
else:
device['status'] = 'DOWN'
backend.save(device)
return result
return None
def wolDeviceById(id):
#Get Device
device = backend.get(Device, {'id': id})
if device:
#WoL for Device MAC
mac = device['mac']
wolDeviceByMac(mac)
return None
@login_manager.user_loader
def user_loader(user_id):
"""Given *user_id*, return the associated User object.
:param unicode user_id: user_id (email) user to retrieve
"""
user_entry = User.getById(user_id)
if user_entry is not None:
user = User(user_entry[0], user_entry[1])
return user
else:
return None
@app.route('/', methods=('GET', 'POST'))
@login_required
def index():
form = ExampleForm()
form.validate_on_submit() # to get error messages to the browser
# flash('critical message', 'critical')
# flash('error message', 'error')
# flash('warning message', 'warning')
# flash('info message', 'info')
# flash('debug message', 'debug')
# flash('different message', 'different')
# flash('uncategorized message')
alldevices = None
alldevices = backend.filter(Device, {}).sort('name')
#app.logger.info('Devices: %s' % (len(alldevices) ) )
return render_template('index.html', form=form, devices=alldevices)
@app.route('/login', methods=('GET', 'POST'))
def login():
if request.method == 'GET':
form = LoginForm()
form.validate_on_submit() # to get error messages to the browser
return render_template('login.html', form=form)
username = request.form['username']
password = request.form['password']
user_entry = User.get(username, password)
if user_entry is None:
flash('Username or Passord is invalid', 'error')
return redirect(url_for('login'))
user = User(user_entry[0], user_entry[1])
login_user(user, remember=True)
return redirect(request.args.get('next') or url_for('index'))
@app.route("/logout", methods=["GET"])
@login_required
def logout():
"""Logout the current user."""
user = current_user
user.authenticated = False
logout_user()
return redirect(url_for('login'))
@app.route('/addDevice', methods=('GET', 'POST'))
@login_required
def addDevice():
if request.method == 'GET':
form = AddDeviceForm()
form.validate_on_submit() # to get error messages to the browser
return render_template('add_device.html', form=form)
name = request.form['name']
mac = request.form['mac']
ip = request.form['ip']
id = mac.replace(':', '')
try:
newDevice = Device({
"id": id,
"name": name,
"mac": mac,
"ip": ip,
'status': ''
})
backend.save(newDevice)
backend.commit()
except:
flash('Error creating new Device', 'error')
pass
return redirect(url_for('index'))
@app.route('/editListDevice', methods=('GET', 'POST'))
@login_required
def editListDevice():
alldevices = None
alldevices = backend.filter(Device, {}).sort('name')
return render_template('list_device.html', devices=alldevices)
@app.route('/pingDevice/<deviceId>', methods=('GET', 'POST'))
@login_required
def pingDevice(deviceId):
app.logger.info('pingDevice: %s' % (deviceId))
device = getDeviceById(deviceId)
result = pingDeviceById(deviceId)
app.logger.info('pingDevice: %s' % (result))
if result is None:
flash('Ping - Error on device %s' % (device['name']), 'error')
elif result == 0:
flash('Device %s is UP' % (device['name']), 'info')
else:
flash('Device %s is DOWN' % (device['name']), 'error')
return redirect(url_for('index'))
@app.route('/wolDevice/<deviceId>', methods=('GET', 'POST'))
@login_required
def wolDevice(deviceId):
app.logger.info('wolDevice: %s' % (deviceId))
device = getDeviceById(deviceId)
result = wolDeviceById(deviceId)
if device:
flash('WoL sent to %s' % (device['name']), 'info')
else:
flash('WoL error', 'error')
return redirect(url_for('index'))
@app.route('/deleteDevice/<deviceId>', methods=('GET', 'POST'))
@login_required
def deleteDevice(deviceId):
app.logger.info('wolDevice: %s' % (deviceId))
device = getDeviceById(deviceId)
try:
backend.delete(device)
backend.commit()
flash('%s Deleted' % (device['name']), 'info')
except:
flash('Delete error', 'error')
pass
return redirect(url_for('editListDevice'))
return app
def __init__(self):
"""Load backend."""
self.db = FileBackend(expanduser("~/.omesa/db"))
def __init__(self, trigger_id, jsonfilelist, triggerdir, datadir, real,
trigger_path):
#os.system('kinit -k -t /var/keytab/desgw.keytab desgw/des/[email protected]')
tstart = time.time()
if real:
self.backend = FileBackend("./realdb")
else:
self.backend = FileBackend("./testdb")
try:
thisevent = self.backend.get(Trigger, {'id': trigger_id})
print 'Found this event in desgw database...'
except Trigger.DoesNotExist:
thisevent = Trigger({
'id':
trigger_id,
'jsonfilelist':
jsonfilelist,
'triggerpath':
triggerdir,
'mapspath':
datadir,
'jobids': [
(0, 'jsonfile_corresponding_to_jobid.json'),
],
})
print 'Database entry created!'
self.trigger_id = trigger_id
self.trigger_path = trigger_path
self.backend.save(thisevent)
self.backend.commit()
with open(os.path.join(triggerdir, "strategy.yaml"), "r") as f:
self.config = yaml.safe_load(f)
self.filterobslist = np.array(self.config['exposure_filter'],
dtype='str')
self.strategydict = {}
for f in np.unique(self.filterobslist):
self.strategydict[f] = len(
self.filterobslist[self.filterobslist == f])
self.connection = ea.connect(DATABASE)
self.cursor = self.connection.cursor()
self.jsonfilelist = jsonfilelist
print self.jsonfilelist
if hardjson:
self.jsonfilelist = hj
self.trigger_id = trigger_id
self.datadir = datadir
self.triggerdir = triggerdir
self.processingdir = os.path.join(self.triggerdir, 'PROCESSING')
if not os.path.exists(self.processingdir):
os.makedirs(self.processingdir)
dire = './processing/' + trigger_id + '/'
if not os.path.exists(dire):
os.makedirs(dire)
with open(os.path.join(triggerdir, "strategy.yaml"), "r") as f:
self.strategy = yaml.safe_load(f)
with open("jobmanager.yaml", "r") as g:
self.jmconfig = yaml.safe_load(g)
q1 = "select expnum,nite,mjd_obs,telra,teldec,band,exptime,propid,obstype,object from exposure where " \
"nite>20130828 and nite<20150101 and expnum<300000 and obstype='object' order by expnum" # y1 images
self.connection.query_and_save(q1, './processing/exposuresY1.tab')
q2 = "select expnum,nite,mjd_obs,radeg,decdeg,band,exptime,propid,obstype,object from prod.exposure where " \
"nite>20150901 and obstype='object' order by expnum" # y2 and later
self.connection.query_and_save(q2, './processing/exposuresCurrent.tab')
os.system(
'cat ./processing/exposuresY1.tab ./processing/exposuresCurrent.tab > ./processing/exposures.list'
)
self.submit_all_jsons_for_sejobs(
) #preps all DES images that already exist
tfin = time.time()
print 'TOTAL SE JOBS TIME', tfin - tstart
#sys.exit()
self.monitor_images_from_mountain(
) #A loop that waits for images off mountain and submits for processing
from blitzdb import Document
from blitzdb import FileBackend
from lxml import etree
import Benotete_Abgabe3.Teilaufgabe1.Aufgabe3 as aufg1
db = FileBackend("./my-db")
class Proceedings(Document):
pass
class Inproceedings(Document):
pass
# Die XML-Datenbasis
#datei = '../test.xml'
datei = '../dblp-2017-05-02.xml'
# Teilaufgabe 2, Nr. 1
def get_inproceedings_by_year(datei, year):
inproceedings = []
# iterparser zum Einlesen der Datei unter Berücksichtigung ausschließlich der "End"-Events
context = etree.iterparse(datei,
events=('end', ),
load_dtd=True,
encoding='ISO-8859-1',
huge_tree=True)
# Iterieren über alle Elemente des Iterparser
def __init__(self, bot):
self.bot = bot
self.backend = FileBackend('db')
self.backend.autocommit = True
bot.logger.info("Responder plugin ready")
def open_database(db_path):
if os.path.basename(db_path) != VisinumDB_name:
db_path = os.path.join(db_path, VisinumDB_name)
db = FileBackend(db_path, {'serializer_class': 'json'})
logger.info("Opening Visinum database %s" % (db_path, ))
return db
import os
import json
from blitzdb import Document, FileBackend
class Inproceedings(Document):
pass
class Proceedings(Document):
pass
file_path = "input/dplp-2017-05-02.xml"
output_folder = 'output/'
db = FileBackend("./My-DB")
# Parses xml file via iterparse and counts number of inproceedings, proceedings and journals
def parsertest():
inproceedings = 0
proceedings = 0
journals = 0
for event, elem in ET.iterparse(file_path,
events=("start", "end"),
load_dtd=True):
if elem.tag == "inproceedings":
if event == "end" and len(list(elem)) > 0:
inproceedings += 1
elem.clear()
def __init__(self, db_path):
self.db = FileBackend(db_path)
def __init__(self, geocoderCache=True, printStatus=False):
self.printStatus = printStatus
self.geocoderCache = geocoderCache
if self.geocoderCache:
self.db = FileBackend('./geo-cache')
def __init__(self, filename):
self._filename = filename
self._backend = FileBackend(self._filename)
def __init__(self, bot):
self.bot = bot
self.backend = FileBackend('./activity-db')
self.backend.autocommit = True
self.scanned = False
bot.logger.info("Activity plugin ready")
from blitzdb import Document
from blitzdb import FileBackend
import csv
backend = FileBackend("my-db")
output_folder = 'output/'
class inproceedings(Document):
pass
# Takes data (list), takes a header-list and a filename, and saves the data into a csv-file
def save_csv(save_data, save_header, filename):
with open(output_folder + filename, 'w+', encoding='windows-1252') as f:
writer = csv.DictWriter(f, save_header, delimiter=';', extrasaction='ignore', lineterminator='\n')
writer.writeheader()
writer.writerows(save_data)
print('Datensätze gespeichert!')
# finds all inproceedings of a given editor
def find_data_by_editor(editor):
results = backend.filter(inproceedings, {})
result_list = []
for result in results:
try:
if (result["proc:editor"] == editor):
result_list.append(result)
class Movie(Document):
pass
the_godfather = Movie({'name': 'The Godfather', 'year': 1972, 'pk': 1})
marlon_brando = Actor({'name': 'Marlon Brando', 'pk': 2})
al_pacino = Actor({'name': 'Al Pacino', 'pk': 3})
print("Backend")
from blitzdb import FileBackend
loc = "./my-db"
backend = FileBackend(loc)
print("Created Backend", loc)
the_godfather.save(backend)
marlon_brando.save(backend)
al_pacino.save(backend)
print("Backend Saved and committed:", os.path.realpath(os.curdir))
# print(backend.get(Movie,{'pk':1}))
# or...
the_godfather = backend.get(Movie, {'name': 'The Godfather'})
print("the_godfather", the_godfather)
the_godfather.cast = {
import os
from blitzdb import Document
from blitzdb import FileBackend
backend = FileBackend('./file_db')
class File(Document):
pass
class Category(Document):
pass
class CategoryItem():
def __init__(self):
self.cat_name = ''
self.cat_screen_name = ''
self.cat_path = ''
def save_cat(self):
catinfo = {}
catinfo['cat_name'] = self.cat_name
catinfo['cat_screen_name'] = self.cat_screen_name
catinfo['cat_slug'] = self.cat_name.replace(' ', '-')
catinfo['cat_path'] = self.cat_path
cat = Category(catinfo)
backend.save(cat)
