def __paged_results(self, url):
r = requests.get(url)
repos = r.json()
results = repos['results']
while repos['next']:
r = requests.get(repos['next'])
repos = r.json()
results += repos['results']
return results
def verifyFacebookToken(token):
APP_SECRET = 'fdd185af07273c8269555b67295db4c7'
APP_ID = '2749120435101395'
appLink = 'https://graph.facebook.com/oauth/access_token?client_id={}&client_secret={}&grant_type=client_credentials'.format(
APP_ID, APP_SECRET)
appToken = requests.get(appLink).json()['access_token']
link = 'https://graph.facebook.com/debug_token?input_token={}&access_token={}'.format(
token, appToken)
try:
userId = requests.get(link).json()['data']['user_id']
except (ValueError, KeyError, TypeError) as error:
return error
return userId
def verifyFacebookToken(token):
APP_SECRET = os.environ.get('APP_SECRET')
APP_ID = os.environ.get('APP_ID')
appLink = 'https://graph.facebook.com/oauth/access_token?client_id={}&client_secret={}&grant_type=client_credentials'.format(
APP_ID, APP_SECRET)
appToken = requests.get(appLink).json()['access_token']
link = 'https://graph.facebook.com/debug_token?input_token={}&access_token={}'.format(
token, appToken)
try:
userId = requests.get(link).json()['data']['user_id']
except (ValueError, KeyError, TypeError) as error:
return Response({"error": error})
return userId
def events():
global client
global active_scouts
req = request.get_json()
# Create scouts instance
nightscouts = scouts()
print(req)
if "status" in req:
if req["status"] == "completed":
phone = req["to"]
# The next line is not recomended its functional but use the global active_scouts variable
# This variable is updated by the daemon process.. that run in another context
# Not the flask context, for that reason we are going to use firebase to get
# fresh data
# uscout = [active_scout for active_scout in active_scouts if active_scout['phone'] == phone]
uscout = nightscouts.getby_personal_phone(phone)
if uscout != None:
entries = requests.get(uscout["nightscout_api"]).json()
glucose = entries[0]['sgv']
sms_glucose_alert(
uscout["emerg_contact"], uscout["username"], glucose)
# print('sms simulation to: {0} {1} {2}'.format(uscout["emerg_contact"], uscout["username"], glucose))
for phone in uscout["extra_contacts"]:
# print('sms simulation to: {0} {1} {2}'.format(phone, uscout["username"], glucose))
sms_glucose_alert(phone, uscout["username"], glucose)
return "Event Received"
def send_request(master_host, namespace, target, rpc, params):
"""Issue a request to the Kubernetes master.
Args:
master_host: The IP address of the master e.g. https://35.188.37.10
namespace: The namespace
target: The K8s service corresponding to the pod.
rpc: Which rpc to call.
params: What parameters to send in the request.
"""
cluster_name = os.getenv("CLUSTER_NAME")
res = subprocess.check_output(["aws", "eks", "get-token", "--cluster-name", cluster_name])
res = json.loads(res)
token = res["status"]["token"]
headers = {
"Authorization": "Bearer " + token.strip(),
}
url = ("{master}/api/v1/namespaces/{namespace}/services/{service}:2222"
"/proxy/{rpc}").format(
master=master_host, namespace=namespace, service=target, rpc=rpc)
r = requests.get(url, headers=headers, params=params, verify=False)
if r.status_code == requests.codes.NOT_FOUND:
logging.info("Request to %s returned 404", url)
return ""
if r.status_code != requests.codes.OK:
msg = "Request to {0} exited with status code: {1}".format(
url, r.status_code)
logging.error(msg)
raise RuntimeError(msg)
logging.info("URL %s returned; %s", url, r.content)
return r.content
def versions(self):
if not self.__versions:
repo_split = self.repository.split('/')
# TODO: Use .match instead
m = re.search('(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$)',
repo_split[0])
if m:
if repo_split[0].endswith('gcr.io'):
logging.debug('Adding gcr docker repository...')
self.__versions += [
DockerRepositoryGcr(name=repo_split[0],
namespace=repo_split[1],
gcr_key_file=self.gcr_key_file)]
else:
v1_response = requests.get('https://%s/v1' % self.repository)
if v1_response.ok:
logging.debug('Adding v1 docker repository...')
self.__versions += [DockerRepositoryV1(name=repo_split[0], namespace=repo_split[1])]
# v2_response = requests.get('https://%s/v2' % self.repository)
# if v2_response.ok:
# if v2_response.status_code == 401:
else:
logging.debug('Adding docker store repository...')
self.__versions += [DockerStore(namespace=repo_split[0])]
logging.debug('Docker factory returns: %s' % self.__versions)
return self.__versions
def paginate(url, headers, min_count=30, start_page=1, params=None, limit=None):
'''paginate will send posts to a url with post_url
until the results count is not exceeded
Parameters
==========
min_count: the results count to go to
start_page: the starting page
'''
if params is None:
params = dict()
result = []
result_count = 1000
page = start_page
while result_count >= 30:
# If the user set a limit, honor it
if limit is not None:
if len(result) >= limit:
return result
params['page'] = page
paginated_url = format_params(url, params)
new_result = requests.get(paginated_url, headers=headers).json()
result_count = len(new_result)
# If the user triggers bad credentials, empty repository, stop
if isinstance(new_result, dict):
return result
result = result + new_result
page += 1
return result
def tags(self, image_name, token=None):
if not token:
token = self.token()
result = requests.get(
'https://%s/v2/%s/%s/tags/list' % (self.name, self.namespace, image_name),
headers={'Authorization': 'Bearer %s' % token}).json()
return natsorted(result['tags'], reverse=True)
def get_client_id(project_id, location, composer_environment):
# [START composer_get_environment_client_id]
import google.auth
import google.auth.transport.requests
import requests
import six.moves.urllib.parse
# Authenticate with Google Cloud.
# See: https://cloud.google.com/docs/authentication/getting-started
credentials, _ = google.auth.default(
scopes=['https://www.googleapis.com/auth/cloud-platform'])
authed_session = google.auth.transport.requests.AuthorizedSession(
credentials)
# project_id = 'YOUR_PROJECT_ID'
# location = 'us-central1'
# composer_environment = 'YOUR_COMPOSER_ENVIRONMENT_NAME'
environment_url = (
'https://composer.googleapis.com/v1beta1/projects/{}/locations/{}'
'/environments/{}').format(project_id, location, composer_environment)
composer_response = authed_session.request('GET', environment_url)
environment_data = composer_response.json()
airflow_uri = environment_data['config']['airflowUri']
# The Composer environment response does not include the IAP client ID.
# Make a second, unauthenticated HTTP request to the web server to get the
# redirect URI.
redirect_response = requests.get(airflow_uri, allow_redirects=False)
redirect_location = redirect_response.headers['location']
# Extract the client_id query parameter from the redirect.
parsed = six.moves.urllib.parse.urlparse(redirect_location)
query_string = six.moves.urllib.parse.parse_qs(parsed.query)
print(query_string['client_id'][0])
def oauthroute():
token = oauth.fetch_token('https://accounts.google.com/o/oauth2/token',
authorization_response=request.url,
client_secret=client_secret)
req = google.auth.transport.requests.Request()
id_info = id_token.verify_oauth2_token(token['id_token'], req, client_id)
headers = {'Authorization': 'Bearer ' + token["access_token"]}
r = requests.get(
'https://content-people.googleapis.com/v1/people/me?personFields=names',
headers=headers)
person = r.json()
query = client.query(kind=constants.volunteers)
query.add_filter("email", "=", id_info['email'])
results = list(query.fetch())
if len(results) == 0:
new_user = datastore.Entity(key=client.key(constants.volunteers))
client.put(new_user)
new_user.update({
"first_name":
person['names'][0]['givenName'].split(' ')[0],
"last_name":
person['names'][0]['familyName'],
"email":
id_info["email"],
"board_member":
False,
"hours":
0
})
client.put(new_user)
return "Your JWT is: %s" % token['id_token'], 201
def get_client_id(project_id, location, composer_environment):
# [START composer_get_environment_client_id]
import google.auth
import google.auth.transport.requests
import requests
import urllib.parse
# Authenticate with Google Cloud.
# See: https://cloud.google.com/docs/authentication/getting-started
credentials, _ = google.auth.default(
scopes=['https://www.googleapis.com/auth/cloud-platform'])
authed_session = google.auth.transport.requests.AuthorizedSession(
credentials)
# project_id = 'YOUR_PROJECT_ID'
# location = 'us-central1'
# composer_environment = 'YOUR_COMPOSER_ENVIRONMENT_NAME'
environment_url = (
'https://composer.googleapis.com/v1beta1/projects/{}/locations/{}'
'/environments/{}').format(project_id, location, composer_environment)
composer_response = authed_session.request('GET', environment_url)
environment_data = composer_response.json()
airflow_uri = environment_data['config']['airflowUri']
# The Composer environment response does not include the IAP client ID.
# Make a second, unauthenticated HTTP request to the web server to get the
# redirect URI.
redirect_response = requests.get(airflow_uri, allow_redirects=False)
redirect_location = redirect_response.headers['location']
# Extract the client_id query parameter from the redirect.
parsed = urllib.parse.urlparse(redirect_location)
query_string = urllib.parse.parse_qs(parsed.query)
print(query_string['client_id'][0])
def callback():
# Get authorization code Google sent back to you
code = request.args.get("code")
# Find out what URL to hit to get tokens that allow you to ask for
# things on behalf of a user
google_provider_cfg = get_google_provider_cfg()
token_endpoint = google_provider_cfg["token_endpoint"]
# Prepare and send request to get tokens! Yay tokens!
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code,
)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)
# Parse the tokens!
client.parse_request_body_response(json.dumps(token_response.json()))
# Now that we have tokens (yay) let's find and hit URL
# from Google that gives you user's profile information,
# including their Google Profile Image and Email
userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)
# We want to make sure their email is verified.
# The user authenticated with Google, authorized our
# app, and now we've verified their email through Google!
if userinfo_response.json().get("email_verified"):
unique_id = userinfo_response.json()["sub"]
users_email = userinfo_response.json()["email"]
else:
return "User email not available or not verified by Google.", 400
# Create a user in our db with the information provided
# by Google
# Create a user in our db with the information provided
# by Google
user = User(id_=users_email)
# Doesn't exist? Add to database of suspicious people
if not User.get(users_email):
User.suspicious(users_email)
print("User doesn't exist")
# Begin user session by logging the user in
login_user(user)
# Send user back to homepage
return redirect(url_for("index"))
def get_YT_title(yt_ID):
html = requests.get(f"http://www.youtube.com/watch?v={yt_ID}").text
soup = BeautifulSoup(html, "lxml") #enter your youtube url here
try:
video_title = soup.find('title').text
return video_title.replace(' - YouTube', '')
except:
return "error"
def POST(url, headers, data=None, params=None):
'''post_url will use the requests library to post to a url
'''
if data is not None:
return requests.post(url,
headers=headers,
data=json.dumps(data))
return requests.get(url, headers=headers)
def list(self):
r = requests.get('https://%s/v1/search?q=%s' % (self.name, self.namespace))
search = r.json()
search_results = search['results']
while search['num_pages'] != search['page']:
search = requests.get('https://%s/v1/search?q=%s&page=%d'
% (self.name, self.namespace, search['page'] + 1)).json()
search_results += search['results']
return [
DockerRepositoryRecord(
repository=None if self.name == DockerRepositoryV1.DEFAULT_VALUE else self.name,
namespace=self.namespace,
name=search_hit['name'].split('/')[1],
tags=self.tags(search_hit['name'].split('/')[1]))
for search_hit in search_results
if search_hit['name'].startswith('%s/' % self.name.rstrip('/'))
]
def acquire_token(audience: str = AUDIENCE_URL) -> str:
# Construct a URL with the audience and format.
url = METADATA_VM_IDENTITY_URL.format(audience, FORMAT, LICENSES)
# Request a token from the metadata server.
r = requests.get(url, headers=METADATA_HEADERS)
# Extract and return the token from the response.
r.raise_for_status()
return r.text
def job(id):
# Calling nemo global client variable
global client
global active_scouts
global nightscout_failed_pings
global nightscout_failed_update_wait_mark
global start_scouts
print("Alerts Job " + id + "")
if active_scouts != None:
if start_scouts == False:
refresh_scouts('Starting_Scouts')
for active_scout in active_scouts:
print(active_scout["nightscout_api"])
try:
entries = requests.get(active_scout["nightscout_api"]).json()
glucose = entries[0]['sgv']
# No failed connection, so initialise the failed pings to zero for the active user
nightscout_failed_pings[active_scout["phone"]] = 0
# Check if the last NIGHTSCOUT entry doesn't exceed the NIGHTSCOUT NOT_UPDATE SECONDS limit.
# In other words, this code verifies if nightscout entries get updates
current_isoformat_datetime = datetime.utcnow().isoformat()
nightscout_datetime = entries[0]['dateString']
# Little trick to make UTC isodate from nodejs moment library compatible with python isoformat
nightscout_isoformat_datetime = nightscout_datetime.replace(
"Z", "+00:00")
# Difference in seconds between current time and last nightscout entry
time_difference = calendar.timegm(datetime.fromisoformat(current_isoformat_datetime).utctimetuple(
)) - calendar.timegm(datetime.fromisoformat(nightscout_isoformat_datetime).utctimetuple())
print(time_difference, " ", os.getenv(
"NIGHTSCOUT_NOT_UPDATE_SECONDS"))
if time_difference > int(os.getenv("NIGHTSCOUT_NOT_UPDATE_SECONDS")):
raise Exception("entry_update")
else:
nightscout_failed_update_wait_mark[active_scout["phone"]] = 0
# We add a dynamic attribute called glucose to pass glucose info to events url
if 70 <= glucose <= 240:
print("{0} is inside the range for {1}".format(
glucose, active_scout["username"]))
else:
print("Executing emergency call and loading sms NCCO if needed")
call_glucose_alert(active_scout["phone"], glucose)
except KeyError:
print("Key error")
except Exception as instance:
if instance.args[0] == 'entry_update':
handle_nightscout_failed_update(
active_scout["phone"], active_scout["nightscout_api"], active_scout["username"])
print(
"No updated entries for user, executing the failed update handler for user " + active_scout["username"])
else:
handle_nightscout_failed_pings(
active_scout["phone"], active_scout["nightscout_api"], active_scout["username"])
print("Server could not establish connection with " +
active_scout["nightscout_api"])
def list(self):
token = self.token()
response = requests.get('https://%s/v2/%s/tags/list' % (self.name, self.namespace),
headers={'Authorization': 'Bearer %s' % token})
return [
DockerRepositoryRecord(repository=self.name,
namespace=self.namespace,
name=child,
tags=self.tags(child, token))
for child in response.json()['child']
]
def complete_login(self, request, app, token, **kwargs):
resp = requests.get(self.profile_url,
params={
"access_token": token.token,
"alt": "json"
},
timeout=5)
resp.raise_for_status()
extra_data = resp.json()
login = self.get_provider().sociallogin_from_response(
request, extra_data)
return login
def send_signed_request():
"""Send a request to an App Engine service, with signed identity token.
This uses the metadata service to get a signed identity token for the
default service account, with the target audience ("aud"). The token is
added to a new request, and we show the response from the target service.
"""
target_url = get_target_url()
token = get_identity_token(audience=target_url)
response = requests.get(target_url,
headers={'Authorization': 'Bearer ' + token})
response.raise_for_status()
return response.json()
def get_client_id(project_id, location, composer_environment):
# [START composer_get_environment_client_id]
# This script is intended to be used with Composer 1 environments
# In Composer 2, the Airflow Webserver is not in the tenant project
# so there is no tenant client ID
# See https://cloud.google.com/composer/docs/composer-2/environment-architecture
# for more details
import google.auth
import google.auth.transport.requests
import requests
import six.moves.urllib.parse
# Authenticate with Google Cloud.
# See: https://cloud.google.com/docs/authentication/getting-started
credentials, _ = google.auth.default(
scopes=["https://www.googleapis.com/auth/cloud-platform"])
authed_session = google.auth.transport.requests.AuthorizedSession(
credentials)
# project_id = 'YOUR_PROJECT_ID'
# location = 'us-central1'
# composer_environment = 'YOUR_COMPOSER_ENVIRONMENT_NAME'
environment_url = (
"https://composer.googleapis.com/v1beta1/projects/{}/locations/{}"
"/environments/{}").format(project_id, location, composer_environment)
composer_response = authed_session.request("GET", environment_url)
environment_data = composer_response.json()
composer_version = environment_data["config"]["softwareConfig"][
"imageVersion"]
if "composer-1" not in composer_version:
version_error = (
"This script is intended to be used with Composer 1 environments. "
"In Composer 2, the Airflow Webserver is not in the tenant project, "
"so there is no tenant client ID. "
"See https://cloud.google.com/composer/docs/composer-2/environment-architecture for more details."
)
raise (RuntimeError(version_error))
airflow_uri = environment_data["config"]["airflowUri"]
# The Composer environment response does not include the IAP client ID.
# Make a second, unauthenticated HTTP request to the web server to get the
# redirect URI.
redirect_response = requests.get(airflow_uri, allow_redirects=False)
redirect_location = redirect_response.headers["location"]
# Extract the client_id query parameter from the redirect.
parsed = six.moves.urllib.parse.urlparse(redirect_location)
query_string = six.moves.urllib.parse.parse_qs(parsed.query)
print(query_string["client_id"][0])
def fetch_manifest():
mani_ref = db.collection('environment').document('manifest')
mani_doc = mani_ref.get()
if mani_doc.exists and dt.datetime.now(
dt.timezone.utc) - mani_doc.update_time < dt.timedelta(hours=24):
manifest = mani_doc.to_dict()
else:
print('from source')
url = 'https://store.opencravat.org/manifest.yml'
data = requests.get(url)
out = data.content
manifest = yaml.load(out, Loader=yaml.FullLoader)
mani_ref.set(manifest)
return manifest
def get_client_id(airflow_uri) -> str:
# The Composer environment response does not include the IAP client ID.
# Make a second, unauthenticated HTTP request to the web server to get the
# redirect URI.
redirect_response = requests.get(airflow_uri, allow_redirects=False)
redirect_location = redirect_response.headers['location']
# Extract the client_id query parameter from the redirect.
parsed = six.moves.urllib.parse.urlparse(redirect_location)
query_string = six.moves.urllib.parse.parse_qs(parsed.query)
client_id = query_string['client_id'][0]
print("client_id is: ")
print(client_id)
return client_id
def callback():
# Get authorization code Google sent back to you
code = request.args.get("code")
google_provider_cfg = get_google_provider_cfg()
token_endpoint = google_provider_cfg["token_endpoint"]
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)
client.parse_request_body_response(json.dumps(token_response.json()))
userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)
if userinfo_response.json().get("email_verified"):
google_uid = userinfo_response.json()["sub"]
users_email = userinfo_response.json()["email"]
users_name = userinfo_response.json()["given_name"]
else:
return "User email not available or not verified by Google.", 400
user = User(google_id=google_uid, first_name=users_name, email=users_email)
# If user does not exist in db, create and add them to it
if not db.session.query(
exists().where(User.google_id == google_uid)).scalar():
db.session.add(user)
db.session.commit()
else:
user = db.session.query(User).filter_by(google_id=google_uid).first()
# Begin user session by logging the user in
login_user(user)
# Send user back to homepage
return redirect(url_for("home"))
def get(url):
"""
Makes a REST GET call to the given url and returns response
"""
params = {'key': 'AIzaSyCIkzCe8fd_8roPjePi_t_kKVBX-aOCwYM'}
bearer = get_auth_token()
headers = {
'content-type': 'application/json',
'Accept-Charset': 'UTF-8',
'Authorization': 'Bearer ' + bearer
}
# print(url, headers)
response = requests.get(url, headers=headers, params=params)
response.raise_for_status()
return json.loads(response.content)
def markdown():
mname = request.args.get('module')
version = request.args.get('version')
mdoc_ref = db.collection('environment').document('manifest').collection(
'module-doc').document(mname)
mdoc = mdoc_ref.get()
md_text = None
if mdoc.exists and dt.datetime.now(
dt.timezone.utc) - mdoc.update_time < dt.timedelta(hours=24):
md_text = mdoc.to_dict().get('data')
if md_text is None:
url = f'https://store.opencravat.org/modules/{mname}/{version}/{mname}.md'
r = requests.get(url)
r.raise_for_status()
md_text = r.text
mdoc_ref.set({'data': md_text})
return md_text
def make_get_request_to_ai_platform(
uri: str,
credentials: Optional[google.auth.credentials.Credentials] = None,
timeout_ms: int = constants.DEFAULT_TIMEOUT):
"""Makes a get request to AI Platform.
Args:
uri: URI of the model resource.
credentials: The OAuth2.0 credentials to use for GCP services.
timeout_ms: Timeout for each service call to the api (in milliseconds).
Returns:
Request results in json format.
"""
headers = _get_request_header(credentials)
r = requests.get(uri, headers=headers, timeout=timeout_ms)
return _handle_ai_platform_response(uri, r)
def get_client_id() -> str:
"""
Alternatively:
`curl -v <airflow-url>`, e.g. https://bc5c0e43e23571a62-tp.appspot.com/`
And the client_id will be printed in the URL
after "https://accounts.google.com/o/oauth2/v2/auth?client_id="
"""
airflow_uri = get_airflow_uri()
# The Composer environment response does not include the IAP client ID.
# Make a second, unauthenticated HTTP request to the web server to get the redirect URI.
redirect_response = requests.get(airflow_uri, allow_redirects=False)
redirect_location = redirect_response.headers['location']
# Extract the client_id query parameter from the redirect.
parsed = six.moves.urllib.parse.urlparse(redirect_location)
query_string = six.moves.urllib.parse.parse_qs(parsed.query)
return query_string['client_id'][0]
def get(self, attachment_url):
"""
Get an attachment
:param attachment_url: Attachment URL
:type attachment_url: str
:return: File content-type, File name, File content
:rtype: (str, str, str)
"""
# Check if attachment URL is valid URL
if not is_valid_url(attachment_url):
logging.info(
f"Attachment '{attachment_url}' cannot be downloaded, not a valid url"
)
return None, None, None
# Parse url into file name and type
file_name = unquote_plus(urlparse(attachment_url).path).split("/")[-1]
file_type = mimetypes.guess_type(file_name)[0]
# Refresh authentication token
self.credentials.refresh(self.auth_req)
request_headers = {"Authorization": f"Bearer {self.credentials.token}"}
# Get bucket
try:
response = requests.get(attachment_url, headers=request_headers)
response.raise_for_status()
except requests.exceptions.RequestException as e:
logging.error(
f"Attachment '{attachment_url}' cannot be downloaded, skipping upload: {str(e)}"
)
return None, None, None
else:
logging.debug(f"Successfully downloaded attachment '{attachment_url}'")
return file_type, file_name, response.content
def authenticate(self, username=None, password=None):
print('Facebook ! ')
url = 'https://graph.facebook.com/v2.11/me?fields=id,name,email,birthday'
access_token = 'Bearer ' + username
response = requests.get(url, headers={
'Authorization': access_token
}).json()
if 'id' in response:
try:
user = User.objects.get(email=response['email'])
except User.DoesNotExist:
user = User.objects.create(
username=response['email'],
email=response['email'],
name=response['name'],
birth_date=datetime.datetime.strptime(
response['birthday'], "%m/%d/%Y").strftime("%Y-%m-%d"),
password=get_random_string(length=32))
return user
else:
return None
def search_cars(filter, param):
print('SEARCH CARS\n' + 'FILTER: ' + filter + ', PARAM: ' + param)
try:
response = requests.get(
'http://localhost:5000/api/cars?{}={}'.format(filter, param))
data = json.loads(response.text)
cars = data['cars']
except:
print("Problem communicating with server")
cars = []
print('%-2s | %-10s | %-10s | %-8s | %s | %s | %s' %
("ID", "Make", "Body Type", "Colour", "No. Seats", "Cost/Hour",
"Location"))
print(
'---+------------+------------+----------+-----------+-----------+----------------------'
)
for car in cars:
print('%-2d | %-10s | %-10s | %-8s | %-9d | $%-8d | %s' %
(car['id'], car['make'], car['body_type'], car['colour'],
car['no_seats'], car['cost_per_hour'], car['location']))