def run(self):
while not self.terminated:
if self.event.wait(1):
try:
self.logger.debug("An upload processor is running...")
if self.stream:
# Count how many retries so far.
retry = 0
# Flag when the upload completed successfully.
success = False
# Maxiumum amount of exceptions handled before giving up.
MAX_RETRY = 3
while (retry < MAX_RETRY):
try:
client = ApiClient(self.username, self.token, self.url)
client.upload_file(self.device_id, stream=self.stream, ext='.jpg')
retry = MAX_RETRY
success = True
except Exception as e:
self.logger.error(e)
retry += 1
# Fallback recovery, this is bad - save the image to another location.
if not success:
self.logger.error("Failed to report an image...")
self.save_image(stream=self.stream, dir=self.fallback_dir)
finally:
self.event.clear()
with self.lock:
self.logger.debug("Upload processor returned to the pool.")
self.pool.append(self)
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 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
class Credentials:
def __init__(self, app_token):
self.base = 'credentials'
self.api_client = ApiClient(app_token)
def widget(self):
return self.api_client.call_api('get', url=self.base)
def resource(self, resource_id):
url = self.base + '?search=resource_id:' + str(resource_id)
return self.api_client.call_api('get', url)
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 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 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 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)
class Availability:
def __init__(self, app_token):
self.base = 'findtime'
self.api_client = ApiClient(app_token)
def query(self, resource_ids, **kwargs):
"""
Required
Note: only resource_ids or calendar_ids are required
:param resource_ids: array, resource-uuids
:param: calendar_ids: array of strings, use this for only specific calendars
Optional:
:param length: string, how much time must each avaliable timeslot contain
:param filters: array (mixed types, see filters)
:param start: string, human written time eg, 1 day, tomorrow, 2 weeks
:param future: string, defines the end of the search-space
:param sort: string, chronologica order of results, accepted values: asc, desc
:param ignore_all_day_events: boolean, ignore all day events in this query?
:param all_solutions: boolean, return overlapping timeslots?
:param emails: array of strings, check emails for mutual availability
:param buffer: string, amount of time to add to each booking
:param no_day_span: boolean, if you dont want time-slots that span span days
"""
data = kwargs
if type(resource_ids) == str:
data['resource_ids'] = [resource_ids]
return self.api_client.call_api('post', self.base, data)
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 get_data(self):
result = []
response = ApiClient.fetch(self, self.url)
data = response.get("data", {})
children = data.get("children", {})
return [
child['data']['preview']['images'][0]['source']['url']
for child in children if 'preview' in child.get("data", {})
]
def results():
# retrieves user query inputs
park_name = request.args.get('park_name')
state = request.args.get('state')
designation = request.args.get('designation')
keyword = request.args.get('keyword')
# api client builds the query with specific parameters
parks = ApiClient.parks(park_name=park_name,
state=state,
designation=designation,
keyword=keyword)
return render_template("results.html", parks=parks)
class CoreV1Api(object):
def __init__(self):
self.api_client = ApiClient()
def list_pods(self, **kwargs):
namespace = kwargs.get('namespace')
url = 'api/v1/pods'
if namespace:
url = 'api/v1/namespaces/{}/pods'.format(namespace)
headers = {
'Content-type': 'application/json'
}
return self.api_client.api_call('GET', url, headers=headers)
def list_services(self, **kwargs):
namespace = kwargs.get('namespace')
url = 'api/v1/services'
if namespace:
url = 'api/v1/namespaces/{}/services'.format(namespace)
headers = {
'Content-type': 'application/json'
}
return self.api_client.api_call('GET', url, headers=headers)
def submit_deployment(self, **kwargs):
if ('data' not in kwargs) or (kwargs['data'] is None):
raise ValueError("Missing the required parameter `data` when calling `submit_deployment`")
data = kwargs.get('data')
namespace = kwargs.get('namespace', 'default')
url = 'apis/extensions/v1beta1/namespaces/{}/deployments'.format(namespace)
headers = {
'Content-type': 'application/yaml'
}
return self.api_client.api_call('POST', url, data=data, headers=headers)
class CoreV1Api(object):
def __init__(self):
self.api_client = ApiClient()
def list_pods(self, **kwargs):
namespace = kwargs.get('namespace')
url = 'api/v1/pods'
if namespace:
url = 'api/v1/namespaces/{}/pods'.format(namespace)
headers = {'Content-type': 'application/json'}
return self.api_client.api_call('GET', url, headers=headers)
def list_services(self, **kwargs):
namespace = kwargs.get('namespace')
url = 'api/v1/services'
if namespace:
url = 'api/v1/namespaces/{}/services'.format(namespace)
headers = {'Content-type': 'application/json'}
return self.api_client.api_call('GET', url, headers=headers)
def submit_deployment(self, **kwargs):
if ('data' not in kwargs) or (kwargs['data'] is None):
raise ValueError(
"Missing the required parameter `data` when calling `submit_deployment`"
)
data = kwargs.get('data')
namespace = kwargs.get('namespace', 'default')
url = 'apis/extensions/v1beta1/namespaces/{}/deployments'.format(
namespace)
headers = {'Content-type': 'application/yaml'}
return self.api_client.api_call('POST',
url,
data=data,
headers=headers)
class AppClient:
def __init__(self, app_token):
self.base = 'app'
self.api_client = ApiClient(app_token, self.base)
def get_current_app(self):
"""
returns the application object
"""
return self.api_client.call_api('get')
def invite_resources(self, email):
"""
required
:param email: string, email address to invite
returns: the new resource object
"""
url = self.base + '/invite'
data = {'email': email}
return self.api_client.call_api('post', url, data=data)
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 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 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]
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)
class Calendar:
def __init__(self, app_token):
self.base = 'calendars'
self.api_client = ApiClient(app_token, self.base)
def create(self, resource_id, name, description, **kwargs):
"""
required
:param resource_id: string, id of the resource to create the calendar for
:param name: string, name of calendar
:param description: string, description of the calendar
optional
:param backgroundcolor: string, hex color to use as background for events
:param foregroundcolor: string, hex color to use as forground for events
returns new calendar object
"""
data = kwargs
data['resource_id'] = resource_id
data['name'] = name
data['description'] = description
return self.api_client.call_api('post', data=data)
def list(self):
return self.api_client.call_api('get')
def retrieve(self, calendar_id):
"""
required
:param calendar_id: string, id of calendar
returns calendar object
"""
url = self.base + '/' + str(calendar_id)
return self.api_client.call_api('get', url)
def update(self, calendar_id, **kwargs):
"""
required
:param calendar_id: string, id of calendar
optional
:param name: string, name of the calendar
:param description: string, description of the calendar
:param foregroundcolor: string, hex color code of the forground
:param backgroundcolor: string, hex color code of the background
:param provider_sync: boolean, enable or disable syncing
:param primary: boolean, set the calendar as primary
return boolean
"""
url = self.base + '/' + str(calendar_id)
data = kwargs
return self.api_client.call_api('put', url, data)
def delete(self, calendar_id):
"""
required
:param calendar_id: string, calendar id to delete
returns boolean
"""
url = self.base + '/' + str(calendar_id)
return self.api_client.call_api('delete', url)
def create(cls, base, username, password):
"""Factory method using default ApiClient class."""
client = ApiClient(base, username, password)
return cls(client)
def create(cls, base, username, password):
client = ApiClient(base, username, password)
return cls(client)
def main():
"""
Let's setup logging.
Note: The 'logging.json->loggers' configuration corresponds to each item returned by 'logging.getLogger'
we'll just setup root to handle everything but we could target specific modules if we wanted to by simply
defining a logger targeting a specific module name.
"""
try:
# attempt to load from the config file
logger_config = Configuration('logging.json')
logging.config.dictConfig(logger_config.get())
logging.info("\n\n+ ================================ +\n+ Logging initialised. \n+ ================================ +\n")
except Exception as e:
print("Error with logging:", type(e), e)
quit()
config = Configuration('motion.json')
force_capture = config.get('force_capture')
force_capture_time = config.get('force_capture_time')
url = config.get('home_url')
username = config.get('username')
token = config.get('token')
device_id = None
api = ApiClient(username, token, url)
try:
id_config = Configuration('id.json', catch_errors=False)
device_id = id_config.get('id')
if not device_id or not api.confirm_device_id(device_id):
logging.error("Device ID not registered.")
raise Exception("Device ID not registered.")
except Exception as e:
logging.debug(type(e), e)
device_name = config.get('device_name')
logging.info("Provisioning new device: %s." % device_name)
device_id = api.register_device(device_name)
id_config.set('id', device_id)
id_config.save()
logging.info("Registered new device: %s" % device_id)
pool_lock = threading.Lock()
pool = []
m = None
logging.info("Queuing upload processors.")
# TODO: Upload processors consume memory, actively monitor memory and set an upper limit of how many processors can be running...
# TODO: What if the server goes down? Network storage?
for i in range(config.get('upload_processor_count', 15)):
logging.debug("Adding upload processor %i." % i)
pool.append(UploadProcessor(pool_lock, pool))
logging.info("Starting motion detection loop.")
fallback_dir = os.path.join(config.get('fallback_dir', '/home/pi/default_fallback_dir'), device_id)
fallback_space_to_reserve = config.get('fallback_space_to_reserve', 16)
try:
m = Motion()
running = True
time_now = time.time()
while running:
# If motion was detected, or we've manually scheduled an image to be uploaded.
if m.detect_motion() or m.get_capture_queue_length() > 0:
with pool_lock:
if pool:
processor = pool.pop()
else:
processor = None
if processor:
logging.debug("Acquired an upload processor.")
# load the processor with an image and required backend auth details.
processor.stream = m.pop_capture_stream_queue()
processor.username = username
processor.token = token
processor.url = url
processor.device_id = device_id
processor.fallback_dir = fallback_dir
# tell the processor to start working.
processor.event.set()
else:
logging.info("Upload processor pool exhausted. Waiting for more uploaders...")
# Do we want to capture images every N seconds?
if (force_capture):
# If timeout, let's capture an image to be processed.
if ((time.time() - time_now) > force_capture_time):
# Reset the clock
time_now = time.time()
logging.info("Timeout reached. Capturing an image.")
m.capture_to_stream_queue()
# Maintain fallback directory - don't use up more space than allocated
keep_disk_space_free(dir=fallback_dir, fallback_space_to_reserve=fallback_space_to_reserve)
except Exception as e:
# TODO: Keep a proper log of errors and causes. We'll be logging this to the server and recovering the device by restarting it after a given timeout.
logging.critical(type(e), e)
finally:
if m:
m.close()
logging.info("Terminating upload processors.")
while pool:
processor = pool.pop()
processor.terminated = True
processor.join()
logging.debug("Upload processor terminated.")
logging.info("Program ended.")
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
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]])
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}')
class Resource:
def __init__(self, app_token):
self.base = "resources"
self.api_client = ApiClient(app_token)
def list(self):
"""
returns an object of resources
"""
return self.api_client.call_api('get', self.base)
def create(self,
name,
timezone=None,
email=None,
first_name=None,
last_name=None,
password=None,
tags=[]):
"""
required
:param name: string, name of the resource
:param timezone: timezone of the resource
defaults to machine local
optional
:param email: string
:param first_name: string
:param last_name: string
:param password: string, if not set, a random password will be assigned
"""
if not timezone:
timezone = get_localzone()
data = {'name': name, 'timezone': str(timezone)}
if email:
data['email'] = email
if first_name:
data['first_name'] = first_name
if last_name:
data['last_name'] = last_name
if password:
data['password'] = password
return self.api_client.call_api('post', self.base, data)
def retrieve(self, resource_id):
"""
:param resource_id: id of resource
returns the resource object
"""
url = self.base + '/' + str(resource_id)
return self.api_client.call_api('get', url)
def update(self, resource_id, **kwargs):
"""
required
:param resource_id: id of the resource
optional
:param name: string
:param first_name: string
:param last_name: string
:param password: string, if not set, a random password will be assigned
:param timezone: timezone of the resource defaults to machine local
"""
url = self.base + '/' + str(resource_id)
data = kwargs
data['id'] = str(resource_id)
if len(data) <= 1:
return False
return self.api_client.call_api('put', url, kwargs)
def delete(self, id):
url = self.base + '/' + str(id)
return self.api_client.call_api('delete', url)
def __init__(self):
self.api_client = ApiClient()
def __init__(self, app_token):
self.base = "resources"
self.api_client = ApiClient(app_token)
