AscSortStatement.translate() - Code Metrics - Inspection of "Merge pull request #10 from BenoitEchernier/master" - pyjobs/web - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3d112a...bb5fc0 )

by Bastien

created 2016-09-15 14:15 UTC

AscSortStatement.translate() A

↳ Parent: AscSortStatement

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	2
rs	10

# -*- coding: utf-8 -*-
import abc


class Translatable(object):
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def translate(self, translator):
        pass

    @abc.abstractmethod
    def __str__(self):
        return str()


class QueryStatement(Translatable):
    __metaclass__ = abc.ABCMeta


class SortStatement(Translatable):
    __metaclass__ = abc.ABCMeta

    _to_sort = None

    def __init__(self, to_sort):
        self.to_sort = to_sort

    @property
    def to_sort(self):
        return self._to_sort

    @to_sort.setter
    def to_sort(self, to_sort):
        self._to_sort = to_sort


class Filter(QueryStatement):
    __metaclass__ = abc.ABCMeta


class Sort(list, QueryStatement):

    def __init__(self):
        super(list, self).__init__()
        self._type = SortStatement

    def append(self, sort):
        if not isinstance(sort, SortStatement):
            raise TypeError('sort should be of type %s.' % self._type)

        super(Sort, self).append(sort)

    def translate(self, translator):
        return translator.translate_sort(self)

    def __str__(self):
        res = 'Sort['

        for i, e in enumerate(self):
            if i > 0:
                res = '{}, '.format(res)

            res = '{}{}'.format(res, e)

        return '{}]'.format(res)


class AscSortStatement(SortStatement):
    def translate(self, translator):
        return translator.translate_asc_sort_statement(self)

    def __str__(self):
        return 'AscSortStatement[to_sort: {}]'.format(self.to_sort)


class DescSortStatement(SortStatement):
    def translate(self, translator):
        return translator.translate_desc_sort_statement(self)

    def __str__(self):
        return 'DescSortStatement[to_sort: {}]'.format(self.to_sort)


class BooleanFilter(Filter):
    _field = None
    _value = None

    def __init__(self, field, value):
        self.field = field
        self.value = value

    def translate(self, translator):
        return translator.translate_boolean_filter(self)

    @property
    def field(self):
        return self._field

    @field.setter
    def field(self, field):
        if not isinstance(field, basestring):
            raise TypeError('field should be of type: %s.' % basestring)

        self._field = field

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if not isinstance(value, bool):
            raise TypeError('value should be of type: %s.' % bool)

        self._value = value

    def __str__(self):
        return 'BooleanFilter: [{} == {}]'.format(self.field, self.value)


class KeywordFilter(Filter):
    _fields = None
    _keywords = None

    def __init__(self, fields, keywords):
        self.fields = fields
        self.keywords = keywords

    def translate(self, translator):
        return translator.translate_keyword_filter(self)

    @property
    def fields(self):
        return self._fields

    @fields.setter
    def fields(self, fields):
        if not isinstance(fields, list) \
                or not all(isinstance(f, basestring) for f in fields):
            raise TypeError('fields should be a list of strings.')

        self._fields = fields

    @property
    def keywords(self):
        return self._keywords

    @keywords.setter
    def keywords(self, keywords):
        if not isinstance(keywords, list) \
                or not all(isinstance(kw, basestring) for kw in keywords):
            raise TypeError('keywords should be a list of strings.')

        self._keywords = keywords

    def __str__(self):
        return 'KeywordFilter: [{}, {}]'.format(self._fields, self._keywords)


class GeolocationFilter(Filter):
    _center = None
    _radius = None
    _unit = None

    from enum import Enum

    class UnitsEnum(Enum):
        KM = 'km'
        M = 'm'

    class Center(object):
        _latitude = None
        _longitude = None

        def __init__(self, latitude, longitude):
            self.latitude = latitude
            self.longitude = longitude

        @property
        def latitude(self):
            return self._latitude

        @latitude.setter
        def latitude(self, latitude):
            if not isinstance(latitude, float):
                raise TypeError('latitude should be of type %s.' % float)

            self._latitude = latitude

        @property
        def longitude(self):
            return self._longitude

        @longitude.setter
        def longitude(self, longitude):
            if not isinstance(longitude, float):
                raise TypeError('longitude should be of type %s.' % float)

            self._longitude = longitude

        def __str__(self):
            return '[{}, {}]'.format(self.latitude, self.longitude)

    def __init__(self, center, radius, unit=UnitsEnum.KM):
        self.center = center
        self.radius = radius
        self.unit = unit

    def translate(self, translator):
        return translator.translate_geolocation_filter(self)

    @property
    def center(self):
        return self._center

    @center.setter
    def center(self, center):
        center_type = GeolocationFilter.Center
        if not isinstance(center, center_type):
            raise TypeError('center should be of type %s.', center_type)

        self._center = center

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, radius):
        if not isinstance(radius, float):
            raise TypeError('radius should be of type %s.' % float)

        self._radius = radius

    @property
    def unit(self):
        return self._unit.value

    @unit.setter
    def unit(self, unit):
        unit_enum = GeolocationFilter.UnitsEnum
        if unit not in unit_enum:
            raise TypeError('unit should be of type %s.' % unit_enum)

        self._unit = unit

    def __str__(self):
        return 'GeolocationFilter[Center: {}, Radius: {}, Unit: {}]'\
            .format(self._center, self._radius, self._unit)


