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)