def main():
if len(sys.argv) < 3:
print(
'Usage: Path to model config path to model last_checkpoint model type'
)
output_dir = sys.argv[2]
model_type = sys.argv[3]
cfg.merge_from_file(sys.argv[1])
cfg.merge_from_list(["OUTPUT_DIR", output_dir])
model = ChataDemo(cfg, model_type)
client = ApiClient()
client.login()
#latest_id = client.get_latest()
newest_ids = client.get_new_publications()
for pub_id in newest_ids:
pages = client.get_pages(pub_id)
print(pub_id)
for id, url in pages:
print(id)
print(url)
resp = urllib.request.urlopen(url)
image = np.asarray(bytearray(resp.read()), dtype="uint8")
image = cv2.imdecode(image, cv2.IMREAD_COLOR)
predictions = model.get_predictions(image)
annotations = annotate(predictions)
print(annotations)
if annotations:
print('writing annotation...')
for annotation in annotations:
client.add_annotation(id, annotation)
def run_main(args: Arguments):
api = ApiClient(args.subdomain, args.username, args.token)
stats = UserStats()
topic_id = None
posts = api.get_posts(topic_id,
filter_from=args.filter_from,
filter_to=args.filter_to)
for post in posts:
if api_util.included_in_date_range(post['created_at'],
filter_from=args.filter_from,
filter_to=args.filter_to):
stats.observe_post_by_user(post['author_id'])
comments = api.get_comments(post['id'],
filter_from=args.filter_from,
filter_to=args.filter_to)
for comment in comments:
stats.observe_comment_by_user(comment['author_id'])
if args.outputfile:
with open(args.outputfile, "w") as f:
for line in stats.to_csv():
f.write(line)
f.write('\n')
print(f"Results saved to {args.outputfile}")
else:
print("--- RESULTS ---")
for line in stats.to_csv():
print(line)
def authenticate(self):
try:
configuration = Configuration()
if os.name != 'nt':
permissions = os.stat(self.config).st_mode
if (permissions & 4) or (permissions & 32):
print(
'Warning: Your Kaggle API key is readable by other users on '
+
'this system! To fix this, you can run \'chmod 600 {}\''
.format(self.config))
with open(self.config, 'r') as f:
config_data = json.load(f)
self.copy_config_value(self.CONFIG_NAME_PROXY, config_data)
self.copy_config_value(self.CONFIG_NAME_PATH, config_data)
self.copy_config_value(self.CONFIG_NAME_COMPETITION, config_data)
self.copy_config_value(self.CONFIG_NAME_USER, config_data)
configuration.username = config_data[self.CONFIG_NAME_USER]
configuration.password = config_data[self.CONFIG_NAME_KEY]
if self.CONFIG_NAME_PROXY in config_data:
configuration.proxy = config_data[self.CONFIG_NAME_PROXY]
self.api_client = ApiClient(configuration)
except Exception as error:
if 'Proxy' in type(error).__name__:
sys.exit('The specified proxy ' +
config_data[self.CONFIG_NAME_PROXY] +
' is not valid, please check your proxy settings')
else:
sys.exit(
'Unauthorized: you must download an API key from ' +
'https://www.kaggle.com/<username>/account\nThen put ' +
self.config_file + ' in the folder ' + self.config_path)
def main():
charts_cfg = cfg.clone()
tables_cfg = cfg.clone()
charts_cfg.merge_from_file(charts_path)
tables_cfg.merge_from_file(tables_path)
model_charts = ChataDemo(charts_cfg, "charts")
model_tables = ChataDemo(tables_cfg, "tables")
client = ApiClient()
client.login()
newest_ids = client.get_new_publications()
for pub_id in newest_ids:
pages = client.get_pages(pub_id)
print(pub_id)
for id, url in pages:
print(id)
print(url)
resp = urllib.request.urlopen(url)
image = np.asarray(bytearray(resp.read()), dtype="uint8")
image = cv2.imdecode(image, cv2.IMREAD_COLOR)
predictions_charts = model_charts.get_predictions(image)
predictions_tables = model_tables.get_predictions(image)
annotations_charts = annotate(predictions_charts)
annotations_tables = annotate(predictions_tables)
annotations = annotations_charts+annotations_tables
print(annotations)
if annotations:
client.add_annotation(id, annotations)
def get_mock_trello(trello_config):
api_client = ApiClient()
api_client.get = mock_get([{
"id": "5eeb648682bb2c685cc659f0",
"name": NOT_STARTED,
"closed": False,
"pos": 1,
"softLimit": None,
"idBoard": "5eeb6486ebbfa66d2e519922",
"subscribed": False
}, {
"id": "5eeb648623bb2c685cc659f0",
"name": IN_PROGRESS,
"closed": False,
"pos": 2,
"softLimit": None,
"idBoard": "5eeb6486ebbfa66d2e519922",
"subscribed": False
}, {
"id": "5eeb6486cae807625c9f0819",
"name": COMPLETED,
"closed": False,
"pos": 3,
"softLimit": None,
"idBoard": "5eeb6486ebbfa66d2e519922",
"subscribed": False
}])
trello = Trello(trello_config, api_client)
return trello, api_client, trello_config
def __init__(self):
self._last_invalid_measurements = {}
self._mail_sender = MailSender(config['sender'],
config['receiver_email'],
config['MONITORED_VALUES'])
self._timer = MonitorTimer()
self._api_client = ApiClient()
self.test_dedicated_state = False
def __init__(self, access_token: str):
"""
VenmoAPI Client
:param access_token: <str> Need access_token to work with the API.
"""
super().__init__()
self.__access_token = validate_access_token(access_token=access_token)
self.__api_client = ApiClient(access_token=access_token)
self.user = UserApi(self.__api_client)
def log_out(access_token: str) -> bool:
"""
Revoke your access_token
:param access_token: <str>
:return:
"""
resource_path = '/oauth/access_token'
api_client = ApiClient(access_token=access_token)
api_client.call_api(resource_path=resource_path, method='DELETE')
confirm(f"Successfully logged out.")
return True
def get_access_token(username: str,
password: str,
device_id: str = None) -> str:
"""
Log in using your credentials and get an access_token to use in the API
:param username: <str> Can be username, phone number (without +1) or email address.
:param password: <str> Account's password
:param device_id: <str> [optional] A valid device-id.
:return: <str> access_token
"""
authn_api = AuthenticationApi(api_client=ApiClient(),
device_id=device_id)
return authn_api.login_with_credentials_cli(username=username,
password=password)
def test_get_comments(self, mock_requests_get):
expected = [
{'id': 2, 'body': 'some comment', 'postId': 2},
{'id': 3, 'body': 'some comment', 'postId': 2}
]
mock_response = MagicMock()
mock_response.json.return_value = expected
mock_requests_get.return_value = mock_response
r = ApiClient().get_comments()
self.assertEqual(r, expected)
def test_app():
trello_config = Config(".env").trello_config
trello = Trello(trello_config, ApiClient()).create_test_board()
application = app.create_app({}, trello)
thread = Thread(target=lambda: application.run(use_reloader=False))
thread.daemon = True
thread.start()
# I really feel like this shouldn't be necessary, but otherwise selenium makes requests before flask has started
time.sleep(1)
yield app
thread.join(1)
trello.delete_board()
def __init__(self,
base_url,
token,
sleep_seconds=2,
timeout_seconds=sys.maxsize,
timeout_func=_default_timeout_func,
verbose=True):
"""
:param base_url: Base URL of API such as https://acme.cloud.databricks.com/api/2.0
:param token: API token
:param sleep_seconds: Seconds to sleep when polling for cluster readiness
:param timeout_seconds: Timeout in seconds
:param verbose: To be verbose or not?
"""
self.api_client = ApiClient(base_url, token)
self.base_url = base_url
self.sleep_seconds = sleep_seconds
self.timeout_seconds = timeout_seconds
self.timeout_func = timeout_func
self.verbose = verbose
config_file = "config.json"
if os.path.exists(config_file):
logging.info("Reading config file {}".format(config_file))
with open(config_file, 'rb') as f:
dct = json.loads(f.read())
self.cluster_noninit_states = set(dct['cluster_noninit_states'])
self.run_terminal_states = set(dct['run_terminal_states'])
else:
self.cluster_noninit_states = {
"RUNNING", "TERMINATED", "ERROR", "UNKNOWN"
}
self.run_terminal_states = {
"TERMINATED", "SKIPPED", "INTERNAL_ERROR"
}
logging.info("cluster_noninit_states: {}".format(
self.cluster_noninit_states))
logging.info("run_terminal_states: {}".format(
self.run_terminal_states))
def run_main(args: Arguments):
api = ApiClient(args.subdomain, args.username, args.token)
selected_user_id = None
while True:
mode = enquiries.choose('Select an action:', ['Get stats', 'Award badge', 'Exit'])
print(mode)
if mode == 'Exit':
return
elif mode == 'Award badge':
if selected_user_id:
badges = api.get_badges()
badge_labels = map(lambda b: f"{b['id']} {b['name']}", badges)
badge = enquiries.choose('Select a badge:', badge_labels)
badge_id = badge.split(' ', 1)[0]
print(f"Assigning badge {badge_id} to user {selected_user_id}")
response = api.create_badge_assignment(selected_user_id, badge_id)
print(str(response))
else:
print("First select a user, for example by looking at stats")
elif mode == 'Get stats':
stats = UserStats()
topic_id = None
posts = api.get_posts(topic_id, filter_from=args.filter_from, filter_to=args.filter_to)
for post in posts:
if api_util.included_in_date_range(post['created_at'], filter_from=args.filter_from, filter_to=args.filter_to):
stats.observe_post_by_user(post['author_id'])
comments = api.get_comments(post['id'], filter_from=args.filter_from, filter_to=args.filter_to)
for comment in comments:
stats.observe_comment_by_user(comment['author_id'])
users = []
for user_id in stats.stats_by_user:
userstats = stats.stats_by_user[user_id]
user = f"{user_id} - {userstats.get('posts') or 0} posts, {userstats.get('comments') or 0} comments"
users.append(user)
select_user = enquiries.choose('Here are your top contributors. Select one:', users)
selected_user_id = select_user.split(' ', 1)[0]
"""
This module is sample code that shows how to invoke the web service to get datasets
We will show how to use this for problem on identifying algebric identities
Author: Palacode Narayana Iyer Anantharaman
Date: 5 Oct 2018
"""
from api_client import ApiClient
if __name__ == "__main__":
# in order to use the web service, first create the instance of ApiClient class
client = ApiClient()
# test it with echo service
val = client.echo("hi there!!!!")
print("The Service Returned: ", val)
# you can use the method algebric identity simulated dataset
# this will be rate limited
num_samples = 5
val = client.algebra(5)
inputs = val["inputs"]
outputs = val["outputs"]
for inp, outp in zip(inputs, outputs):
print(inp, outp)
from api_client import ApiClient
import json
api = ApiClient()
query_params = {'page_no': 1, "page_size": 2}
rooms_resp = api.request("GET",
"http://127.0.0.1:5000/rooms",
query_params=query_params,
_preload_content=True)
data = json.loads(rooms_resp.data)
f1 = "D:/work/py-apps/client/config/openapi.json"
with open(f1) as f:
oas_data = json.load(f)
urls = []
"""
path:
method:
parameters,
order:
dependent: [""]
type: full|incremental
pagination: true or false
"""
for path, path_dict in oas_data.get("paths"):
for method, method_dict in path_dict:
url = {
from dotenv import load_dotenv
import os
from state import read_state, write_state, ALERTED_FOR_LEVEL, update_state_alert_level
from webhook import make_webhook
def optional_environ(name, default):
return default if name not in os.environ else os.environ[name]
load_dotenv()
api_host = optional_environ("API_HOST", "localhost")
api_port = int(optional_environ("API_PORT", "5000"))
client = ApiClient(api_host, api_port)
state = read_state()
def get_msg_data(dist):
return f"\n\tDistance: {dist}\n\tWarning At: {warn_distance}"
def handle_salt_low(current_distance):
dist = current_distance["distance"]
alerted = ALERTED_FOR_LEVEL in state
if dist < warn_distance or alerted:
return
update_state_alert_level(dist)
webhook(
def __init__(self, app_token):
self.base = 'calendars'
self.api_client = ApiClient(app_token, self.base)
def get_influx_database(self):
return self.args['influxdb_database']
def get_mqtt_url(self):
return self.args['mqtt_url']
def get_telemetry_types(self):
return self.args['telemetry_types']
def get_streams_per_telegraf(self):
return self.args['streams_per_telegraf']
options = Options(sys.argv[1:])
api_client = ApiClient(options.get_api_url(), options.get_api_key())
influx_client = InfluxClient(options.get_influx_url(),
options.get_influx_port(),
options.get_influx_username(),
options.get_influx_password())
company_id = api_client.get_company_id()
database = options.get_influx_database()
measurement = 'telemetry'
unique_ids = api_client.get_telemetry_unique_ids(
api_venue_id=options.get_api_venue_id())
topics = [
'/stream/%s/%s' % elem
for elem in itertools.product(unique_ids, options.get_telemetry_types())
label_dict = {
0: "T-shirt/top",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle boot"
}
if __name__ == "__main__":
# in order to use the web service, first create the instance of ApiClient class
client = ApiClient(
) # NOTE: you need to call ApiClient(auth_key=YOUR_API_KEY)
# if needed, test it with echo service
# this is the simplest service that we can use to check if web service is running correctly
# uncomment the code below to test echo()
# val = client.echo("hi there!!!!")
# print("For the echo service the returned value is: ", val)
# you can use the method get_fashion_mnist_data to get data for fashion mnist
# this will be rate limited to 10000 samples per call
# for test accounts we will return a sample of 5 records to give you a feel
num_samples = 10
images, labels = client.get_fashion_mnist_data(num_samples)
# you can print the labels returned by the service and examine
# I am printing first 10 labels below
async def main(loop):
aio_jikan = AioJikan(loop=loop)
seasons = ['winter', 'spring', 'summer', 'fall']
root_url = 'https://sovetromantica.com'
apiSesson = ApiClient()
await apiSesson.login('silverlynxx', '123456')
# year = 2019
# season = 'spring'
for year in range(1990, 2021):
for season in seasons:
season_year = await aio_jikan.season(year=year, season=season)
season_anime = season_year['anime']
for anime in season_anime:
print('\n', anime['title'])
embed_links_sub, embed_links_dub = await parse_sovetromantica(
anime['title'], 'anime')
for link in embed_links_sub:
num = int(re.findall(r'_(\d*?)-subtitles', link)[-1])
num_len = len(str(num))
ep_num = ''
if num_len == 1:
ep_num = f'e00{num}'
if num_len == 2:
ep_num = f'e0{num}'
if num_len == 3:
ep_num = f'e{num}'
record_headline = f'{anime["title"]} ({ep_num}) (sub) [sovetromantica]'
record_text = f'{anime["title"]} ({ep_num}) [{season} {year}]'
tags = []
tags.append(
('_'.join(re.findall(r'\W?(\w+)\W?',
anime['title']))).lower())
tags.append(str(year))
tags.append(f'{season}_{year}')
tags.append('sub')
tags.append(ep_num)
record_resp = await apiSesson.create_record(
record_headline, record_text, tags)
recordid = record_resp[0]['data']['recordid']
media_data = {'url': f'{root_url}{link}'}
media_type = 'embedded_video'
media_description = f'{anime["title"]} ({ep_num}) (sub) [sovetromantica]'
media_resp = await apiSesson.set_record_media(
recordid, media_data, media_type, media_description)
for link in embed_links_dub:
num = int(re.findall(r'_(\d*?)-dubbed', link)[-1])
num_len = len(str(num))
ep_num = ''
if num_len == 1:
ep_num = f'e00{num}'
if num_len == 2:
ep_num = f'e0{num}'
if num_len == 3:
ep_num = f'e{num}'
record_headline = f'{anime["title"]} ({ep_num}) (dub) [sovetromantica]'
record_text = f'{anime["title"]} ({ep_num}) [{season} {year}]'
tags = []
tags.append(
('_'.join(re.findall(r'\W?(\w+)\W?',
anime['title']))).lower())
tags.append(str(year))
tags.append(f'{season}_{year}')
tags.append('dub')
tags.append(ep_num)
record_resp = await apiSesson.create_record(
record_headline, record_text, tags)
recordid = record_resp[0]['data']['recordid']
media_data = {'url': f'{root_url}{link}'}
media_type = 'embedded_video'
media_description = f'{anime["title"]} ({ep_num}) (dub) [sovetromantica]'
media_resp = await apiSesson.set_record_media(
recordid, media_data, media_type, media_description)
await aio_jikan.close()
await apiSesson.close()
def create(cls, base, username, password):
"""Factory method using default ApiClient class."""
client = ApiClient(base, username, password)
return cls(client)
def main():
api_client = ApiClient(SECUREX_VISIBILITY_HOST_NAME, SECUREX_CLIENT_ID,
SECUREX_CLIENT_PASSWORD)
# read stored cursor of last security event item from previous script run (if any)
# to process only new or modified events in current script run
previous_events_end_cursor = read_events_end_cursor()
# USE BULK LOADING RESOURCES ON API TO PRELOAD EVENTS AND IMPORTANT REFERRED OBJECTS
# remember events
events = []
# cached contextual objects - alerts, threat detections, threat intel records, assets
cached_context_objects = {}
threat_detection_ids = []
affected_asset_ids = []
# iterate over all security events sorted by unique modification sequence number ensuring no event is missed
events_iterator = api_client.create_collection_iterator(
collection_url_path=build_event_with_threat_detections_ids_url(
api_client.get_customer_id()),
query_params={
"sort": "modificationSequenceNumber",
},
cursor=previous_events_end_cursor)
# remember events and get ids of related object (threat detections and assets) to "bulk load" them
for event in events_iterator:
events.append(event)
threat_detection_ids.extend(event["threatDetectionIds"])
affected_asset_ids.append(event["affectedAssetId"])
alert_ids = []
threat_intel_record_ids = []
for distinct_threat_detection_ids_chunk in chunk_list(
list(set(threat_detection_ids))):
# bulk load threat detections chunk by their ids
threat_detections_iterator = api_client.create_collection_iterator(
collection_url_path=build_search_threat_detection_with_alert_id_url(
api_client.get_customer_id()),
request_body={
"filter": {
"threatDetectionIds": distinct_threat_detection_ids_chunk
}
})
# keep threat detections in "cached_context_objects" and extract IDs of alerts and threat intel records
for threat_detection in threat_detections_iterator:
cached_context_objects[threat_detection["id"]] = threat_detection
alert_ids.extend(threat_detection["alertIds"])
threat_intel_record_ids.append(
threat_detection["threatIntelRecordId"])
for distinct_affected_asset_ids_chunk in chunk_list(
list(set(affected_asset_ids))):
# bulk load assets chunk by their ids
affected_asset_iterator = api_client.create_collection_iterator(
collection_url_path=build_assets_search_url(
api_client.get_customer_id()),
request_body={
"filter": {
"assetId": distinct_affected_asset_ids_chunk
}
})
# keep assets in "cached_context_objects"
for affected_asset in affected_asset_iterator:
cached_context_objects[affected_asset["id"]] = affected_asset
# bulk load alerts
alerts_iterator = api_client.create_collection_iterator(
collection_url_path=build_alerts_search_url(
api_client.get_customer_id()),
request_body={"filter": {
"alertIds": list(set(alert_ids))
}})
# keep alerts in "cached_context_objects"
for alert in alerts_iterator:
cached_context_objects[alert["id"]] = alert
# bulk load threat intelligence records
threat_intel_records_iterator = api_client.create_collection_iterator(
collection_url_path=build_threat_intel_search_url(),
request_body={
"filter": {
"threatIntelRecordId": list(set(threat_intel_record_ids))
}
})
# keep threat intelligence records in "cached_context_objects"
for threat_intel_record in threat_intel_records_iterator:
cached_context_objects[threat_intel_record["id"]] = threat_intel_record
# PROCESS EVENTS AND OTHER CONTEXTUAL OBJECTS
# start with events, get contextual objects for each event from cached_context_objects and log them together
for event in events:
# get affected asset referred by event
affected_asset = cached_context_objects.get(event["affectedAssetId"],
None)
# get IDs references to threat detections from event (usually one, can be [])
threat_detection_ids = event["threatDetectionIds"]
# process event with threat detections (called "convicting" security event)
for threat_detection_id in threat_detection_ids:
# get parent objects to event - threat detections and alert
# and also threat intel record from threat-catalog bounded context
threat_detection_with_alert_ids = cached_context_objects.get(
threat_detection_id, None)
threat_intel_record = cached_context_objects.get(
threat_detection_with_alert_ids["threatIntelRecordId"],
None) if threat_detection_with_alert_ids else None
# get IDs references to alerts (usually one)
alert_ids = threat_detection_with_alert_ids[
"alertIds"] if threat_detection_with_alert_ids else []
for alert_id in alert_ids:
alert = cached_context_objects.get(alert_id, None)
# log event with all related objects - alert, threat detection, threat intel record
log_event_attributes(event, affected_asset,
threat_detection_with_alert_ids,
threat_intel_record, alert)
else:
# process event with missing threat detection or missing alert (might be GC)
log_event_attributes(event, affected_asset,
threat_detection_with_alert_ids,
threat_intel_record)
else:
# process event without threat detections (called "contextual" security event)
# log event just with affected_asset
log_event_attributes(event, affected_asset)
# store events end_cursor for next script run
if events_iterator.end_cursor():
write_events_end_cursor(events_iterator.end_cursor())
def __init__(self):
self.api_client = ApiClient()
def download_samples(starting_page=0, limit=sys.maxsize, image_size="s"):
api_client = ApiClient(starting_page=starting_page,
limit=limit,
image_size=image_size)
asyncio.run(api_client.start_bulk_download())
def create(cls, base, username, password):
client = ApiClient(base, username, password)
return cls(client)
def __init__(self, app_token):
self.base = "resources"
self.api_client = ApiClient(app_token)
import pickle
import nltk
from api_client import ApiClient
my_auth_key = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NTQ2MjY5ODAsImlhdCI6MTUzOTA3NDk4MCwibmJmIjoxNTM5MDc0OTgwLCJpZGVudGl0eSI6MTF9.kbHzSmkCqCu3akW7bMM6Vj4flZ-CVGuRYixh-k2x0Ps"
client = ApiClient(auth_key=my_auth_key)
#Load the dataset that was obtained from API and pickeled beforehand
with open('dataset.pkl', 'rb') as handle:
dataset = pickle.load(handle)
#Extract all questions tokenized as sentences from the dataset
sentences = []
for i in dataset:
sentences += nltk.sent_tokenize(i['question1'])
sentences += nltk.sent_tokenize(i['question2'])
#Tokenize as words and find their frequency and select top 10000
word_dist = nltk.FreqDist()
for s in sentences:
word_dist.update([i.lower() for i in nltk.word_tokenize(s)])
word_dist = word_dist.most_common(10000)
#obtain the glove vectors for the 10000 words from the web service
embeddings_list = []
for i in range(10, 100):
embeddings_list += client.w2v(
[i[0] for i in word_dist[i * 100:i * 100 + 100]])
from flask import Flask, render_template, request, redirect, url_for
from config import Config
from trello import Trello
from status import COMPLETED, IN_PROGRESS
from view_model import ViewModel
from api_client import ApiClient
config = Config('.env')
trello = Trello(config.trello_config, ApiClient())
def create_app(script_info, trello=trello):
app = Flask(__name__)
# Allowing POST so we don't need frontend JS
@app.route('/item/<id>/mark-completed', methods=['PUT', 'POST'])
def mark_completed(id):
trello.set_status(id, COMPLETED)
return redirect('/')
@app.route('/item/<id>/start-item', methods=['PUT', 'POST'])
def start_item(id):
trello.set_status(id, IN_PROGRESS)
return redirect('/')
@app.route('/item/<id>/delete', methods=['DELETE', 'POST'])
def delete(id):
item = trello.delete_item(id)
return redirect('/')
@app.route('/item/add', methods=['POST'])
def add_item():
def main():
'''
main entry point into the 'app'
every function needs a Docstring in order to follow best
practices
'''
# show_intro()
'''
collect the environment options from the command line
this is packaged and managed via the EnvironmentOptions
module in the environment_options directory
'''
environment_options = EnvironmentOptions()
environment_options.get_options()
if environment_options.debug:
print(f'{environment_options}\n')
'''
check to make sure all required options have been specified
if the username and password have not been provided on the
command line, we'll prompt for them here
'''
if not environment_options.cluster_ip:
raise DetailsMissingException('Cluster IP is required.')
elif not environment_options.username:
raise DetailsMissingException('Username is required.')
elif not environment_options.password:
raise DetailsMissingException('Password is required.')
else:
if environment_options.debug:
print('All parameters OK.\n')
if environment_options.debug:
print('Creating instance of ApiClient class ...')
client_blueprint = ApiClient(
environment_options.cluster_ip,
(f'blueprints/{environment_options.blueprint_uuid}'
'/runtime_editables'), '', environment_options.username,
environment_options.password, environment_options.read_timeout)
if environment_options.debug:
print(f'Client info: {client_blueprint}\n')
if environment_options.debug:
print('Requesting blueprint details ...\n')
results_blueprint = client_blueprint.send_request()
'''
check to see if there are app profile references
in the JSON response
this is ONLY required if --app_profile was not
specified as a command-line parameter
if no app_profile has been specified, we can get it
from the API request we just made
if no app_profile has been specified but it is also
missing from the JSON response, it likely indicates
a failed request or a request that wasn't a call to
a blueprint's runtime_editables api
***Important note:
This demo script only looks for
an app profile named 'Default'; if no matching app
profile reference exists in your environment, please
edit the 'Default' name below, and/or manually construct
the value of app_profile_reference
'''
if environment_options.app_profile_reference == '':
if environment_options.debug:
print('No app profile specified; grabbing it from '
'the blueprint spec ...')
if 'resources' in results_blueprint:
if len(results_blueprint['resources']) > 0:
if 'app_profile_reference' in results_blueprint[
'resources'][0]:
if len(results_blueprint['resources'][0]) > 0:
if environment_options.debug:
print('App profile reference found.')
for reference in results_blueprint['resources']:
if (reference['app_profile_reference']['name']
== 'Default'):
environment_options.app_profile_reference = (
reference['app_profile_reference']
['uuid'])
if environment_options.debug:
print(
'Default app profile reference UUID extracted.'
)
else:
print('no app profile references found; exiting.')
sys.exit()
else:
print('no app profile references found; exiting.')
sys.exit()
else:
print('no app profile references found; exiting.')
sys.exit()
else:
print('no app profile references found; exiting.')
sys.exit()
else:
if environment_options.debug:
print(
'App profile already specified; using command line parameter ...'
)
pass
'''
at this point we do have our app profile reference
we can continue with the next part of the script, i.e.
creating the payload/request body that will be sent
with the actual launch request
'''
if environment_options.debug:
print('Building blueprint launch payload ...\n')
payload = ('{ '
'"spec":{ '
f'"app_name":"{environment_options.app_name}", '
f'"app_description":"{environment_options.app_desc}", '
'"app_profile_reference":{ '
'"kind":"app_profile", '
'"name":"Default", '
f'"uuid":"{environment_options.app_profile_reference}" '
'} '
'} '
'}')
if environment_options.debug:
print(f'Payload: \n{payload}\n')
if environment_options.debug:
print('Creating instance of ApiClient class ...')
client_launch = ApiClient(
environment_options.cluster_ip,
(f'blueprints/{environment_options.blueprint_uuid}'
'/simple_launch'),
payload,
environment_options.username,
environment_options.password,
environment_options.read_timeout,
method='post')
if environment_options.debug:
print(f'Client info: {client_launch}\n')
if environment_options.debug:
print('Sending request ...\n')
results_launch = client_launch.send_request()
if environment_options.debug:
print(f'Results: \n{results_launch}')
def __init__(self, app_token):
self.base = 'credentials'
self.api_client = ApiClient(app_token)