Route4Me.user_license_url() - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/route4..." - route4me/route4me-python-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( e3a209...bb2a36 )

by Juan Jose

created 2017-03-02 05:37 UTC

Route4Me.user_license_url() A

↳ Parent: Route4Me

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	6
rs	9.4285

import json
import requests

# codebeat:disable[TOO_MANY_FUNCTIONS, LOC, ABC, ARITY, TOTAL_LOC]
try:
    from urllib import urlencode
except ImportError:
    from urllib.parse import urlencode
from route4me.activity_feed import ActivityFeed
from route4me.address import Address
from route4me.address_book import AddressBook
from route4me.avoidance_zones import AvoindanceZones
from route4me.exceptions import APIException
from route4me.gps import SetGPS
from route4me.optimization import Optimization
from route4me.orders import Order
from route4me.rapid_address import RapidAddress
from route4me.route import Route
from route4me.territory import Territory
from route4me.utils import json2obj
from route4me.file_uploading import FileUploading
from route4me.members import Members
from route4me.vehicles import Vehicle
from route4me.constants import HEADERS
from route4me.api_endpoints import API_HOST, ROUTE_HOST


class Route4Me(object):
    """
    Route4Me Python SDK
    """

    def __init__(self,
                 key,
                 headers=HEADERS,
                 redirects=True,
                 verify_ssl=True,
                 proxies={}):
        self.key = key
        self.response = None
        self.activity_feed = ActivityFeed(self)
        self.address = Address(self)
        self.address_book = AddressBook(self)
        self.avoidance_zones = AvoindanceZones(self)
        self.file_uploading = FileUploading(self)
        self.optimization = Optimization(self)
        self.members = Members(self)
        self.vehicles = Vehicle(self)
        self.order = Order(self)
        self.setGPS = SetGPS(self)
        self.route = Route(self)
        self.rapid_address = RapidAddress(self)
        self.territory = Territory(self)
        self.headers = headers
        self.redirects = redirects
        self.verify_ssl = verify_ssl
        self.proxies = proxies

    def _make_request(self, url, params, data, request_method):
        """
        Make request to API
        :param url:
        :param params:
        :param data:
        :param request_method:
        :return: response
        :raise: APIException
        """
        request_params = self._transform_params(params)
        response = request_method(url, request_params, data)
        if not 200 <= response.status_code < 400:
            raise APIException(response.status_code, response.text,
                               response.url)
        return response

    def _transform_params(self, params):
        """
        Convert params dict to url params
        :param params:
        :return:
        """
        return urlencode(params)

    def get(self, request_method):
        """
        Execute optimization
        :param request_method:
        :return: JSON
        """
        params = self.optimization.get_params()
        return self._make_request(API_HOST, params,
                                  json.dumps(self.optimization.data),
                                  request_method)

    def _request_post(self, url, request_params, data=None, files=None):
        """
        POST request
        :param url:
        :param request_params:
        :param data:
        :param files:
        :return:
        """
        return requests.post(url, params=request_params,
                             allow_redirects=self.redirects,
                             proxies=self.proxies, files=files,
                             data=data, headers=self.headers, verify=self.verify_ssl)

    def _request_get(self, url, request_params, data=None):
        """
        GET request
        :param url:
        :param request_params:
        :param data:
        :return:
        """
        return requests.get(url, params=request_params,
                            allow_redirects=self.redirects,
                            proxies=self.proxies,
                            data=data, headers=self.headers, verify=self.verify_ssl)

    def _request_put(self, url, request_params, data=None):
        """
        PUT request
        :param url:
        :param request_params:
        :param data:
        :return:
        """
        return requests.request('PUT', url, params=request_params,
                                proxies=self.proxies,
                                data=data, headers=self.headers, verify=self.verify_ssl)

    def _request_delete(self, url, request_params, data=None):
        """
        DELETE request
        :param url:
        :param request_params:
        :param data:
        :return:
        """
        return requests.request('DELETE', url, params=request_params,
                                data=data, headers=self.headers, verify=self.verify_ssl)

    def run_optimization(self):
        """
        Run optimization and return response as an object.
        :return: response as an object
        """
        self.response = self.get(self._request_post)
        try:
            response = self.response.json()
            return response
        except AttributeError:
            raise
        except ValueError:
            raise
        except Exception:
            raise

    def re_optimization(self, optimization_id, data={}):
        """
        Execute reoptimization
        :param optimization_id:
        :return: response as a object
        """
        self.optimization.optimization_problem_id(optimization_id)
        self.optimization.reoptimize(1)
        data = {'parameters': data}
        self.response = self._make_request(API_HOST,
                                           self.optimization.get_params(),
                                           json.dumps(data),
                                           self._request_put)
        try:
            response = json2obj(self.response.content)
            return response
        except ValueError:
            raise
        except Exception:
            raise

    def get_optimization(self, optimization_problem_id):
        """
        Get optimization given optimization_problem_id
        :param optimization_problem_id:
        :return:
        """
        self.optimization.optimization_problem_id(optimization_problem_id)
        self.response = self.get(self._request_get)
        self.parse_response()

    def parse_response(self):
        """
        Parse response and set it to Route4me instance
        :return:
        """
        response = json.loads(self.response.content)
        if 'addresses' in response:
            self.address.addresses = self.response['addresses']

    def export_result_to_json(self, file_name):
        """
        Export response to JSON File
        :param file_name:
        :return:
        """
        if self.response:
            try:
                f = open(file_name, 'w')
                f.write(json.dumps(self.response.content,
                                   ensure_ascii=False,
                                   sort_keys=True,
                                   indent=4))
                f.close()
            except Exception:
                raise

    def export_request_to_json(self, file_name):
        """
        Export resquest to JSON File
        :param file_name:
        :return:
        """
        if self.optimization.data:
            try:
                f = open(file_name, 'w')
                f.write(json.dumps(self.optimization.data,
                                   ensure_ascii=False,
                                   sort_keys=True,
                                   indent=4))
                f.close()
            except Exception:
                raise

