def get_from_inventory(item: int = 0):
make_class_dictable(Inventory)
if int(item) > 0:
return Inventory.query.get(item).asdict()
return list(map(operator.methodcaller('asdict'), Inventory.query.all()))
def test_make_class_dictable(self):
assert not hasattr(MakeClassDictable, 'asdict')
m = MakeClassDictable('dictable')
self.session.add(m)
self.session.commit()
assert not hasattr(m, 'asdict')
make_class_dictable(MakeClassDictable)
assert m.asdict() == {'id': m.id, 'name': m.name}
def test_make_class_dictable(self):
assert not hasattr(MakeClassDictable, 'asdict')
m = MakeClassDictable('dictable')
self.session.add(m)
self.session.commit()
assert not hasattr(m, 'asdict')
make_class_dictable(MakeClassDictable)
assert m.asdict() == {'id': m.id, 'name': m.name}
def create_app():
app = Flask(__name__)
app.config.from_pyfile('config.py')
app.jinja_env.filters["usd"] = usd
app.jinja_env.filters["capitalize"] = capitalize
csrf.init_app(app)
db.app = app
db.init_app(app)
with app.app_context():
make_class_dictable(db.Model)
from . import models
Migrate(app, db)
Session(app)
Bootstrap(app)
FontAwesome(app)
Mobility(app)
JWTManager(app)
def errorhandler(e):
"""Handle error"""
if isinstance(e, CSRFError):
return Redirects.login(True)
if not isinstance(e, HTTPException):
e = InternalServerError()
return _templates.apology(e.name, e.code)
for code in default_exceptions:
app.errorhandler(code)(errorhandler)
mail.init(app)
stock.init(app)
token.init(app)
sms.init(app)
geo.init(app)
with app.app_context():
from .views import auths, accounts, portfolios
from .apis import markets, portfolios, tokens
@app.after_request
def after_request(response):
"""Ensure responses aren't cached"""
response.headers[
"Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
return app
import json
import unittest
from flask import Flask, url_for
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.alchemyview import AlchemyView
from dictalchemy import make_class_dictable
import colander as c
SQLALCHEMY_DATABASE_URI = 'sqlite://'
app = Flask(__name__)
app.config.from_object(__name__)
db = SQLAlchemy(app)
make_class_dictable(db.Model)
class SimpleModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
def __init__(self, name):
self.name = name
class SimpleModelSchema(c.MappingSchema):
name = c.SchemaNode(c.String())
import math
import logging
from flask_appbuilder import Model
from dictalchemy import make_class_dictable
from .form import Form, FormCollaborator
from .value import Value
from .user_agent import UserAgent
from .event import Event, EventType
from .fields import Field, TextField, SelectField, PhoneField, Choice, DescriptionField
from .mixins import SoftDeleteableMixin, TimeStampMixin, MultipleMixin
from .constraints import RequiredConstraint, RangeConstraint, MinConstraint, MaxConstraint
from .page import PageRequest, PageResult
from app.models.repositories import (
FormRepository,
FieldRepository,
ValueRepository,
EventRepository,
CollaboratorRepository,
RoleRepository,
)
make_class_dictable(Model)
logger = logging.getLogger(__file__)
from dictalchemy import make_class_dictable
from sqlalchemy import Column, String, Integer
from sqlalchemy.ext.declarative import declarative_base
from flask_login import UserMixin
from DataBaseSession import DataBaseSession
Base = declarative_base()
make_class_dictable(Base)
class Users(UserMixin, Base):
__tablename__ = 'users'
id = Column("id", Integer, autoincrement=True, primary_key=True, nullable=False)
user_name = Column("user_name", String(32), quote=True)
password = Column("password", String(32), quote=True)
db_session = DataBaseSession.session
def is_active(self):
return True
def get_id(self):
return self.id
def is_authenticated(self):
return True
def is_anonymous(self):
return False
from flask.ext.migrate import Migrate, MigrateCommand
# -------------------
# Init
# -------------------
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///sand.db"
heroku = Heroku(app)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
make_class_dictable(db.Model)
# -------------------
# Settings
# -------------------
def add_cors_header(response):
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers[
'Access-Control-Allow-Headers'] = 'Authorization, Content-Type'
response.headers[
'Access-Control-Allow-Methods'] = 'POST, GET, PUT, PATCH, DELETE, OPTIONS'
return response
else:
meta = self.meta._primary_entity.mapper.class_(
key, json.dumps(value))
self.meta.append(meta)
return self
def deleteMeta(self, key):
""" Get a meta value
Args:
key (str): The meta key to remove
Returns:
self
"""
meta = self.meta.filter(
self.meta._primary_entity.mapper.class_.key == key).first()
if meta is not None:
meta.delete()
return self
# allow our models to easily be converted to dicts
# see: https://pythonhosted.org/dictalchemy/#using-make-class-dictable
make_class_dictable(BaseModel)
from dictalchemy import make_class_dictable
from sqlalchemy import ForeignKey
from sqlalchemy import Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import TEXT, VARCHAR, INTEGER, BOOLEAN
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, relationship
Base = declarative_base()
make_class_dictable(Base)
class User(Base):
__tablename__ = 'users'
id = Column(INTEGER, primary_key=True)
first_name = Column(VARCHAR(100))
last_name = Column(VARCHAR(100))
about_me = Column(TEXT)
emails = relationship('Email')
class Email(Base):
__tablename__ = 'emails'
id = Column(INTEGER, primary_key=True)
user_id = Column(INTEGER, ForeignKey('users.id'))
address = Column(VARCHAR(200))
is_primary = Column(BOOLEAN)
# -*- coding: UTF-8 -*-
from sqlalchemy import desc
from App.connexion import *
from Model.NewsModel import News
from dictalchemy import make_class_dictable
make_class_dictable(News)
def tableautoDict(objet):
liste = []
for item in objet:
liste.append(item)
return liste
def GetArgument(objet, *args):
dict = {}
maliste = []
i = 0
while i < len(objet):
dict = {}
for arg in args:
dict[arg] = str(getattr(objet[i], arg))
maliste.append(dict)
i = i + 1
return maliste
def getNewsByID(id):
news = session.query(News).filter_by(id=id).first()
def import_engine_automapped_data(app, **kwargs):
global Model, Base
logger.debug("kwargs: %s" % kwargs)
model_class_names = []
engine = kwargs.get('engine', None)
if not engine:
raise Exception("engine isn't set")
bind_name = kwargs.get('bind_name')
if not bind_name:
raise Exception("bind_name isn't set or doesn't exist in app.config")
obj = None
prefix = kwargs.get('class_prefix', '')
#return (None, (None,))
with app.app_context():
#bind_name = 'genesis_eg1'
with not_profiled():
metadata = MetaData(engine)
if kwargs.get('use_no_pk_tables', False):
table_objs = get_no_primary_key_table_names(
app, bind_name=bind_name, engine=engine)
for table_obj in table_objs:
table_name = table_obj['table_name']
inspector = table_obj['inspector']
cols = inspector.get_columns(table_name)
col = cols[0]
c_name = col.pop('name')
c_type = col.pop('type')
col['primary_key'] = True
cls = Table(table_name,
metadata,
Column(c_name, c_type, **col),
autoload=True,
extend_existing=True)
class_name = prefix \
+ camelize_and_dedigitize_genesis_classname(
Base, table_name, None,
)
session = Session(engine)
metadata.reflect(bind=engine)
Model = declarative_base(metadata=metadata,
cls=(db.Model, ),
bind=engine)
Base = automap_base(metadata=metadata, declarative_base=Model)
Base.prepare(
engine,
reflect=True,
classname_for_table=camelize_and_dedigitize_genesis_classname,
name_for_collection_relationship=singular_noun_collection,
generate_relationship=generate_relationship_custom,
)
obj = Base
for cls in Base.classes:
if bind_name:
cls.__table__.info = {'bind_key': bind_name}
setattr(cls, '__bind_key__', bind_name)
make_class_dictable(cls)
class_name = prefix + cls.__name__
model_class_names.append(class_name)
logger.debug("Base class name: %s" % cls.__name__)
if kwargs.get('use_automapped_classes', False):
add_to_automapped_classes(bind_name, class_name, cls)
else:
globals()[class_name] = cls
return (obj, tuple(model_class_names))
# -*- coding: UTF-8 -*-
from sqlalchemy import desc
from App.connexion import *
from Model.PromosModel import Promos
from dictalchemy import make_class_dictable
from sqlalchemy import and_
from unidecode import unidecode
make_class_dictable(Promos)
def tableautoDict(objet):
liste = []
for item in objet:
liste.append(item)
return liste
def GetArgument(objet, *args):
dict = {}
maliste = []
i = 0
while i < len(objet):
dict = {}
for arg in args:
if arg == 'item':
dict[arg] = unidecode(
str(getattr(objet[i], arg)).encode('ascii', 'ignore'))
else:
dict[arg] = str(getattr(objet[i], arg))
from dictalchemy import make_class_dictable
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
ModelBase = declarative_base()
make_class_dictable(ModelBase)
class Note(ModelBase):
__tablename__ = 'notes'
id = Column(Integer, primary_key=True)
name = Column(String, nullable=False)
content = Column(String, nullable=True)
# -*- coding: UTF-8 -*-
from sqlalchemy import desc
from App.connexion import *
from Model.FreechampModel import FreeChamp
from dictalchemy import make_class_dictable
make_class_dictable(FreeChamp)
def tableautoDict(objet):
liste = []
for item in objet:
liste.append(item)
return liste
def GetArgument(objet, *args):
dict = {}
maliste = []
i = 0
while i < len(objet):
dict = {}
for arg in args:
dict[arg] = str(getattr(objet[i], arg))
maliste.append(dict)
i = i + 1
return maliste
def getFreeChampByID(id):
