def init_tables(self):
db = self.db
# person group table
pgSchema = [Field('gid', 'CHAR(255)', True, True, None),
Field('name', 'TEXT', True, False, None),
Field('user_data', 'TEXT', False, False, None)]
self.tables['PersonGroup'] = Table(db, 'PersonGroup', pgSchema)
# person table
pSchema = [Field('pid', 'CHAR(255)', True, True, None),
Field('name', 'TEXT', True, False, None),
Field('alias', 'TEXT', True, False, None),
Field('gid', 'CHAR(255)', True, False, ForeignKey(self.tables['PersonGroup'].name, 'gid'))]
self.tables['Person'] = Table(db, 'Person', pSchema)
# face table
fSchema = [Field('fid', 'CHAR(255)', True, True, None),
Field('image', 'TEXT', True, False, None),
Field('pid', 'CHAR(255)', True, False, ForeignKey(self.tables['Person'].name, 'pid'))]
self.tables['Face'] = Table(db, 'Face', fSchema)
# event table
eSchema = [Field('name', 'TEXT', True, False, None),
Field('description', 'TEXT', True, False, None),
Field('timestamp', 'BIGINT', True, False, None)]
self.tables['Event'] = Table(db, 'Event', eSchema)
# clockin table
cSchema = [Field('timestamp', 'BIGINT', True, False, None),
Field('eid', 'INT', True, False, ForeignKey(self.tables['Event'].name, 'id')),
Field('pid', 'CHAR(255)', True, False, ForeignKey(self.tables['Person'].name, 'pid'))]
self.tables['ClockIn'] = Table(db, 'ClockIn', cSchema)
def setUp(self):
try:
os.remove(self.FILENAME)
except Exception as e:
pass
self._table = Table(self.FILENAME)
self.db_manage = DBManager(self._table)
def test_01_blank_tables(self):
# start with two tables that will be empty
t1 = Table()
t2 = Table()
# the result of the cartesian product of two empty tables
# should iteslf be an empty table
result = squeal.cartesian_product(t1, t2)
# we'll know it's an empty table if its dictionary is empty
result_dict = result.get_dict()
expected = {}
self.assertEqual(result_dict, expected,
"product of two empty tables should be empty")
def test_to_json(self):
table = Table('table', ['column'], ColumnTypes([str]))
database = Database('database')
database.add_table(table)
self.assertEqual(
{
'name': 'database',
'tables': {
'table': table.to_json()
}
}, database.to_json())
def seakEntity(self, entity: Entity, forceUpdate: bool = False):
if (entity.getName()
not in self._entitesALreadyFormated.keys()) | forceUpdate:
self._entity = entity
self._tableEncours = Table()
self._recupDatas()
self._decoupeComment()
self._entitesALreadyFormated[entity.getName()] = self._entity
self._tablesAlreadyDone[entity.getName()] = self._tableEncours
else:
self._entity = self._entitesALreadyFormated[entity.getName()]
self._tableEncours = self._tablesAlreadyDone[entity.getName()]
self._recupDataWithCopieEntity(entity)
def test_03_blank_table_second(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# set table 2
table_2.set_dict({'t2.title': ['CSCA', '08']})
# the result should return 0 row, and titles of t2
result = squeal.cartesian_product(table_1, table_2)
# we'll know it's an empty table if its dictionary is empty
# but t2 has title, so we should return its title
result_dict = result.get_dict()
expected = {'t2.title': []}
self.assertEqual(result_dict, expected,
'''if one table is empty, result should be empty,
and return another tables' title''')
def setUp(self):
try:
os.remove(self.FILENAME)
except Exception as e:
pass
self._table = Table(self.FILENAME)
self.db_manage = DBManager(self._table)
def start(self, index):
"""
爬虫启动入口
:param index: 对应表的结尾序号
"""
domains = Table(index).get_unexplored_domain() # 获取需要爬取的域名
re_link = re.compile('/data/whoishistory/\d')
source = 'openwhois'
for domain in domains:
self.get_whowas(self.domain_format(domain))
def post(self, database_name, table_name):
try:
print(request.args)
sql = request.args.get('sql')
_dbms.get_database(database_name).add_table(
Table.from_sql(table_name, sql)
)
return {'message': 'Database created successfully'}
except Exception as e:
traceback.print_exc()
raise InvalidUsage(str(e), 400)
def joinTable(from_tables):
for table in from_tables:
if table not in db.tables:
print "Error:", table, " does not exist"
exit()
if len(from_tables) == 2:
obj1 = db.tables[from_tables[0]]
obj2 = db.tables[from_tables[1]]
columns = (obj1.columns) + (obj2.columns)
obj3 = Table("result", columns)
data = []
for row1 in obj1.data:
for row2 in obj2.data:
data.append(row1 + row2)
obj3.update_data(data)
elif len(from_tables) == 1:
obj3 = db.tables[from_tables[0]]
else:
print "Error: This Engine Don't support operation on more than 2 tables"
exit()
return obj3
def _decoupeComment(self):
lfichier = len(self._lines)
ln = 0
commentStarted = False
findEntity = "# @ORM/" + baseCommandeAnnotation[0] + "="
self._entity.clearAttibutes()
while ln < lfichier:
self._actualLine = self._lines[ln]
if self._fieldEncours:
if preFormatLineAnnotation(self._actualLine)[0:1] == '_':
vals = preFormatLineAnnotation(
self._actualLine)[1:].split(":")
self._entity.addAttributeToListAttributes(vals[0])
if self._fieldEncours.key == "PRI":
self._entity.setPrimaryKey(vals[0])
self._tableEncours.setPrimaryKey(
self._nameMysqlFieldEncours)
if self.isLineContain(stToContain=findEntity,
addPreCarShort=False):
self._tableEncours = Table()
self._tableEncours.fieldsName = []
self._tableEncours.name = preFormatLineAnnotation(
self._actualLine)[18:]
if self.isLineContain(startAnnotationFormat, False):
commentStarted = True
self._fieldEncours = FieldTable()
ln += 1
self._actualLine = self._lines[ln]
if commentStarted:
while not self.isLineContain(startAnnotationFormat, False):
self._actualLine = self._lines[ln]
if self.isLineContain("# @ORM/", False):
self._commandAnnotationEntity()
ln += 1
self._actualLine = self._lines[ln]
self._tableEncours.fields[
self._fieldEncours.name] = self._fieldEncours
self._tableEncours.fieldsName.append(self._fieldEncours.name)
commentStarted = False
ln += 1
def test_04_blank_row_second(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# table 1 has no row only titles, but table 2 has
table_1.set_dict({'t1.title': []})
table_2.set_dict({'t2.title': ['CSCA', '08']})
# the result of the cartesian product of a table without any row
# it should return no row
result = squeal.cartesian_product(table_1, table_2)
# if there is no row for one table, then result should be no row
result_dict = result.get_dict()
expected = {'t2.title': [], 't1.title': []}
self.assertEqual(result_dict, expected,
'''if one table has no row, product should be empty,
but it has all the title names''')
def test_06_two_blank_rows(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# two tables both have no row
table_1.set_dict({'t1.title': []})
table_2.set_dict({'t2.title': []})
# the result of the cartesian product of a table without any row
# it should return no row
result = squeal.cartesian_product(table_1, table_2)
# if there is no row for one table, then result should be no row
result_dict = result.get_dict()
expected = {'t2.title': [], 't1.title': []}
self.assertEqual(result_dict, expected,
'''if two tables has no row, then there is no row
to return but title names''')
def test_07_normal_cases(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# set two tables
table_1.set_dict({'CSC': ['A08', 'A67'], 'MAT': ['A31', 'A23']})
table_2.set_dict({'c.A08': ['term work', 'term tests', 'final']})
result = squeal.cartesian_product(table_1, table_2)
# get the result dict of cartesian product
result_dict = result.get_dict()
expected = {'MAT': ['A31', 'A31', 'A31', 'A23', 'A23', 'A23'],
'c.A08': ['term work', 'term tests', 'final', 'term work',
'term tests', 'final'],
'CSC': ['A08', 'A08', 'A08', 'A67', 'A67', 'A67']}
self.assertEqual(result_dict, expected,
'''your cartesian product must get something
wrong''')
def test_08_normal_test(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# set two tables
table_1.set_dict({'m.A31': ['homework', 'midterm', 'final']})
table_2.set_dict({'c.A08': ['term work', 'term tests', 'final']})
result = squeal.cartesian_product(table_1, table_2)
# get the result dict of cartesian product
result_dict = result.get_dict()
expected = {'m.A31': ['homework', 'homework', 'homework', 'midterm',
'midterm', 'midterm', 'final', 'final', 'final'],
'c.A08': ['term work', 'term tests', 'final', 'term work',
'term tests', 'final', 'term work',
'term tests', 'final']}
self.assertEqual(result_dict, expected,
'''your cartesian product must get something
wrong''')
def test_11_normal_test(self):
# initialize two tables
table_1 = Table()
table_2 = Table()
# set two tables
table_1.set_dict({'a': ['1', '2', '3', '4']})
table_2.set_dict({'b': ['10', '11', '12'], 'c': ['99', '98', '97']})
result = squeal.cartesian_product(table_2, table_1)
# get the result dict of cartesian product
result_dict = result.get_dict()
expected = {'a': ['1', '2', '3', '4', '1', '2', '3', '4', '1', '2',
'3', '4'],
'b': ['10', '10', '10', '10', '11', '11', '11', '11',
'12', '12', '12', '12'],
'c': ['99', '99', '99', '99', '98', '98', '98', '98',
'97', '97', '97', '97']}
self.assertEqual(result_dict, expected,
'''your cartesian product must get something
wrong''')
def setUp(self):
t1, t2, t3 = Table(), Table(), Table()
t1.set_dict({
'a.str': ['one', 'two', 'three', 'one'],
'a.val': ['1', '2', '3', '1'],
'a.a': ['1', '2', '3', '4']
})
t2.set_dict({
'b.str': ['one', 'two', 'three', 'one'],
'b.b': ['1', '2', '3', '3'],
'b.val': ['1', '2', '3', '1']
})
t3.set_dict({'c.c': ['1', '2'], 'c.val': ['100', '200']})
self.db = {'tablea': t1, 'tableb': t2, 'tablec': t3}
self.dbo = Database()
self.dbo.set_dict(self.db)
def test_join(self):
table1 = Table('table1', ['c1', 'c2'], ColumnTypes([int, int]))
table1.append_row([1, 2])
table1.append_row([1, 4])
table1.append_row([2, 3])
table2 = Table('table2', ['c1', 'c3'], ColumnTypes([int, str]))
table2.append_row([1, 'str1'])
table2.append_row([2, 'str2'])
table3 = table1.join(table2, 'c1')
rows_data = list(map(lambda x: x.data, table3.rows))
self.assertTrue([1, 2, 'str1'] in rows_data)
self.assertTrue([1, 4, 'str1'] in rows_data)
self.assertTrue([2, 3, 'str2'] in rows_data)
# Created by Marsify, 2019
import discord
from discord.ext import commands
import random
import config
import rules_and_sets as rns
from database import Table
rules = Table('rules', rns.rule_list)
sets = Table('sets', rns.set_list)
rules.delete_table()
sets.delete_table()
rules.create_table()
sets.create_table()
# Generates a random list of sets and rules based on the specified mode. Used when spinning the wheel.
def generate(mode):
# Return values
rule_list = []
set_list = []
# Entries from database
rule_values = []
set_values = []
# 'Standard' mode has a separate method of set generation.
if mode == 'standard':
rule_values = rules.get_values(1)
import numpy as np
import vision
from PIL import Image
from database import Column, Integer, Float, String, Boolean
from database import Model, CRUDMixin, ForeignKey, Table
from database import relationship, backref
from vision.track.interpolation import LinearFill
from meta_table import video_evaluation_association_table
import config
logger = logging.getLogger("vatic.models")
boxes_attributes = Table(
"boxes2attributes", Column("box_id", Integer, ForeignKey("boxes.id")),
Column("attribute_id", Integer, ForeignKey("attributes.id")))
class Video(Model, CRUDMixin):
__tablename__ = "videos"
id = Column(Integer, primary_key=True)
slug = Column(String(250), index=True)
width = Column(Integer)
height = Column(Integer)
totalframes = Column(Integer)
location = Column(String(250))
skip = Column(Integer, default=0, nullable=False)
perobjectbonus = Column(Float, default=0)
completionbonus = Column(Float, default=0)
def _getTables(self):
self.cursor.execute("SHOW TABLES")
for c in self.cursor:
self.tablesNames.append(c[0])
self.tables[c[0]] = Table(name=c[0])
def test_cant_create_table(self):
table = Table(self.FILENAME)
with mock.patch.object(table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
table.create_table_if_not_exists()
class EntityAnnotation:
_entity: Entity = None
_pathEntity = 'database/entity/'
_lines = []
_tableEncours: Table = None
_fieldEncours: FieldTable = None
_actualLine: str = None
_entitesALreadyFormated = {}
_tablesAlreadyDone = {}
_nameMysqlFieldEncours = ""
_fileCreator = FileCommentedCreator(filePath=_pathEntity)
def __init__(self, entity: Entity = None, forceUpdate: bool = False):
if entity is not None:
self.seakEntity(entity, forceUpdate)
def seakEntity(self, entity: Entity, forceUpdate: bool = False):
if (entity.getName()
not in self._entitesALreadyFormated.keys()) | forceUpdate:
self._entity = entity
self._tableEncours = Table()
self._recupDatas()
self._decoupeComment()
self._entitesALreadyFormated[entity.getName()] = self._entity
self._tablesAlreadyDone[entity.getName()] = self._tableEncours
else:
self._entity = self._entitesALreadyFormated[entity.getName()]
self._tableEncours = self._tablesAlreadyDone[entity.getName()]
self._recupDataWithCopieEntity(entity)
def writeTableInEntityFile(self, table: Table = None):
if table is not None:
self._tableEncours = table
self._fileCreator.convertMysqlToEntityFile(
tableToPut=self._tableEncours)
def _recupDatas(self):
fileName = self._pathEntity + self._entity.getName() + '.py'
with open(fileName, "r") as fopen:
self._lines = fopen.readlines()
def _decoupeComment(self):
lfichier = len(self._lines)
ln = 0
commentStarted = False
findEntity = "# @ORM/" + baseCommandeAnnotation[0] + "="
self._entity.clearAttibutes()
while ln < lfichier:
self._actualLine = self._lines[ln]
if self._fieldEncours:
if preFormatLineAnnotation(self._actualLine)[0:1] == '_':
vals = preFormatLineAnnotation(
self._actualLine)[1:].split(":")
self._entity.addAttributeToListAttributes(vals[0])
if self._fieldEncours.key == "PRI":
self._entity.setPrimaryKey(vals[0])
self._tableEncours.setPrimaryKey(
self._nameMysqlFieldEncours)
if self.isLineContain(stToContain=findEntity,
addPreCarShort=False):
self._tableEncours = Table()
self._tableEncours.fieldsName = []
self._tableEncours.name = preFormatLineAnnotation(
self._actualLine)[18:]
if self.isLineContain(startAnnotationFormat, False):
commentStarted = True
self._fieldEncours = FieldTable()
ln += 1
self._actualLine = self._lines[ln]
if commentStarted:
while not self.isLineContain(startAnnotationFormat, False):
self._actualLine = self._lines[ln]
if self.isLineContain("# @ORM/", False):
self._commandAnnotationEntity()
ln += 1
self._actualLine = self._lines[ln]
self._tableEncours.fields[
self._fieldEncours.name] = self._fieldEncours
self._tableEncours.fieldsName.append(self._fieldEncours.name)
commentStarted = False
ln += 1
def _commandAnnotationEntity(self):
if not tools.dataNotNull(self._actualLine):
return False
marqueur = "@ORM/"
clfM = len(marqueur) + 2
if self.isLineContain("@ORM/", True):
val = preFormatLineAnnotation(self._actualLine)[clfM:]
lbca = len(baseCommandeAnnotation[1])
com = val[0:lbca]
if com == baseCommandeAnnotation[1]:
self._fieldEncours = FieldTable()
stName = lbca + 1
self._fieldEncours.name = val[stName:]
self._nameMysqlFieldEncours = val[stName:]
return True
lbca = len(baseCommandeAnnotation[2])
com = val[0:lbca]
if com == baseCommandeAnnotation[2]:
self._commandeColumn(val)
return True
lbca = len(baseCommandeAnnotation[3])
com = val[0:lbca]
if com == baseCommandeAnnotation[3]:
self._fieldEncours.extra = 'auto_increment'
return True
else:
return False
def _commandeColumn(self, line: str):
# Commands => 'type', 'nullable', key
cl = len(baseCommandeAnnotation[2]) + 1
localCommandsSt = re.sub('\n', '', line[cl:])
localCommandsSt = re.sub('\)$', '', localCommandsSt)
localCommandsAr = localCommandsSt.split(",")
for lc in localCommandsAr:
lcNet = re.sub('^\s', '', lc)
lcNet = re.sub('\s$', '', lcNet)
if lcNet[0:4] == 'type':
typeLine = re.sub("\(\d*\)", '', lcNet[5:])
lenRech = re.search('\d+', lcNet[5:])
if lenRech:
if lenRech.group(0):
self._fieldEncours.length = int(lenRech.group(0))
else:
self._fieldEncours.length = 0
else:
self._fieldEncours.length = 0
self._fieldEncours.type = findTypeFromMysql(typeLine)
elif lcNet[0:3] == 'key':
value = re.sub('^\s*', '', lcNet[4:])
value = re.sub('\s=$', '', value)
self._fieldEncours.key = value
elif lcNet[0:8] == 'nullable':
self._fieldEncours.nullable = True
return
def isLineContain(self, stToContain: str, addPreCarShort: bool = False):
if addPreCarShort:
stToContain = "# " + stToContain
ltofind = len(stToContain)
if preFormatLineAnnotation(self._actualLine)[0:ltofind] == stToContain:
return True
return False
def getTable(self):
return self._tableEncours
def getEntity(self):
return self._entity
def _recupDataWithCopieEntity(self, newEntity: Entity):
for attr in self._entity.getAttributes():
self._entity.__setattr__(attr, newEntity.__getattribute__(attr))
newEntity.addAttributeToListAttributes(attr)
class DBTest(TestCase):
FILENAME = ":memory:"
def setUp(self):
try:
os.remove(self.FILENAME)
except Exception as e:
pass
self._table = Table(self.FILENAME)
self.db_manage = DBManager(self._table)
def tearDown(self):
self._table = None
self.db_manage = None
def test_add(self):
self.assertEqual(len(self._table.list()), 0)
record = Record("a", "b", "c")
self._table.add(record)
self.assertEqual(len(self._table.list()), 1)
def test_delete(self):
record = Record("a", "b", "c")
self._table.add(record)
record = self._table.get("a")
with self.assertRaises(ErrorDatabase):
self._table.delete("test")
self._table.delete(record.pk)
self.assertEqual(len(self._table.list()), 0)
def test_get_non_exists(self):
record = self._table.get(5)
self.assertIsNone(record)
record = self._table.get("test")
self.assertIsNone(record)
def test_get_password(self):
record = Record("a", "b", "c")
self._table.add(record)
result = self.db_manage.get_password("a")
self.assertIsNotNone(result)
result2 = self.db_manage.get_password("c")
self.assertIsNotNone(result2)
result3 = self.db_manage.get_password("d")
self.assertIsNone(result3)
self.assertEqual(result[0], result2[0])
self.assertEqual(result[1], result2[1])
def test_wrong_db_file(self):
with mock.patch.object(database.db, 'connect', side_effect=IOError("1")):
with self.assertRaises(ErrorDatabase):
table = Table(self.FILENAME)
def test_cant_create_table(self):
table = Table(self.FILENAME)
with mock.patch.object(table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
table.create_table_if_not_exists()
def test_cant_add_record(self):
record = Record("a", "b", "c")
with mock.patch.object(self._table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
self._table.add(record)
def test_cant_get(self):
count_before = len(self._table.list())
record = Record("test_cant_get", "test_cant_get", "test_cant_get")
self._table.add(record)
record = self._table.get("test_cant_get")
self.assertIsNotNone(record)
pk = record.pk
with mock.patch.object(self._table, '_connection') as mock_connection:
mock_connection.cursor = mock.Mock(side_effect=ValueError("1"))
record = self._table.get("test_cant_get")
self.assertIsNone(record)
self._table.delete(pk)
self.assertEqual(len(self._table.list()), count_before)
def test_ui(self):
with mock.patch.object(sys, 'argv', ["database.py"]):
with self.assertRaises(SystemExit):
database.main()
with mock.patch.object(sys, 'argv', ['database.py', 'test.db']):
with mock.patch.object(database.Table, '__init__', side_effect=database.ErrorDatabase()):
with self.assertRaises(SystemExit):
database.main()
def post(self):
"""New Table"""
table = Table(id=str(uuid.uuid4()), **api.payload)
save(table)
return table, 201
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from database import Column, Integer, Float, String, Boolean
from database import Model, ForeignKey, Table
from database import relationship, backref
video_evaluation_association_table = Table(
'video_evaluation_association',
Column('evaluation_sets_id', Integer, ForeignKey('evaluation_sets.id')),
Column('videos_id', Integer, ForeignKey('videos.id')))
classifier_evaluation_association_table = Table(
'classifier_evaluation_association',
Column('evaluation_sets_id', Integer, ForeignKey('evaluation_sets.id')),
Column('classifiers_id', Integer, ForeignKey('classifiers.id')))
video_classifier_association_table = Table(
'video_classifier_association',
Column('videos_id', Integer, ForeignKey('videos.id')),
Column('classifiers_id', Integer, ForeignKey('classifiers.id')))
import time
import sqlite3
from database import Integer, String, Column, Table
DB_FN = 'hits.db'
db = sqlite3.connect(DB_FN)
Hits = Table(
'hits',
db,
Column('ip', String()),
Column('localip', String()),
Column('epoch', Integer()),
Column('request', String()),
)
Hits.create()
def insert(ip, localip, request):
now = int(time.time())
Hits.insert([[ip, localip, now, request]])
class DBTest(TestCase):
FILENAME = ":memory:"
def setUp(self):
try:
os.remove(self.FILENAME)
except Exception as e:
pass
self._table = Table(self.FILENAME)
self.db_manage = DBManager(self._table)
def tearDown(self):
self._table = None
self.db_manage = None
def test_add(self):
self.assertEqual(len(self._table.list()), 0)
record = Record("a", "b", "c")
self._table.add(record)
self.assertEqual(len(self._table.list()), 1)
def test_delete(self):
record = Record("a", "b", "c")
self._table.add(record)
record = self._table.get("a")
with self.assertRaises(ErrorDatabase):
self._table.delete("test")
self._table.delete(record.pk)
self.assertEqual(len(self._table.list()), 0)
def test_get_non_exists(self):
record = self._table.get(5)
self.assertIsNone(record)
record = self._table.get("test")
self.assertIsNone(record)
def test_get_password(self):
record = Record("a", "b", "c")
self._table.add(record)
result = self.db_manage.get_password("a")
self.assertIsNotNone(result)
result2 = self.db_manage.get_password("c")
self.assertIsNotNone(result2)
result3 = self.db_manage.get_password("d")
self.assertIsNone(result3)
self.assertEqual(result[0], result2[0])
self.assertEqual(result[1], result2[1])
def test_wrong_db_file(self):
with mock.patch.object(database.db,
'connect',
side_effect=IOError("1")):
with self.assertRaises(ErrorDatabase):
table = Table(self.FILENAME)
def test_cant_create_table(self):
table = Table(self.FILENAME)
with mock.patch.object(table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
table.create_table_if_not_exists()
def test_cant_add_record(self):
record = Record("a", "b", "c")
with mock.patch.object(self._table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
self._table.add(record)
def test_cant_get(self):
count_before = len(self._table.list())
record = Record("test_cant_get", "test_cant_get", "test_cant_get")
self._table.add(record)
record = self._table.get("test_cant_get")
self.assertIsNotNone(record)
pk = record.pk
with mock.patch.object(self._table, '_connection') as mock_connection:
mock_connection.cursor = mock.Mock(side_effect=ValueError("1"))
record = self._table.get("test_cant_get")
self.assertIsNone(record)
self._table.delete(pk)
self.assertEqual(len(self._table.list()), count_before)
def test_ui(self):
with mock.patch.object(sys, 'argv', ["database.py"]):
with self.assertRaises(SystemExit):
database.main()
with mock.patch.object(sys, 'argv', ['database.py', 'test.db']):
with mock.patch.object(database.Table,
'__init__',
side_effect=database.ErrorDatabase()):
with self.assertRaises(SystemExit):
database.main()
def test_wrong_db_file(self):
with mock.patch.object(database.db,
'connect',
side_effect=IOError("1")):
with self.assertRaises(ErrorDatabase):
table = Table(self.FILENAME)
def test_cant_create_table(self):
table = Table(self.FILENAME)
with mock.patch.object(table, '_connection') as mock_connection:
mock_connection.execute = mock.Mock(side_effect=ValueError("1"))
with self.assertRaises(ErrorDatabase):
table.create_table_if_not_exists()
def __init__(self, name: str, statistics: database.Statistics,
resources: Any):
Table.__init__(self, name, statistics, resources)
self.entries = {}
def test_persist(self):
dbms: DBMS = DBMS()
db1: Database = dbms.create_database('db1')
table1 = Table('table1', ['c1', 'c2'], ColumnTypes([int, str]))
table1.append_row([1, '1'])
table1.append_row([2, '2'])
table2 = Table('table2', ['c1', 'c2'], ColumnTypes([str, int]))
table2.append_row(['1', 1])
table2.append_row(['2', 2])
table3 = Table('table3', ['c1', 'c3'], ColumnTypes([int, int]))
table3.append_row([1, 1])
table3.append_row([1, 2])
table3.append_row([2, 1])
table3.append_row([2, 2])
db1.add_table(table1)
db1.add_table(table2)
db1.add_table(table3)
db2: Database = dbms.create_database('db2')
table3 = Table('table3', ['c1', 'c2'], ColumnTypes([Char, Color]))
table3.append_row([Char('a'), Color('#ffffff')])
table3.append_row([Char('b'), Color('#aaaaaa')])
table4 = Table('table4', ['c1', 'c2'], ColumnTypes([Color, Char]))
table4.append_row([Color('#ffffff'), Char('a')])
table4.append_row([Color('#ffffff'), Char('a')])
db2.add_table(table3)
db2.add_table(table4)
dbms.persist()
DBMS.load()
for database_name in dbms.get_databases_names():
for table_name, table in dbms.get_database(
database_name)._tables.items():
print(table.to_json())
def __init__(self, *args, **kwargs):
print('initializing window...')
tk.Tk.__init__(self, *args, **kwargs)
tk.Tk.wm_title(self, "Windkanal-Tool")
#early response to user
self.update_idletasks()
print('initializing sensors...')
self.adc = MCP3008(0, 0)
self.pressureSensors = Spd610Array()
self.forceSensors = LoadCells()
self.forceSensors.start()
self.motorController = PWM(32)
self.pid = PID(100 / 22, 5, 1)
self.pid.setWindup(1)
print('initializing database...')
Table.__init__(self, ["windspeed", "set_value", "motor_pwm"] +
["pressure_{}".format(i) for i in range(8)] +
["adc_{}".format(i) for i in range(1)] +
["force_X_sum", "force_Y_sum", "force_Z_sum"] +
["force_X_1", "force_Y_1", "force_Z_1"] +
["force_X_2", "force_Y_2", "force_Z_2"] +
["force_X_3", "force_Y_3", "force_Z_3"])
print('initializing GUI...')
self.menubar = tk.Menu(self)
self.frameVar = tk.StringVar()
self.menubar.add_radiobutton(indicatoron=0,
variable=self.frameVar,
value='Page_1',
command=self.show_frame,
label="Bedienelemente")
self.menubar.add_radiobutton(indicatoron=0,
variable=self.frameVar,
value='Page_2',
command=self.show_frame,
label="Kräfte")
self.menubar.add_radiobutton(indicatoron=0,
variable=self.frameVar,
value='Page_3',
command=self.show_frame,
label="Druck")
self.menubar.add_radiobutton(indicatoron=0,
variable=self.frameVar,
value='Page_4',
command=self.show_frame,
label="Einstellungen")
self.menubar.add_command(state=tk.DISABLED, label=" ")
self.motorEnabled = tk.IntVar()
self.menubar.add_checkbutton(
indicatoron=0,
variable=self.motorEnabled,
background='#dd5252',
label="Motor freischalten",
command=lambda: self.menubar.entryconfigure(
"Motor freischalten",
background='#dd5252'
if self.motorEnabled.get() == 0 else 'green'))
self.motorEnabled.set(0)
self.menubar.add_command(state=tk.DISABLED, label=" ")
self.menubar.add_command(label="Messwerte speichern",
command=self.save_dialog)
self.menubar.add_command(label='Messwerte löschen', command=self.reset)
self.menubar.add_command(state=tk.DISABLED, label=" ")
self.menubar.add_command(label="Beenden",
foreground="red",
command=self.stop)
tk.Tk.config(self, menu=self.menubar)
container = tk.Frame(self)
container.pack(side="top", fill="both", expand=True)
container.grid_rowconfigure(0, weight=1)
container.grid_columnconfigure(0, weight=1)
self.frames = {}
for F in (Page_1, Page_2, Page_3, Page_4):
frame = F(container, self)
self.frames[F.__name__] = frame
frame.grid(row=0, column=0, sticky="nsew")
self.frameVar.set('Page_1')
self.show_frame()
print('program ready!')
self.windspeed = 0
self.adcValue = 0
self.pwmValue = 0
self.pidDelay = 100
self.pidThread = threading.Thread(target=self.pidThreadFunction)
self.pidThread.daemon = True
self.pidThread.start()
self.intervalDelay = 300 # ms
self.interval()
