def empty(self, *args, **options):
"""
Creates an empty content database for the Khan channel. This ensures
that an empty content database exists in the default distribution and
for tests.
Especially useful for creating an *EMPTY TEMPLATE*
retrievecontentpack empty en --template
"""
lang = args[1]
if not options.get('template', False):
content_db_path = topic_settings.CONTENT_DATABASE_PATH.format(
channel=topic_settings.CHANNEL,
language=lang,
)
else:
content_db_path = topic_settings.CONTENT_DATABASE_TEMPLATE_PATH.format(
channel=topic_settings.CHANNEL,
language=lang,
)
if os.path.exists(content_db_path):
if options.get("force", False):
os.unlink(content_db_path)
else:
raise CommandError(
"Content database already exists: {}".format(
content_db_path))
db = SqliteDatabase(content_db_path)
db.connect()
db.create_table(Item, safe=True)
db.create_table(AssessmentItem, safe=True)
db.close()
self.complete(
_("Saved empty content database in {}.").format(content_db_path))
class Database:
def __init__(self):
self.movies = SqliteDatabase('movies.db')
def setup(self):
self.movies.connect()
self.movies.create_table(Movie)
def add(self, movie):
row = Movie.create(
serial=movie.serial,
title=movie.metadata.title,
image=movie.metadata.image,
year=movie.metadata.year,
plot=movie.metadata.plot,
runtime=movie.metadata.runtime,
rating=movie.metadata.rating,
format=movie.metadata.format,
resolution=movie.metadata.resolution,
filename=movie.metadata.filename,
magnet_link=movie.metadata.magnet_link,
downloaded=False
)
row.save()
def is_duplicate(self, serial):
db_movie = Movie.select().where(Movie.serial == serial)
return db_movie is None
def initsys():
if not os.path.exists(PHOTO_PATH):
os.mkdir(PHOTO_PATH)
if not os.path.exists(DB_PATH):
db = SqliteDatabase(os.path.join(APP_PATH, 'fanhao.db'))
db.create_table(models.fanhao)
db.close()
def init(dbname="blender-models.db"):
db = SqliteDatabase(path.join(MORSEWEB_ROOT, dbname))
db.connect()
if not BlenderModel.table_exists():
db.create_table(BlenderModel)
for pathname in RESOURCES:
populate(pathname)
def init(dbname="blender-models.db"):
db = SqliteDatabase(path.join(MORSEWEB_ROOT, dbname))
db.connect()
if not BlenderModel.table_exists():
db.create_table(BlenderModel)
for pathname in RESOURCES:
populate(pathname)
def init():
path = os.path.expanduser('~/.config/aesop/database.db')
global database
database = SqliteDatabase(path)
database_proxy.initialize(database)
database.connect()
for model in BaseModel.__subclasses__():
try:
database.create_table(model)
except Exception:
pass
else:
if model == Config:
Config.create_default()
def empty(self, *args, **options):
"""
Creates an empty content database for the Khan channel. This ensures
that an empty content database exists in the default distribution and
for tests.
Especially useful for creating an *EMPTY TEMPLATE*
retrievecontentpack empty en --template
"""
lang = args[1]
if not options.get('template', False):
content_db_path = topic_settings.CONTENT_DATABASE_PATH.format(
channel=topic_settings.CHANNEL,
language=lang,
)
else:
content_db_path = topic_settings.CONTENT_DATABASE_TEMPLATE_PATH.format(
channel=topic_settings.CHANNEL,
language=lang,
)
if os.path.exists(content_db_path):
if options.get("force", False):
os.unlink(content_db_path)
else:
raise CommandError(
"Content database already exists: {}".format(
content_db_path
)
)
db = SqliteDatabase(
content_db_path
)
db.connect()
db.create_table(Item, safe=True)
db.create_table(AssessmentItem, safe=True)
db.close()
self.complete(
_("Saved empty content database in {}.").format(
content_db_path
)
)
class Database:
def __init__(self):
self.movies = SqliteDatabase('movies.db')
def setup(self):
self.movies.connect()
self.movies.create_table(Movie)
def get(self, serial):
movie = Movie.get(Movie.serial == serial)
if movie is None:
return None
movie = MovieMetadata(movie.serial, json.loads(movie.metadata))
return movie
def add(self, movie):
row = Movie.create(serial=movie.serial,
metadata=json.dumps(movie.metadata))
row.save()
def is_duplicate(self, serial):
db_movie = Movie.select().where(Movie.serial == serial)
return db_movie is None
from bottle import route, run, template, static_file, request
from jinja2 import Environment, FileSystemLoader, select_autoescape
from peewee import Model, TextField, CharField, DateTimeField, ForeignKeyField, SqliteDatabase
db = SqliteDatabase('pyhp.db')
db.connect()
class SessionStore(Model):
token = CharField()
data = CharField()
try:
db.create_table(SessionStore)
except:
pass
def get_token():
token = ''.join([random.choice('0123456789abcdef') for i in range(32)])
env = Environment(loader=FileSystemLoader('pages'),
autoescape=select_autoescape(['html', 'xml']))
"""
@route('/')
@route('/hello')
@route('/hello/')
@route('/hello/<name>')
s_item = CharField()
s_summary = CharField()
s_details = CharField()
s_result = CharField()
s_scantime = DateTimeField()
class Meta:
database = DB
try:
DB.connect()
if not SCAN.table_exists():
print(Fore.YELLOW + "SCAN Table Not Exist, And Now We Will Create It" +
Fore.RESET)
DB.create_table(SCAN)
except Exception as e:
pass
def summary2detail(summaryid):
res = SCAN.select().dicts().where(SCAN.s_item == summaryid)
print(Fore.GREEN + "[+] :" + Fore.RESET + res[0]['s_item'])
print("\t--", res[0]['s_summary'])
# print("\t--",res[0]['s_details'])
return res[0]['s_summary'], res[0]['s_details']
def insertDB(scanres):
return {"result": True, "reason": "SUCCESS"}
else:
return {"result": False, "reason": "UNKNOWN"}
def quantity_new_card(filename):
f = None
try:
NewCard.delete().execute()
finally:
f = open(filename)
lines = csv.reader(f)
for line in lines:
try:
input("将卡放上，按下任意键开始刷卡, 当前卡号：{}".format(line[0]))
result = newCard(line[0], line[1])
print('当前卡号: ' + line[0])
print('结果{},原因:{}'.format(result['result'], result['reason']))
except Exception as e:
continue
f.close()
dstname = '待上传.csv'
open(dstname, 'w').close()
dump_csv(NewCard.select(NewCard.cardname, NewCard.cardpass, NewCard.money),
dstname)
return
temper.create_table(NewCard, True)
class Meta(object):
database = db
class Message(Model):
# TODO: date + user
content = TextField()
date = DateTimeField(default=datetime.datetime.now)
user = ForeignKeyField(User, related_name='messages')
class Meta(object):
database = db
for model in (User, Message):
try:
db.create_table(model)
except:
pass
def get_user(request, token=None):
if not token:
token = request.cookies.get('token', 'NO_TOKEN')
try:
user = User.get(User.token == token)
return user
except User.DoesNotExist:
return None
def check_login(username, password):
pwd_hash = hashlib.sha224((config.password_salt + password).encode('utf-8')).hexdigest()
try:
def create_database():
with open('data.db', 'w+') as f:
f.write('')
db = SqliteDatabase('data.db')
db.connect()
db.create_table(Client)
def create_tables():
database = SqliteDatabase(DATABASE_NAME)
database.connect()
database.create_table([Dungeon, DungeonLevel, DungeonObject])
