_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q255000 | BatchWebhooks.update | validation | def update(self, batch_webhook_id, data):
"""
Update a webhook that will fire whenever any batch request completes
processing.
:param batch_webhook_id: The unique id for the batch webhook.
:type batch_webhook_id: :py:class:`str`
:param data: The request body parameters
... | python | {
"resource": ""
} |
q255001 | BatchWebhooks.delete | validation | def delete(self, batch_webhook_id):
"""
Remove a batch webhook. Webhooks will no longer be sent to the given
URL.
:param batch_webhook_id: The unique id for the batch webhook.
:type batch_webhook_id: :py:class:`str`
"""
self.batch_webhook_id = batch_webhook_id
... | python | {
"resource": ""
} |
q255002 | Stores.create | validation | def create(self, data):
"""
Add a new store to your MailChimp account.
Error checking on the currency code verifies that it is in the correct
three-letter, all-caps format as specified by ISO 4217 but does not
check that it is a valid code as the list of valid codes changes over... | python | {
"resource": ""
} |
q255003 | Stores.update | validation | def update(self, store_id, data):
"""
Update a store.
:param store_id: The store id.
:type store_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
"""
self.store_id = store_id
return self._mc_client._patch(u... | python | {
"resource": ""
} |
q255004 | StoreProductImages.create | validation | def create(self, store_id, product_id, data):
"""
Add a new image to the product.
:param store_id: The store id.
:type store_id: :py:class:`str`
:param product_id: The id for the product of a store.
:type product_id: :py:class:`str`
:param data: The request body ... | python | {
"resource": ""
} |
q255005 | StoreProductImages.get | validation | def get(self, store_id, product_id, image_id, **queryparams):
"""
Get information about a specific product image.
:param store_id: The store id.
:type store_id: :py:class:`str`
:param product_id: The id for the product of a store.
:type product_id: :py:class:`str`
... | python | {
"resource": ""
} |
q255006 | ConversationMessages.create | validation | def create(self, conversation_id, data):
"""
Post a new message to a conversation.
:param conversation_id: The unique id for the conversation.
:type conversation_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
data = {
... | python | {
"resource": ""
} |
q255007 | StoreOrders.create | validation | def create(self, store_id, data):
"""
Add a new order to a store.
:param store_id: The store id.
:type store_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
data = {
"id": string*,
"customer": obje... | python | {
"resource": ""
} |
q255008 | ListMemberNotes.create | validation | def create(self, list_id, subscriber_hash, data):
"""
Add a new note for a specific subscriber.
The documentation lists only the note request body parameter so it is
being documented and error-checked as if it were required based on the
description of the method.
:param... | python | {
"resource": ""
} |
q255009 | ListMemberTags.update | validation | def update(self, list_id, subscriber_hash, data):
"""
Update tags for a specific subscriber.
The documentation lists only the tags request body parameter so it is
being documented and error-checked as if it were required based on the
description of the method.
The data ... | python | {
"resource": ""
} |
q255010 | ListSegments.update | validation | def update(self, list_id, segment_id, data):
"""
Update a specific segment in a list.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param segment_id: The unique id for the segment.
:type segment_id: :py:class:`str`
:param data: The r... | python | {
"resource": ""
} |
q255011 | TemplateFolders.update | validation | def update(self, folder_id, data):
"""
Update a specific folder used to organize templates.
:param folder_id: The unique id for the File Manager folder.
:type folder_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
data = ... | python | {
"resource": ""
} |
q255012 | ListMembers.create | validation | def create(self, list_id, data):
"""
Add a new member to the list.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
data = {
"status": string*, (Must be on... | python | {
"resource": ""
} |
q255013 | ListMembers.update | validation | def update(self, list_id, subscriber_hash, data):
"""
Update information for a specific list member.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param subscriber_hash: The MD5 hash of the lowercase version of the
list member’s email ad... | python | {
"resource": ""
} |
q255014 | ListMembers.create_or_update | validation | def create_or_update(self, list_id, subscriber_hash, data):
"""
Add or update a list member.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param subscriber_hash: The MD5 hash of the lowercase version of the
list member’s email address.
... | python | {
"resource": ""
} |
q255015 | ListMembers.delete | validation | def delete(self, list_id, subscriber_hash):
"""
Delete a member from a list.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param subscriber_hash: The MD5 hash of the lowercase version of the
list member’s email address.
:type subsc... | python | {
"resource": ""
} |
q255016 | ListMembers.delete_permanent | validation | def delete_permanent(self, list_id, subscriber_hash):
"""
Delete permanently a member from a list.
:param list_id: The unique id for the list.
:type list_id: :py:class:`str`
:param subscriber_hash: The MD5 hash of the lowercase version of the
list member’s email addres... | python | {
"resource": ""
} |
q255017 | AutomationEmailActions.pause | validation | def pause(self, workflow_id, email_id):
"""
Pause an automated email.
:param workflow_id: The unique id for the Automation workflow.
:type workflow_id: :py:class:`str`
:param email_id: The unique id for the Automation workflow email.
:type email_id: :py:class:`str`
... | python | {
"resource": ""
} |
q255018 | AutomationEmailActions.start | validation | def start(self, workflow_id, email_id):
"""
Start an automated email.
:param workflow_id: The unique id for the Automation workflow.
:type workflow_id: :py:class:`str`
:param email_id: The unique id for the Automation workflow email.
:type email_id: :py:class:`str`
... | python | {
"resource": ""
} |
q255019 | AutomationEmailActions.delete | validation | def delete(self, workflow_id, email_id):
"""
Removes an individual Automation workflow email.
:param workflow_id: The unique id for the Automation workflow.
:type workflow_id: :py:class:`str`
:param email_id: The unique id for the Automation workflow email.
:type email_i... | python | {
"resource": ""
} |
q255020 | Campaigns.create | validation | def create(self, data):
"""
Create a new MailChimp campaign.
The ValueError raised by an invalid type in data does not mention
'absplit' as a potential value because the documentation indicates
that the absplit type has been deprecated.
:param data: The request body par... | python | {
"resource": ""
} |
q255021 | Campaigns.update | validation | def update(self, campaign_id, data):
"""
Update some or all of the settings for a specific campaign.
:param campaign_id: The unique id for the campaign.
:type campaign_id: :py:class:`str`
:param data: The request body parameters
:type data: :py:class:`dict`
data ... | python | {
"resource": ""
} |
q255022 | Campaigns.delete | validation | def delete(self, campaign_id):
"""
Remove a campaign from your MailChimp account.
:param campaign_id: The unique id for the campaign.
:type campaign_id: :py:class:`str`
"""
self.campaign_id = campaign_id
return self._mc_client._delete(url=self._build_path(campaig... | python | {
"resource": ""
} |
q255023 | StoreCartLines.delete | validation | def delete(self, store_id, cart_id, line_id):
"""
Delete a cart.
:param store_id: The store id.
:type store_id: :py:class:`str`
:param cart_id: The id for the cart.
:type cart_id: :py:class:`str`
:param line_id: The id for the line item of a cart.
:type l... | python | {
"resource": ""
} |
q255024 | BatchOperations.create | validation | def create(self, data):
"""
Begin processing a batch operations request.
:param data: The request body parameters
:type data: :py:class:`dict`
data = {
"operations": array*
[
{
"method": string* (Must be one of "GET", "... | python | {
"resource": ""
} |
q255025 | BatchOperations.all | validation | def all(self, get_all=False, **queryparams):
"""
Get a summary of batch requests that have been made.
:param get_all: Should the query get all results
:type get_all: :py:class:`bool`
:param queryparams: The query string parameters
queryparams['fields'] = []
query... | python | {
"resource": ""
} |
q255026 | BatchOperations.get | validation | def get(self, batch_id, **queryparams):
"""
Get the status of a batch request.
:param batch_id: The unique id for the batch operation.
:type batch_id: :py:class:`str`
:param queryparams: The query string parameters
queryparams['fields'] = []
queryparams['exclude_... | python | {
"resource": ""
} |
q255027 | BatchOperations.delete | validation | def delete(self, batch_id):
"""
Stops a batch request from running. Since only one batch request is
run at a time, this can be used to cancel a long running request. The
results of any completed operations will not be available after this
call.
:param batch_id: The uniqu... | python | {
"resource": ""
} |
q255028 | _reformat_policy | validation | def _reformat_policy(policy):
"""
Policies returned from boto3 are massive, ugly, and difficult to read.
This method flattens and reformats the policy.
:param policy: Result from invoking describe_load_balancer_policies(...)
:return: Returns a tuple containing policy_name and the reformatted policy... | python | {
"resource": ""
} |
q255029 | get_load_balancer | validation | def get_load_balancer(load_balancer, flags=FLAGS.ALL ^ FLAGS.POLICY_TYPES, **conn):
"""
Fully describes an ELB.
:param loadbalancer: Could be an ELB Name or a dictionary. Likely the return value from a previous call to describe_load_balancers. At a minimum, must contain a key titled 'LoadBalancerName'.
... | python | {
"resource": ""
} |
q255030 | GCPCache.get | validation | def get(self, key, delete_if_expired=True):
"""
Retrieve key from Cache.
:param key: key to look up in cache.
:type key: ``object``
:param delete_if_expired: remove value from cache if it is expired.
Default is True.
:type delete_if_exp... | python | {
"resource": ""
} |
q255031 | GCPCache.insert | validation | def insert(self, key, obj, future_expiration_minutes=15):
"""
Insert item into cache.
:param key: key to look up in cache.
:type key: ``object``
:param obj: item to store in cache.
:type obj: varies
:param future_expiration_minutes: number of minutes item is va... | python | {
"resource": ""
} |
q255032 | GCPCache._update_cache_stats | validation | def _update_cache_stats(self, key, result):
"""
Update the cache stats.
If no cache-result is specified, we iniitialize the key.
Otherwise, we increment the correct cache-result.
Note the behavior for expired. A client can be expired and the key
still exists.
... | python | {
"resource": ""
} |
q255033 | GCPCache.get_access_details | validation | def get_access_details(self, key=None):
"""Get access details in cache."""
if key in self._CACHE_STATS:
return self._CACHE_STATS['access_stats'][key]
else:
return self._CACHE_STATS['access_stats'] | python | {
"resource": ""
} |
q255034 | GCPCache.get_stats | validation | def get_stats(self):
"""Get general stats for the cache."""
expired = sum([x['expired'] for _, x in
self._CACHE_STATS['access_stats'].items()])
miss = sum([x['miss'] for _, x in
self._CACHE_STATS['access_stats'].items()])
hit = sum([x['hit'] fo... | python | {
"resource": ""
} |
q255035 | get_vpc_flow_logs | validation | def get_vpc_flow_logs(vpc, **conn):
"""Gets the VPC Flow Logs for a VPC"""
fl_result = describe_flow_logs(Filters=[{"Name": "resource-id", "Values": [vpc["id"]]}], **conn)
fl_ids = []
for fl in fl_result:
fl_ids.append(fl["FlowLogId"])
return fl_ids | python | {
"resource": ""
} |
q255036 | get_classic_link | validation | def get_classic_link(vpc, **conn):
"""Gets the Classic Link details about a VPC"""
result = {}
try:
cl_result = describe_vpc_classic_link(VpcIds=[vpc["id"]], **conn)[0]
result["Enabled"] = cl_result["ClassicLinkEnabled"]
# Check for DNS as well:
dns_result = describe_vpc_cl... | python | {
"resource": ""
} |
q255037 | get_subnets | validation | def get_subnets(vpc, **conn):
"""Gets the VPC Subnets"""
subnets = describe_subnets(Filters=[{"Name": "vpc-id", "Values": [vpc["id"]]}], **conn)
s_ids = []
for s in subnets:
s_ids.append(s["SubnetId"])
return s_ids | python | {
"resource": ""
} |
q255038 | get_route_tables | validation | def get_route_tables(vpc, **conn):
"""Gets the VPC Route Tables"""
route_tables = describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc["id"]]}], **conn)
rt_ids = []
for r in route_tables:
rt_ids.append(r["RouteTableId"])
return rt_ids | python | {
"resource": ""
} |
q255039 | get_network_acls | validation | def get_network_acls(vpc, **conn):
"""Gets the VPC Network ACLs"""
route_tables = describe_network_acls(Filters=[{"Name": "vpc-id", "Values": [vpc["id"]]}], **conn)
nacl_ids = []
for r in route_tables:
nacl_ids.append(r["NetworkAclId"])
return nacl_ids | python | {
"resource": ""
} |
q255040 | get_client | validation | def get_client(service, service_type='client', **conn_args):
"""
User function to get the correct client.
Based on the GOOGLE_CLIENT_MAP dictionary, the return will be a cloud or general
client that can interact with the desired service.
:param service: GCP service to connect to. E.g. 'gce', 'iam'... | python | {
"resource": ""
} |
q255041 | get_gcp_client | validation | def get_gcp_client(**kwargs):
"""Public GCP client builder."""
return _gcp_client(project=kwargs['project'], mod_name=kwargs['mod_name'],
pkg_name=kwargs.get('pkg_name', 'google.cloud'),
key_file=kwargs.get('key_file', None),
http_auth=kwargs.... | python | {
"resource": ""
} |
q255042 | _gcp_client | validation | def _gcp_client(project, mod_name, pkg_name, key_file=None, http_auth=None,
user_agent=None):
"""
Private GCP client builder.
:param project: Google Cloud project string.
:type project: ``str``
:param mod_name: Module name to load. Should be found in sys.path.
:type mod_name: ... | python | {
"resource": ""
} |
q255043 | _googleauth | validation | def _googleauth(key_file=None, scopes=[], user_agent=None):
"""
Google http_auth helper.
If key_file is not specified, default credentials will be used.
If scopes is specified (and key_file), will be used instead of DEFAULT_SCOPES
:param key_file: path to key file to use. Default is None
:typ... | python | {
"resource": ""
} |
q255044 | _build_google_client | validation | def _build_google_client(service, api_version, http_auth):
"""
Google build client helper.
:param service: service to build client for
:type service: ``str``
:param api_version: API version to use.
:type api_version: ``str``
:param http_auth: Initialized HTTP client to use.
:type http... | python | {
"resource": ""
} |
q255045 | iter_project | validation | def iter_project(projects, key_file=None):
"""
Call decorated function for each item in project list.
Note: the function 'decorated' is expected to return a value plus a dictionary of exceptions.
If item in list is a dictionary, we look for a 'project' and 'key_file' entry, respectively.
If item i... | python | {
"resource": ""
} |
q255046 | get_creds_from_kwargs | validation | def get_creds_from_kwargs(kwargs):
"""Helper to get creds out of kwargs."""
creds = {
'key_file': kwargs.pop('key_file', None),
'http_auth': kwargs.pop('http_auth', None),
'project': kwargs.get('project', None),
'user_agent': kwargs.pop('user_agent', None),
'api_version':... | python | {
"resource": ""
} |
q255047 | rewrite_kwargs | validation | def rewrite_kwargs(conn_type, kwargs, module_name=None):
"""
Manipulate connection keywords.
Modifieds keywords based on connection type.
There is an assumption here that the client has
already been created and that these keywords are being
passed into methods for interacting with various ... | python | {
"resource": ""
} |
q255048 | gce_list_aggregated | validation | def gce_list_aggregated(service=None, key_name='name', **kwargs):
"""General aggregated list function for the GCE service."""
resp_list = []
req = service.aggregatedList(**kwargs)
while req is not None:
resp = req.execute()
for location, item in resp['items'].items():
if key... | python | {
"resource": ""
} |
q255049 | gce_list | validation | def gce_list(service=None, **kwargs):
"""General list function for the GCE service."""
resp_list = []
req = service.list(**kwargs)
while req is not None:
resp = req.execute()
for item in resp.get('items', []):
resp_list.append(item)
req = service.list_next(previous_r... | python | {
"resource": ""
} |
q255050 | service_list | validation | def service_list(service=None, key_name=None, **kwargs):
"""General list function for Google APIs."""
resp_list = []
req = service.list(**kwargs)
while req is not None:
resp = req.execute()
if key_name and key_name in resp:
resp_list.extend(resp[key_name])
else:
... | python | {
"resource": ""
} |
q255051 | get_cache_access_details | validation | def get_cache_access_details(key=None):
"""Retrieve detailed cache information."""
from cloudaux.gcp.decorators import _GCP_CACHE
return _GCP_CACHE.get_access_details(key=key) | python | {
"resource": ""
} |
q255052 | get_user_agent_default | validation | def get_user_agent_default(pkg_name='cloudaux'):
"""
Get default User Agent String.
Try to import pkg_name to get an accurate version number.
return: string
"""
version = '0.0.1'
try:
import pkg_resources
version = pkg_resources.get_distribution(pkg_name).version
e... | python | {
"resource": ""
} |
q255053 | list_rules | validation | def list_rules(client=None, **kwargs):
"""
NamePrefix='string'
"""
result = client.list_rules(**kwargs)
if not result.get("Rules"):
result.update({"Rules": []})
return result | python | {
"resource": ""
} |
q255054 | list_targets_by_rule | validation | def list_targets_by_rule(client=None, **kwargs):
"""
Rule='string'
"""
result = client.list_targets_by_rule(**kwargs)
if not result.get("Targets"):
result.update({"Targets": []})
return result | python | {
"resource": ""
} |
q255055 | list_buckets | validation | def list_buckets(client=None, **kwargs):
"""
List buckets for a project.
:param client: client object to use.
:type client: Google Cloud Storage client
:returns: list of dictionary reprsentation of Bucket
:rtype: ``list`` of ``dict``
"""
buckets = client.list_buckets(**kwargs)
retu... | python | {
"resource": ""
} |
q255056 | list_objects_in_bucket | validation | def list_objects_in_bucket(**kwargs):
"""
List objects in bucket.
:param Bucket: name of bucket
:type Bucket: ``str``
:returns list of objects in bucket
:rtype: ``list``
"""
bucket = get_bucket(**kwargs)
if bucket:
return [o for o in bucket.list_blobs()]
else:
r... | python | {
"resource": ""
} |
q255057 | modify | validation | def modify(item, output='camelized'):
"""
Calls _modify and either passes the inflection.camelize method or the inflection.underscore method.
:param item: dictionary representing item to be modified
:param output: string 'camelized' or 'underscored'
:return:
"""
if output == 'camelized':
... | python | {
"resource": ""
} |
q255058 | get_role_managed_policy_documents | validation | def get_role_managed_policy_documents(role, client=None, **kwargs):
"""Retrieve the currently active policy version document for every managed policy that is attached to the role."""
policies = get_role_managed_policies(role, force_client=client)
policy_names = (policy['name'] for policy in policies)
d... | python | {
"resource": ""
} |
q255059 | get_group | validation | def get_group(group_name, users=True, client=None, **kwargs):
"""Get's the IAM Group details.
:param group_name:
:param users: Optional -- will return the IAM users that the group is attached to if desired (paginated).
:param client:
:param kwargs:
:return:
"""
# First, make the initial... | python | {
"resource": ""
} |
q255060 | get_group_policy_document | validation | def get_group_policy_document(group_name, policy_name, client=None, **kwargs):
"""Fetches the specific IAM group inline-policy document."""
return client.get_group_policy(GroupName=group_name, PolicyName=policy_name, **kwargs)['PolicyDocument'] | python | {
"resource": ""
} |
q255061 | _get_base | validation | def _get_base(server_certificate, **conn):
"""Fetch the base IAM Server Certificate."""
server_certificate['_version'] = 1
# Get the initial cert details:
cert_details = get_server_certificate_api(server_certificate['ServerCertificateName'], **conn)
if cert_details:
server_certificate.upda... | python | {
"resource": ""
} |
q255062 | boto3_cached_conn | validation | def boto3_cached_conn(service, service_type='client', future_expiration_minutes=15, account_number=None,
assume_role=None, session_name='cloudaux', region='us-east-1', return_credentials=False,
external_id=None, arn_partition='aws'):
"""
Used to obtain a boto3 client ... | python | {
"resource": ""
} |
q255063 | get_rules | validation | def get_rules(security_group, **kwargs):
""" format the rule fields to match AWS to support auditor reuse,
will need to remap back if we want to orchestrate from our stored items """
rules = security_group.pop('security_group_rules',[])
for rule in rules:
rule['ip_protocol'] = rule.pop('prot... | python | {
"resource": ""
} |
q255064 | get_security_group | validation | def get_security_group(security_group, flags=FLAGS.ALL, **kwargs):
result = registry.build_out(flags, start_with=security_group, pass_datastructure=True, **kwargs)
""" just store the AWS formatted rules """
result.pop('security_group_rules', [])
return result | python | {
"resource": ""
} |
q255065 | get_inline_policies | validation | def get_inline_policies(group, **conn):
"""Get the inline policies for the group."""
policy_list = list_group_policies(group['GroupName'])
policy_documents = {}
for policy in policy_list:
policy_documents[policy] = get_group_policy_document(group['GroupName'], policy, **conn)
return polic... | python | {
"resource": ""
} |
q255066 | get_managed_policies | validation | def get_managed_policies(group, **conn):
"""Get a list of the managed policy names that are attached to the group."""
managed_policies = list_attached_group_managed_policies(group['GroupName'], **conn)
managed_policy_names = []
for policy in managed_policies:
managed_policy_names.append(policy... | python | {
"resource": ""
} |
q255067 | get_users | validation | def get_users(group, **conn):
"""Gets a list of the usernames that are a part of this group."""
group_details = get_group_api(group['GroupName'], **conn)
user_list = []
for user in group_details.get('Users', []):
user_list.append(user['UserName'])
return user_list | python | {
"resource": ""
} |
q255068 | _get_base | validation | def _get_base(group, **conn):
"""Fetch the base IAM Group."""
group['_version'] = 1
# Get the initial group details (only needed if we didn't grab the users):
group.update(get_group_api(group['GroupName'], users=False, **conn)['Group'])
# Cast CreateDate from a datetime to something JSON serializa... | python | {
"resource": ""
} |
q255069 | get_base | validation | def get_base(managed_policy, **conn):
"""Fetch the base Managed Policy.
This includes the base policy and the latest version document.
:param managed_policy:
:param conn:
:return:
"""
managed_policy['_version'] = 1
arn = _get_name_from_structure(managed_policy, 'Arn')
policy = get... | python | {
"resource": ""
} |
q255070 | Catalog.get_short_version | validation | def get_short_version(self):
'''obtain the shory geoserver version
'''
gs_version = self.get_version()
match = re.compile(r'[^\d.]+')
return match.sub('', gs_version).strip('.') | python | {
"resource": ""
} |
q255071 | Catalog.save | validation | def save(self, obj, content_type="application/xml"):
"""
saves an object to the REST service
gets the object's REST location and the data from the object,
then POSTS the request.
"""
rest_url = obj.href
data = obj.message()
headers = {
"Conten... | python | {
"resource": ""
} |
q255072 | Catalog.get_stores | validation | def get_stores(self, names=None, workspaces=None):
'''
Returns a list of stores in the catalog. If workspaces is specified will only return stores in those workspaces.
If names is specified, will only return stores that match.
names can either be a comma delimited string or an arra... | python | {
"resource": ""
} |
q255073 | Catalog.get_store | validation | def get_store(self, name, workspace=None):
'''
Returns a single store object.
Will return None if no store is found.
Will raise an error if more than one store with the same name is found.
'''
stores = self.get_stores(workspaces=workspace, names=name)
retur... | python | {
"resource": ""
} |
q255074 | Catalog.delete_granule | validation | def delete_granule(self, coverage, store, granule_id, workspace=None):
'''Deletes a granule of an existing imagemosaic'''
params = dict()
workspace_name = workspace
if isinstance(store, basestring):
store_name = store
else:
store_name = store.name
... | python | {
"resource": ""
} |
q255075 | Catalog.list_granules | validation | def list_granules(self, coverage, store, workspace=None, filter=None, limit=None, offset=None):
'''List granules of an imagemosaic'''
params = dict()
if filter is not None:
params['filter'] = filter
if limit is not None:
params['limit'] = limit
if offset ... | python | {
"resource": ""
} |
q255076 | Catalog.mosaic_coverages | validation | def mosaic_coverages(self, store):
'''Returns all coverages in a coverage store'''
params = dict()
url = build_url(
self.service_url,
[
"workspaces",
store.workspace.name,
"coveragestores",
store.name,
... | python | {
"resource": ""
} |
q255077 | Catalog.publish_featuretype | validation | def publish_featuretype(self, name, store, native_crs, srs=None, jdbc_virtual_table=None, native_name=None):
'''Publish a featuretype from data in an existing store'''
# @todo native_srs doesn't seem to get detected, even when in the DB
# metadata (at least for postgis in geometry_columns) and t... | python | {
"resource": ""
} |
q255078 | Catalog.get_resources | validation | def get_resources(self, names=None, stores=None, workspaces=None):
'''
Resources include feature stores, coverage stores and WMS stores, however does not include layer groups.
names, stores and workspaces can be provided as a comma delimited strings or as arrays, and are used for filtering.
... | python | {
"resource": ""
} |
q255079 | Catalog.get_resource | validation | def get_resource(self, name=None, store=None, workspace=None):
'''
returns a single resource object.
Will return None if no resource is found.
Will raise an error if more than one resource with the same name is found.
'''
resources = self.get_resources(names=name, ... | python | {
"resource": ""
} |
q255080 | Catalog.get_layergroup | validation | def get_layergroup(self, name, workspace=None):
'''
returns a single layergroup object.
Will return None if no layergroup is found.
Will raise an error if more than one layergroup with the same name is found.
'''
layergroups = self.get_layergroups(names=name, works... | python | {
"resource": ""
} |
q255081 | Catalog.get_style | validation | def get_style(self, name, workspace=None):
'''
returns a single style object.
Will return None if no style is found.
Will raise an error if more than one style with the same name is found.
'''
styles = self.get_styles(names=name, workspaces=workspace)
retur... | python | {
"resource": ""
} |
q255082 | Catalog.get_workspaces | validation | def get_workspaces(self, names=None):
'''
Returns a list of workspaces in the catalog.
If names is specified, will only return workspaces that match.
names can either be a comma delimited string or an array.
Will return an empty list if no workspaces are found.
''... | python | {
"resource": ""
} |
q255083 | Catalog.get_workspace | validation | def get_workspace(self, name):
'''
returns a single workspace object.
Will return None if no workspace is found.
Will raise an error if more than one workspace with the same name is found.
'''
workspaces = self.get_workspaces(names=name)
return self._return... | python | {
"resource": ""
} |
q255084 | md_link | validation | def md_link(node):
"""Extract a metadata link tuple from an xml node"""
mimetype = node.find("type")
mdtype = node.find("metadataType")
content = node.find("content")
if None in [mimetype, mdtype, content]:
return None
else:
return (mimetype.text, mdtype.text, content.text) | python | {
"resource": ""
} |
q255085 | build_url | validation | def build_url(base, seg, query=None):
"""
Create a URL from a list of path segments and an optional dict of query
parameters.
"""
def clean_segment(segment):
"""
Cleans the segment and encodes to UTF-8 if the segment is unicode.
"""
segment = segment.strip('/')
... | python | {
"resource": ""
} |
q255086 | prepare_upload_bundle | validation | def prepare_upload_bundle(name, data):
"""GeoServer's REST API uses ZIP archives as containers for file formats such
as Shapefile and WorldImage which include several 'boxcar' files alongside
the main data. In such archives, GeoServer assumes that all of the relevant
files will have the same base name ... | python | {
"resource": ""
} |
q255087 | md_dimension_info | validation | def md_dimension_info(name, node):
"""Extract metadata Dimension Info from an xml node"""
def _get_value(child_name):
return getattr(node.find(child_name), 'text', None)
resolution = _get_value('resolution')
defaultValue = node.find("defaultValue")
strategy = defaultValue.find("strategy") i... | python | {
"resource": ""
} |
q255088 | md_dynamic_default_values_info | validation | def md_dynamic_default_values_info(name, node):
"""Extract metadata Dynamic Default Values from an xml node"""
configurations = node.find("configurations")
if configurations is not None:
configurations = []
for n in node.findall("configuration"):
dimension = n.find("dimension")
... | python | {
"resource": ""
} |
q255089 | md_jdbc_virtual_table | validation | def md_jdbc_virtual_table(key, node):
"""Extract metadata JDBC Virtual Tables from an xml node"""
name = node.find("name")
sql = node.find("sql")
escapeSql = node.find("escapeSql")
escapeSql = escapeSql.text if escapeSql is not None else None
keyColumn = node.find("keyColumn")
keyColumn = ke... | python | {
"resource": ""
} |
q255090 | md_entry | validation | def md_entry(node):
"""Extract metadata entries from an xml node"""
key = None
value = None
if 'key' in node.attrib:
key = node.attrib['key']
else:
key = None
if key in ['time', 'elevation'] or key.startswith('custom_dimension'):
value = md_dimension_info(key, node.find(... | python | {
"resource": ""
} |
q255091 | DimensionInfo.resolution_millis | validation | def resolution_millis(self):
'''if set, get the value of resolution in milliseconds'''
if self.resolution is None or not isinstance(self.resolution, basestring):
return self.resolution
val, mult = self.resolution.split(' ')
return int(float(val) * self._multipier(mult) * ... | python | {
"resource": ""
} |
q255092 | MySQLBrowserResource._init | validation | def _init(self):
"""Read resource information into self._cache, for cached access.
See DAVResource._init()
"""
# TODO: recalc self.path from <self._file_path>, to fix correct file system case
# On windows this would lead to correct URLs
self.provider._count_get_res... | python | {
"resource": ""
} |
q255093 | as_DAVError | validation | def as_DAVError(e):
"""Convert any non-DAVError exception to HTTP_INTERNAL_ERROR."""
if isinstance(e, DAVError):
return e
elif isinstance(e, Exception):
# traceback.print_exc()
return DAVError(HTTP_INTERNAL_ERROR, src_exception=e)
else:
return DAVError(HTTP_INTERNAL_ERROR... | python | {
"resource": ""
} |
q255094 | DAVError.get_user_info | validation | def get_user_info(self):
"""Return readable string."""
if self.value in ERROR_DESCRIPTIONS:
s = "{}".format(ERROR_DESCRIPTIONS[self.value])
else:
s = "{}".format(self.value)
if self.context_info:
s += ": {}".format(self.context_info)
elif self... | python | {
"resource": ""
} |
q255095 | VirtualResource.handle_delete | validation | def handle_delete(self):
"""Change semantic of DELETE to remove resource tags."""
# DELETE is only supported for the '/by_tag/' collection
if "/by_tag/" not in self.path:
raise DAVError(HTTP_FORBIDDEN)
# path must be '/by_tag/<tag>/<resname>'
catType, tag, _rest = uti... | python | {
"resource": ""
} |
q255096 | VirtualResource.handle_copy | validation | def handle_copy(self, dest_path, depth_infinity):
"""Change semantic of COPY to add resource tags."""
# destPath must be '/by_tag/<tag>/<resname>'
if "/by_tag/" not in dest_path:
raise DAVError(HTTP_FORBIDDEN)
catType, tag, _rest = util.save_split(dest_path.strip("/"), "/", 2... | python | {
"resource": ""
} |
q255097 | VirtualResource.handle_move | validation | def handle_move(self, dest_path):
"""Change semantic of MOVE to change resource tags."""
# path and destPath must be '/by_tag/<tag>/<resname>'
if "/by_tag/" not in self.path:
raise DAVError(HTTP_FORBIDDEN)
if "/by_tag/" not in dest_path:
raise DAVError(HTTP_FORBID... | python | {
"resource": ""
} |
q255098 | VirtualResourceProvider.get_resource_inst | validation | def get_resource_inst(self, path, environ):
"""Return _VirtualResource object for path.
path is expected to be
categoryType/category/name/artifact
for example:
'by_tag/cool/My doc 2/info.html'
See DAVProvider.get_resource_inst()
"""
_logger.info(... | python | {
"resource": ""
} |
q255099 | WsgiDAVApp.add_provider | validation | def add_provider(self, share, provider, readonly=False):
"""Add a provider to the provider_map routing table."""
# Make sure share starts with, or is '/'
share = "/" + share.strip("/")
assert share not in self.provider_map
if compat.is_basestring(provider):
# Syntax:... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.