def forwards(self, orm): # Adding model 'Score' db.create_table('djangoratings_score', ( ('id', orm['djangoratings.Score:id']), ('content_type', orm['djangoratings.Score:content_type']), ('object_id', orm['djangoratings.Score:object_id']), ('key', orm['djangoratings.Score:key']), ('score', orm['djangoratings.Score:score']), ('votes', orm['djangoratings.Score:votes']), )) db.send_create_signal('djangoratings', ['Score']) # Adding model 'Vote' db.create_table('djangoratings_vote', ( ('id', orm['djangoratings.Vote:id']), ('content_type', orm['djangoratings.Vote:content_type']), ('object_id', orm['djangoratings.Vote:object_id']), ('key', orm['djangoratings.Vote:key']), ('score', orm['djangoratings.Vote:score']), ('user', orm['djangoratings.Vote:user']), ('ip_address', orm['djangoratings.Vote:ip_address']), ('date_added', orm['djangoratings.Vote:date_added']), ('date_changed', orm['djangoratings.Vote:date_changed']), )) db.send_create_signal('djangoratings', ['Vote']) # Creating unique_together for [content_type, object_id, key, user, ip_address] on Vote. db.create_unique('djangoratings_vote', ['content_type_id', 'object_id', 'key', 'user_id', 'ip_address']) # Creating unique_together for [content_type, object_id, key] on Score. db.create_unique('djangoratings_score', ['content_type_id', 'object_id', 'key'])
def create_cam_table(): """ The C{cam} table defines a mapping between camera names and C{cam_id}s. """ drop_table("image") create_table("cam", [id_field("id", "TINYINT"), "name CHAR(3) NOT NULL UNIQUE"])
def create_starcount_table(): """ The C{starcount} table stores the number of stars identified by AptPhot in each image. """ create_table("starcount", [int_field("image_id"), int_field("nstars"), fk_field("image_id", "image(id)")])
def create_unzip_table(): """ The C{unzip} table keeps track of which images have been unzipped and the resulting filenames. """ create_table("unzip", [pk_field("image_id", "INT"), type_field("success", "TINYINT"), str_field("outputfile", 50, True), fk_field("image_id", "image(id)")])
def create_flat_table(): """ The C{flat} table keeps track of which images have been flat fielded and where the names of the resulting images. """ create_table("flat", [pk_field("image_id", "INT"), str_field("flatfile", 25), str_field("outputfile", 50), fk_field("image_id", "image(id)")])
def create_imstat_table(): """ The C{imstat} table stores the result of running C{imstat} on each image. """ create_table("imstat", [pk_field("image_id", "INT"), int_field("min"), int_field("max"), int_field("mean"), int_field("stddev"), fk_field("image_id", "image(id)")])
def create_star_table(): """ The C{star} table keeps track of the catalogue stars which are identified by AptPhot. """ drop_table("phot") create_table("star", [id_field("star_id", "INT"), int_field("cat_id", True), float_field("ra"), float_field("decl")])
def create_astrom_table(): """ The C{astrom} table records the results of running C{AptAstrom} on each image. """ create_table("astrom", [pk_field("image_id", "INT"), type_field("success", "TINYINT"), float_field("smag"), float_field("zmag"), float_field("sky"), fk_field("image_id", "image(id)")])
def create_image_table(): """ The C{image} table defines a mapping between filenames and C{image_id}s. These C{image_id}s are used as the primary method of identifying images in the rest of the system. """ create_table("image", [id_field("id", "INT"), str_field("filename", 100, True), str_field("basename", 50, True), type_field("cam_id", "TINYINT"), type_field("time", "DATETIME"), fk_field("cam_id", "cam(id)")])
def create_phot_table(): """ The C{phot} table keeps track of the individual stars which are identified in each image by AptPhot. """ create_table("phot", [int_field("image_id"), int_field("star_id"), float_field("vmag"), float_field("smag"), float_field("mag3"), float_field("mag4"), str_field("err3", 100), str_field("err4", 100), float_field("X"), float_field("Y"), fk_field("star_id", "star(star_id)"), fk_field("image_id", "image(id)"), "KEY (image_id, star_id)"])
def create_header_table(): """ The C{header} table stores a selection of FITS header fields from each image. """ create_table("header", [pk_field("image_id", "INT"), float_field("temp"), float_field("exposure"), type_field("time", "DATETIME"), float_field("sunzd"), float_field("moonzd"), float_field("moondist"), float_field("moonphase"), float_field("moonmag"), float_field("ra"), float_field("decl"), float_field("lst"), float_field("jd"), float_field("crval1"), float_field("crval2"), fk_field("image_id", "image(id)")])
def setup(): conn = db.connection() db.create_table(conn)
def get_last_row_bm_date(): sqlite_path = data_path(silent=True) with db.connect(sqlite_path) as fafi: db.create_table(fafi) return db.last_row_bm_date(fafi)
def init_profile(con): create_table(con,"balance","(id INTEGER PRIMARY KEY, timecode, idr, btc)") create_table(con,"trades","(id INTEGER PRIMARY KEY, trade_id, timecode, market, trans_type, price, amount, fee, status)") create_table(con,"history","(id INTEGER PRIMARY KEY, trade_id, timecode, opentime, closetime, openprice, closeprice,openamount, closeamount, profit, percent_profit)")
def create_table(self): db.create_table()
def setup_cloud_resources() -> None: create_s3_bucket() create_table() create_queue()
def main(): if not os.path.exists(config.db_name): db.create_db(config.db_name) db.create_table(config.db_name, config.block_tx_table_name) assign_work(config.block_tx_table_name)
def create_table_orm(): create_table()
def setup(): # any tasks the program needs to complete before it can start db.create_table()
now = datetime.now() start_date = now - timedelta(days=7) # set end_date one day before current datetime to catch as much replies as possible end_date = now - timedelta(days=1) context_free = False else: # if country == "GR" database = os.path.join(dir_path, "databases", "twitter_without_cntx_gr.db") mps_file = "gr_candidate_meps.csv" start_date = None context_free = True # create sqlite db and create tables if not os.path.exists(database): db.create_db(database) # create a database connection conn = db.create_connection(database) if conn is not None: # create twitter_user table db.create_table(conn, db.sql_create_user_table) # create tweets table db.create_table(conn, db.sql_create_tweet_table) else: print("Error! cannot create the database connection.") get_tweets(mps_file, database, country, context_free, start_date, end_date) # stream_tweets() # stream_tweets_referring_meps() # plot_followers(database) # search_tweets_referring_meps(database)
def init_db(): with app.app.app_context(): db.create_table(app.get_db())
def bic_details(bic): print(f'Requesting {bic} ...') page = requests.get(bic) soup = BeautifulSoup(page.content, 'html.parser') data = {} for row in soup.select('tr > td > strong'): data[row.get_text()] = row.parent.find_next_sibling().get_text().strip( ) return data # BIC codes sql_create_bic_table = """ CREATE TABLE IF NOT EXISTS bic ( swift text PRIMARY KEY, country text, bank text, branch text, city text, zipcode text, address text ); """ conn = create_connection('swift.db') create_table(conn, sql_create_bic_table) for country in countries: for bic in bics_from_country(country, []): detail = bic_details(bic) create_bic(conn, tuple(detail.values())) conn.commit() conn.close()
elif option == "3": rows = db.select_all(conn) if not rows: print("no passwords stored yet") else: display_pwds(cipher, rows) submenu(conn, cipher) elif option == "4": print("Bye!") break else: #error handle print("no such option") if __name__ == '__main__': conn = db.connect_db(r"pwds.db") db.create_table(conn) welcomemsg() print( "If you are the first time here, please use the following key and save it to a safe place." ) print(crypt.new_key().decode(), '\n') print( "You will need to enter this key to get your passwords in the future") input("If you already got your encryption key, please ignore this message") key = get_key() menu(conn, key)
from tkinter import simpledialog from ttkthemes import themed_tk as ttkt import random from datetime import datetime from datetime import timedelta from datetime import date from dateutil.parser import parse import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart import tkcalendar from tkcalendar import Calendar, DateEntry from start import username import db db.create_table() db.create_table2() db.create_table3() db.create_table4() tasks_due=[] root = ttkt.ThemedTk() #Main window tname=db.get_theme(username) if len(tname)==0 : #If youare opening for the first time default theme will be appear. root.set_theme('radiance') else: #else the theme last you change will be appear. root.set_theme(tname[0][0]) root.title("Task Diary") columns = ("task_name", "priority_of_task", "category", "is_done","deadline")
def list_user(): db.create_table() users=db.all_users() return render_template('list.html',users=users)
import ConfigParser import re import os.path from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler import time # ------------------------------------------------- import db import hud import wx class MyHandler(FileSystemEventHandler): def on_modified(self, event): print event.event_type evt = hud.App.TableUpdateEvent(src_path=event.src_path) wx.PostEvent(wx.GetApp().TopWindow, evt) return if __name__ == '__main__': db.create_table() app = hud.App(False) observer = Observer() observer.schedule(MyHandler(), "C:\Users\cyka\AppData\Roaming\PacificPoker\HandHistory\Lufftre") observer.start() try: app.MainLoop() finally: observer.join() print 'done'
def save_photos_db(self): cur, conn, dbname = db.connect_database() db.create_table(cur, conn) for k, v in self.sorted_photos.items(): db.add_photos(k, v, cur, conn) print(f'Photos have been saved in database {dbname}!')
'mysql_engine': DbVars.ENGINE, 'mysql_charset': DbVars.CHARSET, 'mysql_collate': DbVars.COLLATE } id = Column(INTEGER(unsigned=True), primary_key=True, autoincrement=True) parent_id = Column(INTEGER(unsigned=True), ForeignKey('parent.id', ondelete="CASCADE")) name = Column(VARCHAR(256), unique=True) parent = relationship('Parent', back_populates='children') create_table() def insert_test_data(): with transaction_context() as session: p1 = Parent() p1.name = "p1" c1 = Child() c1.name = "c1" c2 = Child() c2.name = "c2" p1.childs = [c1, c2] session.add(p1)