class Query(list):

    def __init__(self):
        super(list, self).__init__()
        self._type = QueryStatement

    def append(self, query_elem):
        if not isinstance(query_elem, QueryStatement):
            raise TypeError('search_filter should be of type %s.' % self._type)

        super(Query, self).append(query_elem)

    def __str__(self):
        res = 'Query['

        for i, e in enumerate(self):
            if i > 0:
                res = '{}, '.format(res)

            res = '{}{}'.format(res, e)

        return '{}]'.format(res)


class QueryTranslator(object):
    __metaclass__ = abc.ABCMeta

    _query_object = None

    @abc.abstractmethod
    def __init__(self, query_object):
        self.query_object = query_object

    @property
    def query_object(self):
        return self._query_object

    @query_object.setter
    def query_object(self, query_object):
        if not query_object:
            raise ValueError('query_object should not be null.')

        self._query_object = query_object

    def translate(self, query):
        if not isinstance(query, Query):
            raise TypeError('query should be of type %s.' % Query)

        for search_query in query:
            self.query_object = search_query.translate(self)

        return self.query_object

    @abc.abstractmethod
    def translate_sort(self, multi_sort):
        pass

    @abc.abstractmethod
    def translate_asc_sort_statement(self, asc_sort):
        pass

    @abc.abstractmethod
    def translate_desc_sort_statement(self, desc_sort):
        pass

    @abc.abstractmethod
    def translate_boolean_filter(self, search_filter):
        pass

    @abc.abstractmethod
    def translate_keyword_filter(self, search_filter):
        pass

    @abc.abstractmethod
    def translate_geolocation_filter(self, search_filter):
        pass


class QueryBuilder(object):
    _translator = None

    def __init__(self, translator):
        self.translator = translator
        self._query = Query()

    @property
    def translator(self):
        return self._translator

    @translator.setter
    def translator(self, translator):
        qt_type = QueryTranslator
        if not isinstance(translator, qt_type):
            raise TypeError('translator should be of type %s.' % qt_type)

        self._translator = translator

    def add_elem(self, elem):
        self._query.append(elem)

    def build(self):
        return self.translator.translate(self._query)

    def __str__(self):
        return self._query.__str__()


class BaseSearchQuery(object):
    __metaclass__ = abc.ABCMeta

    _query_builder = None

    @abc.abstractmethod
    def __init__(self, query_builder):
        self.builder = query_builder

    @property
    def builder(self):
        return self._query_builder

    @builder.setter
    def builder(self, builder):
        build_type = QueryBuilder
        if not isinstance(builder, build_type):
            raise TypeError('query_builder should be of type %s.' % build_type)

        self._query_builder = builder

    def add_elem(self, elem):
        self.builder.add_elem(elem)

    @abc.abstractmethod
    def execute_query(self):
        pass

    def __str__(self):
        return self.builder.__str__()


1		# -- coding: utf-8 --
2		import abc
3
4
5		class Translatable(object):
6		__metaclass__ = abc.ABCMeta
7
8		@abc.abstractmethod
9		def translate(self, translator):
10		pass
11
12		@abc.abstractmethod
13		def __str__(self):
14		return str()
15
16
17		class QueryStatement(Translatable):
18		__metaclass__ = abc.ABCMeta
19
20
21		class SortStatement(Translatable):
22		__metaclass__ = abc.ABCMeta
23
24		_to_sort = None
25
26		def __init__(self, to_sort):
27		self.to_sort = to_sort
28
29		@property
30		def to_sort(self):
31		return self._to_sort
32
33		@to_sort.setter
34		def to_sort(self, to_sort):
35		self._to_sort = to_sort
36
37
38		class Filter(QueryStatement):
39		__metaclass__ = abc.ABCMeta
40
41
42	View Code Duplication	class Sort(list, QueryStatement):
		0 ignored issues – show Duplication introduced 2016-09-15 14:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
