# data = db_session.query(dataset).one_or_none()
from orm import Base
data = db_session.query(Base.metadata.tables['sil_data']).all()
print(data)
return data.dump() if data is not None else ('Not found', 404)
logging.basicConfig(level=logging.INFO)
app = connexion.FlaskApp(__name__)
#app.run_mode = 'Server' # that will only change the database type
app.run_mode = 'Client'
app.add_api('spock_api.yaml')
if app.run_mode == 'Client':
db_session, db_engine = orm.init_db('sqlite:///:memory:')
elif app.run_mode == 'Server':
db_session, db_engine = orm.init_db(
'postgresql://*****:*****@localhost:5432/spock')
else:
print('Unknow run mode! Exiting.')
sys.exit(-1)
logging.info('Run mode: %s', app.run_mode)
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
return NoContent, (200 if p is not None else 201)
def delete_pet(pet_id):
pet = db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).one_or_none()
if pet is not None:
logging.info('Deleting pet %s..', pet_id)
db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('sqlite:///:memory:')
app = connexion.FlaskApp(__name__)
app.add_api('swagger.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(
port=8080,
threaded=False # in-memory database isn't shared across threads
db_session.add(orm.Pet(**pet))
db_session.commit()
return NoContent, (200 if p is not None else 201)
def delete_pet(pet_id):
pet = db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).one_or_none()
if pet is not None:
logging.info('Deleting pet %s..', pet_id)
db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('sqlite:///dv_pet.db')
app = connexion.App(__name__)
app.add_api('swagger.yaml')
# set the WSGI application callable to allow using uWSGI:
# uwsgi --http :8080 -w app
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(port=8090)
return NoContent, (200 if p is not None else 201)
def delete_pet(pet_id):
pet = db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).one_or_none()
if pet is not None:
logging.info('Deleting pet %s..', pet_id)
db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('sqlite:///dv_pet.db')
app = connexion.App(__name__)
app.add_api('swagger.yaml')
# set the WSGI application callable to allow using uWSGI:
# uwsgi --http :8080 -w app
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(port=8090)
'Port': 8080,
'Check': {
'http':
'http://{address}:{port}/health'.format(address=SERVICE_ADDRESS,
port=PORT),
'interval':
'10s'
}
}
logging.info('Service registration parameters: ', data)
res = requests.put(url, data=json.dumps(data))
return res.text
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db(
'postgresql://*****:*****@postgresdb:5432/soa-payment-service')
app = connexion.FlaskApp(__name__)
app.add_api('openapi.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
try:
logging.info(register())
except:
def main():
global db_session
logging.basicConfig(level=logging.INFO)
db_session = init_db('mysql://*****:*****@0.0.0.0:3306/slbr?charset=utf8')
language_repository = LanguageRepository(db_session)
definition_repository = DefinitionRepository(db_session)
expression_repository = ExpressionRepository(db_session)
languages = language_repository.get_all()
values = []
shutil.rmtree("dist", ignore_errors=True)
os.mkdir("dist")
os.makedirs("dist/expressions/0", exist_ok=True)
with open("dist/expressions/0/index.html", "w+")as f:
f.write("""---
layout: letter
pagination:
enabled: true
collection: expressions
category: "0"
debug: false
sort_field: 'title'
sort_reverse: false
permalink: "/0/"
title: "Expressions with 0-9"
---""")
for expression_letter in range(ord("a"), ord("z")+1):
l = chr(expression_letter)
os.makedirs(f"dist/expressions/{l}", exist_ok=True)
with open(f"dist/expressions/{l}/index.html", "w+")as f:
f.write(f"""---
layout: letter
pagination:
enabled: true
collection: expressions
category: {l}
debug: false
sort_field: 'title'
sort_reverse: false
permalink: "/{l}/"
title: "Expressions with {l.upper()}"
---""")
for language in languages:
logging.info("Language %s", language.description)
# For now we will compromise in having only English, for ease of Jekyll set-up
if language.slug == "en":
expressions = expression_repository.get_all()
for expression in expressions:
definitions = definition_repository.find_by_expression(expression.id)
logging.info("Found %d definitions", len(definitions))
expression_dict = {
"expression": expression.text,
"letter": expression.char,
"definitions": []
}
for definition in definitions:
if definition.status != '2':
continue
expression = expression_repository.find(definition.expression_id)
logging.info("Expression: (%s) - [%s] = [%s]", definition.status, expression.text, definition.description)
definition_dict = {
"definition": definition.description,
"author": definition.contributor,
"example": definition.example,
"created": definition.created_at.isoformat()
}
expression_dict["definitions"].append(definition_dict)
# interesting... the definitions or len(definitions) is giving 1 entry even when the DB has 0
# so we force it to be realized/eval'd here
if expression_dict["definitions"]:
values.append(expression_dict)
url_filename = quote_plus(expression.text.lower())
letter = expression.char.lower()
os.makedirs(f"dist/_expressions/{letter}", exist_ok=True)
with open(f"dist/_expressions/{letter}/{url_filename}.md", "w+") as f:
f.write(f"""---
layout: expression
category: {letter}
title: "{expression.text}"
expression: {json.dumps(expression.text)}
permalink: "/{letter}/{url_filename}/"
definitions:
""")
for definition in expression_dict["definitions"]:
f.write(f""" - definition: {json.dumps(definition['definition'])}
example: {json.dumps(definition['example'])}
created: "{definition['created']}"
author: "{definition['author']}"
""")
f.write("---\n")
# produce a JSON for inspection
# this file already is free of private info, i.e. no user IP or e-mail
with open("slbr.json", "w+") as f:
json.dump(values, f, indent=4, sort_keys=True)
logging.info('Creating call...')
call['created'] = datetime.datetime.utcnow()
db_session.add(orm.Call(**call))
db_session.commit()
return NoContent, 201
logging.basicConfig(level=logging.INFO)
db_filename = "api.db"
# delete db if already exists
try:
os.remove(db_filename)
except OSError:
pass
db_session = orm.init_db('sqlite:///' + db_filename)
app = connexion.FlaskApp(__name__)
app.add_api('swagger.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
"""
cleanup
"""
db_session.remove()
if __name__ == '__main__':
track_history = orm.TrackHistory(track_id=track.id, **body)
db_session.add(track_history)
return track_history.dump()
else:
return 'Not found', 404
# return track.dump() if track is not None else ('Not found', 404)
# TODO: filter by current user_id over wrapper
def get_track(track_id):
track = db_session.query(orm.Track).filter(orm.Track.id == track_id).one_or_none()
return track.dump() if track is not None else ('Not found', 404)
db_connstring = os.environ.get('NEURO_CONNSTRING', 'sqlite:///:memory:')
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db(db_connstring)
app = connexion.FlaskApp(__name__)
app.add_api('openapi.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(port=8081, use_reloader=True, threaded=False)
def delete_tweet(tweet_id):
tweet = db_session.query(
orm.Tweet).filter(orm.Tweet.id == tweet_id).one_or_none()
if tweet is not None:
logging.info('Deleting tweet %s..', tweet_id)
db_session.query(orm.Tweet).filter(orm.Tweet.id == tweet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('postgresql://*****:*****@0.0.0.0:5432/sqlalchemy')
app = connexion.FlaskApp(__name__)
app.add_api("openapi.yml")
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
@app.route('/')
def home():
'''
db_session.add(orm.Pet(**pet))
db_session.commit()
return NoContent, (200 if p is not None else 201)
def delete_pet(pet_id):
pet = db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).one_or_none()
if pet is not None:
logging.info('Deleting pet %s..', pet_id)
db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('sqlite:///:memory:')
app = connexion.FlaskApp(__name__)
app.add_api('swagger.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
if __name__ == '__main__':
app.run(port=8080)
def delete_pet(pet_id):
pet = db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).one_or_none()
if pet is not None:
logging.info('Deleting pet %s..', pet_id)
db_session.query(orm.Pet).filter(orm.Pet.id == pet_id).delete()
db_session.commit()
return NoContent, 204
else:
return NoContent, 404
kinesis_client = boto3.client('kinesis')
logging.basicConfig(level=logging.INFO)
db_session = orm.init_db('sqlite:///example.db')
app = connexion.FlaskApp(__name__)
app.add_api('swagger.yaml')
application = app.app
@application.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
def stream_init():
logging.info('initializing the kinesis streaming ... ')
try:
kinesis_client.create_stream(StreamName='Pets', ShardCount=1)
except:
from orm import create_session, SystemPar, init_db, SystemCode db_session = create_session() init_db(db_session) db_session.close()
def session_reconnect():
global db_session
db_session = orm.init_db(ssh, db_host, db_name, db_user, db_password,
db_port, ssh_username, ssh_password, 'utf8mb4')
