-
Notifications
You must be signed in to change notification settings - Fork 2
/
pynepal.py
280 lines (211 loc) · 8.04 KB
/
pynepal.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
import json
from .utils import clean_string
# Parse all states
with open('pynepal/db/provinces.json', 'r') as json_provinces:
json_provinces = json.load(json_provinces)
# Parse all districts.
with open('pynepal/db/districts.json', 'r') as json_districts:
json_districts = json.load(json_districts)
# Parse all municipalities.
with open('pynepal/db/municipalities.json', 'r') as json_municipalities:
json_municipalities = json.load(json_municipalities)
class AbstractObj(object):
"""
Abstract class for state, district and municipalities,
"""
def __init__(self, **kwargs):
for attr, val in kwargs.items():
# Convert to lower case if instance is string else do nothing
attr = clean_string(attr) if isinstance(attr, str) else attr
val = clean_string(val) if isinstance(val, str) else val
if not hasattr(self, attr):
setattr(self, attr, val)
def __repr__(self):
if hasattr(self, "name"):
return "{}('{}')".format(self.__class__.__name__, getattr(self, "name").lower())
class lists(list):
"""
Return the list object with with overloaded . operator
attributes are check against the attr_list
"""
def __init__(self, *args, attr_list=[]):
super(lists, self).__init__()
self._attr_list = attr_list
# append the items
for item in args:
self.append(item)
def __getattr__(self, attrname):
# If attribute is two word, split it and check in attr_list
# attribute is given in the form of self.eastern_rukum
attrname = " ".join(attrname.split("_"))
if attrname not in self._attr_list:
raise AttributeError("{} has no attribute {}".format(
self.__class__.__name__, attrname))
# Search the districts object and return the value.
for item in self:
if item.name == attrname:
return item
return list(filter(lambda item: item.name == attrname, self))[0]
class RuralMunicipality(AbstractObj):
"""
Represent RuralMunicipality
"""
pass
class Municipality(AbstractObj):
"""
Class for municipality object
"""
pass
class SubMetropolitan(AbstractObj):
"""
Class for submetropolitian city
"""
pass
class Metropolitan(AbstractObj):
"""
Class for submetropolitian city
"""
pass
# Create the list of metropolitian, submetropolitian, and municipalites and remote municipalities
metropolitans, sub_metropolitans, municipalities, rural_municipalities = list(
), list(), list(), list()
types = ("metropolitan", "submetropolitan",
"municipality", "ruralmunicipality")
for item in json_municipalities:
if item.get('type') in types:
if item.get('type') == "metropolitan":
metropolitans.append(Metropolitan(**item))
elif item.get('type') == "submetropolitan":
sub_metropolitans.append(SubMetropolitan(**item))
elif item.get('type') == "municipality":
municipalities.append(Municipality(**item))
elif item.get('type') == "ruralmunicipality":
rural_municipalities.append(RuralMunicipality(**item))
# name list of all metropolitans
metropolitan_names = list()
for metropolitan in metropolitans:
# clean up metropolitan name
name = getattr(metropolitan, "name", None)
if name:
metropolitan_names.append(clean_string(name))
pass
# List of metropolitans, having attribute as metropolitan name
# metropolitans.kathmandu returns Metropolitan("Kathmandu")
metropolitans = lists(*metropolitans, attr_list=metropolitan_names)
# name list of all sub_metropolitans
sub_metropolitan_names = list()
for sub_metropolitan in sub_metropolitans:
# clean up sub metropolitan name
name = getattr(sub_metropolitan, "name", None)
if name:
sub_metropolitan_names.append(clean_string(name))
# sub_metropolitians, municipalities, rural_municipalities
sub_metropolitans = lists(
*sub_metropolitans, attr_list=sub_metropolitan_names)
# name list of all municipality
municipality_names = list()
for municipality in municipalities:
# clean up sub municipality name
name = getattr(municipality, "name", None)
if name:
municipality_names.append(clean_string(name))
# Municipalities list
municipalities = lists(*municipalities, attr_list=municipality_names)
# Name list of all rural municipality
rural_municipalities_names = list()
for rural_municipality in rural_municipalities:
# clean up rural municipality name
name = getattr(municipality, "name", None)
if name:
rural_municipalities_names.append(clean_string(name))
# rural municipalities list
rural_municipalities = lists(
*rural_municipalities, attr_list=rural_municipalities_names)
class District(AbstractObj):
"""
Class for district
"""
pass
# Create List of districts using list type
districts = [District(**json_district) for json_district in json_districts]
# Create a list of districts that support (.) operator, example: districts.gulmi.name
# List of district name
district_names = []
for district in districts:
name = getattr(district, "name")
# Clean name example eastern rukum to eastern_rukum
name = clean_string(name)
district_names.append(name)
# List of districts
districts = lists(*districts, attr_list=district_names)
class Province(AbstractObj):
"""
State class to hold information about states of Nepal
"""
@property
def districts(self):
"""
Return all the district of this state
"""
province_districts = [
dist for dist in districts if dist.province_no == self.province_no]
# Create and return of list of districts
return lists(*province_districts, attr_list=province_districts)
@property
def metropolitans(self):
"""
Return the list of all metropolitans from this province
"""
metropolitans_list = [
metropolitan for metropolitan in metropolitans if metropolitan.province_no == self.province_no]
return metropolitans_list
@property
def sub_metropolitans(self):
"""
Return the list of all metropolitans from this province
"""
sub_metropolitan_lists = [
sub_metropolitan for sub_metropolitan in sub_metropolitans if sub_metropolitan.province_no == self.province_no]
return sub_metropolitan_lists
@property
def municipalities(self):
"""
Return the list of municipalities of this province
"""
municipalities_list = [
municipality for municipality in municipalities if municipality.province_no == self.province_no]
return municipalities_list
@property
def rural_municipalities(self):
"""
Return the list of municipalities of this province
"""
rural_municipality_lists = [
rural_municipality for rural_municipality in rural_municipalities if rural_municipality.province_no == self.province_no]
return rural_municipality_lists
class _Provinces(list):
"""
Return list of provinces
"""
province_names = ("province_one", "province_two", "province_three",
"province_four", "province_five", "province_six", "province_seven")
indexes = {"one": 1, "two": 2, "three": 3,
"four": 4, "five": 5, "six": 6, "seven": 7}
def __init__(self):
super(_Provinces, self).__init__()
for json_province in json_provinces:
self.append(Province(**json_province))
# Sort province based on province no.
self.sort(key=lambda state: state.province_no)
def __getattr__(self, attrname):
"""
nepal_provinces = _Provinces()
nepal_provinces.province_one
"""
if attrname not in self.province_names:
raise AttributeError("{} has no attribute {}".format(
self.__class__.__name__, attrname))
_, index = attrname.split("_")
return self[self.indexes.get(index)-1]
# List of provinces
provinces = _Provinces()