| # Copyright (c) 2014 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. |
| # |
| |
| from boto.cloudsearch2.optionstatus import IndexFieldStatus |
| from boto.cloudsearch2.optionstatus import ServicePoliciesStatus |
| from boto.cloudsearch2.optionstatus import ExpressionStatus |
| from boto.cloudsearch2.optionstatus import AvailabilityOptionsStatus |
| from boto.cloudsearch2.optionstatus import ScalingParametersStatus |
| from boto.cloudsearch2.document import DocumentServiceConnection |
| from boto.cloudsearch2.search import SearchConnection |
| |
| |
| def handle_bool(value): |
| if value in [True, 'true', 'True', 'TRUE', 1]: |
| return True |
| return False |
| |
| |
| class Domain(object): |
| """ |
| A Cloudsearch domain. |
| |
| :ivar name: The name of the domain. |
| |
| :ivar id: The internally generated unique identifier for the domain. |
| |
| :ivar created: A boolean which is True if the domain is |
| created. It can take several minutes to initialize a domain |
| when CreateDomain is called. Newly created search domains are |
| returned with a False value for Created until domain creation |
| is complete |
| |
| :ivar deleted: A boolean which is True if the search domain has |
| been deleted. The system must clean up resources dedicated to |
| the search domain when delete is called. Newly deleted |
| search domains are returned from list_domains with a True |
| value for deleted for several minutes until resource cleanup |
| is complete. |
| |
| :ivar processing: True if processing is being done to activate the |
| current domain configuration. |
| |
| :ivar num_searchable_docs: The number of documents that have been |
| submittted to the domain and indexed. |
| |
| :ivar requires_index_document: True if index_documents needs to be |
| called to activate the current domain configuration. |
| |
| :ivar search_instance_count: The number of search instances that are |
| available to process search requests. |
| |
| :ivar search_instance_type: The instance type that is being used to |
| process search requests. |
| |
| :ivar search_partition_count: The number of partitions across which |
| the search index is spread. |
| """ |
| |
| def __init__(self, layer1, data): |
| """ |
| Constructor - Create a domain object from a layer1 and data params |
| |
| :type layer1: :class:`boto.cloudsearch2.layer1.Layer1` object |
| :param layer1: A :class:`boto.cloudsearch2.layer1.Layer1` object |
| which is used to perform operations on the domain. |
| """ |
| self.layer1 = layer1 |
| self.update_from_data(data) |
| |
| def update_from_data(self, data): |
| self.created = data['Created'] |
| self.deleted = data['Deleted'] |
| self.processing = data['Processing'] |
| self.requires_index_documents = data['RequiresIndexDocuments'] |
| self.domain_id = data['DomainId'] |
| self.domain_name = data['DomainName'] |
| self.search_instance_count = data['SearchInstanceCount'] |
| self.search_instance_type = data.get('SearchInstanceType', None) |
| self.search_partition_count = data['SearchPartitionCount'] |
| self._doc_service = data['DocService'] |
| self._service_arn = data['ARN'] |
| self._search_service = data['SearchService'] |
| |
| @property |
| def service_arn(self): |
| return self._service_arn |
| |
| @property |
| def doc_service_endpoint(self): |
| return self._doc_service['Endpoint'] |
| |
| @property |
| def search_service_endpoint(self): |
| return self._search_service['Endpoint'] |
| |
| @property |
| def created(self): |
| return self._created |
| |
| @created.setter |
| def created(self, value): |
| self._created = handle_bool(value) |
| |
| @property |
| def deleted(self): |
| return self._deleted |
| |
| @deleted.setter |
| def deleted(self, value): |
| self._deleted = handle_bool(value) |
| |
| @property |
| def processing(self): |
| return self._processing |
| |
| @processing.setter |
| def processing(self, value): |
| self._processing = handle_bool(value) |
| |
| @property |
| def requires_index_documents(self): |
| return self._requires_index_documents |
| |
| @requires_index_documents.setter |
| def requires_index_documents(self, value): |
| self._requires_index_documents = handle_bool(value) |
| |
| @property |
| def search_partition_count(self): |
| return self._search_partition_count |
| |
| @search_partition_count.setter |
| def search_partition_count(self, value): |
| self._search_partition_count = int(value) |
| |
| @property |
| def search_instance_count(self): |
| return self._search_instance_count |
| |
| @search_instance_count.setter |
| def search_instance_count(self, value): |
| self._search_instance_count = int(value) |
| |
| @property |
| def name(self): |
| return self.domain_name |
| |
| @property |
| def id(self): |
| return self.domain_id |
| |
| def delete(self): |
| """ |
| Delete this domain and all index data associated with it. |
| """ |
| return self.layer1.delete_domain(self.name) |
| |
| def get_analysis_schemes(self): |
| """ |
| Return a list of Analysis Scheme objects. |
| """ |
| return self.layer1.describe_analysis_schemes(self.name) |
| |
| def get_availability_options(self): |
| """ |
| Return a :class:`boto.cloudsearch2.option.AvailabilityOptionsStatus` |
| object representing the currently defined availability options for |
| the domain. |
| :return: OptionsStatus object |
| :rtype: :class:`boto.cloudsearch2.option.AvailabilityOptionsStatus` |
| object |
| """ |
| return AvailabilityOptionsStatus( |
| self, refresh_fn=self.layer1.describe_availability_options, |
| refresh_key=['DescribeAvailabilityOptionsResponse', |
| 'DescribeAvailabilityOptionsResult', |
| 'AvailabilityOptions'], |
| save_fn=self.layer1.update_availability_options) |
| |
| def get_scaling_options(self): |
| """ |
| Return a :class:`boto.cloudsearch2.option.ScalingParametersStatus` |
| object representing the currently defined scaling options for the |
| domain. |
| :return: ScalingParametersStatus object |
| :rtype: :class:`boto.cloudsearch2.option.ScalingParametersStatus` |
| object |
| """ |
| return ScalingParametersStatus( |
| self, refresh_fn=self.layer1.describe_scaling_parameters, |
| refresh_key=['DescribeScalingParametersResponse', |
| 'DescribeScalingParametersResult', |
| 'ScalingParameters'], |
| save_fn=self.layer1.update_scaling_parameters) |
| |
| def get_access_policies(self): |
| """ |
| Return a :class:`boto.cloudsearch2.option.ServicePoliciesStatus` |
| object representing the currently defined access policies for the |
| domain. |
| :return: ServicePoliciesStatus object |
| :rtype: :class:`boto.cloudsearch2.option.ServicePoliciesStatus` object |
| """ |
| return ServicePoliciesStatus( |
| self, refresh_fn=self.layer1.describe_service_access_policies, |
| refresh_key=['DescribeServiceAccessPoliciesResponse', |
| 'DescribeServiceAccessPoliciesResult', |
| 'AccessPolicies'], |
| save_fn=self.layer1.update_service_access_policies) |
| |
| def index_documents(self): |
| """ |
| Tells the search domain to start indexing its documents using |
| the latest text processing options and IndexFields. This |
| operation must be invoked to make options whose OptionStatus |
| has OptionState of RequiresIndexDocuments visible in search |
| results. |
| """ |
| self.layer1.index_documents(self.name) |
| |
| def get_index_fields(self, field_names=None): |
| """ |
| Return a list of index fields defined for this domain. |
| :return: list of IndexFieldStatus objects |
| :rtype: list of :class:`boto.cloudsearch2.option.IndexFieldStatus` |
| object |
| """ |
| data = self.layer1.describe_index_fields(self.name, field_names) |
| |
| data = (data['DescribeIndexFieldsResponse'] |
| ['DescribeIndexFieldsResult'] |
| ['IndexFields']) |
| |
| return [IndexFieldStatus(self, d) for d in data] |
| |
| def create_index_field(self, field_name, field_type, |
| default='', facet=False, returnable=False, |
| searchable=False, sortable=False, |
| highlight=False, source_field=None, |
| analysis_scheme=None): |
| """ |
| Defines an ``IndexField``, either replacing an existing |
| definition or creating a new one. |
| |
| :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 |
| int | double | literal | text | date | latlon | |
| int-array | double-array | literal-array | text-array | date-array |
| |
| :type default: string or int |
| :param default: The default value for the field. If the |
| field is of type ``int`` 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 ``int, int-array, text, text-array``. |
| |
| :type returnable: bool |
| :param returnable: A boolean to indicate whether values |
| of this field can be returned in search results or |
| used in ranking. |
| |
| :type searchable: bool |
| :param searchable: A boolean to indicate whether search |
| is enabled for this field or not. |
| |
| :type sortable: bool |
| :param sortable: A boolean to indicate whether sorting |
| is enabled for this field or not. Does not apply to |
| fields of array types. |
| |
| :type highlight: bool |
| :param highlight: A boolean to indicate whether highlighting |
| is enabled for this field or not. Does not apply to |
| fields of type ``double, int, date, latlon`` |
| |
| :type source_field: list of strings or string |
| :param source_field: For array types, this is the list of fields |
| to treat as the source. For singular types, pass a string only. |
| |
| :type analysis_scheme: string |
| :param analysis_scheme: The analysis scheme to use for this field. |
| Only applies to ``text | text-array`` field types |
| |
| :return: IndexFieldStatus objects |
| :rtype: :class:`boto.cloudsearch2.option.IndexFieldStatus` object |
| |
| :raises: BaseException, InternalException, LimitExceededException, |
| InvalidTypeException, ResourceNotFoundException |
| """ |
| index = { |
| 'IndexFieldName': field_name, |
| 'IndexFieldType': field_type |
| } |
| if field_type == 'literal': |
| index['LiteralOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['LiteralOptions']['DefaultValue'] = default |
| if source_field: |
| index['LiteralOptions']['SourceField'] = source_field |
| elif field_type == 'literal-array': |
| index['LiteralArrayOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable |
| } |
| if default: |
| index['LiteralArrayOptions']['DefaultValue'] = default |
| if source_field: |
| index['LiteralArrayOptions']['SourceFields'] = \ |
| ','.join(source_field) |
| elif field_type == 'int': |
| index['IntOptions'] = { |
| 'DefaultValue': default, |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['IntOptions']['DefaultValue'] = default |
| if source_field: |
| index['IntOptions']['SourceField'] = source_field |
| elif field_type == 'int-array': |
| index['IntArrayOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable |
| } |
| if default: |
| index['IntArrayOptions']['DefaultValue'] = default |
| if source_field: |
| index['IntArrayOptions']['SourceFields'] = \ |
| ','.join(source_field) |
| elif field_type == 'date': |
| index['DateOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['DateOptions']['DefaultValue'] = default |
| if source_field: |
| index['DateOptions']['SourceField'] = source_field |
| elif field_type == 'date-array': |
| index['DateArrayOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable |
| } |
| if default: |
| index['DateArrayOptions']['DefaultValue'] = default |
| if source_field: |
| index['DateArrayOptions']['SourceFields'] = \ |
| ','.join(source_field) |
| elif field_type == 'double': |
| index['DoubleOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['DoubleOptions']['DefaultValue'] = default |
| if source_field: |
| index['DoubleOptions']['SourceField'] = source_field |
| elif field_type == 'double-array': |
| index['DoubleArrayOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable |
| } |
| if default: |
| index['DoubleArrayOptions']['DefaultValue'] = default |
| if source_field: |
| index['DoubleArrayOptions']['SourceFields'] = \ |
| ','.join(source_field) |
| elif field_type == 'text': |
| index['TextOptions'] = { |
| 'ReturnEnabled': returnable, |
| 'HighlightEnabled': highlight, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['TextOptions']['DefaultValue'] = default |
| if source_field: |
| index['TextOptions']['SourceField'] = source_field |
| if analysis_scheme: |
| index['TextOptions']['AnalysisScheme'] = analysis_scheme |
| elif field_type == 'text-array': |
| index['TextArrayOptions'] = { |
| 'ReturnEnabled': returnable, |
| 'HighlightEnabled': highlight |
| } |
| if default: |
| index['TextArrayOptions']['DefaultValue'] = default |
| if source_field: |
| index['TextArrayOptions']['SourceFields'] = \ |
| ','.join(source_field) |
| if analysis_scheme: |
| index['TextArrayOptions']['AnalysisScheme'] = analysis_scheme |
| elif field_type == 'latlon': |
| index['LatLonOptions'] = { |
| 'FacetEnabled': facet, |
| 'ReturnEnabled': returnable, |
| 'SearchEnabled': searchable, |
| 'SortEnabled': sortable |
| } |
| if default: |
| index['LatLonOptions']['DefaultValue'] = default |
| if source_field: |
| index['LatLonOptions']['SourceField'] = source_field |
| |
| data = self.layer1.define_index_field(self.name, index) |
| |
| data = (data['DefineIndexFieldResponse'] |
| ['DefineIndexFieldResult'] |
| ['IndexField']) |
| |
| return IndexFieldStatus(self, data, |
| self.layer1.describe_index_fields) |
| |
| def get_expressions(self, names=None): |
| """ |
| Return a list of rank expressions defined for this domain. |
| :return: list of ExpressionStatus objects |
| :rtype: list of :class:`boto.cloudsearch2.option.ExpressionStatus` |
| object |
| """ |
| fn = self.layer1.describe_expressions |
| data = fn(self.name, names) |
| |
| data = (data['DescribeExpressionsResponse'] |
| ['DescribeExpressionsResult'] |
| ['Expressions']) |
| |
| return [ExpressionStatus(self, d, fn) for d in data] |
| |
| def create_expression(self, name, value): |
| """ |
| Create a new expression. |
| |
| :type name: string |
| :param name: The name of an expression for processing |
| during a search request. |
| |
| :type value: string |
| :param value: The expression to evaluate for ranking |
| or thresholding while processing a search request. The |
| Expression syntax is based on JavaScript expressions |
| and supports: |
| |
| * Single value, sort enabled numeric fields (int, double, date) |
| * Other expressions |
| * The _score variable, which references a document's relevance |
| score |
| * The _time variable, which references the current epoch time |
| * Integer, floating point, hex, and octal literals |
| * Arithmetic operators: + - * / % |
| * Bitwise operators: | & ^ ~ << >> >>> |
| * Boolean operators (including the ternary operator): && || ! ?: |
| * Comparison operators: < <= == >= > |
| * Mathematical functions: abs ceil exp floor ln log2 log10 logn |
| max min pow sqrt pow |
| * Trigonometric functions: acos acosh asin asinh atan atan2 atanh |
| cos cosh sin sinh tanh tan |
| * The haversin distance function |
| |
| Expressions always return an integer value from 0 to the maximum |
| 64-bit signed integer value (2^63 - 1). Intermediate results are |
| calculated as double-precision floating point values and the return |
| value is rounded to the nearest integer. If the expression is |
| invalid or evaluates to a negative value, it returns 0. If the |
| expression evaluates to a value greater than the maximum, it |
| returns the maximum value. |
| |
| The source data for an Expression can be the name of an |
| IndexField of type int or double, another Expression or the |
| reserved name _score. The _score source is |
| defined to return as a double from 0 to 10.0 (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. |
| |
| :return: ExpressionStatus object |
| :rtype: :class:`boto.cloudsearch2.option.ExpressionStatus` object |
| |
| :raises: BaseException, InternalException, LimitExceededException, |
| InvalidTypeException, ResourceNotFoundException |
| """ |
| data = self.layer1.define_expression(self.name, name, value) |
| |
| data = (data['DefineExpressionResponse'] |
| ['DefineExpressionResult'] |
| ['Expression']) |
| |
| return ExpressionStatus(self, data, |
| self.layer1.describe_expressions) |
| |
| def get_document_service(self): |
| return DocumentServiceConnection(domain=self) |
| |
| def get_search_service(self): |
| return SearchConnection(domain=self) |
| |
| def __repr__(self): |
| return '<Domain: %s>' % self.domain_name |
