import sys
import time
from challenge import views
from challenge.config import get_config
from challenge.server import Server
from challenge.models import Base
from challenge.models.orm import Orm
config_challenge = get_config()
def init_db(orm):
"""Create Database."""
import challenge.models.payments
import challenge.models.boleto
import challenge.models.credit_card
Base.metadata.create_all(bind=orm.engine)
def delete_all(orm):
"""Delete all database."""
# Base.metadata.reflect(bind=engine, extend_existing=True)
Base.metadata.drop_all(bind=orm.engine)
# db_session.expunge_all()
def start():
server = Server(instances=config_challenge.AMOUNT_PROCESS,
port=config_challenge.PORT_SERVER)
server.start(views)
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from challenge.service import Singleton
from challenge.config import get_config
config = get_config()
class Orm(metaclass=Singleton):
"""Relation Object."""
__TYPE__ = "abstract"
def __init__(self):
self.__engine = create_engine(
config.SQLALCHEMY_DATABASE_URI,
pool_pre_ping=True,
pool_size=config.SQLALCHEMY_POOL_SIZE,
)
self.__db_session = scoped_session(
sessionmaker(autocommit=False, autoflush=False,
bind=self.__engine))
@property
def session(self):
"""Property db_session."""
return self.__db_session
@property
def engine(self):
"""Property engine."""
from challenge.config import get_config
from sqlalchemy import Column, DateTime, func
from sqlalchemy.ext.declarative import declarative_base
from .orm import Orm
config_neighbors = get_config()
Base = declarative_base()
class BaseModel(Base):
"""Defaut Classe to tables of system."""
__abstract__ = True
__TYPE__ = "abstract"
date_created = Column(DateTime, default=func.current_timestamp())
date_modified = Column(DateTime,
default=func.current_timestamp(),
onupdate=func.current_timestamp())
@property
def __orm(self):
return Orm()
@property
def session(self):
return self.__orm.session
def remove_session(self):
"""Method clear session sqlalchemy."""
self.__orm.remove_session()
import logging
import multiprocessing
from concurrent.futures import ThreadPoolExecutor
from tornado.concurrent import Future, chain_future
from tornado.ioloop import IOLoop
from tornado.web import RequestHandler
from challenge.config import get_config
from challenge.exceptions import ERRORS_CHALLENGE
COUNT_CPU = multiprocessing.cpu_count()
config_ = get_config()
logger = logging.getLogger(__file__)
class ApiJsonHandler(RequestHandler):
"""Class default to create views."""
def initialize(self):
self.set_header("Content-Type", "application/json")
@property
def _message_error_default(self):
"""Error Internal Server."""
return "Error Internal Server"
def _execute_ioloop(self, func, *args):
"""Execute method ioloop."""
pool = ThreadPoolExecutor(max_workers=COUNT_CPU)
old_future = pool.submit(func, *args)
new_future = Future()