def setUpClass(self):
"""Database setup before the tests."""
print("Creating a temporary database...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.session = session
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.app = app_factory(self.API_NAME)
self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(),
self.HYDRUS_SERVER_URL, self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
print("Classes and properties added successfully.")
print("Setting up Hydrus utilities... ")
self.api_name_util = set_api_name(self.app, self.API_NAME)
self.session_util = set_session(self.app, self.session)
self.doc_util = set_doc(self.app, self.doc)
self.client = self.app.test_client()
print("Creating utilities context... ")
self.api_name_util.__enter__()
self.session_util.__enter__()
self.doc_util.__enter__()
self.client.__enter__()
print("Setup done, running tests...")
def main():
"""Initialize the drone database."""
# Drop database if exists and create a new one.
print("Droping database if exist")
Base.metadata.drop_all(engine)
print("Creating models....")
Base.metadata.create_all(engine)
print("Done")
# Parse and insert classes to DB
Session = sessionmaker(bind=engine)
session = Session()
doc = doc_gen("dummy", "dummy")
doc_classes = get_classes(doc.generate())
doc_properties = get_all_properties(doc_classes)
insert_classes(doc_classes, session=session)
print("Classes inserted successfully.")
insert_properties(doc_properties, session=session)
print("Properties inserted successfully.")
return None
def setUpClass(self):
"""Database setup before the tests."""
print("Creating a temporary datatbsse...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
self.session = session
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.app = app_factory(self.API_NAME)
self.doc = doc_maker.createDoc(doc_writer_sample.api_doc.generate(),
self.HYDRUS_SERVER_URL, self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
add_user(1, "test", self.session)
self.auth_header = {
"Authorization": "Basic " + generate_basic_digest(1, "test")
}
print("Classes, Properties and Users added successfully.")
print("Setup done, running tests...")
def setUpClass(self):
"""Database setup before the CRUD tests."""
print("Creating a temporary datatbsse...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.session = session
self.doc = doc_maker.create_doc(doc, self.HYDRUS_SERVER_URL,
self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
# Getting list of classes from APIDoc
self.doc_collection_classes = [
self.doc.collections[i]["collection"].class_.title
for i in self.doc.collections
]
print(self.doc_collection_classes)
print(random.choice(self.doc_collection_classes))
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
print("Classes and properties added successfully.")
print("Setup done, running tests...")
def setUp(self):
"""Database setup before the tests."""
super(AuthTestCase, self).setUp()
print("Creating a temporary datatbase...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.session = session
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME)
self.gs = Getter_setter(self.session, self.HYDRUS_SERVER_URL, self.API_NAME, self.doc, True)
self.app = app_factory(self.API_NAME, self.gs)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
add_user(1, "test", self.session)
self.auth_header = {"Authorization": "Basic " + b64encode(b"1:test").decode("utf-8")}
self.wrong_id = {"Authorization": "Basic " + b64encode(b"2:test").decode("utf-8")}
self.wrong_pass = {"Authorization": "Basic " + b64encode(b"1:test2").decode("utf-8")}
print("Classes, Properties and Users added successfully.")
print("Setting up Hydrus utilities... ")
print("Creating utilities context... ")
print("Setup done, running tests...")
def setUpClass(self):
"""Database setup before the tests."""
print("Creating a temporary datatbase...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.session = session
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.app = app_factory(self.API_NAME)
self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(),
self.HYDRUS_SERVER_URL, self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
add_user(1, "test", self.session)
self.auth_header = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"1:test").decode("ascii"))
}
self.wrong_id = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"2:test").decode("ascii"))
}
self.wrong_pass = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"1:test2").decode("ascii"))
}
print("Classes, Properties and Users added successfully.")
print("Setting up Hydrus utilities... ")
self.api_name_util = set_api_name(self.app, self.API_NAME)
self.session_util = set_session(self.app, self.session)
self.doc_util = set_doc(self.app, self.doc)
self.auth_util = set_authentication(self.app, True)
self.token_util = set_token(self.app, False)
self.client = self.app.test_client()
print("Creating utilities context... ")
self.api_name_util.__enter__()
self.session_util.__enter__()
self.doc_util.__enter__()
self.auth_util.__enter__()
self.token_util.__enter__()
self.client.__enter__()
print("Setup done, running tests...")
def get_doc_classes_and_properties(doc):
"""
Extract classes and properties from a given HydraDoc object
:param doc: HydraDoc object whose classes and properties have to extracted
:type doc: HydraDoc
:return: classes and properties in the HydraDoc object in a tuple
:rtype: tuple(list, set)
"""
test_classes = doc_parse.get_classes(doc)
test_properties = doc_parse.get_all_properties(test_classes)
return (test_classes, test_properties)
def setUpClass(self):
"""Database setup before the CRUD tests."""
print("Creating a temporary datatbsse...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.session = session
self.doc = doc
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
print("Classes and properties added successfully.")
print("Setup done, running tests...")
def setUpClass(self):
"""Database setup before the CRUD tests."""
print("Creating a temporary datatbsse...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.session = session
self.doc = doc_maker.create_doc(
doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
print("Classes and properties added successfully.")
print("Setup done, running tests...")
def setUp(self):
"""Database setup before the tests."""
super(ViewsTestCase, self).setUp()
print("Creating a temporary database...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
self.session = scoped_session(sessionmaker(bind=engine))
self.HYDRUS_SERVER_URL = "http://hydrus.com"
self.API_NAME = "demoapi"
self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(), self.HYDRUS_SERVER_URL, self.API_NAME)
self.gs = Getter_setter(self.session, self.HYDRUS_SERVER_URL, self.API_NAME, self.doc, False)
self.app = app_factory(self.API_NAME, self.gs)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
print("Classes and properties added successfully.")
print("Setting up Hydrus utilities... ")
print("Creating utilities context... ")
print("Setup done, running tests...")
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str,
hydradoc: str, port: int, serverurl: str, token: bool,
serve: None) -> None:
"""
Python Hydrus CLI
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param hydradoc <str> : Sets the link to the HydraDoc file.
:param port <int> : Sets the API server port.
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:param serve : Starts up the server.
:return : None.
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port))
# The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample]
click.echo("Creating the API Documentation")
apidoc = doc_maker.create_doc(json.loads(hydradoc.read()),
HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
# You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc.generate())
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
click.echo("Starting the application")
with set_authentication(app, auth):
# Use authentication for all requests
with set_token(app, token):
with set_api_name(app, api):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', port), app)
click.echo("Server running at:")
click.echo(HYDRUS_SERVER_URL + API_NAME)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see
# hydrus/hydraspec/doc_writer_sample]
print("Creating the API Documentation")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
print("Adding Classes and Properties")
# Get all the classes from the doc
# You can also pass dictionary defined in
# hydrus/hydraspec/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc)
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
print("Adding authorized users")
add_user(id_=1, paraphrase="test", session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
print("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str,
hydradoc: str, port: int, serverurl: str, token: bool,
serve: None) -> None:
"""
Python Hydrus CLI
:param openapi: : Sets the link to the Open Api Doc file.
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param hydradoc <str> : Sets the link to the HydraDoc file
(Supported formats - [.py, .jsonld, .yaml])
:param port <int> : Sets the API server port.
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:param serve : Starts up the server.
:return : None.
Raises:
Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml].
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port))
# The name of the API or the EntryPoint, the api will be at
# http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object
# using doc_maker or you may create your own HydraDoc Documentation using
# doc_writer [see hydra_python_core/doc_writer_sample]
click.echo("Creating the API Documentation")
if hydradoc:
# Getting hydradoc format
# Currently supported formats [.jsonld, .py, .yaml]
try:
hydradoc_format = hydradoc.split(".")[-1]
if hydradoc_format == 'jsonld':
with open(hydradoc, 'r') as f:
doc = json.load(f)
elif hydradoc_format == 'py':
doc = SourceFileLoader(
"doc", "./examples/drones/doc.py").load_module().doc
elif hydradoc_format == 'yaml':
with open(hydradoc, 'r') as stream:
doc = parse(yaml.load(stream))
else:
raise ("Error - hydradoc format not supported.")
click.echo("Using %s as hydradoc" % hydradoc)
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
except BaseException:
click.echo("Problem parsing specified hydradoc file, "
"using sample hydradoc as default.")
apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL,
API_NAME)
else:
click.echo("No hydradoc specified, using sample hydradoc as default.\n"
"For creating api documentation see this "
"https://www.hydraecosystem.org/01-Usage.html#newdoc\n"
"You can find the example used in examples/drones/doc.py")
apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL,
API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
# You can also pass dictionary defined in
# hydra_python_core/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc.generate())
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
click.echo("Starting the application")
with set_authentication(app, auth):
# Use authentication for all requests
with set_token(app, token):
with set_api_name(app, api):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', port), app)
click.echo("Server running at:")
click.echo("{}{}".format(HYDRUS_SERVER_URL,
API_NAME))
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
api_doc = parse(documentation)
f = open("./astrodemo/hydra_doc.py", "w")
f.write(api_doc)
f.close()
api = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL, API_NAME)
engine = create_engine(DB_URL)
session = sessionmaker(bind=engine)()
print("Droping database if exist")
Base.metadata.drop_all(engine)
print("Creating models....")
Base.metadata.create_all(engine)
print("Done")
classes = doc_parse.get_classes(api_document)
properties = doc_parse.get_all_properties(classes)
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
session = sessionmaker(bind=engine)()
app = app_factory(API_NAME)
with set_api_name(app, API_NAME):
with set_doc(app, api):
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
with set_session(app, session):
http_server = WSGIServer(('', PORT), app)
print(HYDRUS_SERVER_URL + API_NAME)
try:
http_server.serve_forever()
def serve(
adduser: tuple,
api: str,
auth: bool,
dburl: str,
pagination: bool,
hydradoc: str,
port: int,
pagesize: int,
serverurl: str,
token: bool,
use_db: bool,
stale_records_removal_interval: int,
) -> None:
"""
Starts up the server.
\f
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param pagination <bool>: Toggles the pagination.
:param hydradoc <str> : Sets the link to the HydraDoc file
(Supported formats - [.py, .jsonld, .yaml])
:param port <int> : Sets the API server port.
:param pagesize <int> : Sets maximum size of page(view).
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:stable_records_removal_interval <int> : Interval period between removal
of stale modification records.
:return : None
Raises:
Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml].
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = f"{serverurl}:{str(port)}/"
# The name of the API or the EntryPoint, the api will be at
# http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL, connect_args={"check_same_thread": False})
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object
# using doc_maker or you may create your own HydraDoc Documentation using
# doc_writer [see hydra_python_core/doc_writer_sample]
click.echo("Creating the API Documentation")
if hydradoc:
# Getting hydradoc format
# Currently supported formats [.jsonld, .py, .yaml]
try:
hydradoc_format = hydradoc.split(".")[-1]
if hydradoc_format == "jsonld":
with open(hydradoc, "r") as f:
doc = json.load(f)
elif hydradoc_format == "py":
doc = SourceFileLoader("doc", hydradoc).load_module().doc
elif hydradoc_format == "yaml":
with open(hydradoc, "r") as stream:
doc = parse(yaml.load(stream))
else:
raise ("Error - hydradoc format not supported.")
click.echo(f"Using {hydradoc} as hydradoc")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
except BaseException:
if FOUND_DOC:
click.echo("Problem parsing specified hydradoc file"
"Using hydradoc from environment variable")
else:
click.echo("Problem parsing specified hydradoc file, "
"using sample hydradoc as default.")
apidoc = doc_maker.create_doc(APIDOC_OBJ, HYDRUS_SERVER_URL,
API_NAME)
else:
if FOUND_DOC:
click.echo(
"No hydradoc specified, using hydradoc from environment variable."
)
else:
click.echo(
"No hydradoc specified, using sample hydradoc as default.\n"
"For creating api documentation see this "
"https://www.hydraecosystem.org/01-Usage.html#newdoc\n"
"You can find the example used in hydrus/samples/hydra_doc_sample.py"
)
apidoc = doc_maker.create_doc(APIDOC_OBJ, HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
# Get all the classes from the doc
# You can also pass dictionary defined in
# hydra_python_core/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc)
# Insert them into the database
if use_db is False:
Base.metadata.drop_all(engine)
click.echo("Adding Classes and Properties")
create_database_tables(classes)
click.echo("Creating models")
Base.metadata.create_all(engine)
# Add authorized users and pass if they already exist
click.echo("Adding authorized users")
try:
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
except UserExists:
pass
# Insert them into the database
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME, apidoc.doc_name)
# Set the name of the API
# Create a socket for the app
socketio = create_socket(app, session)
click.echo("Starting the application")
#
# Nested context managers
#
# Use authentication for all requests
# Set the API Documentation
# Set HYDRUS_SERVER_URL
# Set the Database session
# Enable/disable pagination
# Set page size of a collection view
with set_authentication(app, auth) as _, set_token(
app, token) as _, set_api_name(app, api) as _, set_doc(
app, apidoc) as _, set_hydrus_server_url(
app, HYDRUS_SERVER_URL) as _, set_session(
app, session) as _, set_pagination(
app,
pagination) as _, set_page_size(app,
pagesize) as _:
# Run a thread to remove stale modification records at some
# interval of time.
remove_stale_modification_records(session,
stale_records_removal_interval)
# Start the hydrus app
socketio.run(app, port=port)
click.echo("Server running at:")
click.echo(f"{HYDRUS_SERVER_URL}{API_NAME}")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample]
print("Creating the API Documentation")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
print("Adding Classes and Properties")
# Get all the classes from the doc
classes = doc_parse.get_classes(
apidoc.generate()
) # You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
print("Adding authorized users")
add_user(id_=1, paraphrase="test", session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
if __name__ == "__main__":
engine = create_engine(DB_URL)
print("Droping database if exist")
Base.metadata.drop_all(engine)
print("Creating models....")
Base.metadata.create_all(engine)
print("Done")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
session = sessionmaker(bind=engine)()
classes = doc_parse.get_classes(apidoc.generate())
properties = doc_parse.get_all_properties(classes)
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
app = app_factory(API_NAME)
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
http_server = WSGIServer(('', PORT), app)
if __name__ == "__main__":
engine = create_engine(DB_URL)
print("Droping database if exist")
Base.metadata.drop_all(engine)
print("Creating models....")
Base.metadata.create_all(engine)
print("Done")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
session = sessionmaker(bind=engine)()
classes = doc_parse.get_classes(apidoc.generate())
properties = doc_parse.get_all_properties(classes)
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
app = app_factory(API_NAME)
with set_doc(app, apidoc):
with set_authentication(app, False):
with set_token(app, False):
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
with set_session(app, session):
http_server = WSGIServer(('', PORT), app)
http_server.serve_forever()
def startserver(adduser, api, auth, hydradoc, port, serve):
"""Python Hydrus CLI"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = 'sqlite:///:memory:'
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "http://localhost:" + str(port) + "/"
# The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample]
click.echo("Creating the API Documentation")
apidoc = doc_maker.create_doc(json.loads(hydradoc.read()),
HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
classes = doc_parse.get_classes(
apidoc.generate()
) # You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
getter_setter = Getter_setter(session, HYDRUS_SERVER_URL, API_NAME, apidoc,
True)
print("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME, getter_setter)
# Set the name of the API
print("Starting the application")
http_server = WSGIServer(('', 8080), app)
print("Server running at:")
print(HYDRUS_SERVER_URL + API_NAME)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
