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')