def makedb(dbfile):
db = SqliteExtDatabase(dbfile)
db.connect()
global BaseModel
class BaseModel(Model):
class Meta:
database = db
global UniqueString
class UniqueString(BaseModel):
raw = CharField(index=True)
count = IntegerField()
malware_count = IntegerField()
p_malware = FloatField(index=True)
global Entity
class Entity(BaseModel):
name = CharField(index=True)
label = FloatField()
global String
class String(BaseModel):
uniquestring = ForeignKeyField(UniqueString,index=True)
entity = ForeignKeyField(Entity,index=True)
source = CharField(index=True,null=True)
# create database
db.create_tables([Entity,String,UniqueString])
return db
def start_database(dbname, sqlite=False, tbl_name=None, **kwargs):
"""Connect to a SQLite or MySQL database.
Args:
dbname (str): Database path (SQLite) or name (MySQL).
Kwargs:
sqlite (bool): Use SQLite instead of MySQL.
tbl_name (str): Alternative name for locations table.
host (str): MySQL host.
user (str): Username for MySQL.
passwd (str): Password for MySQL.
ssl (dict): Dictionary of paths to SSL certificates.
"""
if sqlite:
db = SqliteExtDatabase(dbname)
else:
db = MySQLDatabase(dbname, **kwargs)
if tbl_name is not None:
Location._meta.db_table = tbl_name.strip()
dbproxy.initialize(db)
db.create_table(Location, safe=True)
return db
class Database(object):
def __init__(self, database):
"""Create a Database object.
:param database: database file name
:type database: str
:returns: Database
"""
self.database = SqliteExtDatabase('%s.db' % database)
self.models = models
def create(self, force = False, verbose = True):
"""Create the database: create the file and the database tables.
:param force: force the creation of a database even if another with the same name already exists
:type db: bool
"""
if not os.path.isfile(self.database.database) or force == True: # self.database.database corresponds to the database file
try:
self.database.create_tables([self.models.Category, self.models.Music, self.models.Rating, self.models.Score])
except Exception:
print("Une erreur est survenue lors de la création de la base de données.")
else:
if verbose:
print("La base de données existe déjà.")
def connect(self):
"""Connect to the database."""
try:
self.database.connect()
except Exception:
print("Une erreur est survenue lors de la connexion à la base de données.")
def populate(self, what):
""" Populate database with CSV files"""
if what == "categories":
csv_data = csv.get_csv_data("%s/categories" % settings.POPULATE_FILES_DIR)
for data in csv_data:
try:
models.Category.create(name=data[0])
except Exception:
print("Une erreur est survenue lors du remplissage de la base de données.")
elif what == "musics":
csv_data_files = csv.get_csv_data("%s/musics" % settings.POPULATE_FILES_DIR, 7) # Hardcoded number of musics CSV file should be fixed
for csv_data in csv_data_files:
for data in csv_data:
try:
models.Music.create(name=data[0], category=data[1])
except Exception:
print("Une erreur est survenue lors du remplissage de la base de données.")
def memdb():
mdb = SqliteExtDatabase(':memory:')
models = [db.Job]
mdb.bind(models)
mdb.connect()
mdb.create_tables(models)
yield mdb
mdb.close()
def get_tape_mgr(db=None):
changer = get_changer()
if db is None:
db = SqliteExtDatabase(':memory:')
db.connect()
database_proxy.initialize(db)
return tapemgr.TapeManager(db,
changer,
storage_choosers,
cleaning_chooser,
init_db=True)
def __init__(self, database):
"""Create a Database object.
:param database: database file name
:type database: str
:returns: Database
"""
self.database = SqliteExtDatabase('%s.db' % database)
self.models = models
def test_database():
test_db = SqliteExtDatabase(":memory:")
with test_db.bind_ctx(ALL_MODELS):
test_db.create_tables(ALL_MODELS)
try:
yield
finally:
test_db.drop_tables(ALL_MODELS)
test_db.close()
def init_database(self):
migrate_db = SqliteExtDatabase(self.config.database.path)
# Run migrations
del (logging.getLogger('peewee_migrate').handlers[:])
router = Router(migrate_db)
router.run()
migrate_db.close()
self.db = SqliteQueueDatabase(self.config.database.path)
models = [Event]
self.db.bind(models)
def _init_db(self, db_path):
from playhouse.sqlite_ext import SqliteExtDatabase
if db_path is None:
db_path = os.path.join(os.path.expanduser('~'), '.etesync', 'data.db')
directory = os.path.dirname(db_path)
if directory != '' and not os.path.exists(directory):
os.makedirs(directory)
database = SqliteExtDatabase(db_path, pragmas={'foreign_keys': 1})
database.connect()
self._set_db(database)
def setup(cls):
"""sets up the SQL System"""
mode = CONFIG["database"]["mode"].value.lower()
if mode == "sqlite3":
database = SqliteExtDatabase(
PROGRAMCONFIGLOCATION + "/Tackem.db",
pragmas={
"journal_mode": "wal",
"foreign_keys": 0
},
)
elif mode == "mysql":
database = MySQLDatabase(
CONFIG["database"]["database"].value,
user=CONFIG["database"]["username"].value,
password=CONFIG["database"]["password"].value,
host=CONFIG["database"]["host"].value,
port=CONFIG["database"]["port"].value,
)
else:
print(mode)
cls.__db.initialize(database)
if mode == "sqlite3":
cls.__migrator = SqliteMigrator(cls.__db)
elif mode == "mysql":
cls.__migrator = MySQLMigrator(cls.__db)
TableVersion.create_table()
def __init__(self, db_path):
pragmas = [
('journal_mode', 'wal2'),
('cache_size', -1024*64)]
self.db_path = os.path.join(db_path, DATASOURCE_NAME, f"{DATASOURCE_NAME}.db")
self.db_object = SqliteExtDatabase(self.db_path, pragmas=pragmas, detect_types=sqlite3.PARSE_DECLTYPES)
backups_table, status_table, stats_table, backup_list_table = initialize(self.db_object)
self.datasource_name = DATASOURCE_NAME
self.config = {
"tables": {
"stats_table": stats_table,
"status_table": status_table,
"backup_table": backups_table,
"backup_list_table": backup_list_table,
},
"utils":{
"stats": stats,
"status": status
}
}
self.routes = {"GET": [ ("stats", stats), ("status", status), ("backup_list", backup_list),\
("start_fresh_backup", start_fresh_backup), ("generate_mnemonic", new_mnemonic)],
"POST": [ ("store_mnemonic", store_mnemonic), ("check_mnemonic", check_mnemonic)]}
def init_db():
driver = get_config('DATABASE', 'driver')
host = get_config(driver, 'host')
username = get_config(driver, 'username')
password = get_config(driver, 'password')
database = get_config(driver, 'database')
port = int(get_config(driver, 'port'))
if driver == 'POSTGRESQL':
db = PostgresqlDatabase(database,
user=username,
host=host,
password=password)
elif driver == 'SQLITE':
from playhouse.sqlite_ext import SqliteExtDatabase
db = SqliteExtDatabase('data/database.db')
elif driver == 'MYSQL':
db = MySQLDatabase(database,
user=username,
host=host,
password=password,
port=port)
else:
raise NotSupportedError
return db
def __init__(self, key_field=None, value_field=None, ordered=False,
database=None, table_name='keyvalue'):
if key_field is None:
key_field = CharField(max_length=255, primary_key=True)
if not key_field.primary_key:
raise ValueError('key_field must have primary_key=True.')
if value_field is None:
value_field = PickleField()
self._key_field = key_field
self._value_field = value_field
self._ordered = ordered
self._database = database or SqliteExtDatabase(':memory:')
self._table_name = table_name
support_on_conflict = (isinstance(self._database, PostgresqlDatabase) or
(isinstance(self._database, SqliteDatabase) and
self._database.server_version >= (3, 24)))
if support_on_conflict:
self.upsert = self._postgres_upsert
self.update = self._postgres_update
else:
self.upsert = self._upsert
self.update = self._update
self.model = self.create_model()
self.key = self.model.key
self.value = self.model.value
# Ensure table exists.
self.model.create_table()
def __post_init__(self):
self.path = os.path.join(self.directory, "plugins", self.plugin_name)
self.pragmas = [('journal_mode', 'wal2'), ('cache_size', -1024 * 64)]
self.db_object = SqliteExtDatabase(
os.path.join(self.path, f"{self.plugin_name}.db"),
pragmas=self.pragmas,
detect_types=sqlite3.PARSE_DECLTYPES)
class DatabaseHandler:
"""Class for managing database connection and loading given data into database"""
# static field for storing database connection by peewee
db = SqliteExtDatabase("database.db",
pragmas=(("cache_size", -1024 * 64),
("journal_mode", "wal"), ("foreign_keys",
1)))
def __init__(self):
"""Calls method create_table for Person class"""
self.create_table(Person)
def create_table(self, table_class):
"""Create table from Person class in database"""
table_class.create_table()
def insert_data_into_person(self, data):
"""Call insert_data method with Person as parameter"""
self.insert_data(data, Person)
def insert_data(self, data, table_class):
"""
Insert data into database in chunks using peewee functions
:param table_class: Class which should store the given date in database
:param data: List of persons to be stored in database
"""
with self.db.atomic():
for batch in chunked(data, 5):
table_class.insert_many(batch).execute()
def __init__(self, db_path):
pragmas = [('journal_mode', 'wal2'), ('cache_size', -1024 * 64)]
self.db_path = os.path.join(db_path, DATASOURCE_NAME,
f"{DATASOURCE_NAME}.db")
self.db_object = SqliteExtDatabase(
self.db_path,
pragmas=pragmas,
detect_types=sqlite3.PARSE_DECLTYPES)
creds_table = initialize(self.db_object)
self.datasource_name = DATASOURCE_NAME
self.config = {
"tables": {
"creds_table": creds_table,
},
"utils": {}
}
self.routes = {
"GET": [("logout", user_logout), ("is_logged_in", is_logged_in)],
"POST": [("login", login), ("signup", signup),
("confirm_signup", confirm_signup),
("forgot_password", forgot_password),
("confirm_forgot_password", confirm_forgot_password),
("change_password", change_password)]
}
def __init__(self):
self.settings = get_settings()
self.isdebug = util.bc(self.settings[util.SETTINGS_KEYS[4]])
inmemory = util.bc(self.settings[util.SETTINGS_KEYS[0]])
if inmemory:
val = ':memory:'
else:
val = (self.settings[util.SETTINGS_KEYS[1]])
self.db = db
if not self.db:
hou.session.DBCONNECTION = DatabaseProxy()
self.db.initialize(
SqliteExtDatabase(val,
pragmas=(("cache_size", -1024 * 64),
("journal_mode",
"off"), ("temp_store", "memory"),
("synchronous", 0))))
if inmemory or not os.path.isfile(
self.settings[util.SETTINGS_KEYS[1]]):
db.create_tables([
Settings,
HContext,
Hotkeys,
HotkeysIndex,
])
self.initialsetup(self.cur)
self.cur = db.cursor()
self.isdebug = None
self.contexttime = 0
self.hotkeystime = 0
def __init__(self,
key_field=None,
value_field=None,
ordered=False,
database=None,
table_name='keyvalue'):
if key_field is None:
key_field = CharField(max_length=255, primary_key=True)
if not key_field.primary_key:
raise ValueError('key_field must have primary_key=True.')
if value_field is None:
value_field = PickleField()
self._key_field = key_field
self._value_field = value_field
self._ordered = ordered
self._database = database or SqliteExtDatabase(':memory:')
self._table_name = table_name
self._has_upsert = not isinstance(self._database, PostgresqlDatabase)
self.model = self.create_model()
self.key = self.model.key
self.value = self.model.value
# Ensure table exists.
self.model.create_table()
def _recreate_db():
src_dir = os.path.dirname(os.path.abspath(__file__))
db_path = os.path.join(src_dir, '../data/main.db')
if os.path.exists(db_path):
os.remove(db_path)
pragmas = [('journal_mode', 'wal'), ('cache_size', -1024 * 32)]
return SqliteExtDatabase(db_path, pragmas=pragmas)
def clean(db_loc):
"""
Some fragments are duplicates, or are not included in the db, but there are still atom and pseudoatom records
that refer to them. This is not ideal, so this script deletes these orphan records.
:param db_loc:
:return:
"""
# create the database for the output
db = SqliteExtDatabase(
db_loc,
pragmas={
'cache_size': -1024 * 64, # 64MB page-cache.
'journal_mode':
'wal', # Use WAL-mode (you should always use this!).
'foreign_keys': 0,
'wal_autocheckpoint': 10,
})
# get the models
Fragment, Heritage, PseudoAtoms, Atoms = lib_read(db)
Fragment.create_table(safe=True)
Heritage.create_table(safe=True)
PseudoAtoms.create_table(safe=True)
Atoms.create_table(safe=True)
logger.debug("Trying to clean up the database:")
logger.debug("Deleting missing ATOM records")
with db.atomic():
bad_atoms = Atoms.delete().where(
(Atoms.frag.not_in(Fragment.select())))
bad_atoms.execute()
logger.debug("Deleting missing PSEUDO_ATOM records")
with db.atomic():
bad_patoms = PseudoAtoms.delete().where(
(PseudoAtoms.frag.not_in(Fragment.select())))
bad_patoms.execute()
logger.debug("Deleting missing HERITAGE records")
with db.atomic():
bad_heritage = Heritage.delete().where(
(Heritage.frag.not_in(Fragment.select())))
bad_heritage.execute()
logger.info("Done.")
def connection(self):
if self._connection is None:
self._connection = SqliteExtDatabase(
self._path,
pragmas=(
('cache_size', -1024 * 64), # 64MB page-cache.
('journal_mode', 'wal'), # Use WAL-mode (Write Ahead Log).
))
return self._connection
def import_song_statistic_from(self, database_file):
self.logger.info('Importing database songs statistics')
try:
from playhouse.sqlite_ext import SqliteExtDatabase
other_database = SqliteExtDatabase(database_file)
cursor = other_database.execute_sql(
"SELECT ADDED, LAST_PLAYED, PLAYED, TITLE, ARTIST, ALBUM FROM SONG"
)
with database_context.atomic():
for row in cursor.fetchall():
database_context.execute_sql(
"UPDATE SONG SET ADDED = ?, LAST_PLAYED = ?, PLAYED = ? WHERE TITLE = ? AND ARTIST = ? AND ALBUM = ?",
row)
other_database.close()
except:
self.logger.exception(
'Error while importing database songs statistics')
def _open_db(path: PathOrStr):
db.initialize(
SqliteExtDatabase(str(path),
pragmas={
'synchronous': 0,
'cache_size': -1024 * 64,
}))
tables = [Relation, Language, Label, Concept, Edge]
db.create_tables(tables)
def connect(path, spatialite_path, evn_sep=';'):
"""
データベースへの接続
@param path sqliteのパス
@param spatialite_path mod_spatialiteへのパス
@param env_sep 環境変数PATHの接続文字 WINDOWSは; LINUXは:
"""
os.environ["PATH"] = os.environ["PATH"] + evn_sep + os.path.dirname(
spatialite_path)
db = SqliteExtDatabase(path)
database_proxy.initialize(db)
db.field_overrides = {
'polygon': 'POLYGON',
'point': 'POINT',
'linestring': 'LINESTRING',
'multipolygon': 'MULTIPOLYGON',
'multipoint': 'MULTIPOINT',
'multilinestring': 'MULTILINESTRING',
}
db.load_extension(os.path.basename(spatialite_path))
def get_database(storage_path):
db = SqliteExtDatabase(
storage_path,
pragmas=(
('cache_size', -1024 * 16), # 16MB page-cache
('journal_mode', 'wal'),
('foreign_keys', 1),
),
regexp_function=True,
)
return db
def __init__(self, database=None):
if database is None:
database = SqliteExtDatabase(':memory:')
if HAVE_C_EXTENSION:
register_json_contains(database)
else:
database.register_function(_json_contains, 'json_contains')
self.database = database
self.V, self.E = self.create_models()
def get_db():
path = get_path_db()
if path is None:
print(
"\n Error - Cannot fetch database because it has not yet been configured.\n"
)
else:
# peewee ORM connection to database:
#db = SqliteDatabase(path)
db = SqliteExtDatabase(path)
return db
def __init__(self, database):
"""Create a Database object.
:param database: database file name
:type database: str
:returns: Database
"""
self.database = SqliteExtDatabase('%s.db' % database)
self.models = models
def init_database(self):
# Migrate DB location
old_db_path = os.path.join(CLIPS_DIR, "frigate.db")
if not os.path.isfile(
self.config.database.path) and os.path.isfile(old_db_path):
os.rename(old_db_path, self.config.database.path)
# Migrate DB schema
migrate_db = SqliteExtDatabase(self.config.database.path)
# Run migrations
del logging.getLogger("peewee_migrate").handlers[:]
router = Router(migrate_db)
router.run()
migrate_db.close()
self.db = SqliteQueueDatabase(self.config.database.path)
models = [Event, Recordings]
self.db.bind(models)
def dbInit():
if 'CLEARDB_DATABASE_URL' in os.environ:
PROD = True
url = urlparse.urlparse(os.environ['CLEARDB_DATABASE_URL'])
db = peewee.MySQLDatabase(url.path[1:],
host=url.hostname,
user=url.username,
passwd=url.password)
else:
db = SqliteExtDatabase('weather.db')
class BaseModel(Model):
class Meta:
database = db
class CityGraph(BaseModel):
image_url = CharField()
city = CharField()
title = CharField()
date = DateField()
class Meta:
primary_key = CompositeKey('city', 'date')
db.connect()
db.create_tables([CityGraph], safe=True)
return CityGraph
def makedb(dbfile):
db = SqliteExtDatabase(dbfile)
db.connect()
global BaseModel
class BaseModel(Model):
class Meta:
database = db
global UniqueString
class UniqueString(BaseModel):
raw = CharField(index=True)
count = IntegerField()
malware_count = IntegerField()
p_malware = FloatField(index=True)
global Entity
class Entity(BaseModel):
name = CharField(index=True)
label = FloatField()
global String
class String(BaseModel):
uniquestring = ForeignKeyField(UniqueString, index=True)
entity = ForeignKeyField(Entity, index=True)
source = CharField(index=True, null=True)
# create database
db.create_tables([Entity, String, UniqueString])
return db
def _init_db(self, db_path):
from playhouse.sqlite_ext import SqliteExtDatabase
directory = os.path.dirname(db_path)
if directory != '' and not os.path.exists(directory):
os.makedirs(directory)
database = SqliteExtDatabase(db_path, pragmas={
'journal_mode': 'wal',
'foreign_keys': 1,
})
self._set_db(database)
def setup(path: str):
db = SqliteExtDatabase(path)
# Ensure foreign key and constraints are enforced.
db.pragma('foreign_keys', 1, permanent=True)
db.pragma('ignore_check_constraints', 0, permanent=True)
# Bind to database.
_proxy.initialize(db)
def __init__(self, db_path):
pragmas = [('journal_mode', 'wal2'), ('cache_size', -1024 * 64)]
self.db_path = os.path.join(db_path, DATASOURCE_NAME,
f"{DATASOURCE_NAME}.db")
self.db_object = SqliteExtDatabase(
self.db_path,
pragmas=pragmas,
detect_types=sqlite3.PARSE_DECLTYPES)
creds_table, status_table, stats_table, email_table,\
email_attachment_table, email_content_table,\
image_table, purchase_table, reservation_table, \
archives_table, location_table, location_approximate_table = initialize(self.db_object)
self.datasource_name = DATASOURCE_NAME
self.config = {
"tables": {
"creds_table": creds_table,
"image_table": image_table,
"email_table": email_table,
"email_attachment_table": email_attachment_table,
"email_content_table": email_content_table,
"purchase_table": purchase_table,
"archives_table": archives_table,
"reservation_table": reservation_table,
"location_table": location_table,
"location_approximate_table": location_approximate_table,
"stats_table": stats_table,
"status_table": status_table
},
"utils": {
"stats": stats,
"status": status
}
}
self.routes = {
"GET": [("emails/filter", emails_filter),
("images/filter", image_filter),
("locations/filter", locations_filter),
("delete_zip", delete_original_path),
("purchases/filter", purchases_filter),
("reservations/filter", reservations_filter),
("attachments/filter", attachment_filter)],
"POST": [("parse", parse), ("cancel_parse", cancel_parse),
("restart_parse", restart_parse)]
}
def test_get_relations(self):
test_db = 'test.db'
if isfile(test_db):
remove(test_db)
db = SqliteExtDatabase(test_db)
db.connect()
Subreddit, Relationship = obtain_models(db)
s_a = Subreddit.create(name='subreddit A',
subs=666,
over18=True,
iconURL='https://domain/pic.jpg')
s_b = Subreddit.create(name='subreddit B',
subs=777,
over18=False,
iconURL='https://domain/pic2.jpg')
Relationship.create(a=s_a, b=s_b)
relations_a = s_a.find_relations()
self.assertIn(s_b, relations_a)
#!/usr/bin/env python2
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
import os
db = SqliteExtDatabase(os.path.dirname(os.path.realpath(__file__))+'/corpus.db')
db.connect()
class BaseModel(Model):
class Meta:
database = db
class Tweet(BaseModel):
id = BigIntegerField(unique=True)
mentioning = CharField()
screen_name = CharField()
text = TextField()
created_at = DateTimeField(null=True)
ingested_at = DateTimeField(default=datetime.datetime.now)
classification = CharField(null=True)
#db.create_tables([Tweet])
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
import sys, os
db = SqliteExtDatabase('my_database.db')
class BaseModel(Model):
class Meta:
database = db
class User(BaseModel):
username = CharField(unique=True)
ip = CharField()
class Channel(BaseModel):
name = CharField(unique=True)
num = IntegerField(default=0)
class ChannelPublisher(BaseModel):
ch_id = ForeignKeyField(Channel, related_name='channel_pub')
pub_id = ForeignKeyField(User, related_name='publisher')
class ChannelSubscriber(BaseModel):
ch_id = ForeignKeyField(Channel, related_name='channel_sub')
sub_id = ForeignKeyField(User, related_name='subscriber')
ts = IntegerField()
class Feed(BaseModel):
ch_id = ForeignKeyField(Channel, related_name='channel_feed')
pub_id = ForeignKeyField(User, related_name='publisher_feed')
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
db = SqliteExtDatabase("db.sqlite3")
class BaseModel(Model):
class Meta:
database = db
class User(BaseModel):
username = CharField(unique=True, null=False)
created_at = DateTimeField(default=datetime.datetime.now)
class Meta:
db_table = "users"
class Channel(BaseModel):
channel = CharField(unique=True, null=False)
twitch_auth = CharField(default="")
twitchalerts_auth = CharField(default="")
streamtip_auth = CharField(default="")
created_at = DateTimeField(default=datetime.datetime.now)
class Meta:
db_table = "channels"
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
db = SqliteExtDatabase('store/virus_manager.db',
threadlocals=True)
class BaseModel(Model):
class Meta:
database = db
class ManagedMachine(BaseModel):
image_name = TextField(unique=True)
reference_image = TextField()
creation_time = IntegerField()
class Infection(BaseModel):
name = TextField()
machine = ForeignKeyField(ManagedMachine,
related_name='infections')
db.create_tables([ManagedMachine, Infection], True)
from __future__ import print_function
import os
import cv2
import numpy as np
from matplotlib import pyplot as plt
from matplotlib.widgets import Button
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
#create db connector
os.remove('my_database.db')
db = SqliteExtDatabase('my_database.db')
#base model class to extend it
class BaseModel(Model):
class Meta:
database = db
#point at all rows at once
class MultiDimensionalPoint(BaseModel):
first_pos_x = FloatField()
first_pos_y = FloatField()
second_pos_x = FloatField()
second_pos_y = FloatField()
third_pos_x = FloatField()
third_pos_y = FloatField()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
from collections import Counter
import NLP, utiltools
import TFIDF
import re
import random
import requests
import numpy as np
import dealSQL
DBPLACE = '/Users/masaMikam/Dropbox/Project/umiA/Data/LANGUAGEsid.sqlite3'
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
database = SqliteExtDatabase(DBPLACE, autocommit=False, journal_mode='persist')
database.connect()
class BaseModel(Model):
class Meta:
database = database
class trigram(BaseModel):
W1 = CharField(null=True)
W2 = CharField(null=True)
W3 = CharField(null=True)
P1 = CharField(null=True)
P2 = CharField(null=True)
P3 = CharField(null=True)
cnt = IntegerField(null=True)
ok = IntegerField(null=True)
ng = IntegerField(null=True)
class Meta:
# -*- coding: utf-8 -*-
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
from pplib.base_model import BaseM
db = SqliteExtDatabase('../data/tatoeba/tatoeba.db')
time_format = '%Y-%m-%d %H:%M:%S'
class BaseModel(Model, BaseM):
class Meta:
database = db
class User(BaseModel):
username = CharField(unique=True)
class Sentence(BaseModel):
user = CharField(null=True) # username
num = IntegerField(primary_key=True)
lang = FixedCharField(8)
text = CharField()
create_time = DateTimeField(default=datetime.datetime.now, null=True)
#!/usr/bin/python
# encoding: utf-8
import sys
from workflow import Workflow
from peewee import *
from glob import iglob
import json
import os
from playhouse.sqlite_ext import SqliteExtDatabase, SearchField, FTSModel
import datetime
wf = Workflow()
libpath = wf.stored_data('library_location')
db = SqliteExtDatabase("quiver.db")
if os.path.exists("quiver.db"):
os.remove("quiver.db")
# Create the database
class Note(Model):
uuid = CharField()
title = CharField(index = True)
notebook = CharField(index = True)
last_modified = DateTimeField()
class Meta:
database = db
class NoteIndex(FTSModel):
uuid = CharField()
import tornado.ioloop
from tornado.options import options
from playhouse.sqlite_ext import SqliteExtDatabase, ClosureTable
from peewee import (Model, CharField, ForeignKeyField, IntegerField,
BooleanField, DateTimeField, DoesNotExist, OperationalError)
import fs
log = logging.getLogger("tornado.general")
"""
connect to db
load closure module
create tables
"""
db = SqliteExtDatabase(options.db_file)
db.load_extension(options.sqlite_closure_table_so)
class File(Model):
path = CharField()
bytes = IntegerField()
is_dir = BooleanField()
modified = DateTimeField()
size = CharField() # redundant
parent = ForeignKeyField('self', null=True, related_name='children')
class Meta:
database = db
# -*- coding: utf-8 -*-
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
from pplib.base_model import BaseM
db = SqliteExtDatabase('../data/jdict_v1.db')
time_format = '%Y-%m-%d %H:%M:%S'
class BaseModel(Model, BaseM):
class Meta:
database = db
def dict__property(self, k):
d = self.__dict__['_data']
return d[k] if k in d else None
class Word(BaseModel):
text = CharField(primary_key=True)
kana = CharField()
romaji = CharField(null=True)
audio = CharField(null=True)
translation_key = CharField() # first alternatives or text
tags = CharField(null=True) # ','.join([tag1, tag2])
# -*- coding: utf-8 -*-
import sys
from datetime import datetime
from peewee import CharField, DateTimeField, Model, TextField
from playhouse.sqlite_ext import SqliteExtDatabase
db = SqliteExtDatabase('db/rss_atom_mattermost.db')
db.connect()
try:
import html2text
except ImportError as exc:
print('Error: failed to import module. ({}). \nInstall missing modules'
' using "sudo pip install -r requirements.txt"'.format(exc))
sys.exit(1)
class RssFeed(object):
def __init__(self, name, url, iconurl, user, channel, showname, showtitle,
showdescription, showurl):
self.Name = name
self.Url = url
self.Iconurl = iconurl
self.User = user
self.Channel = channel
self.ShowName = showname
self.ShowTitle = showtitle
self.ShowDescription = showdescription
self.ShowUrl = showurl
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
from data_models import User
from data_models import ActionType
from data_models import EncsPPC_Action
from settings_provider import SettingsProvider
from pprint import pprint
settings_provider = SettingsProvider('settings.json')
database_path = settings_provider.database_path()
db = SqliteExtDatabase(database_path)
db.connect()
db.create_tables([User, ActionType, EncsPPC_Action])
action_type_list = ['in', 'out']
for action_type_value in action_type_list:
action_type = ActionType()
action_type.description = action_type_value
action_type.save()
from peewee import *
from playhouse.sqlite_ext import SqliteExtDatabase
import datetime
import time
custom_db = SqliteExtDatabase('blah.db')
class BaseModel(Model):
class Meta:
database = custom_db
class User(BaseModel):
name = CharField(unique=True)
time = IntegerField()
custom_db.connect()
# custom_db.create_tables([User])
# db.connect()
try:
charlie = User.create(name='charlie', time=0)
charlie.save()
except:
print "user creation error"
# User.create(name='benard').save()
try:
print User.get(User.name == 'sally')
except DoesNotExist:
print "Does not exist"
user = User.get(User.name == 'charlie')
