from active_alchemy import ActiveAlchemy from app.helpers import DB_PATH db = ActiveAlchemy(DB_PATH)
from active_alchemy import ActiveAlchemy
db = ActiveAlchemy("sqlite:///foo.db") # DB file
class User(db.Model):
name = db.Column(db.String(25), unique=True)
location = db.Column(db.String(50), default="USA")
last_access = db.Column(db.DateTime)
def main():
db.drop_all()
db.create_all()
for user in User.query():
print(user.name)
user = User.create(name="Mardix", location="Moon")
user2 = User.create(name="Mardix", location="Moon")
db.session.add(user2)
db.session.commit()
main()
import requests
import shutil
import cv2
import secrets
from pyagender import PyAgender
import time
from datetime import datetime
from time import sleep
from active_alchemy import ActiveAlchemy
db = ActiveAlchemy('sqlite:///db.sqlite')
# settings
url = "https://thispersondoesnotexist.com/image"
male_threshold = 0.4
female_threshold = 0.6
temp_file = "temp_img.jpg"
times_to_run = 500
seconds_to_sleep = 2
class ImageRecord(db.Model):
id = db.Column(db.Integer, primary_key=True)
gender = db.Column(db.String(10))
age = db.Column(db.Integer)
filename = db.Column(db.String(100))
hosting = db.Column(db.String(100), default="local")
#!/usr/bin/env python3
import wx
import wx.aui
from active_alchemy import ActiveAlchemy
db = ActiveAlchemy('sqlite:///compendium.db')
class Account(db.Model):
id = db.Column(db.Integer, primary_key=True)
last_four = db.Column(db.String, nullable=False)
issuer_id = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.Integer, nullable=False)
def __repr__(self):
return '<Account %r>' % self.last_four
class AccountsTab(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent=parent, id=wx.ID_ANY)
nb = wx.Notebook(self, wx.ID_ANY, style=wx.NB_LEFT)
print('Before iterating Accounts')
for account in Account.query().all():
print('Adding account: ', account)
nb.AddPage(AccountTab(nb), account.last_four)
print('After iterating Accounts')
class TestActiveAlchemy(unittest.TestCase):
@staticmethod
def create_test_model(db):
class TestModel(db.Model):
#__tablename__ = "test_model"
name = db.Column(db.String(20))
location = db.Column(db.String(20))
class BaseTestModel(db.BaseModel):
__tablename__ = "test_model"
__primary_key__ = "id"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
location = db.Column(db.String(20))
db.create_all()
return TestModel, BaseTestModel
def setUp(self):
uri = 'sqlite://'
self.db = ActiveAlchemy(uri)
self.model, self.base_model = self.create_test_model(self.db)
def tearDown(self):
self.db.query(self.model).delete()
self.db.commit()
def add_entry(self):
return self.model(name="Max", location="Charlotte").save()
def test_init_save(self):
e = self.add_entry()
self.assertIsNotNone(e)
def test_table_name(self):
self.assertEquals(table_name, self.model.__table__.name)
def test_create(self):
data = {"name": "Jones", "location": "Miami"}
self.assertIs(0, len(list(self.model.query())))
v = self.add_entry()
self.assertIs(1, len(list(self.model.query())))
e = v.create(**data)
self.assertIsNotNone(e)
self.assertIs(2, len(list(self.model.query())))
e.update(location="Japan")
self.assertEquals(e.location, "Japan")
def test_update(self):
n_loc = "ATL"
e = self.add_entry()
e.update(location=n_loc)
self.assertEqual(n_loc, e.location)
def test_delete(self):
e = self.add_entry()
e.delete()
self.assertTrue(e.is_deleted)
def test_undelete(self):
e = self.add_entry()
e.delete()
self.assertTrue(e.is_deleted)
e.delete(False)
self.assertFalse(e.is_deleted)
def test_delete_hard(self):
e = self.add_entry()
self.assertIs(1, len(list(self.model.query())))
e.delete(hard_delete=True)
self.assertIs(0, len(list(self.model.query(include_deleted=True))))
def test_get(self):
e = self.add_entry()
self.assertIsNotNone(self.model.get(e.id))
def test_get_basemodel(self):
e = self.add_entry()
self.assertIsNotNone(self.base_model.get(e.id))
def test_get_deleted(self):
e = self.add_entry().delete()
self.assertIsNone(self.model.get(e.id))
self.assertIsNotNone(self.model.get(e.id, include_deleted=True))
def test_query(self):
self.add_entry()
self.add_entry()
self.add_entry()
self.add_entry()
self.add_entry()
self.assertIs(5, len(list(self.model.query())))
def test_all_but_deleted(self):
self.add_entry()
self.add_entry()
self.add_entry().delete()
self.add_entry().delete()
self.add_entry()
self.assertIs(3, len(list(self.model.query())))
def test_all_but_undeleted(self):
self.add_entry()
self.add_entry()
self.add_entry().delete()
self.add_entry().delete().delete(False)
self.add_entry()
self.assertIs(4, len(list(self.model.query())))
self.assertIs(5, len(list(self.model.query(include_deleted=True))))
def test_to_dict(self):
e = self.add_entry()
self.assertIsInstance(e.to_dict(), dict)
def test_to_json(self):
e = self.add_entry()
self.assertIsInstance(e.to_json(), str)
def test_all_distinct(self):
for n in xrange(15):
self.add_entry()
es = self.model.query(self.model.name.distinct())
self.assertIs(1, len(list(es)))
def test_paginate(self):
for n in xrange(15):
self.add_entry()
es = self.model.query().paginate(page=2, per_page=4)
self.assertIs(4, es.total_pages)
import hashlib
import random
import enquiries
import json
import subprocess
import scrypt, os, binascii
import base64
from cryptography.fernet import Fernet
from active_alchemy import ActiveAlchemy
import config
db = ActiveAlchemy("mysql+pymysql://{}:{}@{}:{}/{}".format(
config.db_username, config.db_password, config.db_endpoint, config.dc_port,
config.db_name))
class Site(db.Model):
site_name = db.Column(db.String(25))
password = db.Column(db.String(25))
def generate_key():
key = Fernet.generate_key()
with open("secret.key", "wb") as key_file:
key_file.write(key)
def load_key():
return open("secret.key", "rb").read()
import os
import datetime
import collections
from active_alchemy import ActiveAlchemy, or_
db_file = os.path.join(os.path.dirname(__file__), 'test2.sqlite')
db = ActiveAlchemy('sqlite:///{}'.format(db_file))
class User(db.Model):
tablename = 'user'
id = db.Column(db.Integer, primary_key=True)
user_chat = db.Column(db.String)
known_words = db.Column(db.String)
active_5 = db.Column(db.String)
tmp = db.Column(db.String)
btnID = db.Column(db.Integer, default=0)
db.create_all()
# import ast
# a = ['qq','ww','ee']
# a2 = "['qq','ww','ee']"
#
# b = repr(a)
# b2 = ast.literal_eval(a2)
#
# import json
# a = {'1':3, '3':'qwe'}
# a2 = "{'1':3, '3':'qwe'}"
from active_alchemy import ActiveAlchemy
from sqlalchemy import ForeignKey
from find_website import find_domain
from db_utility import find_dbEntry
from newspaper import Article as NA
from urllib.parse import urlparse
db = ActiveAlchemy("sqlite:///foorealtho.db")
class Website(db.Model):
name = db.Column(db.String(50), unique=True)
description = db.Column(db.String(50))
leaning = db.Column(db.String(50))
articles = db.relationship('Article')
def ok(self):
print('hello')
# def __init__(self): #does this work
# find_stuff()
# update_code()
class Article(db.Model):
title = db.Column(db.String(50))
description = db.Column(db.String(50))
tag = db.Column(db.String(50))
text = db.Column(db.String(50))
from datetime import datetime
from active_alchemy import ActiveAlchemy
from sqlalchemy import distinct, func
from elasticsearch import Elasticsearch
from decimal import Decimal
import pytz
import calendar
import json
import os
db = ActiveAlchemy(os.environ['DATABASE_URL'])
es_service = os.environ.get("ES_SERVICE", "localhost")
es = Elasticsearch(['http://' + es_service + ':9200/'])
pricing = json.load(open("region_instance_prices.json"))
EXTRA_MONEY = 1.2 # if you want to tune billings, this is the dial. 1.2 means add 20% on top of what is calculated
# that we pay to AWS or whichever host
SECONDS_IN_HR = 3600
BYTES_IN_GB = 1000000000
STORAGE_PRICE_GB_MONTH = 0.03
class Billing(db.Model):
id = db.Column(db.Integer, primary_key=True)
storage_cost = db.Column(db.Numeric, nullable=False, default=0)
compute_cost = db.Column(db.Numeric, nullable=False, default=0)
project = db.Column(db.Text)
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
created_date = db.Column(db.DateTime, default=datetime.utcnow())
closed_out = db.Column(db.Boolean, nullable=False, default=False)
import os
import re
from active_alchemy import ActiveAlchemy
from mawie import helpers
connection_string = helpers.DB_PATH
if connection_string.startswith('sqlite'):
db_file = re.sub("sqlite.*:///", "", connection_string)
os.makedirs(os.path.dirname(db_file), exist_ok=True)
with open(db_file, "a+"):
pass
db = ActiveAlchemy(connection_string)
from active_alchemy import ActiveAlchemy
db = ActiveAlchemy('sqlite:///apps.db')
class TestActiveAlchemy(unittest.TestCase):
@staticmethod
def create_test_model(db):
class TestModel(db.Model):
#__tablename__ = "test_model"
name = db.Column(db.String(20))
location = db.Column(db.String(20))
class BaseTestModel(db.BaseModel):
__tablename__ = "test_model"
__primary_key__ = "id"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
location = db.Column(db.String(20))
db.create_all()
return TestModel, BaseTestModel
def setUp(self):
uri = 'sqlite://'
self.db = ActiveAlchemy(uri)
self.model, self.base_model = self.create_test_model(self.db)
def tearDown(self):
self.db.query(self.model).delete()
self.db.commit()
def add_entry(self):
return self.model(name="Max", location="Charlotte").save()
def test_init_save(self):
e = self.add_entry()
self.assertIsNotNone(e)
def test_table_name(self):
self.assertEquals(table_name, self.model.__table__.name)
def test_create(self):
data = {
"name": "Jones",
"location": "Miami"
}
self.assertIs(0, len(list(self.model.query())))
v = self.add_entry()
self.assertIs(1, len(list(self.model.query())))
e = v.create(**data)
self.assertIsNotNone(e)
self.assertIs(2, len(list(self.model.query())))
e.update(location="Japan")
self.assertEquals(e.location, "Japan")
def test_update(self):
n_loc = "ATL"
e = self.add_entry()
e.update(location=n_loc)
self.assertEqual(n_loc, e.location)
def test_delete(self):
e = self.add_entry()
e.delete()
self.assertTrue(e.is_deleted)
def test_undelete(self):
e = self.add_entry()
e.delete()
self.assertTrue(e.is_deleted)
e.delete(False)
self.assertFalse(e.is_deleted)
def test_delete_hard(self):
e = self.add_entry()
self.assertIs(1, len(list(self.model.query())))
e.delete(hard_delete=True)
self.assertIs(0, len(list(self.model.query(include_deleted=True))))
def test_get(self):
e = self.add_entry()
self.assertIsNotNone(self.model.get(e.id))
def test_get_basemodel(self):
e = self.add_entry()
self.assertIsNotNone(self.base_model.get(e.id))
def test_get_deleted(self):
e = self.add_entry().delete()
self.assertIsNone(self.model.get(e.id))
self.assertIsNotNone(self.model.get(e.id, include_deleted=True))
def test_query(self):
self.add_entry()
self.add_entry()
self.add_entry()
self.add_entry()
self.add_entry()
self.assertIs(5, len(list(self.model.query())))
def test_all_but_deleted(self):
self.add_entry()
self.add_entry()
self.add_entry().delete()
self.add_entry().delete()
self.add_entry()
self.assertIs(3, len(list(self.model.query())))
def test_all_but_undeleted(self):
self.add_entry()
self.add_entry()
self.add_entry().delete()
self.add_entry().delete().delete(False)
self.add_entry()
self.assertIs(4, len(list(self.model.query())))
self.assertIs(5, len(list(self.model.query(include_deleted=True))))
def test_to_dict(self):
e = self.add_entry()
self.assertIsInstance(e.to_dict(), dict)
def test_to_json(self):
e = self.add_entry()
self.assertIsInstance(e.to_json(), str)
def test_all_distinct(self):
for n in xrange(15):
self.add_entry()
es = self.model.query(self.model.name.distinct())
self.assertIs(1, len(list(es)))
def test_paginate(self):
for n in xrange(15):
self.add_entry()
es = self.model.query().paginate(page=2, per_page=4)
self.assertIs(4, es.total_pages)
def setUp(self):
uri = 'sqlite://'
self.db = ActiveAlchemy(uri)
self.model, self.base_model = self.create_test_model(self.db)
'''Defines the database model.'''
from active_alchemy import ActiveAlchemy
from btmodules.global_constants import defaultWalletAmount
import json
db = ActiveAlchemy('sqlite:///blacktrack.db')
class User(db.Model):
dc_uniqueid = db.Column(db.String(100))
dc_username = db.Column(db.String(100))
real_name = db.Column(db.String(100))
wallet = db.Column(db.Integer, default=defaultWalletAmount)
total_bets = db.Column(db.Integer, default=0)
total_wins = db.Column(db.Integer, default=0)
total_losses = db.Column(db.Integer, default=0)
total_buyins = db.Column(db.Integer, default=0)
total_winnings = db.Column(db.Integer, default=0)
class Bets(db.Model):
bet_user_id = db.Column(db.String(25))
bet_amount = db.Column(db.Integer)
was_a_win = db.Column(db.Boolean)
def userInDatabase(userID):
'''Queries the database for the user. Returns False if they don't exist in the database yet.'''
query = User.query().order_by(
User.updated_at.desc()
) # Query the user table, sorting by last updated, and store the results in a list.
def setUp(self):
uri = 'sqlite://'
self.db = ActiveAlchemy(uri)
self.model, self.base_model = self.create_test_model(self.db)
from flask import Flask, send_from_directory
from active_alchemy import ActiveAlchemy
from flask_login import LoginManager
import os
import sys
# Globally accessible variables
db = ActiveAlchemy("sqlite:///Conduit.db?check_same_thread=False")
login_manager = LoginManager()
app_config = {}
def get_config_value(item, default=None):
global app_config
return app_config.get(item, default)
def parse_port(port, config=None):
try:
int(port)
except ValueError:
if port == "cfg" and config:
port = config.get("socket_port", None)
port = parse_port(port)
else:
return False
return port
def create_app(config="Production", socket_port=None):
global app_config
import datetime
import time
from active_alchemy import ActiveAlchemy
from sqlalchemy.types import TypeDecorator, DateTime, Integer
from scrapebin.config import cfg
db = ActiveAlchemy(cfg.get('database', 'uri'))
class Paste(db.Model):
__tablename__ = 'tbl_paste'
__primary_key__ = 'key'
id = db.Column(db.String(30), primary_key=True)
title = db.Column(db.String(60))
date = db.Column(db.String(30))
size = db.Column(db.String(50))
expire = db.Column(db.String(10))
user = db.Column(db.String(120))
syntax = db.Column(db.String(120))
backup_created = db.Column(db.Boolean, default=0)
def __init__(self, **kwargs):
self.id = kwargs.get('key')
self.title = kwargs.get('title')
self.date = kwargs.get('date')
self.size = kwargs.get('size')
self.expire = kwargs.get('expire')
self.user = kwargs.get('user')
self.syntax = kwargs.get('syntax')
