refactor(elasticpy/): formatted code as per PEP8 guidelines

Author: aniketmaithani

elasticpy/connection.py

@@ -17,17 +17,17 @@
 except ImportError:
     pass
 
+
 class ElasticConnection(object):
     if _use_gevent:
         session = None
         session_lock = RLock()
 
-
     def __init__(self, timeout=None, **params):
         self.status_code = 0
-        self.timeout=timeout
+        self.timeout = timeout
         self.encoding = None
-        self.headers = {'Content-Type' : 'Application/json; charset=utf-8'}
+        self.headers = {'Content-Type': 'Application/json; charset=utf-8'}
         if params.has_key('encoding'):
             self.encoding = 'utf8'
             del params['encoding']
@@ -37,40 +37,42 @@ def __init__(self, timeout=None, **params):
                 ElasticConnection.session = requests.Session(**params)
                 ElasticConnection.session_lock.release()
         else:
-            self.session = requests.Session(timeout=timeout, **params) 
+            self.session = requests.Session(timeout=timeout, **params)
+
     def get(self, url):
         try:
-            response = self.session.get(url,headers=self.headers,timeout=self.timeout)
+            response = self.session.get(url, headers=self.headers, timeout=self.timeout)
         except requests.ConnectionError as e:
             self.status_code = 0
-            return {'error':e.message}
+            return {'error': e.message}
         self.status_code = response.status_code
-        return json.loads(response.content,encoding=self.encoding)
+        return json.loads(response.content, encoding=self.encoding)
+
     def post(self, url, data):
         body = json.dumps(data)
         try:
-            response = self.session.post(url,data=body,headers=self.headers,timeout=self.timeout)
+            response = self.session.post(url, data=body, headers=self.headers, timeout=self.timeout)
         except requests.ConnectionError as e:
             self.status_code = 0
-            return {'error' : e.message}
+            return {'error': e.message}
         self.status_code = response.status_code
-        return json.loads(response.content,encoding=self.encoding)
+        return json.loads(response.content, encoding=self.encoding)
 
     def put(self, url, data):
         body = json.dumps(data)
         try:
-            response = self.session.post(url,data=body,headers=self.headers,timeout=self.timeout)
+            response = self.session.post(url, data=body, headers=self.headers, timeout=self.timeout)
         except requests.ConnectionError as e:
             self.status_code = 0
-            return {'error' : e.message}
+            return {'error': e.message}
         self.status_code = response.status_code
-        return json.loads(response.content,encoding=self.encoding)
+        return json.loads(response.content, encoding=self.encoding)
 
-    def delete(self,url):
+    def delete(self, url):
         try:
-            response = self.session.delete(url,headers=self.headers,timeout=self.timeout)
+            response = self.session.delete(url, headers=self.headers, timeout=self.timeout)
         except requests.ConnectionError as e:
             self.status_code = 0
-            return {'error' : e.message}
+            return {'error': e.message}
         self.status_code = response.status_code
-        return json.loads(response.content,encoding=self.encoding)
+        return json.loads(response.content, encoding=self.encoding)

elasticpy/facet.py

@@ -7,8 +7,8 @@
 '''
 
 
-
 class ElasticFacet(dict):
+
     '''
     Facets for search
     http://www.elasticsearch.org/guide/reference/api/search/facets/
@@ -31,7 +31,7 @@ def terms(self, facet_name, field, size=10, order=None, all_terms=False, exclude
         Regex Patterns: The terms API allows to define regex expression that will control which terms will be included in the faceted list.
         '''
 
-        self[facet_name] = dict(terms=dict(field=field,size=size))
+        self[facet_name] = dict(terms=dict(field=field, size=size))
         if order:
             self[facet_name][terms]['order'] = order
         if all_terms:
@@ -45,7 +45,7 @@ def terms(self, facet_name, field, size=10, order=None, all_terms=False, exclude
 
         return self
 
-    def range(self,facet_name, field, ranges=[]):
+    def range(self, facet_name, field, ranges=[]):
         '''
         Range facet allow to specify a set of ranges and get both the number of docs (count) that fall within each range, and aggregated data either based on the field, or using another field.
         http://www.elasticsearch.org/guide/reference/api/search/facets/range-facet.html
@@ -66,7 +66,7 @@ def range(self,facet_name, field, ranges=[]):
         }
         '''
 
-        self[facet_name] = {'range'  : { 'field' : field,'ranges' : [] }}
+        self[facet_name] = {'range': {'field': field, 'ranges': []}}
         for s in ranges:
             if not isinstance(s, slice):
                 continue
@@ -78,4 +78,3 @@ def range(self,facet_name, field, ranges=[]):
             self[facet_name]['range']['ranges'].append(entry)
 
         return self
-

elasticpy/filter.py

@@ -7,29 +7,29 @@
 '''
 
 
-
 class ElasticFilter(dict):
