Example #1
0
def main():
    # Get requests.session
    session = load_session_or_login()

    # Get database session for add and commit sql_item
    db_engine = db_connect()
    create_engine(db_engine)
    Session = sessionmaker(bind=db_engine)
    db_session = Session()

    # Run actual spider code non-blockingly

    # Generate ebooks and push to subscribers' kindle

    return True
Example #2
0
    def __init__(self, path, db=None, engine=None):
        self.path = path
        self.working = None

        if not os.path.exists(path):
            os.makedirs(path)
            self.db = db or 'sqlite:///%s/sqlite3.db' % path
            self.settings_write({'DB': self.db})
        else:
            self.settings_read()
            self.db = db or self.settings['DB']
            
        self.engine = engine or create_engine(self.db, echo=False)
        self.session = self.engine.create_session()
Example #3
0
    def __init__(self, **kwargs):
        self.backup = kwargs.get('backup', True)
        self.normalize = kwargs.get('normalize', True)
        self.dbpath = kwargs.get('dbpath')
        if not self.dbpath:
            self.dbpath = DEFAULT_DB_FILE
        logger.debug(_("Using database file '%s'") % self.dbpath)
        
        engine = kwargs.get('engine')
        if not engine:
            engine = create_engine('sqlite:///%s' % self.dbpath)
            metadata.bind = engine
            session.configure(bind=engine)

        self._photoset = None
        self._db_version = None
Example #4
0
from flask import Flask, flash, redirect, render_template, request, session, abort
import os
from sqlalchemy.orm import sessionmaker
from models import User, Post, create_engine, Category
from datetime import datetime
from flask_frozen import Freezer

engine = create_engine('sqlite:///dbMyBlog.db', echo=True)

freezer = Freezer(app)
app = Flask(__name__,  static_url_path='')


@app.route('/')
def home():
    return render_template('index.html')


@app.route('/static/<path:path>')
def send_static(path):
    return send_from_directory('static', path)

@app.route('/portfolio')
def portfolio():
    return render_template('portfolio.html')

@app.route('/hire')
def hire():
    return render_template('hire.html')
 
@app.route('/login', methods=['GET','POST'])
Example #5
0
 def _init_database(db_path):
     engine = models.create_engine(db_path)
     models.create_tables(engine)
     session = models.create_session(engine)
     return session
Example #6
0
from flask import Flask, request, render_template, redirect, url_for, jsonify
from models import User, Movie, engine, session, create_engine
import webbrowser

app = Flask(__name__)

engine = create_engine('postgresql://*****:*****@localhost/movie_db')
db_conn = engine.connect()


# for the web
# create a new row in the movie table
@app.route('/main/createnewmovie', methods=['GET', 'POST'])
def create_movie():
    if request.method == 'POST':
        # check if the user already exists
        check_existing_user = session.query(
            User.id).filter(User.name == request.form['actor_name']).scalar()
        check_movie_exists = session.query(Movie).filter(
            Movie.movie_title == request.form['movie-name']).scalar()
        if check_existing_user and check_movie_exists:
            return "Movie and the role player already exists! Thanks for participation!"
        elif check_existing_user:
            # add new movie
            add_newmovie = Movie(
                movieimdbid=request.form['movie-imdb'],
                movie_title=request.form['movie-name'],
                movie_rating=request.form['ratings'],
                movie_releaseyear=request.form['release-year'],
                movie_votes=request.form['votes'])
            session.add(add_newmovie)
Example #7
0
        url = "https://web3api.io/api/v2/market/tokens/prices/" + tokenAddress + '/latest'

        headers = {"x-api-key": secrets.api_key}

        response = requests.get(url, headers=headers)
        query = json.loads(response.content)
        payload = query['payload']
        tkADD = payload[0]['address']
        tkNAME = payload[0]['name']
        tkSYMBOL = payload[0]['symbol']
        tkPRICE = payload[0]['priceUSD']
        print(tkADD, tkPRICE, tkNAME, tkSYMBOL)

        db_string = 'postgresql://*****:*****@localhost/practiceDataDB'
        db = models.create_engine(db_string, echo=False)
        base = models.declarative_base()
        base.metadata.create_all(db)
        db_Session = sessionmaker(db)
        db_session = db_Session()
        result = Price(address=tkADD,
                       name=tkNAME,
                       symbol=tkSYMBOL,
                       price=tkPRICE)

        db_session.add(result)
        db_session.commit()
        print('entry added')
        db_session.close()
    if choice2.lower() == 'historical':
        # https://docs.amberdata.io/reference#get-historical-token-price for questions on querystring
Example #8
0
# -*- coding: utf8 -*-
import os
import unittest

from fixture import DataSet, DataTestCase, SQLAlchemyFixture

from models import create_engine, metadata, session, Photo, Tag, Meta
from controller import FSpotController


# Setup temporary database
DB_PATH = ':memory:'
engine = create_engine('sqlite:///' + DB_PATH)
metadata.bind = engine
session.configure(bind=engine)
metadata.create_all()

BASE_PATH=os.path.abspath(os.path.dirname(__file__))

"""
Fixtures
"""
dbfixture = SQLAlchemyFixture(env={'PhotoData': Photo, 
                                   'TagData': Tag,
                                   'MetaData': Meta},
                              engine=metadata.bind)

class PhotoData(DataSet):
    class on_disk:
        base_uri = os.path.join('file://', BASE_PATH, 'tests')
        filename = 'bee.jpg'
from sqlalchemy.exc import IntegrityError
from sqlalchemy.engine.url import URL
import config
import pandas as pd
import binance_d
from binance_d.model.constant import CandlestickInterval
from binance_d.requestclient import FuncResponse
import binance_f
from binance_f.model.constant import CandlestickInterval
from binance_f.requestclient import FuncResponse
import datetime
import time
import click
import constants

engine = create_engine(URL(**config.Config.DATABASE))
create_table(engine)
Base.metadata.bind = engine
DBSession = sessionmaker()
DBSession.bind = engine
session = DBSession()

@click.group()
def cli():
    """
    A cli helper to update binance data for channel calculations
    
    Some useful information on times: 
    BTCUSDT: M Futures contract start date: 2020-8-11
    """