elodie.geolocation   F
last analyzed

Complexity

Total Complexity 62

Size/Duplication

Total Lines 234
Duplicated Lines 0 %

Importance

Changes 0
Metric Value
eloc 166
dl 0
loc 234
rs 3.44
c 0
b 0
f 0
wmc 62

9 Functions

Rating   Name   Duplication   Size   Complexity  
A dms_to_decimal() 0 8 2
A dms_string() 0 8 5
A decimal_to_dms() 0 8 2
C parse_result() 0 16 9
A get_key() 0 15 4
A get_prefer_english_names() 0 18 5
D coordinates_by_name() 0 44 12
D place_name() 0 41 13
C lookup() 0 36 10

How to fix   Complexity   

Complexity

Complex classes like elodie.geolocation often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

1
"""Look up geolocation information for media objects."""
2
from __future__ import print_function
3
from __future__ import division
4
from future import standard_library
5
from past.utils import old_div
6
7
standard_library.install_aliases()  # noqa
8
9
from os import path
10
11
import requests
12
import urllib.request
13
import urllib.parse
14
import urllib.error
15
16
from elodie.config import load_config
17
from elodie import constants
18
from elodie import log
19
from elodie.localstorage import Db
20
21
__KEY__ = None
22
__DEFAULT_LOCATION__ = 'Unknown Location'
23
__PREFER_ENGLISH_NAMES__ = None
24
25
26
def coordinates_by_name(name):
27
    # Try to get cached location first
28
    db = Db()
29
    cached_coordinates = db.get_location_coordinates(name)
30
    if(cached_coordinates is not None):
31
        return {
32
            'latitude': cached_coordinates[0],
33
            'longitude': cached_coordinates[1]
34
        }
35
36
    # If the name is not cached then we go ahead with an API lookup
37
    geolocation_info = lookup(location=name)
38
39
    if(geolocation_info is not None):
40
        if(
41
            'results' in geolocation_info and
42
            len(geolocation_info['results']) != 0 and
43
            'locations' in geolocation_info['results'][0] and
44
            len(geolocation_info['results'][0]['locations']) != 0
45
        ):
46
47
            # By default we use the first entry unless we find one with
48
            #   geocodeQuality=city.
49
            geolocation_result = geolocation_info['results'][0]
50
            use_location = geolocation_result['locations'][0]['latLng']
51
            # Loop over the locations to see if we come accross a
52
            #   geocodeQuality=city.
53
            # If we find a city we set that to the use_location and break
54
            for location in geolocation_result['locations']:
55
                if(
56
                    'latLng' in location and
57
                    'lat' in location['latLng'] and
58
                    'lng' in location['latLng'] and
59
                    location['geocodeQuality'].lower() == 'city'
60
                ):
61
                    use_location = location['latLng']
62
                    break
63
64
            return {
65
                'latitude': use_location['lat'],
66
                'longitude': use_location['lng']
67
            }
68
69
    return None
70
71
72
def decimal_to_dms(decimal):
73
    decimal = float(decimal)
74
    decimal_abs = abs(decimal)
75
    minutes, seconds = divmod(decimal_abs*3600, 60)
76
    degrees, minutes = divmod(minutes, 60)
77
    degrees = degrees
78
    sign = 1 if decimal >= 0 else -1
79
    return (degrees, minutes, seconds, sign)
80
81
82
def dms_to_decimal(degrees, minutes, seconds, direction=' '):
83
    sign = 1
84
    if(direction[0] in 'WSws'):
85
        sign = -1
86
    return (
87
        float(degrees) + old_div(float(minutes), 60) +
88
        old_div(float(seconds), 3600)
89
    ) * sign
90
91
92
def dms_string(decimal, type='latitude'):
93
    # Example string -> 38 deg 14' 27.82" S
94
    dms = decimal_to_dms(decimal)
95
    if type == 'latitude':
96
        direction = 'N' if decimal >= 0 else 'S'
97
    elif type == 'longitude':
98
        direction = 'E' if decimal >= 0 else 'W'
99
    return '{} deg {}\' {}" {}'.format(dms[0], dms[1], dms[2], direction)
0 ignored issues
show
introduced by Jaisen Mathai
The variable direction does not seem to be defined for all execution paths.
Loading history...
100
101
102
def get_key():
103
    global __KEY__
104
    if __KEY__ is not None:
