from flask import Flask
from database.database import Database
from configuration import DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME
# Application flask, représente le serveur
app = Flask(__name__, template_folder="templates")
# Accès à la base de données
database = Database(host=DATABASE_HOST,
user=DATABASE_USER,
password=DATABASE_PASSWORD,
database_name=DATABASE_NAME)
def setUp(self):
initialize_database()
self.database = Database()
self.database.delete_all()
from PyQt5.QtGui import *
#from interface.escolherMateriasDialog import *
from interface.escolherMateriasDialog import *
from database.database import Database
#from interface.cadastroProfessorWindow import *
from interface.cadastroProfessorWindow import *
#from endereco import *
from endereco import *
#from professor import *
from professor import *
import homeAdm
import homeServidor
database = Database()
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
tela = Ui_cadastroProfessor()
tela.setupUi(MainWindow)
Dialog = QtWidgets.QDialog()
dialog = Ui_Dialog()
dialog.setupUi(Dialog)
def voltarHome(id, type):
MainWindow.close()
if type == "administrador":
def vul(page=1):
vuls = Database().select_vul(page)
return render_template('vul.html',
page=page,
max_page=max_vul // 15 + 1,
sendirs=vuls)
def subdomain(page=1):
domains = Database().select_subdomain(page)
return render_template('domain.html',
page=page,
max_page=max_domain // 15 + 1,
domains=domains)
import shutil
from functools import partial
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5 import QtCore
from interface.perfilProfessorWindow import *
from database.database import Database
import homeProfessor
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
tela = Ui_perfilProfessor()
tela.setupUi(MainWindow)
database_professor = Database()
def voltarHome(id):
MainWindow.close()
homeProfessor.startHomeProfessor(id)
def verMaterias(professor):
msg = QMessageBox()
msg.setWindowTitle("Matérias")
msg.setIcon(QMessageBox.Information)
msg.setText("\n".join(professor.getMateria()))
msg.show()
msg.exec_()
def port(page=1):
ports = Database().select_port(page)
return render_template('port.html',
page=page,
max_page=max_port // 15 + 1,
ports=ports)
handler = TimedRotatingFileHandler("log/{}.log".format(DEFAULT_APP_NAME),
when="midnight",
interval=1)
handler.setLevel(log_level)
formatter = logging.Formatter(log_format)
handler.setFormatter(formatter)
handler.suffix = "%Y%m%d"
handler.extMatch = re.compile(r"^\d{8}$")
logger.setLevel(log_level)
logger.addHandler(handler)
try:
create_log_dir_if_does_not_exists('log')
setup_log()
db = Database(logger)
db2 = Database(logger)
service = LPRMasterService(logger, db)
broker = Broker(logger, db2)
except Exception as error:
logger.error(error)
def setup_route():
return [
web.post('/register', service.register),
web.post('/get-state', service.get_data_last_state),
web.delete('/gate', service.delete_gate_id),
web.post('/upload-encoded', service.forward_encoded_image),
web.post('/upload', service.forward_raw_image),
web.post('/upload-url', service.forward_url_image),
def create_user():
database = Database('users')
username = request.args.get('username')
password = request.args.get('password')
res = database.create_user({'username': username, 'password': password})
return res
def chat_id_del(chat_id):
db = Database()
db.query("DELETE FROM profile WHERE chat_id = %s;", (chat_id, ))
db.close()
def chat_id_found(chat_id):
db = Database()
db.query("SELECT chat_id FROM profile WHERE chat_id = %s;", (chat_id, ))
items = [item for item in db.data()]
db.close()
return True if len(items) > 0 else False
def chat_id_add(chat_id):
db = Database()
db.query("INSERT INTO profile (chat_id) VALUES (%s);", (chat_id, ))
db.close()
import csv
from database.database import Database
from database.cars import Car
from constants import DB_URL
db = Database(DB_URL)
con = db.controller
with open("./src/static/data.csv") as file:
reader = csv.DictReader(file)
for row in reader:
car = Car(name=row["name"], color=row["color"])
con.add_car(car)
def __init__(self, TOKEN, SHARD, sqlName='market', reset=False):
self.info = Info(TOKEN, SHARD)
self.database = Database(sqlName, reset)
class Test_Database(unittest.TestCase):
#######################
# User Related Tests ##
#######################
Database().delete_users()
def test_store_user(self):
database: Database = Database()
database.store_user(Samples.sample_user)
user: User = database.get_user(Samples.sample_user.user_key)
self.assertEqual(user.to_dict(), Samples.sample_user.to_dict())
def test_delete_users(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.delete_users()
result = database.get_user_keys()
expected_result: [str] = []
self.assertEqual(result, expected_result)
#
# Calculates the average performance for
# every user stored at Firebase.
#
def test_get_user_keys(self):
database: Database = Database()
database.store_user(Samples.sample_user)
#
#
#
result: [str] = database.get_user_keys()
#
#
#
expected_result: [str] = ['user_042']
#
#
#
self.assertEqual(result, expected_result)
###########################
## Session Related Tests ##
###########################
def test_get_session(self):
set_up()
# Should retrieve an existing session from Firestore.
result: Session = Database().get_session(
Samples.sample_user.user_key, Samples.sample_session.session_key)
timestamp = result.to_dict()['timestamp']
# Defines the expected result.
expected_result: Session = Samples.sample_session
expected_result.timestamp = timestamp
# Expects the result to be equal to a predefined sample session.
self.assertEqual(result.to_dict(), expected_result.to_dict())
clean_up()
def test_store_level(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.store_session('user_042', Samples.sample_session)
database.store_level('user_042', 'session_042', Samples.sample_level)
level: Level = database.get_level('user_042', 'session_042',
Samples.sample_level.key)
self.assertEqual(level.to_dict(), Samples.sample_level.to_dict())
clean_up()
def test_set_average_performance(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.store_session(Samples.sample_user.user_key,
Samples.sample_session)
database.set_average_performance('user_042',
Samples.sample_performance)
result: Performance = database.get_average_performance('user_042')
expected_result: Performance = Samples.sample_performance
self.assertEqual(result.to_dict(),
Samples.sample_performance.to_dict())
clean_up()
def test_get_session_ids(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.store_session(Samples.sample_user.user_key,
Samples.sample_session)
result: [int] = database.get_session_ids(Samples.sample_user.user_key)
self.assertEqual(result, [42])
clean_up()
def test_get_performance(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.store_session(Samples.sample_user.user_key,
Samples.sample_session)
result: Performance = database.get_performance(
Samples.sample_user.user_key, Samples.sample_session.session_key)
expected_result: Performance = Samples.sample_session.performance
self.assertEqual(result.to_dict(), expected_result.to_dict())
clean_up()
def test_get_session_keys(self):
database: Database = Database()
database.store_user(Samples.sample_user)
database.store_session(Samples.sample_user.user_key,
Samples.sample_session)
result = database.get_session_keys('user_042')
expected_result: [str] = ['session_042']
self.assertEqual(result, expected_result)
clean_up()
def get_all_users():
database = Database('users')
res = database.get_all('users')
return res
client_thread.daemon = True
client_thread.start()
def start(self):
"""
Start the server
"""
print(f'\nStarting the server...')
self._setup_sockets()
print(
f'Server socket binded to {self._address}:{str(self._port)} successfully. Listening to incoming connections'
)
self._listen()
print('Stopping the server...')
if __name__ == '__main__':
# Fake database
clients_list = [
ClientModel("klevas",
key_to_bytes(load_key(KLEVAS_KEY_PATH).public_key())),
ClientModel("berzas",
key_to_bytes(load_key(BERZAS_KEY_PATH).public_key()))
]
database = Database(clients_list)
# Start the server
server = Server('0.0.0.0', 5000, database)
server.start()
def initialize_levels(self):
database: Database = Database()
evolution: Evolution = Evolution()
level_01: Level = Level(
'level_01', '01',
TextFileReader().read_text_file('level_01.txt'))
level_02: Level = Level(
'level_02', '02',
TextFileReader().read_text_file('level_02.txt'))
level_03: Level = Level(
'level_03', '03',
TextFileReader().read_text_file('level_03.txt'))
level_04: Level = Level(
'level_04', '04',
TextFileReader().read_text_file('level_04.txt'))
level_05: Level = Level(
'level_05', '05',
TextFileReader().read_text_file('level_05.txt'))
level_06: Level = Level(
'level_06', '06',
TextFileReader().read_text_file('level_06.txt'))
level_07: Level = Level(
'level_07', '07',
TextFileReader().read_text_file('level_07.txt'))
level_08: Level = Level(
'level_08', '08',
TextFileReader().read_text_file('level_08.txt'))
tutorial: Level = Level(
'tutorial', 'tutorial',
TextFileReader().read_text_file('tutorial.txt'))
level_01 = Helper.clean_level(level_01)
level_02 = Helper.clean_level(level_02)
level_03 = Helper.clean_level(level_03)
level_04 = Helper.clean_level(level_04)
level_05 = Helper.clean_level(level_05)
level_06 = Helper.clean_level(level_06)
level_07 = Helper.clean_level(level_07)
level_08 = Helper.clean_level(level_08)
database.store_level_prototype(level_01)
database.store_level_prototype(level_02)
database.store_level_prototype(level_03)
database.store_level_prototype(level_04)
database.store_level_prototype(level_05)
database.store_level_prototype(level_06)
database.store_level_prototype(level_07)
database.store_tutorial(tutorial)
level_01 = evolution.evolve('random_distribution', level_01)
level_02 = evolution.evolve('random_distribution', level_02)
level_03 = evolution.evolve('random_distribution', level_03)
level_04 = evolution.evolve('random_distribution', level_04)
level_05 = evolution.evolve('random_distribution', level_05)
level_06 = evolution.evolve('random_distribution', level_06)
level_07 = evolution.evolve('random_distribution', level_07)
level_08 = evolution.evolve('random_distribution', level_08)
database.store_initial_level(level_01)
database.store_initial_level(level_02)
database.store_initial_level(level_03)
database.store_initial_level(level_04)
database.store_initial_level(level_05)
database.store_initial_level(level_06)
database.store_initial_level(level_07)
database.store_initial_level(level_08)
#!/usr/bin/python
# __author__ = 'jasonsheh'
# -*- coding:utf-8 -*-
from flask import Flask, render_template, request, redirect
from database.database import Database
from database.rules import Rules
from lib.cel import port_scan, domain_scan, sendir_scan, site_scan
app = Flask(__name__)
max_domain = Database().count('subdomain')
max_port = Database().count('port')
max_sendir = Database().count('sendir')
max_fingerprint = Rules().count('application')
max_task = Database().count('task')
max_vul = Database().count('vul')
@app.route('/')
@app.route('/index')
@app.route('/index/<int:page>')
def index(page=1):
tasks = Database().select_task(page)
return render_template('index.html',
page=page,
max_page=max_task,
tasks=tasks,
max_domain=max_domain,
max_port=max_port,
max_sendir=max_sendir,
pag_urls = set(
urljoin(url, href.attrs.get("href")) for href in ul.find_all("a")
if href.attrs.get("href"))
for pag_url in pag_urls:
if pag_url not in self.done_urls:
self.tasks.append(self.get_task(pag_url, self.parse_feed))
post_items = soup.find("div", attrs={"class": "post-items-wrapper"})
posts_urls = set(
urljoin(url, href.attrs.get("href")) for href in
post_items.find_all("a", attrs={"class": "post-item__title"})
if href.attrs.get("href"))
for post_url in posts_urls:
if post_url not in self.done_urls:
self.tasks.append(self.get_task(post_url, self.parse_post))
def run(self):
for task in self.tasks:
task_result = task()
if task_result:
self.db.create_post(task_result)
def save(self, data):
self.db.create_post(data)
if __name__ == "__main__":
database = Database("sqlite:///gb_blog.db")
parser = GbBlogParse("https://gb.ru/posts", database)
parser.run()
def sendir(page=1):
sendir = Database().select_sendir(page)
return render_template('sendir.html',
page=page,
max_page=max_sendir // 15 + 1,
sendirs=sendir)
def setUp(self):
Database.db_file = None # else the runtime destroys testsing framework
Database(self.gentest_config())
self.user = User("Douglas")
self.connection = Database.db_connection
self.cursor = self.connection.cursor()
def delete(id, mode):
Database().delete(id, mode)
from config import database_config
from database.database import Database
from database.tables.tickers_table import TickersTable
from utilities import random_utilities
db = Database(database_config.test_database)
tickers_table = TickersTable(db.cursor())
def test_exists():
assert tickers_table.exists() is True
def test_create():
assert tickers_table.create() is True
def test_add_tickers():
tickers = []
for _ in range(1, 3):
tickers.append(random_utilities.random_letters())
assert tickers_table.add_tickers(tickers) is True
def test_add_tickers_one_duplicate():
new_ticker = random_utilities.random_letters()
tickers_table.add_ticker('test')
tickers = ['test', new_ticker]
assert tickers_table.add_tickers(tickers) is True
retrieved_tickers = tickers_table.get_tickers()
assert new_ticker in retrieved_tickers
import psycopg2.extras
from database.database import Database
from config import database_config
database_name = database_config.test_database
database = Database(database_name)
def database_name_exists():
assert database is not None
def test_exists():
assert database.exists() is True
def test_create():
assert database.create() is True
def test_get_cursor_with_database():
cursor = database.cursor(True)
assert type(cursor) is psycopg2.extras.DictCursor
def test_get_cursor_without_database():
cursor = database.cursor(False)
assert type(cursor) is psycopg2.extras.DictCursor
#
parser = argparse.ArgumentParser()
parser.add_argument('-p',
'--password',
type=str,
default=None,
help='Passwort for database encryption')
parser.add_argument('database',
type=str,
default=None,
help='Database file')
args = parser.parse_args()
database = Database(args.database, args.password)
#
# Fetch all entries from database and compute earliest entry. The latest entry is
# always expected to be at the current date.
#
minimum_timestamp = Timestamp(Configuration.DATABASE_START_DATE)
maximum_timestamp = Timestamp.now()
diff = maximum_timestamp - minimum_timestamp
number_of_steps = 0
step = None
if Configuration.DATABASE_SAMPLING_INTERVAL is Interval.day:
number_of_steps = abs(diff.days)
step = timedelta(days=1)
#!/usr/bin/python # -- coding: utf-8 -- from database.database import Database # initialise the dabatase expaToken = "b3a3520509a6dcf3b4da55c65b0b0659addd151983fcfaff4aadf29aecff2ae0" trelloToken = "9f9de4286e6a5f627f083dc3ca8fdf6dceae7307a06c5e9dcedda4212491a4e3" trelloKey = "448b14b4374aaa9429f4a8b979936e2b" db = Database(expaToken, trelloToken, trelloKey)
#--------------------------------------------------------------------------
# MAIN
#
if __name__ == '__main__':
#
# Parse command line arguments
#
parser = argparse.ArgumentParser ()
parser.add_argument ('-b', '--begin', required=False, type=Timestamp, help='Begin date (YYYY-MM-DD)')
parser.add_argument ('-e', '--end', required=False, type=Timestamp, help='End date (YYYY-MM-DD)')
parser.add_argument ('-d', '--database', required=False, type=str, default=':memory:', help='Database file')
parser.add_argument ('-v', '--verbose', action='store_true', default=False, help='Verbose output')
parser.add_argument ('-s', '--summary', action='store_true', default=False, help='Print summary of available information')
args = parser.parse_args ()
database = Database (args.database)
if args.database == ':memory:':
database.create ()
scraper = GDAXScraper ()
if args.summary:
scraper.summary (args)
sys.exit (0)
scraper.scrape (database, args)
import yaml
import json
import urllib.request
import time
from wallet import Wallet
from database.database import Database
config = yaml.safe_load(open("config.yml"))
db = Database()
db.connect()
walletBitcoin = 0.0
cash_wallet = Wallet()
firstrun = True
transection = 0.002
print ('Starting simulator...')
def getMidPrice():
with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response:
html = response.read()
return float(json.loads(html)['mid'])
def getSellPrice():
with urllib.request.urlopen('https://api.bitfinex.com/v1/pubticker/btcusd') as response:
html = response.read()
return float(json.loads(html)['last_price'])
oldPrice = currentPrice = initPrice = getSellPrice()
from flask import Flask
from database.database import Database
from EasyDraft.config import BaseConfig, PROJECT
from flask.ext.login import LoginManager
from flask_oauth import OAuth
app = Flask(PROJECT)
app.config.from_object(BaseConfig)
login_manager = LoginManager()
login_manager.setup_app(app)
database = Database(app)
oauth = OAuth()
yahoo = oauth.remote_app(
'yahoo',
base_url='http://fantasysports.yahooapis.com/fantasy/v2/',
request_token_url='https://api.login.yahoo.com/oauth/v2/get_request_token',
access_token_url='https://api.login.yahoo.com/oauth/v2/get_token',
authorize_url='https://api.login.yahoo.com/oauth/v2/request_auth',
consumer_key=
'dj0yJmk9SlBOaEx5VjJvRjJMJmQ9WVdrOWIyOVZiMUZpTnpnbWNHbzlNVE0xTURnNE1UVTJNZy0tJnM9Y29uc3VtZXJzZWNyZXQmeD1hOA--',
consumer_secret='eb800ec46583d123c8df54ac2c28f5d2975c06d9')
import EasyDraft.views
