sentence1
stringlengths 52
3.87M
| sentence2
stringlengths 1
47.2k
| label
stringclasses 1
value |
|---|---|---|
def saveDirectory(alias):
"""save a directory to a certain alias/nickname"""
if not settings.platformCompatible():
return False
dataFile = open(settings.getDataFile(), "wb")
currentDirectory = os.path.abspath(".")
directory = {alias : currentDirectory}
pickle.dump(directory, dataFile)
speech.success(alias + " will now link to " + currentDirectory + ".")
speech.success("Tip: use 'hallie go to " + alias + "' to change to this directory.") | save a directory to a certain alias/nickname | entailment |
def goToDirectory(alias):
"""go to a saved directory"""
if not settings.platformCompatible():
return False
data = pickle.load(open(settings.getDataFile(), "rb"))
try:
data[alias]
except KeyError:
speech.fail("Sorry, it doesn't look like you have saved " + alias + " yet.")
speech.fail("Go to the directory you'd like to save and type 'hallie save as " + alias + "\'")
return
try:
(output, error) = subprocess.Popen(["osascript", "-e", CHANGE_DIR % (data[alias])], stdout=subprocess.PIPE).communicate()
except:
speech.fail("Something seems to have gone wrong. Please report this error to [email protected].")
return
speech.success("Successfully navigating to " + data[alias]) | go to a saved directory | entailment |
def list(self, filters=None):
"""List model instances.
Currently this gets *everything* and iterates through all
possible pages in the API. This may be unsuitable for production
environments with huge databases, so finer grained page support
should likely be added at some point.
Args:
filters (dict, optional): API query filters to apply to the
request. For example:
.. code-block:: python
{'name__startswith': 'azure',
'user__in': [1, 2, 3, 4],}
See saltant's API reference at
https://saltant-org.github.io/saltant/ for each model's
available filters.
Returns:
list:
A list of :class:`saltant.models.resource.Model`
subclass instances (for example, container task type
model instances).
"""
# Add in the page and page_size parameters to the filter, such
# that our request gets *all* objects in the list. However,
# don't do this if the user has explicitly included these
# parameters in the filter.
if not filters:
filters = {}
if "page" not in filters:
filters["page"] = 1
if "page_size" not in filters:
# The below "magic number" is 2^63 - 1, which is the largest
# number you can hold in a 64 bit integer. The main point
# here is that we want to get everything in one page (unless
# otherwise specified, of course).
filters["page_size"] = 9223372036854775807
# Form the request URL - first add in the query filters
query_filter_sub_url = ""
for idx, filter_param in enumerate(filters):
# Prepend '?' or '&'
if idx == 0:
query_filter_sub_url += "?"
else:
query_filter_sub_url += "&"
# Add in the query filter
query_filter_sub_url += "{param}={val}".format(
param=filter_param, val=filters[filter_param]
)
# Stitch together all sub-urls
request_url = (
self._client.base_api_url + self.list_url + query_filter_sub_url
)
# Make the request
response = self._client.session.get(request_url)
# Validate that the request was successful
self.validate_request_success(
response_text=response.text,
request_url=request_url,
status_code=response.status_code,
expected_status_code=HTTP_200_OK,
)
# Return a list of model instances
return self.response_data_to_model_instances_list(response.json()) | List model instances.
Currently this gets *everything* and iterates through all
possible pages in the API. This may be unsuitable for production
environments with huge databases, so finer grained page support
should likely be added at some point.
Args:
filters (dict, optional): API query filters to apply to the
request. For example:
.. code-block:: python
{'name__startswith': 'azure',
'user__in': [1, 2, 3, 4],}
See saltant's API reference at
https://saltant-org.github.io/saltant/ for each model's
available filters.
Returns:
list:
A list of :class:`saltant.models.resource.Model`
subclass instances (for example, container task type
model instances). | entailment |
def get(self, id):
"""Get the model instance with a given id.
Args:
id (int or str): The primary identifier (e.g., pk or UUID)
for the task instance to get.
Returns:
:class:`saltant.models.resource.Model`:
A :class:`saltant.models.resource.Model` subclass
instance representing the resource requested.
"""
# Get the object
request_url = self._client.base_api_url + self.detail_url.format(id=id)
response = self._client.session.get(request_url)
# Validate that the request was successful
self.validate_request_success(
response_text=response.text,
request_url=request_url,
status_code=response.status_code,
expected_status_code=HTTP_200_OK,
)
# Return a model instance
return self.response_data_to_model_instance(response.json()) | Get the model instance with a given id.
Args:
id (int or str): The primary identifier (e.g., pk or UUID)
for the task instance to get.
Returns:
:class:`saltant.models.resource.Model`:
A :class:`saltant.models.resource.Model` subclass
instance representing the resource requested. | entailment |
def validate_request_success(
response_text, request_url, status_code, expected_status_code
):
"""Validates that a request was successful.
Args:
response_text (str): The response body of the request.
request_url (str): The URL the request was made at.
status_code (int): The status code of the response.
expected_status_code (int): The expected status code of the
response.
Raises:
:class:`saltant.exceptions.BadHttpRequestError`: The HTTP
request failed.
"""
try:
assert status_code == expected_status_code
except AssertionError:
msg = (
"Request to {url} failed with status {status_code}:\n"
"The reponse from the request was as follows:\n\n"
"{content}"
).format(
url=request_url, status_code=status_code, content=response_text
)
raise BadHttpRequestError(msg) | Validates that a request was successful.
Args:
response_text (str): The response body of the request.
request_url (str): The URL the request was made at.
status_code (int): The status code of the response.
expected_status_code (int): The expected status code of the
response.
Raises:
:class:`saltant.exceptions.BadHttpRequestError`: The HTTP
request failed. | entailment |
def sync(self):
"""Sync this model with latest data on the saltant server.
Note that in addition to returning the updated object, it also
updates the existing object.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
This task instance ... instance after syncing.
"""
self = self.manager.get(uuid=self.uuid)
return self | Sync this model with latest data on the saltant server.
Note that in addition to returning the updated object, it also
updates the existing object.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
This task instance ... instance after syncing. | entailment |
def wait_until_finished(
self, refresh_period=DEFAULT_TASK_INSTANCE_WAIT_REFRESH_PERIOD
):
"""Wait until a task instance with the given UUID is finished.
Args:
refresh_period (int, optional): How many seconds to wait
before checking the task's status. Defaults to 5
seconds.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
This task instance model after it finished.
"""
return self.manager.wait_until_finished(
uuid=self.uuid, refresh_period=refresh_period
) | Wait until a task instance with the given UUID is finished.
Args:
refresh_period (int, optional): How many seconds to wait
before checking the task's status. Defaults to 5
seconds.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
This task instance model after it finished. | entailment |
def create(self, task_type_id, task_queue_id, arguments=None, name=""):
"""Create a task instance.
Args:
task_type_id (int): The ID of the task type to base the task
instance on.
task_queue_id (int): The ID of the task queue to run the job
on.
arguments (dict, optional): The arguments to give the task
type.
name (str, optional): A non-unique name to give the task
instance.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance just created.
"""
# Make arguments an empty dictionary if None
if arguments is None:
arguments = {}
# Create the object
request_url = self._client.base_api_url + self.list_url
data_to_post = {
"name": name,
"arguments": json.dumps(arguments),
"task_type": task_type_id,
"task_queue": task_queue_id,
}
response = self._client.session.post(request_url, data=data_to_post)
# Validate that the request was successful
self.validate_request_success(
response_text=response.text,
request_url=request_url,
status_code=response.status_code,
expected_status_code=HTTP_201_CREATED,
)
# Return a model instance representing the task instance
return self.response_data_to_model_instance(response.json()) | Create a task instance.
Args:
task_type_id (int): The ID of the task type to base the task
instance on.
task_queue_id (int): The ID of the task queue to run the job
on.
arguments (dict, optional): The arguments to give the task
type.
name (str, optional): A non-unique name to give the task
instance.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance just created. | entailment |
def clone(self, uuid):
"""Clone the task instance with given UUID.
Args:
uuid (str): The UUID of the task instance to clone.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance created due to the clone.
"""
# Clone the object
request_url = self._client.base_api_url + self.clone_url.format(
id=uuid
)
response = self._client.session.post(request_url)
# Validate that the request was successful
self.validate_request_success(
response_text=response.text,
request_url=request_url,
status_code=response.status_code,
expected_status_code=HTTP_201_CREATED,
)
# Return a model instance
return self.response_data_to_model_instance(response.json()) | Clone the task instance with given UUID.
Args:
uuid (str): The UUID of the task instance to clone.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance created due to the clone. | entailment |
def terminate(self, uuid):
"""Terminate the task instance with given UUID.
Args:
uuid (str): The UUID of the task instance to terminate.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance that was told to terminate.
"""
# Clone the object
request_url = self._client.base_api_url + self.terminate_url.format(
id=uuid
)
response = self._client.session.post(request_url)
# Validate that the request was successful
self.validate_request_success(
response_text=response.text,
request_url=request_url,
status_code=response.status_code,
expected_status_code=HTTP_202_ACCEPTED,
)
# Return a model instance
return self.response_data_to_model_instance(response.json()) | Terminate the task instance with given UUID.
Args:
uuid (str): The UUID of the task instance to terminate.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance that was told to terminate. | entailment |
def wait_until_finished(
self, uuid, refresh_period=DEFAULT_TASK_INSTANCE_WAIT_REFRESH_PERIOD
):
"""Wait until a task instance with the given UUID is finished.
Args:
uuid (str): The UUID of the task instance to wait for.
refresh_period (float, optional): How many seconds to wait
in between checking the task's status. Defaults to 5
seconds.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance which we waited for.
"""
# Wait for the task to finish
task_instance = self.get(uuid)
while task_instance.state not in TASK_INSTANCE_FINISH_STATUSES:
# Wait a bit
time.sleep(refresh_period)
# Query again
task_instance = self.get(uuid)
return task_instance | Wait until a task instance with the given UUID is finished.
Args:
uuid (str): The UUID of the task instance to wait for.
refresh_period (float, optional): How many seconds to wait
in between checking the task's status. Defaults to 5
seconds.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance which we waited for. | entailment |
def response_data_to_model_instance(self, response_data):
"""Convert response data to a task instance model.
Args:
response_data (dict): The data from the request's response.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance from the reponse data.
"""
# Coerce datetime strings into datetime objects
response_data["datetime_created"] = dateutil.parser.parse(
response_data["datetime_created"]
)
if response_data["datetime_finished"]:
response_data["datetime_finished"] = dateutil.parser.parse(
response_data["datetime_finished"]
)
# Instantiate a model for the task instance
return super(
BaseTaskInstanceManager, self
).response_data_to_model_instance(response_data) | Convert response data to a task instance model.
Args:
response_data (dict): The data from the request's response.
Returns:
:class:`saltant.models.base_task_instance.BaseTaskInstance`:
A task instance model instance representing the task
instance from the reponse data. | entailment |
def kma(inputfile_1, out_path, databases, db_path_kma, min_cov=0.6,
threshold=0.9, kma_path="cge/kma/kma", sample_name="",
inputfile_2=None, kma_mrs=None, kma_gapopen=None,
kma_gapextend=None, kma_penalty=None, kma_reward=None, kma_pm=None,
kma_fpm=None, kma_memmode=False, kma_nanopore=False, debug=False,
kma_add_args=None):
"""
I expect that there will only be one hit pr gene, but if there are
more, I assume that the sequence of the hits are the same in the res
file and the aln file.
"""
threshold = threshold * 100
min_cov = min_cov * 100
kma_results = dict()
kma_results["excluded"] = dict()
if(sample_name):
sample_name = "_" + sample_name
# Initiate output dicts.
gene_align_sbjct = {}
gene_align_query = {}
gene_align_homo = {}
for db in databases:
kma_db = db_path_kma + "/" + db
kma_outfile = out_path + "/kma_" + db + sample_name
kma_cmd = ("%s -t_db %s -o %s -e 1.0" % (kma_path,
kma_db, kma_outfile))
if(inputfile_2 is not None):
kma_cmd += " -ipe " + inputfile_1 + " " + inputfile_2
else:
kma_cmd += " -i " + inputfile_1
if(kma_mrs is not None):
kma_cmd += " -mrs " + str(kma_mrs)
if(kma_gapopen is not None):
kma_cmd += " -gapopen " + str(kma_gapopen)
if(kma_gapextend is not None):
kma_cmd += " -gapextend " + str(kma_gapextend)
if(kma_penalty is not None):
kma_cmd += " -penalty " + str(kma_penalty)
if(kma_reward is not None):
kma_cmd += " -reward " + str(kma_reward)
if(kma_pm is not None):
kma_cmd += " -pm " + kma_pm
if(kma_fpm is not None):
kma_cmd += " -fpm " + kma_fpm
if (kma_memmode):
kma_cmd += " -mem_mode "
if (kma_nanopore):
kma_cmd += " -bcNano "
kma_cmd += " -mp 20 "
if (kma_add_args is not None):
kma_cmd += " " + kma_add_args + " "
# kma output files
align_filename = kma_outfile + ".aln"
res_filename = kma_outfile + ".res"
# If .res file exists then skip mapping
if os.path.isfile(res_filename) and os.access(res_filename, os.R_OK):
print("Found " + res_filename + " skipping DB.")
else:
# Call KMA
if(debug):
print("KMA cmd: " + kma_cmd)
process = subprocess.Popen(kma_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = process.communicate()
kma_results[db] = 'No hit found'
# Open res file
try:
res_file = open(res_filename, "r")
header = res_file.readline()
except IOError as error:
sys.exit("Error: KMA did not run as expected.\n" +
"KMA finished with the following response:" +
"\n{}\n{}".format(out.decode("utf-8"),
err.decode("utf-8")))
for line in res_file:
if kma_results[db] == 'No hit found':
kma_results[db] = dict()
# kma_results[db]["excluded"] = dict()
# continue
data = [data.strip() for data in line.split("\t")]
gene = data[0]
sbjct_len = int(data[3])
sbjct_ident = float(data[4])
coverage = float(data[5])
depth = float(data[-3])
q_value = float(data[-2])
p_value = float(data[-1])
if gene not in kma_results[db]:
hit = gene
else:
hit = gene + "_" + str(len(kma_results[db][gene]) + 1)
exclude_reasons = []
if(coverage < min_cov or sbjct_ident < threshold):
exclude_reasons.append(coverage)
exclude_reasons.append(sbjct_ident)
if(exclude_reasons):
# kma_results[db]["excluded"][hit] = exclude_reasons
kma_results["excluded"][hit] = exclude_reasons
kma_results[db][hit] = dict()
kma_results[db][hit]['sbjct_length'] = sbjct_len
kma_results[db][hit]["perc_coverage"] = coverage
kma_results[db][hit]["sbjct_string"] = []
kma_results[db][hit]["query_string"] = []
kma_results[db][hit]["homo_string"] = []
kma_results[db][hit]["sbjct_header"] = gene
kma_results[db][hit]["perc_ident"] = sbjct_ident
kma_results[db][hit]["query_start"] = "NA"
kma_results[db][hit]["query_end"] = "NA"
kma_results[db][hit]["contig_name"] = "NA"
kma_results[db][hit]["HSP_length"] = ""
kma_results[db][hit]["cal_score"] = q_value
kma_results[db][hit]["depth"] = depth
kma_results[db][hit]["p_value"] = p_value
res_file.close()
if kma_results[db] == 'No hit found':
continue
# Open align file
with open(align_filename, "r") as align_file:
hit_no = dict()
gene = ""
# Parse through alignments
for line in align_file:
# Skip empty lines
if(not line.strip()):
continue
# Check when a new gene alignment start
if line.startswith("#"):
gene = line[1:].strip()
if gene not in hit_no:
hit_no[gene] = str(1)
else:
hit_no[gene] += str(int(hit_no[gene]) + 1)
else:
# Check if gene one of the user specified genes
if hit_no[gene] == '1':
hit = gene
else:
hit = gene + "_" + hit_no[gene]
if hit in kma_results[db]:
line_data = line.split("\t")[-1].strip()
if line.startswith("template"):
kma_results[db][hit]["sbjct_string"] += (
[line_data])
elif line.startswith("query"):
kma_results[db][hit]["query_string"] += (
[line_data])
else:
kma_results[db][hit]["homo_string"] += (
[line_data])
else:
print(hit + " not in results: ", kma_results)
# concatinate all sequences lists and find subject start
# and subject end
gene_align_sbjct[db] = {}
gene_align_query[db] = {}
gene_align_homo[db] = {}
for hit in kma_results[db]:
# if(hit == "excluded"):
# continue
align_sbjct = "".join(kma_results[db][hit]['sbjct_string'])
align_query = "".join(kma_results[db][hit]['query_string'])
align_homo = "".join(kma_results[db][hit]['homo_string'])
# Extract only aligned sequences
start = re.search("^-*(\w+)", align_query).start(1)
end = re.search("\w+(-*)$", align_query).start(1)
kma_results[db][hit]['sbjct_string'] = align_sbjct[start:end]
kma_results[db][hit]['query_string'] = align_query[start:end]
kma_results[db][hit]['homo_string'] = align_homo[start:end]
# Save align start and stop positions relative to
# subject sequence
kma_results[db][hit]['sbjct_start'] = start + 1
kma_results[db][hit]["sbjct_end"] = end + 1
kma_results[db][hit]["HSP_length"] = end - start
# Count gaps in the alignment
kma_results[db][hit]["gaps"] = (
kma_results[db][hit]['sbjct_string'].count("-") +
kma_results[db][hit]['query_string'].count("-"))
# Save sequences covering the entire subject sequence
# in seperate variables
gene_align_sbjct[db][hit] = align_sbjct
gene_align_query[db][hit] = align_query
gene_align_homo[db][hit] = align_homo
return FinderResult(kma_results, gene_align_sbjct, gene_align_query,
gene_align_homo) | I expect that there will only be one hit pr gene, but if there are
more, I assume that the sequence of the hits are the same in the res
file and the aln file. | entailment |
def _ids_and_column_names(names, force_lower_case=False):
"""Ensure all column names are unique identifiers."""
fixed = OrderedDict()
for name in names:
identifier = RowWrapper._make_identifier(name)
if force_lower_case:
identifier = identifier.lower()
while identifier in fixed:
identifier = RowWrapper._increment_numeric_suffix(identifier)
fixed[identifier] = name
return fixed | Ensure all column names are unique identifiers. | entailment |
def _make_identifier(string):
"""Attempt to convert string into a valid identifier by replacing invalid characters with "_"s,
and prefixing with "a_" if necessary."""
string = re.sub(r"[ \-+/\\*%&$£#@.,;:'" "?<>]", "_", string)
if re.match(r"^\d", string):
string = "a_{0}".format(string)
return string | Attempt to convert string into a valid identifier by replacing invalid characters with "_"s,
and prefixing with "a_" if necessary. | entailment |
def _increment_numeric_suffix(s):
"""Increment (or add) numeric suffix to identifier."""
if re.match(r".*\d+$", s):
return re.sub(r"\d+$", lambda n: str(int(n.group(0)) + 1), s)
return s + "_2" | Increment (or add) numeric suffix to identifier. | entailment |
def wrap(self, row: Union[Mapping[str, Any], Sequence[Any]]):
"""Return row tuple for row."""
return (
self.dataclass(
**{
ident: row[column_name]
for ident, column_name in self.ids_and_column_names.items()
}
)
if isinstance(row, Mapping)
else self.dataclass(
**{ident: val for ident, val in zip(self.ids_and_column_names.keys(), row)}
)
) | Return row tuple for row. | entailment |
def wrap_all(self, rows: Iterable[Union[Mapping[str, Any], Sequence[Any]]]):
"""Return row tuple for each row in rows."""
return (self.wrap(r) for r in rows) | Return row tuple for each row in rows. | entailment |
def add_error_handlers(app):
"""Add custom error handlers for PyMacaronCoreExceptions to the app"""
def handle_validation_error(error):
response = jsonify({'message': str(error)})
response.status_code = error.status_code
return response
app.errorhandler(ValidationError)(handle_validation_error) | Add custom error handlers for PyMacaronCoreExceptions to the app | entailment |
def list_backends(self, service_id, version_number):
"""List all backends for a particular service and version."""
content = self._fetch("/service/%s/version/%d/backend" % (service_id, version_number))
return map(lambda x: FastlyBackend(self, x), content) | List all backends for a particular service and version. | entailment |
def create_backend(self,
service_id,
version_number,
name,
address,
use_ssl=False,
port=80,
connect_timeout=1000,
first_byte_timeout=15000,
between_bytes_timeout=10000,
error_threshold=0,
max_conn=20,
weight=100,
auto_loadbalance=False,
shield=None,
request_condition=None,
healthcheck=None,
comment=None):
"""Create a backend for a particular service and version."""
body = self._formdata({
"name": name,
"address": address,
"use_ssl": use_ssl,
"port": port,
"connect_timeout": connect_timeout,
"first_byte_timeout": first_byte_timeout,
"between_bytes_timeout": between_bytes_timeout,
"error_threshold": error_threshold,
"max_conn": max_conn,
"weight": weight,
"auto_loadbalance": auto_loadbalance,
"shield": shield,
"request_condition": request_condition,
"healthcheck": healthcheck,
"comment": comment,
}, FastlyBackend.FIELDS)
content = self._fetch("/service/%s/version/%d/backend" % (service_id, version_number), method="POST", body=body)
return FastlyBackend(self, content) | Create a backend for a particular service and version. | entailment |
def get_backend(self, service_id, version_number, name):
"""Get the backend for a particular service and version."""
content = self._fetch("/service/%s/version/%d/backend/%s" % (service_id, version_number, name))
return FastlyBackend(self, content) | Get the backend for a particular service and version. | entailment |
def update_backend(self, service_id, version_number, name_key, **kwargs):
"""Update the backend for a particular service and version."""
body = self._formdata(kwargs, FastlyBackend.FIELDS)
content = self._fetch("/service/%s/version/%d/backend/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyBackend(self, content) | Update the backend for a particular service and version. | entailment |
def check_backends(self, service_id, version_number):
"""Performs a health check against each backend in version. If the backend has a specific type of healthcheck, that one is performed, otherwise a HEAD request to / is performed. The first item is the details on the Backend itself. The second item is details of the specific HTTP request performed as a health check. The third item is the response details."""
content = self._fetch("/service/%s/version/%d/backend/check_all" % (service_id, version_number))
# TODO: Use a strong-typed class for output?
return content | Performs a health check against each backend in version. If the backend has a specific type of healthcheck, that one is performed, otherwise a HEAD request to / is performed. The first item is the details on the Backend itself. The second item is details of the specific HTTP request performed as a health check. The third item is the response details. | entailment |
def list_cache_settings(self, service_id, version_number):
"""Get a list of all cache settings for a particular service and version."""
content = self._fetch("/service/%s/version/%d/cache_settings" % (service_id, version_number))
return map(lambda x: FastlyCacheSettings(self, x), content) | Get a list of all cache settings for a particular service and version. | entailment |
def create_cache_settings(self,
service_id,
version_number,
name,
action,
ttl=None,
stale_ttl=None,
cache_condition=None):
"""Create a new cache settings object."""
body = self._formdata({
"name": name,
"action": action,
"ttl": ttl,
"stale_ttl": stale_ttl,
"cache_condition": cache_condition,
}, FastlyCacheSettings.FIELDS)
content = self._fetch("/service/%s/version/%d/cache_settings" % (service_id, version_number), method="POST", body=body)
return FastlyCacheSettings(self, content) | Create a new cache settings object. | entailment |
def get_cache_settings(self, service_id, version_number, name):
"""Get a specific cache settings object."""
content = self._fetch("/service/%s/version/%d/cache_settings/%s" % (service_id, version_number, name))
return FastlyCacheSettings(self, content) | Get a specific cache settings object. | entailment |
def update_cache_settings(self, service_id, version_number, name_key, **kwargs):
"""Update a specific cache settings object."""
body = self._formdata(kwargs, FastlyCacheSettings.FIELDS)
content = self._fetch("/service/%s/version/%d/cache_settings/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyCacheSettings(self, content) | Update a specific cache settings object. | entailment |
def delete_cache_settings(self, service_id, version_number, name):
"""Delete a specific cache settings object."""
content = self._fetch("/service/%s/version/%d/cache_settings/%s" % (service_id, version_number, name), method="DELETE")
return self._status(content) | Delete a specific cache settings object. | entailment |
def list_conditions(self, service_id, version_number):
"""Gets all conditions for a particular service and version."""
content = self._fetch("/service/%s/version/%d/condition" % (service_id, version_number))
return map(lambda x: FastlyCondition(self, x), content) | Gets all conditions for a particular service and version. | entailment |
def create_condition(self,
service_id,
version_number,
name,
_type,
statement,
priority="10",
comment=None):
"""Creates a new condition."""
body = self._formdata({
"name": name,
"type": _type,
"statement": statement,
"priority": priority,
"comment": comment,
}, FastlyCondition.FIELDS)
content = self._fetch("/service/%s/version/%d/condition" % (service_id, version_number), method="POST", body=body)
return FastlyCondition(self, content) | Creates a new condition. | entailment |
def get_condition(self, service_id, version_number, name):
"""Gets a specified condition."""
content = self._fetch("/service/%s/version/%d/condition/%s" % (service_id, version_number, name))
return FastlyCondition(self, content) | Gets a specified condition. | entailment |
def update_condition(self, service_id, version_number, name_key, **kwargs):
"""Updates the specified condition."""
body = self._formdata(kwargs, FastlyCondition.FIELDS)
content = self._fetch("/service/%s/version/%d/condition/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyCondition(self, content) | Updates the specified condition. | entailment |
def content_edge_check(self, url):
"""Retrieve headers and MD5 hash of the content for a particular url from each Fastly edge server."""
prefixes = ["http://", "https://"]
for prefix in prefixes:
if url.startswith(prefix):
url = url[len(prefix):]
break
content = self._fetch("/content/edge_check/%s" % url)
return content | Retrieve headers and MD5 hash of the content for a particular url from each Fastly edge server. | entailment |
def get_customer(self, customer_id):
"""Get a specific customer."""
content = self._fetch("/customer/%s" % customer_id)
return FastlyCustomer(self, content) | Get a specific customer. | entailment |
def list_customer_users(self, customer_id):
"""List all users from a specified customer id."""
content = self._fetch("/customer/users/%s" % customer_id)
return map(lambda x: FastlyUser(self, x), content) | List all users from a specified customer id. | entailment |
def update_customer(self, customer_id, **kwargs):
"""Update a customer."""
body = self._formdata(kwargs, FastlyCustomer.FIELDS)
content = self._fetch("/customer/%s" % customer_id, method="PUT", body=body)
return FastlyCustomer(self, content) | Update a customer. | entailment |
def delete_customer(self, customer_id):
"""Delete a customer."""
content = self._fetch("/customer/%s" % customer_id, method="DELETE")
return self._status(content) | Delete a customer. | entailment |
def list_directors(self, service_id, version_number):
"""List the directors for a particular service and version."""
content = self._fetch("/service/%s/version/%d/director" % (service_id, version_number))
return map(lambda x: FastlyDirector(self, x), content) | List the directors for a particular service and version. | entailment |
def create_director(self, service_id, version_number,
name,
quorum=75,
_type=FastlyDirectorType.RANDOM,
retries=5,
shield=None):
"""Create a director for a particular service and version."""
body = self._formdata({
"name": name,
"quorum": quorum,
"type": _type,
"retries": retries,
"shield": shield,
}, FastlyDirector.FIELDS)
content = self._fetch("/service/%s/version/%d/director" % (service_id, version_number), method="POST", body=body)
return FastlyDirector(self, content) | Create a director for a particular service and version. | entailment |
def get_director(self, service_id, version_number, name):
"""Get the director for a particular service and version."""
content = self._fetch("/service/%s/version/%d/director/%s" % (service_id, version_number, name))
return FastlyDirector(self, content) | Get the director for a particular service and version. | entailment |
def update_director(self, service_id, version_number, name_key, **kwargs):
"""Update the director for a particular service and version."""
body = self._formdata(kwargs, FastlyDirector.FIELDS)
content = self._fetch("/service/%s/version/%d/director/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyDirector(self, content) | Update the director for a particular service and version. | entailment |
def get_director_backend(self, service_id, version_number, director_name, backend_name):
"""Returns the relationship between a Backend and a Director. If the Backend has been associated with the Director, it returns a simple record indicating this. Otherwise, returns a 404."""
content = self._fetch("/service/%s/version/%d/director/%s/backend/%s" % (service_id, version_number, director_name, backend_name), method="GET")
return FastlyDirectorBackend(self, content) | Returns the relationship between a Backend and a Director. If the Backend has been associated with the Director, it returns a simple record indicating this. Otherwise, returns a 404. | entailment |
def delete_director_backend(self, service_id, version_number, director_name, backend_name):
"""Deletes the relationship between a Backend and a Director. The Backend is no longer considered a member of the Director and thus will not have traffic balanced onto it from this Director."""
content = self._fetch("/service/%s/version/%d/director/%s/backend/%s" % (service_id, version_number, director_name, backend_name), method="DELETE")
return self._status(content) | Deletes the relationship between a Backend and a Director. The Backend is no longer considered a member of the Director and thus will not have traffic balanced onto it from this Director. | entailment |
def list_domains(self, service_id, version_number):
"""List the domains for a particular service and version."""
content = self._fetch("/service/%s/version/%d/domain" % (service_id, version_number))
return map(lambda x: FastlyDomain(self, x), content) | List the domains for a particular service and version. | entailment |
def create_domain(self,
service_id,
version_number,
name,
comment=None):
"""Create a domain for a particular service and version."""
body = self._formdata({
"name": name,
"comment": comment,
}, FastlyDomain.FIELDS)
content = self._fetch("/service/%s/version/%d/domain" % (service_id, version_number), method="POST", body=body)
return FastlyDomain(self, content) | Create a domain for a particular service and version. | entailment |
def get_domain(self, service_id, version_number, name):
"""Get the domain for a particular service and version."""
content = self._fetch("/service/%s/version/%d/domain/%s" % (service_id, version_number, name))
return FastlyDomain(self, content) | Get the domain for a particular service and version. | entailment |
def update_domain(self, service_id, version_number, name_key, **kwargs):
"""Update the domain for a particular service and version."""
body = self._formdata(kwargs, FastlyDomain.FIELDS)
content = self._fetch("/service/%s/version/%d/domain/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyDomain(self, content) | Update the domain for a particular service and version. | entailment |
def check_domain(self, service_id, version_number, name):
"""Checks the status of a domain's DNS record. Returns an array of 3 items. The first is the details for the domain. The second is the current CNAME of the domain. The third is a boolean indicating whether or not it has been properly setup to use Fastly."""
content = self._fetch("/service/%s/version/%d/domain/%s/check" % (service_id, version_number, name))
return FastlyDomainCheck(self, content) | Checks the status of a domain's DNS record. Returns an array of 3 items. The first is the details for the domain. The second is the current CNAME of the domain. The third is a boolean indicating whether or not it has been properly setup to use Fastly. | entailment |
def check_domains(self, service_id, version_number):
"""Checks the status of all domain DNS records for a Service Version. Returns an array items in the same format as the single domain /check."""
content = self._fetch("/service/%s/version/%d/domain/check_all" % (service_id, version_number))
return map(lambda x: FastlyDomainCheck(self, x), content) | Checks the status of all domain DNS records for a Service Version. Returns an array items in the same format as the single domain /check. | entailment |
def get_event_log(self, object_id):
"""Get the specified event log."""
content = self._fetch("/event_log/%s" % object_id, method="GET")
return FastlyEventLog(self, content) | Get the specified event log. | entailment |
def list_headers(self, service_id, version_number):
"""Retrieves all Header objects for a particular Version of a Service."""
content = self._fetch("/service/%s/version/%d/header" % (service_id, version_number))
return map(lambda x: FastlyHeader(self, x), content) | Retrieves all Header objects for a particular Version of a Service. | entailment |
def create_header(self, service_id, version_number, name, destination, source, _type=FastlyHeaderType.RESPONSE, action=FastlyHeaderAction.SET, regex=None, substitution=None, ignore_if_set=None, priority=10, response_condition=None, cache_condition=None, request_condition=None):
body = self._formdata({
"name": name,
"dst": destination,
"src": source,
"type": _type,
"action": action,
"regex": regex,
"substitution": substitution,
"ignore_if_set": ignore_if_set,
"priority": priority,
"response_condition": response_condition,
"request_condition": request_condition,
"cache_condition": cache_condition,
}, FastlyHeader.FIELDS)
"""Creates a new Header object."""
content = self._fetch("/service/%s/version/%d/header" % (service_id, version_number), method="POST", body=body)
return FastlyHeader(self, content) | Creates a new Header object. | entailment |
def get_header(self, service_id, version_number, name):
"""Retrieves a Header object by name."""
content = self._fetch("/service/%s/version/%d/header/%s" % (service_id, version_number, name))
return FastlyHeader(self, content) | Retrieves a Header object by name. | entailment |
def update_header(self, service_id, version_number, name_key, **kwargs):
"""Modifies an existing Header object by name."""
body = self._formdata(kwargs, FastlyHeader.FIELDS)
content = self._fetch("/service/%s/version/%d/header/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyHeader(self, content) | Modifies an existing Header object by name. | entailment |
def list_healthchecks(self, service_id, version_number):
"""List all of the healthchecks for a particular service and version."""
content = self._fetch("/service/%s/version/%d/healthcheck" % (service_id, version_number))
return map(lambda x: FastlyHealthCheck(self, x), content) | List all of the healthchecks for a particular service and version. | entailment |
def create_healthcheck(self,
service_id,
version_number,
name,
host,
method="HEAD",
path="/",
http_version="1.1",
timeout=1000,
check_interval=5000,
expected_response=200,
window=5,
threshold=3,
initial=1):
"""Create a healthcheck for a particular service and version."""
body = self._formdata({
"name": name,
"method": method,
"host": host,
"path": path,
"http_version": http_version,
"timeout": timeout,
"check_interval": check_interval,
"expected_response": expected_response,
"window": window,
"threshold": threshold,
"initial": initial,
}, FastlyHealthCheck.FIELDS)
content = self._fetch("/service/%s/version/%d/healthcheck" % (service_id, version_number), method="POST", body=body)
return FastlyHealthCheck(self, content) | Create a healthcheck for a particular service and version. | entailment |
def get_healthcheck(self, service_id, version_number, name):
"""Get the healthcheck for a particular service and version."""
content = self._fetch("/service/%s/version/%d/healthcheck/%s" % (service_id, version_number, name))
return FastlyHealthCheck(self, content) | Get the healthcheck for a particular service and version. | entailment |
def purge_url(self, host, path):
"""Purge an individual URL."""
content = self._fetch(path, method="PURGE", headers={ "Host": host })
return FastlyPurge(self, content) | Purge an individual URL. | entailment |
def check_purge_status(self, purge_id):
"""Get the status and times of a recently completed purge."""
content = self._fetch("/purge?id=%s" % purge_id)
return map(lambda x: FastlyPurgeStatus(self, x), content) | Get the status and times of a recently completed purge. | entailment |
def list_request_settings(self, service_id, version_number):
"""Returns a list of all Request Settings objects for the given service and version."""
content = self._fetch("/service/%s/version/%d/request_settings" % (service_id, version_number))
return map(lambda x: FastlyRequestSetting(self, x), content) | Returns a list of all Request Settings objects for the given service and version. | entailment |
def create_request_setting(self,
service_id,
version_number,
name,
default_host=None,
force_miss=None,
force_ssl=None,
action=None,
bypass_busy_wait=None,
max_stale_age=None,
hash_keys=None,
xff=None,
timer_support=None,
geo_headers=None,
request_condition=None):
"""Creates a new Request Settings object."""
body = self._formdata({
"name": name,
"default_host": default_host,
"force_miss": force_miss,
"force_ssl": force_ssl,
"action": action,
"bypass_busy_wait": bypass_busy_wait,
"max_stale_age": max_stale_age,
"hash_keys": hash_keys,
"xff": xff,
"timer_support": timer_support,
"geo_headers": geo_headers,
"request_condition": request_condition,
}, FastlyRequestSetting.FIELDS)
content = self._fetch("/service/%s/version/%d/request_settings" % (service_id, version_number), method="POST", body=body)
return FastlyRequestSetting(self, content) | Creates a new Request Settings object. | entailment |
def get_request_setting(self, service_id, version_number, name):
"""Gets the specified Request Settings object."""
content = self._fetch("/service/%s/version/%d/request_settings/%s" % (service_id, version_number, name))
return FastlyRequestSetting(self, content) | Gets the specified Request Settings object. | entailment |
def update_request_setting(self, service_id, version_number, name_key, **kwargs):
"""Updates the specified Request Settings object."""
body = self._formdata(kwargs, FastlyHealthCheck.FIELDS)
content = self._fetch("/service/%s/version/%d/request_settings/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyRequestSetting(self, content) | Updates the specified Request Settings object. | entailment |
def list_response_objects(self, service_id, version_number):
"""Returns all Response Objects for the specified service and version."""
content = self._fetch("/service/%s/version/%d/response_object" % (service_id, version_number))
return map(lambda x: FastlyResponseObject(self, x), content) | Returns all Response Objects for the specified service and version. | entailment |
def create_response_object(self, service_id, version_number, name, status="200", response="OK", content="", request_condition=None, cache_condition=None):
"""Creates a new Response Object."""
body = self._formdata({
"name": name,
"status": status,
"response": response,
"content": content,
"request_condition": request_condition,
"cache_condition": cache_condition,
}, FastlyResponseObject.FIELDS)
content = self._fetch("/service/%s/version/%d/response_object" % (service_id, version_number), method="POST", body=body)
return FastlyResponseObject(self, content) | Creates a new Response Object. | entailment |
def get_response_object(self, service_id, version_number, name):
"""Gets the specified Response Object."""
content = self._fetch("/service/%s/version/%d/response_object/%s" % (service_id, version_number, name))
return FastlyResponseObject(self, content) | Gets the specified Response Object. | entailment |
def update_response_object(self, service_id, version_number, name_key, **kwargs):
"""Updates the specified Response Object."""
body = self._formdata(kwargs, FastlyResponseObject.FIELDS)
content = self._fetch("/service/%s/version/%d/response_object/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyResponseObject(self, content) | Updates the specified Response Object. | entailment |
def create_service(self, customer_id, name, publish_key=None, comment=None):
"""Create a service."""
body = self._formdata({
"customer_id": customer_id,
"name": name,
"publish_key": publish_key,
"comment": comment,
}, FastlyService.FIELDS)
content = self._fetch("/service", method="POST", body=body)
return FastlyService(self, content) | Create a service. | entailment |
def list_services(self):
"""List Services."""
content = self._fetch("/service")
return map(lambda x: FastlyService(self, x), content) | List Services. | entailment |
def get_service(self, service_id):
"""Get a specific service by id."""
content = self._fetch("/service/%s" % service_id)
return FastlyService(self, content) | Get a specific service by id. | entailment |
def get_service_details(self, service_id):
"""List detailed information on a specified service."""
content = self._fetch("/service/%s/details" % service_id)
return FastlyService(self, content) | List detailed information on a specified service. | entailment |
def get_service_by_name(self, service_name):
"""Get a specific service by name."""
content = self._fetch("/service/search?name=%s" % service_name)
return FastlyService(self, content) | Get a specific service by name. | entailment |
def update_service(self, service_id, **kwargs):
"""Update a service."""
body = self._formdata(kwargs, FastlyService.FIELDS)
content = self._fetch("/service/%s" % service_id, method="PUT", body=body)
return FastlyService(self, content) | Update a service. | entailment |
def delete_service(self, service_id):
"""Delete a service."""
content = self._fetch("/service/%s" % service_id, method="DELETE")
return self._status(content) | Delete a service. | entailment |
def list_domains_by_service(self, service_id):
"""List the domains within a service."""
content = self._fetch("/service/%s/domain" % service_id, method="GET")
return map(lambda x: FastlyDomain(self, x), content) | List the domains within a service. | entailment |
def purge_service(self, service_id):
"""Purge everything from a service."""
content = self._fetch("/service/%s/purge_all" % service_id, method="POST")
return self._status(content) | Purge everything from a service. | entailment |
def purge_service_by_key(self, service_id, key):
"""Purge a particular service by a key."""
content = self._fetch("/service/%s/purge/%s" % (service_id, key), method="POST")
return self._status(content) | Purge a particular service by a key. | entailment |
def get_settings(self, service_id, version_number):
"""Get the settings for a particular service and version."""
content = self._fetch("/service/%s/version/%d/settings" % (service_id, version_number))
return FastlySettings(self, content) | Get the settings for a particular service and version. | entailment |
def update_settings(self, service_id, version_number, settings={}):
"""Update the settings for a particular service and version."""
body = urllib.urlencode(settings)
content = self._fetch("/service/%s/version/%d/settings" % (service_id, version_number), method="PUT", body=body)
return FastlySettings(self, content) | Update the settings for a particular service and version. | entailment |
def get_stats(self, service_id, stat_type=FastlyStatsType.ALL):
"""Get the stats from a service."""
content = self._fetch("/service/%s/stats/%s" % (service_id, stat_type))
return content | Get the stats from a service. | entailment |
def list_syslogs(self, service_id, version_number):
"""List all of the Syslogs for a particular service and version."""
content = self._fetch("/service/%s/version/%d/syslog" % (service_id, version_number))
return map(lambda x: FastlySyslog(self, x), content) | List all of the Syslogs for a particular service and version. | entailment |
def create_syslog(self,
service_id,
version_number,
name,
address,
port=514,
use_tls="0",
tls_ca_cert=None,
token=None,
_format=None,
response_condition=None):
"""Create a Syslog for a particular service and version."""
body = self._formdata({
"name": name,
"address": address,
"port": port,
"use_tls": use_tls,
"tls_ca_cert": tls_ca_cert,
"token": token,
"format": _format,
"response_condition": response_condition,
}, FastlySyslog.FIELDS)
content = self._fetch("/service/%s/version/%d/syslog" % (service_id, version_number), method="POST", body=body)
return FastlySyslog(self, content) | Create a Syslog for a particular service and version. | entailment |
def get_syslog(self, service_id, version_number, name):
"""Get the Syslog for a particular service and version."""
content = self._fetch("/service/%s/version/%d/syslog/%s" % (service_id, version_number, name))
return FastlySyslog(self, content) | Get the Syslog for a particular service and version. | entailment |
def update_syslog(self, service_id, version_number, name_key, **kwargs):
"""Update the Syslog for a particular service and version."""
body = self._formdata(kwargs, FastlySyslog.FIELDS)
content = self._fetch("/service/%s/version/%d/syslog/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlySyslog(self, content) | Update the Syslog for a particular service and version. | entailment |
def change_password(self, old_password, new_password):
"""Update the user's password to a new one."""
body = self._formdata({
"old_password": old_password,
"password": new_password,
}, ["old_password", "password"])
content = self._fetch("/current_user/password", method="POST", body=body)
return FastlyUser(self, content) | Update the user's password to a new one. | entailment |
def get_user(self, user_id):
"""Get a specific user."""
content = self._fetch("/user/%s" % user_id)
return FastlyUser(self, content) | Get a specific user. | entailment |
def create_user(self, customer_id, name, login, password, role=FastlyRoles.USER, require_new_password=True):
"""Create a user."""
body = self._formdata({
"customer_id": customer_id,
"name": name,
"login": login,
"password": password,
"role": role,
"require_new_password": require_new_password,
}, FastlyUser.FIELDS)
content = self._fetch("/user", method="POST", body=body)
return FastlyUser(self, content) | Create a user. | entailment |
def update_user(self, user_id, **kwargs):
"""Update a user."""
body = self._formdata(kwargs, FastlyUser.FIELDS)
content = self._fetch("/user/%s" % user_id, method="PUT", body=body)
return FastlyUser(self, content) | Update a user. | entailment |
def delete_user(self, user_id):
"""Delete a user."""
content = self._fetch("/user/%s" % user_id, method="DELETE")
return self._status(content) | Delete a user. | entailment |
def request_password_reset(self, user_id):
"""Requests a password reset for the specified user."""
content = self._fetch("/user/%s/password/request_reset" % (user_id), method="POST")
return FastlyUser(self, content) | Requests a password reset for the specified user. | entailment |
def list_vcls(self, service_id, version_number):
"""List the uploaded VCLs for a particular service and version."""
content = self._fetch("/service/%s/version/%d/vcl" % (service_id, version_number))
return map(lambda x: FastlyVCL(self, x), content) | List the uploaded VCLs for a particular service and version. | entailment |
def upload_vcl(self, service_id, version_number, name, content, main=None, comment=None):
"""Upload a VCL for a particular service and version."""
body = self._formdata({
"name": name,
"content": content,
"comment": comment,
"main": main,
}, FastlyVCL.FIELDS)
content = self._fetch("/service/%s/version/%d/vcl" % (service_id, version_number), method="POST", body=body)
return FastlyVCL(self, content) | Upload a VCL for a particular service and version. | entailment |
def get_vcl(self, service_id, version_number, name, include_content=True):
"""Get the uploaded VCL for a particular service and version."""
content = self._fetch("/service/%s/version/%d/vcl/%s?include_content=%d" % (service_id, version_number, name, int(include_content)))
return FastlyVCL(self, content) | Get the uploaded VCL for a particular service and version. | entailment |
def get_vcl_html(self, service_id, version_number, name):
"""Get the uploaded VCL for a particular service and version with HTML syntax highlighting."""
content = self._fetch("/service/%s/version/%d/vcl/%s/content" % (service_id, version_number, name))
return content.get("content", None) | Get the uploaded VCL for a particular service and version with HTML syntax highlighting. | entailment |
def get_generated_vcl(self, service_id, version_number):
"""Display the generated VCL for a particular service and version."""
content = self._fetch("/service/%s/version/%d/generated_vcl" % (service_id, version_number))
return FastlyVCL(self, content) | Display the generated VCL for a particular service and version. | entailment |
def get_generated_vcl_html(self, service_id, version_number):
"""Display the content of generated VCL with HTML syntax highlighting."""
content = self._fetch("/service/%s/version/%d/generated_vcl/content" % (service_id, version_number))
return content.get("content", None) | Display the content of generated VCL with HTML syntax highlighting. | entailment |
def set_main_vcl(self, service_id, version_number, name):
"""Set the specified VCL as the main."""
content = self._fetch("/service/%s/version/%d/vcl/%s/main" % (service_id, version_number, name), method="PUT")
return FastlyVCL(self, content) | Set the specified VCL as the main. | entailment |
def update_vcl(self, service_id, version_number, name_key, **kwargs):
"""Update the uploaded VCL for a particular service and version."""
body = self._formdata(kwargs, FastlyVCL.FIELDS)
content = self._fetch("/service/%s/version/%d/vcl/%s" % (service_id, version_number, name_key), method="PUT", body=body)
return FastlyVCL(self, content) | Update the uploaded VCL for a particular service and version. | entailment |
def create_version(self, service_id, inherit_service_id=None, comment=None):
"""Create a version for a particular service."""
body = self._formdata({
"service_id": service_id,
"inherit_service_id": inherit_service_id,
"comment": comment,
}, FastlyVersion.FIELDS)
content = self._fetch("/service/%s/version" % service_id, method="POST", body=body)
return FastlyVersion(self, content) | Create a version for a particular service. | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.