+
     '''
     Wrapper for ElasticSearch filters
     '''
-    
+
     @classmethod
     def and_filter(cls, query):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/and-filter.html
         A filter that matches documents using AND boolean operator on other queries. This filter is more performant then bool filter. Can be placed within queries that accept a filter.
         '''
-        return cls({'and':query})
+        return cls({'and': query})
 
     @classmethod
-    def bool_filter(cls,query):
+    def bool_filter(cls, query):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/bool-filter.html
         A filter that matches documents matching boolean combinations of other queries. Similar in concept to Boolean query, except that the clauses are other filters. Can be placed within queries that accept a filter.
         '''
 
-        return cls({'bool':query})
-    
+        return cls({'bool': query})
+
     @classmethod
     def exists(cls, field):
         '''
@@ -39,17 +39,18 @@ def exists(cls, field):
         > filter.query()
           {'exists' : {'field' : 'user' } }
         '''
-        return cls(exists={'field':field})
-    
+        return cls(exists={'field': field})
+
     @classmethod
     def ids(cls, values, itype=None):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/ids-filter.html
 Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field.
 
         '''
-        instance = cls(ids={'values':values})
-        if itype is not None: instance['ids']['type'] = itype
+        instance = cls(ids={'values': values})
+        if itype is not None:
+            instance['ids']['type'] = itype
 
         return instance
 
@@ -59,16 +60,16 @@ def limit(cls, value):
         http://www.elasticsearch.org/guide/reference/query-dsl/limit-filter.html
         A limit filter limits the number of documents (per shard) to execute on.
         '''
-        return cls(limit={'value':value})
+        return cls(limit={'value': value})
 
     @classmethod
-    def type(cls,value):
+    def type(cls, value):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/type-filter.html
 Filters documents matching the provided document / mapping type. Note, this filter can work even when the _type field is not indexed (using the _uid field).
         '''
-        return cls(type={'value':value})
-    
+        return cls(type={'value': value})
+
     @classmethod
     def geo_bounding_box(cls, field, top_left, bottom_right):
         '''
@@ -81,7 +82,7 @@ def geo_bounding_box(cls, field, top_left, bottom_right):
         > bounds = ElasticFilter().geo_bounding_box('pin.location', "drm3btev3e86", "drm3btev3e86")
 
         '''
-        return cls(geo_bounding_box={field:{'top_left':top_left, 'bottom_right':bottom_right}})
+        return cls(geo_bounding_box={field: {'top_left': top_left, 'bottom_right': bottom_right}})
 
     @classmethod
     def geo_distance(cls, field, center, distance, distance_type=None):
@@ -95,11 +96,11 @@ def geo_distance(cls, field, center, distance, distance_type=None):
         > bounds = ElasticFilter().geo_distance('pin.location', [40.73, -74.1], '300km')
         '''
 
-        instance = cls(geo_distance={'distance':distance, field:center})
-        if distance_type is not None: instance['geo_distance']['distance_type'] = distance_type
+        instance = cls(geo_distance={'distance': distance, field: center})
+        if distance_type is not None:
+            instance['geo_distance']['distance_type'] = distance_type
         return instance
 
-
     @classmethod
     def geo_distance_range(cls, field, center, from_distance, to_distance, distance_type=None):
         '''
@@ -108,8 +109,9 @@ def geo_distance_range(cls, field, center, from_distance, to_distance, distance_
 
 
         '''
-        instance = cls(geo_distance_range={'from':from_distance, 'to':to_distance, field:center})
-        if distance_type is not None: instance['geo_distance_range']['distance_type'] = distance_type
+        instance = cls(geo_distance_range={'from': from_distance, 'to': to_distance, field: center})
+        if distance_type is not None:
+            instance['geo_distance_range']['distance_type'] = distance_type
         return instance
 
     @classmethod
@@ -121,7 +123,7 @@ def geo_polygon(cls, field, points):
 
         > filter = ElasticFilter().geo_polygon('pin.location', [[40, -70], [30, -80], [20, -90]])
         '''
-        return cls(geo_polygon={field:{'points':points}})
+        return cls(geo_polygon={field: {'points': points}})
 
     @classmethod
     def has_child(cls, child_type, query):
@@ -134,8 +136,7 @@ def has_child(cls, child_type, query):
 
         '''
 
-        return cls(has_child={'type':child_type, 'query':query})
-
+        return cls(has_child={'type': child_type, 'query': query})
 
     @classmethod
     def match_all(cls):
@@ -154,7 +155,7 @@ def missing(cls, field):
         Filters documents where a specific field has no value in them.
 
         '''
-        return cls(missing={'field':field})
+        return cls(missing={'field': field})
 
     @classmethod
     def not_filter(cls, query):
@@ -163,19 +164,21 @@ def not_filter(cls, query):
         A filter that filters out matched documents using a query. This filter is more performant then bool filter. Can be placed within queries that accept a filter.
 
         '''