43		def __init__(self):
44		super(list, self).__init__()
45		self._type = SortStatement
46
47		def append(self, sort):
48		if not isinstance(sort, SortStatement):
49		raise TypeError('sort should be of type %s.' % self._type)
50
51		super(Sort, self).append(sort)
52
53		def translate(self, translator):
54		return translator.translate_sort(self)
55
56		def __str__(self):
57		res = 'Sort['
58
59		for i, e in enumerate(self):
60		if i > 0:
61		res = '{}, '.format(res)
62
63		res = '{}{}'.format(res, e)
64
65		return '{}]'.format(res)
66
67
68		class AscSortStatement(SortStatement):
69		def translate(self, translator):
70		return translator.translate_asc_sort_statement(self)
71
72		def __str__(self):
73		return 'AscSortStatement[to_sort: {}]'.format(self.to_sort)
74
75
76		class DescSortStatement(SortStatement):
77		def translate(self, translator):
78		return translator.translate_desc_sort_statement(self)
79
80		def __str__(self):
81		return 'DescSortStatement[to_sort: {}]'.format(self.to_sort)
82
83
84		class BooleanFilter(Filter):
85		_field = None
86		_value = None
87
88		def __init__(self, field, value):
89		self.field = field
90		self.value = value
91
92		def translate(self, translator):
93		return translator.translate_boolean_filter(self)
94
95		@property
96		def field(self):
97		return self._field
98
99		@field.setter
100		def field(self, field):
101		if not isinstance(field, basestring):
102		raise TypeError('field should be of type: %s.' % basestring)
103
104		self._field = field
105
106		@property
107		def value(self):
108		return self._value
109
110		@value.setter
111		def value(self, value):
112		if not isinstance(value, bool):
113		raise TypeError('value should be of type: %s.' % bool)
114
115		self._value = value
116
117		def __str__(self):
118		return 'BooleanFilter: [{} == {}]'.format(self.field, self.value)
119
120
121		class KeywordFilter(Filter):
122		_fields = None
123		_keywords = None
124
125		def __init__(self, fields, keywords):
126		self.fields = fields
127		self.keywords = keywords
128
129		def translate(self, translator):
130		return translator.translate_keyword_filter(self)
131
132		@property
133		def fields(self):
134		return self._fields
135
136		@fields.setter
137		def fields(self, fields):
138		if not isinstance(fields, list) \
139		or not all(isinstance(f, basestring) for f in fields):
140		raise TypeError('fields should be a list of strings.')
141
142		self._fields = fields
143
144		@property
145		def keywords(self):
146		return self._keywords
147
148		@keywords.setter
149		def keywords(self, keywords):
150		if not isinstance(keywords, list) \
151		or not all(isinstance(kw, basestring) for kw in keywords):
152		raise TypeError('keywords should be a list of strings.')
153
154		self._keywords = keywords
155
156		def __str__(self):
157		return 'KeywordFilter: [{}, {}]'.format(self._fields, self._keywords)
158
159
160		class GeolocationFilter(Filter):
161		_center = None
162		_radius = None
163		_unit = None
164
165		from enum import Enum
166
167		class UnitsEnum(Enum):
168		KM = 'km'
169		M = 'm'
170
171		class Center(object):
172		_latitude = None
173		_longitude = None
174
175		def __init__(self, latitude, longitude):
176		self.latitude = latitude
177		self.longitude = longitude
178
179		@property
180		def latitude(self):
181		return self._latitude
182
183		@latitude.setter
184		def latitude(self, latitude):
185		if not isinstance(latitude, float):
186		raise TypeError('latitude should be of type %s.' % float)
187
188		self._latitude = latitude
189
190		@property
191		def longitude(self):
192		return self._longitude
193
194		@longitude.setter
195		def longitude(self, longitude):
196		if not isinstance(longitude, float):
197		raise TypeError('longitude should be of type %s.' % float)
198
199		self._longitude = longitude
200
201		def __str__(self):
202		return '[{}, {}]'.format(self.latitude, self.longitude)
203
204		def __init__(self, center, radius, unit=UnitsEnum.KM):
205		self.center = center
206		self.radius = radius
207		self.unit = unit
208
209		def translate(self, translator):
210		return translator.translate_geolocation_filter(self)
211
212		@property
213		def center(self):
214		return self._center
215
216		@center.setter
217		def center(self, center):
218		center_type = GeolocationFilter.Center
219		if not isinstance(center, center_type):
220		raise TypeError('center should be of type %s.', center_type)
221
222		self._center = center
223
224		@property
225		def radius(self):
226		return self._radius
227
228		@radius.setter
229		def radius(self, radius):
230		if not isinstance(radius, float):
231		raise TypeError('radius should be of type %s.' % float)
232
233		self._radius = radius
234
235		@property
236		def unit(self):
237		return self._unit.value
238
239		@unit.setter
240		def unit(self, unit):
241		unit_enum = GeolocationFilter.UnitsEnum
242		if unit not in unit_enum:
243		raise TypeError('unit should be of type %s.' % unit_enum)
244
245		self._unit = unit
246
247		def __str__(self):
248		return 'GeolocationFilter[Center: {}, Radius: {}, Unit: {}]'\
249		.format(self._center, self._radius, self._unit)
250
251
252	View Code Duplication	class Query(list):
		0 ignored issues – show Duplication introduced 2016-09-15 14:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