# codebeat:enable[TOO_MANY_FUNCTIONS, LOC, ABC, ARITY, TOTAL_LOC]

1			import json
2			import requests
3
4			# codebeat:disable[TOO_MANY_FUNCTIONS, LOC, ABC, ARITY, TOTAL_LOC]
5			try:
6			from urllib import urlencode
7			except ImportError:
8			from urllib.parse import urlencode
9			from route4me.activity_feed import ActivityFeed
10			from route4me.address import Address
11			from route4me.address_book import AddressBook
12			from route4me.avoidance_zones import AvoindanceZones
13			from route4me.exceptions import APIException
14			from route4me.gps import SetGPS
15			from route4me.optimization import Optimization
16			from route4me.orders import Order
17			from route4me.rapid_address import RapidAddress
18			from route4me.route import Route
19			from route4me.territory import Territory
20			from route4me.utils import json2obj
21			from route4me.file_uploading import FileUploading
22			from route4me.members import Members
23			from route4me.vehicles import Vehicle
24			from route4me.constants import HEADERS
25			from route4me.api_endpoints import API_HOST, ROUTE_HOST
26
27
28			class Route4Me(object):
29			"""
30			Route4Me Python SDK
31			"""
32
33			def __init__(self,
34			key,
35			headers=HEADERS,
36			redirects=True,
37			verify_ssl=True,
38			proxies={}):
39			self.key = key
40			self.response = None
41			self.activity_feed = ActivityFeed(self)
42			self.address = Address(self)
43			self.address_book = AddressBook(self)
44			self.avoidance_zones = AvoindanceZones(self)
45			self.file_uploading = FileUploading(self)
46			self.optimization = Optimization(self)
47			self.members = Members(self)
48			self.vehicles = Vehicle(self)
49			self.order = Order(self)
50			self.setGPS = SetGPS(self)
51			self.route = Route(self)
52			self.rapid_address = RapidAddress(self)
53			self.territory = Territory(self)
54			self.headers = headers
55			self.redirects = redirects
56			self.verify_ssl = verify_ssl
57			self.proxies = proxies
58
59			def _make_request(self, url, params, data, request_method):
60			"""
61			Make request to API
62			:param url:
63			:param params:
64			:param data:
65			:param request_method:
66			:return: response
67			:raise: APIException
68			"""
69			request_params = self._transform_params(params)
70			response = request_method(url, request_params, data)
71			if not 200 <= response.status_code < 400:
72			raise APIException(response.status_code, response.text,
73			response.url)
74			return response
75
76			def _transform_params(self, params):
77			"""
78			Convert params dict to url params
79			:param params:
80			:return:
81			"""
82			return urlencode(params)
83
84			def get(self, request_method):
85			"""
86			Execute optimization
87			:param request_method:
88			:return: JSON
89			"""
90			params = self.optimization.get_params()
91			return self._make_request(API_HOST, params,
92			json.dumps(self.optimization.data),
93			request_method)
94
95			def _request_post(self, url, request_params, data=None, files=None):
96			"""
97			POST request
98			:param url:
99			:param request_params:
100			:param data:
101			:param files:
102			:return:
103			"""
104			return requests.post(url, params=request_params,
105			allow_redirects=self.redirects,
106			proxies=self.proxies, files=files,
107			data=data, headers=self.headers, verify=self.verify_ssl)
108
109			def _request_get(self, url, request_params, data=None):
110			"""
111			GET request
112			:param url:
113			:param request_params:
114			:param data:
115			:return:
116			"""
117			return requests.get(url, params=request_params,
118			allow_redirects=self.redirects,
119			proxies=self.proxies,
120			data=data, headers=self.headers, verify=self.verify_ssl)
121
122			def _request_put(self, url, request_params, data=None):
123			"""
124			PUT request
125			:param url:
126			:param request_params:
127			:param data:
128			:return:
129			"""
130			return requests.request('PUT', url, params=request_params,
131			proxies=self.proxies,
132			data=data, headers=self.headers, verify=self.verify_ssl)
133
134			def _request_delete(self, url, request_params, data=None):
135			"""
136			DELETE request
137			:param url:
138			:param request_params:
139			:param data:
140			:return:
141			"""
142			return requests.request('DELETE', url, params=request_params,
143			data=data, headers=self.headers, verify=self.verify_ssl)
144
145			def run_optimization(self):
146			"""
147			Run optimization and return response as an object.
148			:return: response as an object
149			"""
150			self.response = self.get(self._request_post)
151			try:
152			response = self.response.json()
153			return response
154			except AttributeError:
155			raise
156			except ValueError:
157			raise
158			except Exception:
159			raise
160
161			def re_optimization(self, optimization_id, data={}):
162			"""
163			Execute reoptimization
164			:param optimization_id:
165			:return: response as a object
166			"""
167			self.optimization.optimization_problem_id(optimization_id)
168			self.optimization.reoptimize(1)
169			data = {'parameters': data}
170			self.response = self._make_request(API_HOST,
171			self.optimization.get_params(),
172			json.dumps(data),
173			self._request_put)
174			try:
175			response = json2obj(self.response.content)
176			return response
177			except ValueError:
178			raise
179			except Exception:
180			raise
181
182			def get_optimization(self, optimization_problem_id):
183			"""
184			Get optimization given optimization_problem_id
185			:param optimization_problem_id:
186			:return:
187			"""
188			self.optimization.optimization_problem_id(optimization_problem_id)
189			self.response = self.get(self._request_get)
190			self.parse_response()
191
192			def parse_response(self):
193			"""
194			Parse response and set it to Route4me instance
195			:return:
196			"""
197			response = json.loads(self.response.content)
198			if 'addresses' in response:
199			self.address.addresses = self.response['addresses']
200
201			def export_result_to_json(self, file_name):
202			"""
203			Export response to JSON File
204			:param file_name:
205			:return:
206			"""
207			if self.response:
208			try:
209			f = open(file_name, 'w')
210			f.write(json.dumps(self.response.content,
211			ensure_ascii=False,
212			sort_keys=True,
213			indent=4))
214			f.close()
215			except Exception:
216			raise
217
218			def export_request_to_json(self, file_name):
219			"""
220			Export resquest to JSON File
221			:param file_name:
222			:return:
223			"""
224			if self.optimization.data:
225			try:
226			f = open(file_name, 'w')
227			f.write(json.dumps(self.optimization.data,
228			ensure_ascii=False,
229			sort_keys=True,
230			indent=4))
231			f.close()
232			except Exception:
233			raise
234
235			# codebeat:enable[TOO_MANY_FUNCTIONS, LOC, ABC, ARITY, TOTAL_LOC]

route4me / route4me-python-sdk

GitHub Access Token became invalid

Push — master ( e3a209...bb2a36 )

Route4Me.user_license_url() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like