Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/gsutil/boto/cloudsearch/layer1.py

Issue 12042069: Scripts to download files from google storage based on sha1 sums (Closed) Base URL: https://chromium.googlesource.com/chromium/tools/depot_tools.git@master
Patch Set: Removed gsutil/tests and gsutil/docs Created 7 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« download_from_google_storage.py ('K') | « third_party/gsutil/boto/cloudsearch/domain.py ('k') | third_party/gsutil/boto/cloudsearch/layer2.py » ('j') | upload_to_google_storage.py » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/gsutil/boto/cloudsearch/layer1.py
diff --git a/third_party/gsutil/boto/cloudsearch/layer1.py b/third_party/gsutil/boto/cloudsearch/layer1.py
new file mode 100644
index 0000000000000000000000000000000000000000..054fc3230909660be04e799a8a1f2a1cd7958a72
--- /dev/null
+++ b/third_party/gsutil/boto/cloudsearch/layer1.py
@@ -0,0 +1,738 @@
+# Copyright (c) 2012 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.
+# All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import boto
+import boto.jsonresponse
+from boto.connection import AWSQueryConnection
+from boto.regioninfo import RegionInfo
+
+#boto.set_stream_logger('cloudsearch')
+
+
+def do_bool(val):
+ return 'true' if val in [True, 1, '1', 'true'] else 'false'
+
+
+class Layer1(AWSQueryConnection):
+
+ APIVersion = '2011-02-01'
+ DefaultRegionName = boto.config.get('Boto', 'cs_region_name', 'us-east-1')
+ DefaultRegionEndpoint = boto.config.get('Boto', 'cs_region_endpoint',
+ 'cloudsearch.us-east-1.amazonaws.com')
+
+ def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
+ is_secure=True, host=None, port=None,
+ proxy=None, proxy_port=None,
+ proxy_user=None, proxy_pass=None, debug=0,
+ https_connection_factory=None, region=None, path='/',
+ api_version=None, security_token=None,
+ validate_certs=True):
+ if not region:
+ region = RegionInfo(self, self.DefaultRegionName,
+ self.DefaultRegionEndpoint)
+ self.region = region
+ AWSQueryConnection.__init__(self, aws_access_key_id,
+ aws_secret_access_key,
+ is_secure, port, proxy, proxy_port,
+ proxy_user, proxy_pass,
+ self.region.endpoint, debug,
+ https_connection_factory, path,
+ security_token,
+ validate_certs=validate_certs)
+
+ def _required_auth_capability(self):
+ return ['sign-v2']
+
+ def get_response(self, doc_path, action, params, path='/',
+ parent=None, verb='GET', list_marker=None):
+ if not parent:
+ parent = self
+ response = self.make_request(action, params, path, verb)
+ body = response.read()
+ boto.log.debug(body)
+ if response.status == 200:
+ e = boto.jsonresponse.Element(
+ list_marker=list_marker if list_marker else 'Set',
+ pythonize_name=True)
+ h = boto.jsonresponse.XmlHandler(e, parent)
+ h.parse(body)
+ inner = e
+ for p in doc_path:
+ inner = inner.get(p)
+ if not inner:
+ return None if list_marker == None else []
+ if isinstance(inner, list):
+ return [dict(**i) for i in inner]
+ else:
+ return dict(**inner)
+ else:
+ raise self.ResponseError(response.status, response.reason, body)
+
+ def create_domain(self, domain_name):
+ """
+ Create a new search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, LimitExceededException
+ """
+ doc_path = ('create_domain_response',
+ 'create_domain_result',
+ 'domain_status')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'CreateDomain',
+ params, verb='POST')
+
+ def define_index_field(self, domain_name, field_name, field_type,
+ default='', facet=False, result=False,
+ searchable=False, source_attributes=None):
+ """
+ Defines an ``IndexField``, either replacing an existing
+ definition or creating a new one.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type field_name: string
+ :param field_name: The name of a field in the search index.
+
+ :type field_type: string
+ :param field_type: The type of field. Valid values are
+ uint | literal | text
+
+ :type default: string or int
+ :param default: The default value for the field. If the
+ field is of type ``uint`` this should be an integer value.
+ Otherwise, it's a string.
+
+ :type facet: bool
+ :param facet: A boolean to indicate whether facets
+ are enabled for this field or not. Does not apply to
+ fields of type ``uint``.
+
+ :type results: bool
+ :param results: A boolean to indicate whether values
+ of this field can be returned in search results or
+ used in ranking. Does not apply to fields of type ``uint``.
+
+ :type searchable: bool
+ :param searchable: A boolean to indicate whether search
+ is enabled for this field or not. Applies only to fields
+ of type ``literal``.
+
+ :type source_attributes: list of dicts
+ :param source_attributes: An optional list of dicts that
+ provide information about attributes for this index field.
+ A maximum of 20 source attributes can be configured for
+ each index field.
+
+ Each item in the list is a dict with the following keys:
+
+ * data_copy - The value is a dict with the following keys:
+ * default - Optional default value if the source attribute
+ is not specified in a document.
+ * name - The name of the document source field to add
+ to this ``IndexField``.
+ * data_function - Identifies the transformation to apply
+ when copying data from a source attribute.
+ * data_map - The value is a dict with the following keys:
+ * cases - A dict that translates source field values
+ to custom values.
+ * default - An optional default value to use if the
+ source attribute is not specified in a document.
+ * name - the name of the document source field to add
+ to this ``IndexField``
+ * data_trim_title - Trims common title words from a source
+ document attribute when populating an ``IndexField``.
+ This can be used to create an ``IndexField`` you can
+ use for sorting. The value is a dict with the following
+ fields:
+ * default - An optional default value.
+ * language - an IETF RFC 4646 language code.
+ * separator - The separator that follows the text to trim.
+ * name - The name of the document source field to add.
+
+ :raises: BaseException, InternalException, LimitExceededException,
+ InvalidTypeException, ResourceNotFoundException
+ """
+ doc_path = ('define_index_field_response',
+ 'define_index_field_result',
+ 'index_field')
+ params = {'DomainName': domain_name,
+ 'IndexField.IndexFieldName': field_name,
+ 'IndexField.IndexFieldType': field_type}
+ if field_type == 'literal':
+ params['IndexField.LiteralOptions.DefaultValue'] = default
+ params['IndexField.LiteralOptions.FacetEnabled'] = do_bool(facet)
+ params['IndexField.LiteralOptions.ResultEnabled'] = do_bool(result)
+ params['IndexField.LiteralOptions.SearchEnabled'] = do_bool(searchable)
+ elif field_type == 'uint':
+ params['IndexField.UIntOptions.DefaultValue'] = default
+ elif field_type == 'text':
+ params['IndexField.TextOptions.DefaultValue'] = default
+ params['IndexField.TextOptions.FacetEnabled'] = do_bool(facet)
+ params['IndexField.TextOptions.ResultEnabled'] = do_bool(result)
+
+ return self.get_response(doc_path, 'DefineIndexField',
+ params, verb='POST')
+
+ def define_rank_expression(self, domain_name, rank_name, rank_expression):
+ """
+ Defines a RankExpression, either replacing an existing
+ definition or creating a new one.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type rank_name: string
+ :param rank_name: The name of an expression computed for ranking
+ while processing a search request.
+
+ :type rank_expression: string
+ :param rank_expression: The expression to evaluate for ranking
+ or thresholding while processing a search request. The
+ RankExpression syntax is based on JavaScript expressions
+ and supports:
+
+ * Integer, floating point, hex and octal literals
+ * Shortcut evaluation of logical operators such that an
+ expression a || b evaluates to the value a if a is
+ true without evaluting b at all
+ * JavaScript order of precedence for operators
+ * Arithmetic operators: + - * / %
+ * Boolean operators (including the ternary operator)
+ * Bitwise operators
+ * Comparison operators
+ * Common mathematic functions: abs ceil erf exp floor
+ lgamma ln log2 log10 max min sqrt pow
+ * Trigonometric library functions: acosh acos asinh asin
+ atanh atan cosh cos sinh sin tanh tan
+ * Random generation of a number between 0 and 1: rand
+ * Current time in epoch: time
+ * The min max functions that operate on a variable argument list
+
+ Intermediate results are calculated as double precision
+ floating point values. The final return value of a
+ RankExpression is automatically converted from floating
+ point to a 32-bit unsigned integer by rounding to the
+ nearest integer, with a natural floor of 0 and a ceiling
+ of max(uint32_t), 4294967295. Mathematical errors such as
+ dividing by 0 will fail during evaluation and return a
+ value of 0.
+
+ The source data for a RankExpression can be the name of an
+ IndexField of type uint, another RankExpression or the
+ reserved name text_relevance. The text_relevance source is
+ defined to return an integer from 0 to 1000 (inclusive) to
+ indicate how relevant a document is to the search request,
+ taking into account repetition of search terms in the
+ document and proximity of search terms to each other in
+ each matching IndexField in the document.
+
+ For more information about using rank expressions to
+ customize ranking, see the Amazon CloudSearch Developer
+ Guide.
+
+ :raises: BaseException, InternalException, LimitExceededException,
+ InvalidTypeException, ResourceNotFoundException
+ """
+ doc_path = ('define_rank_expression_response',
+ 'define_rank_expression_result',
+ 'rank_expression')
+ params = {'DomainName': domain_name,
+ 'RankExpression.RankExpression': rank_expression,
+ 'RankExpression.RankName': rank_name}
+ return self.get_response(doc_path, 'DefineRankExpression',
+ params, verb='POST')
+
+ def delete_domain(self, domain_name):
+ """
+ Delete a search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException
+ """
+ doc_path = ('delete_domain_response',
+ 'delete_domain_result',
+ 'domain_status')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DeleteDomain',
+ params, verb='POST')
+
+ def delete_index_field(self, domain_name, field_name):
+ """
+ Deletes an existing ``IndexField`` from the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type field_name: string
+ :param field_name: A string that represents the name of
+ an index field. Field names must begin with a letter and
+ can contain the following characters: a-z (lowercase),
+ 0-9, and _ (underscore). Uppercase letters and hyphens are
+ not allowed. The names "body", "docid", and
+ "text_relevance" are reserved and cannot be specified as
+ field or rank expression names.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('delete_index_field_response',
+ 'delete_index_field_result',
+ 'index_field')
+ params = {'DomainName': domain_name,
+ 'IndexFieldName': field_name}
+ return self.get_response(doc_path, 'DeleteIndexField',
+ params, verb='POST')
+
+ def delete_rank_expression(self, domain_name, rank_name):
+ """
+ Deletes an existing ``RankExpression`` from the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type rank_name: string
+ :param rank_name: Name of the ``RankExpression`` to delete.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('delete_rank_expression_response',
+ 'delete_rank_expression_result',
+ 'rank_expression')
+ params = {'DomainName': domain_name, 'RankName': rank_name}
+ return self.get_response(doc_path, 'DeleteRankExpression',
+ params, verb='POST')
+
+ def describe_default_search_field(self, domain_name):
+ """
+ Describes options defining the default search field used by
+ indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_default_search_field_response',
+ 'describe_default_search_field_result',
+ 'default_search_field')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DescribeDefaultSearchField',
+ params, verb='POST')
+
+ def describe_domains(self, domain_names=None):
+ """
+ Describes the domains (optionally limited to one or more
+ domains by name) owned by this account.
+
+ :type domain_names: list
+ :param domain_names: Limits the response to the specified domains.
+
+ :raises: BaseException, InternalException
+ """
+ doc_path = ('describe_domains_response',
+ 'describe_domains_result',
+ 'domain_status_list')
+ params = {}
+ if domain_names:
+ for i, domain_name in enumerate(domain_names, 1):
+ params['DomainNames.member.%d' % i] = domain_name
+ return self.get_response(doc_path, 'DescribeDomains',
+ params, verb='POST',
+ list_marker='DomainStatusList')
+
+ def describe_index_fields(self, domain_name, field_names=None):
+ """
+ Describes index fields in the search domain, optionally
+ limited to a single ``IndexField``.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type field_names: list
+ :param field_names: Limits the response to the specified fields.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_index_fields_response',
+ 'describe_index_fields_result',
+ 'index_fields')
+ params = {'DomainName': domain_name}
+ if field_names:
+ for i, field_name in enumerate(field_names, 1):
+ params['FieldNames.member.%d' % i] = field_name
+ return self.get_response(doc_path, 'DescribeIndexFields',
+ params, verb='POST',
+ list_marker='IndexFields')
+
+ def describe_rank_expressions(self, domain_name, rank_names=None):
+ """
+ Describes RankExpressions in the search domain, optionally
+ limited to a single expression.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type rank_names: list
+ :param rank_names: Limit response to the specified rank names.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_rank_expressions_response',
+ 'describe_rank_expressions_result',
+ 'rank_expressions')
+ params = {'DomainName': domain_name}
+ if rank_names:
+ for i, rank_name in enumerate(rank_names, 1):
+ params['RankNames.member.%d' % i] = rank_name
+ return self.get_response(doc_path, 'DescribeRankExpressions',
+ params, verb='POST',
+ list_marker='RankExpressions')
+
+ def describe_service_access_policies(self, domain_name):
+ """
+ Describes the resource-based policies controlling access to
+ the services in this search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_service_access_policies_response',
+ 'describe_service_access_policies_result',
+ 'access_policies')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DescribeServiceAccessPolicies',
+ params, verb='POST')
+
+ def describe_stemming_options(self, domain_name):
+ """
+ Describes stemming options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_stemming_options_response',
+ 'describe_stemming_options_result',
+ 'stems')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DescribeStemmingOptions',
+ params, verb='POST')
+
+ def describe_stopword_options(self, domain_name):
+ """
+ Describes stopword options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_stopword_options_response',
+ 'describe_stopword_options_result',
+ 'stopwords')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DescribeStopwordOptions',
+ params, verb='POST')
+
+ def describe_synonym_options(self, domain_name):
+ """
+ Describes synonym options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('describe_synonym_options_response',
+ 'describe_synonym_options_result',
+ 'synonyms')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'DescribeSynonymOptions',
+ params, verb='POST')
+
+ def index_documents(self, domain_name):
+ """
+ Tells the search domain to start scanning its documents using
+ the latest text processing options and ``IndexFields``. This
+ operation must be invoked to make visible in searches any
+ options whose <a>OptionStatus</a> has ``OptionState`` of
+ ``RequiresIndexDocuments``.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :raises: BaseException, InternalException, ResourceNotFoundException
+ """
+ doc_path = ('index_documents_response',
+ 'index_documents_result',
+ 'field_names')
+ params = {'DomainName': domain_name}
+ return self.get_response(doc_path, 'IndexDocuments', params,
+ verb='POST', list_marker='FieldNames')
+
+ def update_default_search_field(self, domain_name, default_search_field):
+ """
+ Updates options defining the default search field used by
+ indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type default_search_field: string
+ :param default_search_field: The IndexField to use for search
+ requests issued with the q parameter. The default is an
+ empty string, which automatically searches all text
+ fields.
+
+ :raises: BaseException, InternalException, InvalidTypeException,
+ ResourceNotFoundException
+ """
+ doc_path = ('update_default_search_field_response',
+ 'update_default_search_field_result',
+ 'default_search_field')
+ params = {'DomainName': domain_name,
+ 'DefaultSearchField': default_search_field}
+ return self.get_response(doc_path, 'UpdateDefaultSearchField',
+ params, verb='POST')
+
+ def update_service_access_policies(self, domain_name, access_policies):
+ """
+ Updates the policies controlling access to the services in
+ this search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type access_policies: string
+ :param access_policies: An IAM access policy as described in
+ The Access Policy Language in Using AWS Identity and
+ Access Management. The maximum size of an access policy
+ document is 100KB.
+
+ :raises: BaseException, InternalException, LimitExceededException,
+ ResourceNotFoundException, InvalidTypeException
+ """
+ doc_path = ('update_service_access_policies_response',
+ 'update_service_access_policies_result',
+ 'access_policies')
+ params = {'AccessPolicies': access_policies,
+ 'DomainName': domain_name}
+ return self.get_response(doc_path, 'UpdateServiceAccessPolicies',
+ params, verb='POST')
+
+ def update_stemming_options(self, domain_name, stems):
+ """
+ Updates stemming options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type stems: string
+ :param stems: Maps terms to their stems. The JSON object
+ has a single key called "stems" whose value is a
+ dict mapping terms to their stems. The maximum size
+ of a stemming document is 500KB.
+ Example: {"stems":{"people": "person", "walking":"walk"}}
+
+ :raises: BaseException, InternalException, InvalidTypeException,
+ LimitExceededException, ResourceNotFoundException
+ """
+ doc_path = ('update_stemming_options_response',
+ 'update_stemming_options_result',
+ 'stems')
+ params = {'DomainName': domain_name,
+ 'Stems': stems}
+ return self.get_response(doc_path, 'UpdateStemmingOptions',
+ params, verb='POST')
+
+ def update_stopword_options(self, domain_name, stopwords):
+ """
+ Updates stopword options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type stopwords: string
+ :param stopwords: Lists stopwords in a JSON object. The object has a
+ single key called "stopwords" whose value is an array of strings.
+ The maximum size of a stopwords document is 10KB. Example:
+ {"stopwords": ["a", "an", "the", "of"]}
+
+ :raises: BaseException, InternalException, InvalidTypeException,
+ LimitExceededException, ResourceNotFoundException
+ """
+ doc_path = ('update_stopword_options_response',
+ 'update_stopword_options_result',
+ 'stopwords')
+ params = {'DomainName': domain_name,
+ 'Stopwords': stopwords}
+ return self.get_response(doc_path, 'UpdateStopwordOptions',
+ params, verb='POST')
+
+ def update_synonym_options(self, domain_name, synonyms):
+ """
+ Updates synonym options used by indexing for the search domain.
+
+ :type domain_name: string
+ :param domain_name: A string that represents the name of a
+ domain. Domain names must be unique across the domains
+ owned by an account within an AWS region. Domain names
+ must start with a letter or number and can contain the
+ following characters: a-z (lowercase), 0-9, and -
+ (hyphen). Uppercase letters and underscores are not
+ allowed.
+
+ :type synonyms: string
+ :param synonyms: Maps terms to their synonyms. The JSON object
+ has a single key "synonyms" whose value is a dict mapping terms
+ to their synonyms. Each synonym is a simple string or an
+ array of strings. The maximum size of a stopwords document
+ is 100KB. Example:
+ {"synonyms": {"cat": ["feline", "kitten"], "puppy": "dog"}}
+
+ :raises: BaseException, InternalException, InvalidTypeException,
+ LimitExceededException, ResourceNotFoundException
+ """
+ doc_path = ('update_synonym_options_response',
+ 'update_synonym_options_result',
+ 'synonyms')
+ params = {'DomainName': domain_name,
+ 'Synonyms': synonyms}
+ return self.get_response(doc_path, 'UpdateSynonymOptions',
+ params, verb='POST')
« download_from_google_storage.py ('K') | « third_party/gsutil/boto/cloudsearch/domain.py ('k') | third_party/gsutil/boto/cloudsearch/layer2.py » ('j') | upload_to_google_storage.py » ('J')

Powered by Google App Engine
This is Rietveld 408576698