105
        return __KEY__
106
107
    config_file = '%s/config.ini' % constants.application_directory
108
    if not path.exists(config_file):
109
        return None
110
111
    config = load_config()
112
    if('MapQuest' not in config):
113
        return None
114
115
    __KEY__ = config['MapQuest']['key']
116
    return __KEY__
117
118
def get_prefer_english_names():
119
    global __PREFER_ENGLISH_NAMES__
120
    if __PREFER_ENGLISH_NAMES__ is not None:
121
        return __PREFER_ENGLISH_NAMES__
122
123
    config_file = '%s/config.ini' % constants.application_directory
124
    if not path.exists(config_file):
125
        return False
126
127
    config = load_config()
128
    if('MapQuest' not in config):
129
        return False
130
131
    if('prefer_english_names' not in config['MapQuest']):
132
        return False
133
134
    __PREFER_ENGLISH_NAMES__ = bool(config['MapQuest']['prefer_english_names'])
135
    return __PREFER_ENGLISH_NAMES__
136
137
def place_name(lat, lon):
138
    lookup_place_name_default = {'default': __DEFAULT_LOCATION__}
139
    if(lat is None or lon is None):
140
        return lookup_place_name_default
141
142
    # Convert lat/lon to floats
143
    if(not isinstance(lat, float)):
144
        lat = float(lat)
145
    if(not isinstance(lon, float)):
146
        lon = float(lon)
147
148
    # Try to get cached location first
149
    db = Db()
150
    # 3km distace radious for a match
151
    cached_place_name = db.get_location_name(lat, lon, 3000)
152
    # We check that it's a dict to coerce an upgrade of the location
153
    #  db from a string location to a dictionary. See gh-160.
154
    if(isinstance(cached_place_name, dict)):
155
        return cached_place_name
156
157
    lookup_place_name = {}
158
    geolocation_info = lookup(lat=lat, lon=lon)
159
    if(geolocation_info is not None and 'address' in geolocation_info):
160
        address = geolocation_info['address']
161
        for loc in ['city', 'state', 'country']:
162
            if(loc in address):
163
                lookup_place_name[loc] = address[loc]
164
                # In many cases the desired key is not available so we
165
                #  set the most specific as the default.
166
                if('default' not in lookup_place_name):
167
                    lookup_place_name['default'] = address[loc]
168
169
    if(lookup_place_name):
170
        db.add_location(lat, lon, lookup_place_name)
171
        # TODO: Maybe this should only be done on exit and not for every write.
172
        db.update_location_db()
173
174
    if('default' not in lookup_place_name):
175
        lookup_place_name = lookup_place_name_default
176
177
    return lookup_place_name
178
179
180
def lookup(**kwargs):
181
    if(
182
        'location' not in kwargs and
183
        'lat' not in kwargs and
184
        'lon' not in kwargs
185
    ):
186
        return None
187
188
    key = get_key()
189
    prefer_english_names = get_prefer_english_names()
190
191
    if(key is None):
192
        return None
193
194
    try:
195
        params = {'format': 'json', 'key': key}
196
        params.update(kwargs)
197
        path = '/geocoding/v1/address'
198
        if('lat' in kwargs and 'lon' in kwargs):
199
            path = '/nominatim/v1/reverse.php'
200
        url = 'https://open.mapquestapi.com%s?%s' % (
201
                    path,
202
                    urllib.parse.urlencode(params)
203
              )
204
        headers = {}
205
        if(prefer_english_names):
206
            headers = {'Accept-Language':'en-EN,en;q=0.8'}
207
        r = requests.get(url, headers=headers)
208
        return parse_result(r.json())
209
    except requests.exceptions.RequestException as e:
210
        log.error(e)
211
        return None
212
    except ValueError as e:
213
        log.error(r.text)
214
        log.error(e)
215
        return None
216
217
218
def parse_result(result):
219
    if('error' in result):
220
        return None
221
222
    if(
223
        'results' in result and
224
        len(result['results']) > 0 and
225
        'locations' in result['results'][0]
226
        and len(result['results'][0]['locations']) > 0 and
227
        'latLng' in result['results'][0]['locations'][0]
228
    ):
229
        latLng = result['results'][0]['locations'][0]['latLng']
230
        if(latLng['lat'] == 39.78373 and latLng['lng'] == -100.445882):
231
            return None
232
233
    return result
234