253		def __init__(self):
254		super(list, self).__init__()
255		self._type = QueryStatement
256
257		def append(self, query_elem):
258		if not isinstance(query_elem, QueryStatement):
259		raise TypeError('search_filter should be of type %s.' % self._type)
260
261		super(Query, self).append(query_elem)
262
263		def __str__(self):
264		res = 'Query['
265
266		for i, e in enumerate(self):
267		if i > 0:
268		res = '{}, '.format(res)
269
270		res = '{}{}'.format(res, e)
271
272		return '{}]'.format(res)
273
274
275		class QueryTranslator(object):
276		__metaclass__ = abc.ABCMeta
277
278		_query_object = None
279
280		@abc.abstractmethod
281		def __init__(self, query_object):
282		self.query_object = query_object
283
284		@property
285		def query_object(self):
286		return self._query_object
287
288		@query_object.setter
289		def query_object(self, query_object):
290		if not query_object:
291		raise ValueError('query_object should not be null.')
292
293		self._query_object = query_object
294
295		def translate(self, query):
296		if not isinstance(query, Query):
297		raise TypeError('query should be of type %s.' % Query)
298
299		for search_query in query:
300		self.query_object = search_query.translate(self)
301
302		return self.query_object
303
304		@abc.abstractmethod
305		def translate_sort(self, multi_sort):
306		pass
307
308		@abc.abstractmethod
309		def translate_asc_sort_statement(self, asc_sort):
310		pass
311
312		@abc.abstractmethod
313		def translate_desc_sort_statement(self, desc_sort):
314		pass
315
316		@abc.abstractmethod
317		def translate_boolean_filter(self, search_filter):
318		pass
319
320		@abc.abstractmethod
321		def translate_keyword_filter(self, search_filter):
322		pass
323
324		@abc.abstractmethod
325		def translate_geolocation_filter(self, search_filter):
326		pass
327
328
329		class QueryBuilder(object):
330		_translator = None
331
332		def __init__(self, translator):
333		self.translator = translator
334		self._query = Query()
335
336		@property
337		def translator(self):
338		return self._translator
339
340		@translator.setter
341		def translator(self, translator):
342		qt_type = QueryTranslator
343		if not isinstance(translator, qt_type):
344		raise TypeError('translator should be of type %s.' % qt_type)
345
346		self._translator = translator
347
348		def add_elem(self, elem):
349		self._query.append(elem)
350
351		def build(self):
352		return self.translator.translate(self._query)
353
354		def __str__(self):
355		return self._query.__str__()
356
357
358		class BaseSearchQuery(object):
359		__metaclass__ = abc.ABCMeta
360
361		_query_builder = None
362
363		@abc.abstractmethod
364		def __init__(self, query_builder):
365		self.builder = query_builder
366
367		@property
368		def builder(self):
369		return self._query_builder
370
371		@builder.setter
372		def builder(self, builder):
373		build_type = QueryBuilder
374		if not isinstance(builder, build_type):
375		raise TypeError('query_builder should be of type %s.' % build_type)
376
377		self._query_builder = builder
378
379		def add_elem(self, elem):
380		self.builder.add_elem(elem)
381
382		@abc.abstractmethod
383		def execute_query(self):
384		pass
385
386		def __str__(self):
387		return self.builder.__str__()
388

pyjobs / web

GitHub Access Token became invalid

Push — master ( 3d112a...bb5fc0 )

AscSortStatement.translate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like