-        return cls({'not':query})
+        return cls({'not': query})
 
     @classmethod
     def numeric_range(cls, field, from_value, to_value, include_lower=None, include_upper=None):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/numeric-range-filter.html
         Filters documents with fields that have values within a certain numeric range. Similar to range filter, except that it works only with numeric values, and the filter execution works differently.
         '''
-        instance = cls(numeric_range={field:{'from':from_value, 'to':to_value}})
-        if include_lower is not None: instance['numeric_range'][field]['include_lower'] = include_lower
-        if include_upper is not None: instance['numeric_range'][field]['include_upper'] = include_upper
+        instance = cls(numeric_range={field: {'from': from_value, 'to': to_value}})
+        if include_lower is not None:
+            instance['numeric_range'][field]['include_lower'] = include_lower
+        if include_upper is not None:
+            instance['numeric_range'][field]['include_upper'] = include_upper
         return instance
-    
+
     @classmethod
     def or_filter(cls, query):
         '''
@@ -188,7 +191,7 @@ def or_filter(cls, query):
         > filter = ElasticFilter().or_filter([term1, term2])
         '''
 
-        return cls({'or':query})
+        return cls({'or': query})
 
     @classmethod
     def prefix(cls, field, pre):
@@ -197,16 +200,16 @@ def prefix(cls, field, pre):
         Filters documents that have fields containing terms with a specified prefix (not analyzed). Similar to phrase query, except that it acts as a filter. Can be placed within queries that accept a filter.
         '''
 
-        return cls(prefix={field:pre})
-    
+        return cls(prefix={field: pre})
+
     @classmethod
     def query(cls, query):
         '''
         http://www.elasticsearch.org/guide/reference/query-dsl/query-filter.html
         Wraps any query to be used as a filter. Can be placed within queries that accept a filter.
         '''
         return cls(query=query)
-    
+
     @classmethod
     def range(cls, field, from_value=None, to_value=None, include_lower=None, include_upper=None):
         '''
@@ -215,11 +218,15 @@ def range(cls, field, from_value=None, to_value=None, include_lower=None, includ
         Filters documents with fields that have terms within a certain range. Similar to range query, except that it acts as a filter. Can be placed within queries that accept a filter.
         '''
 
-        instance = cls({'range':{field:{}}})
-        if from_value is not None: instance['range'][field]['from'] = from_value
-        if to_value is not None: instance['range'][field]['to'] = to_value
-        if include_lower is not None: instance['range'][field]['include_lower'] = include_lower
-        if include_upper is not None: instance['range'][field]['include_upper'] = include_upper
+        instance = cls({'range': {field: {}}})
+        if from_value is not None:
+            instance['range'][field]['from'] = from_value
+        if to_value is not None:
+            instance['range'][field]['to'] = to_value
+        if include_lower is not None:
+            instance['range'][field]['include_lower'] = include_lower
+        if include_upper is not None:
+            instance['range'][field]['include_upper'] = include_upper
 
         return instance
 
@@ -241,5 +248,4 @@ def term(cls, field, value):
         Filters documents that have fields that contain a term (not analyzed). Similar to term query, except that it acts as a filter.
         '''
 
-        return cls(term={field:value})
-
+        return cls(term={field: value})

elasticpy/map.py

@@ -8,24 +8,26 @@
 
 
 class ElasticMap(dict):
+
     '''
     Mapping is the process of defining how a document should be mapped to the Search Engine, including its searchable characteristics such as which fields are searchable and if/how they are tokenized. In ElasticSearch, an index may store documents of different "mapping types". ElasticSearch allows one to associate multiple mapping definitions for each mapping type.
 
 Explicit mapping is defined on an index/type level. By default, there isn't a need to define an explicit mapping, since one is automatically created and registered when a new type or new field is introduced (with no performance overhead) and have sensible defaults. Only when the defaults need to be overridden must a mapping definition be provided.
     '''
+
     def __init__(self, field):
         self.field = field
         self[self.field] = dict()
 
-    def type(self,type_name):
+    def type(self, type_name):
         '''
         Assigns a particular type to a field in the mapped properties.
         Available types are: string, integer/long, float/double, boolean and null
         '''
         self[self.field]['type'] = type_name
         return self
 
-    def analyzed(self,should=True):
+    def analyzed(self, should=True):
         '''
         Specifies to the map that the field should be analyzed when indexed.
         '''
@@ -36,10 +38,10 @@ def ignore(self):
         '''
         Specifies that the field should be ignored in the index
         '''
-        self[self.field] = {'index' : 'no'}
+        self[self.field] = {'index': 'no'}
         return self
 
-    def null_value(self,value):
+    def null_value(self, value):
         '''
         Specifies the null value to use when indexing.
         '''
@@ -99,4 +101,3 @@ def include_in_all(self, should=True):
         '''
         self[self.field]['include_in_all'] = should
         return self
-