0001-replace-urllib-calls-by-requests-7898.patch

Serghei Mihai (congés, retour 15/05), 02 mars 2016 19:25

Voir les différences: en ligne côte à côte

Subject: [PATCH] replace urllib calls by requests (#7898)

 passerelle/apps/choosit/models.py |  9 +++----
 passerelle/apps/clicrdv/models.py | 49 +++++++++++++++++----------------------
 passerelle/apps/mobyt/models.py   | 20 +++++++---------
 passerelle/apps/ovh/models.py     | 10 ++++----
 passerelle/apps/oxyd/models.py    | 36 +++++++++++-----------------
 passerelle/apps/solis/solis.py    | 29 ++++++++---------------
 passerelle/apps/solis/test.py     |  8 +++----
 passerelle/repost/models.py       | 15 +++++-------
 8 files changed, 69 insertions(+), 107 deletions(-)

     import re
     import urllib
     import urllib2
     import logging
     import json
     import requests
     from django.utils.translation import ugettext_lazy as _
     from django.db import models
-...
+                    }
                 try:
                     data = urllib.urlencode([('data', json.dumps(params))])
                     r = urllib2.Request('http://sms.choosit.com/webservice', data)
                     p = urllib2.urlopen(r, timeout=5)
                     output = json.load(p)
                     p.close()
                     r = request.get('http://sms.choosit.com/webservice', params=data, timeout=5)
                     output = r.json()
                 except Exception, e:
                     logging.exception(u'%s unable to send message %s to %s',
                             self, text, destinations)
-...
             reg = ChoositRegisterWS(self.url, self.key)
             ws = reg.update(subscriptions, user)
             return {"message": ws['status']}

     import base64
     import datetime
     import json
     import urllib2
     import requests
     from django.conf import settings
     from django.core.urlresolvers import reverse
-...
             return 'clock'
         def get_request(self, uri):
         def get_request(self, uri, req='get', data=None, headers=None):
             kwargs = {}
             url = 'https://%s/api/v1/%s' % (self.server, uri)
             if '?' in url:
                url = url + '&apikey=%s&format=json' % self.apikey
             else:
                url = url + '?apikey=%s&format=json' % self.apikey
             req = urllib2.Request(url)
             authheader = 'Basic ' + \
                 base64.encodestring('%s:%s' % (self.username, self.password))[:-1]
             req.add_header('Authorization', authheader)
             return req
             if data:
                 kwargs.update({'data': data})
             if headers:
                 kwargs.update({'headers': headers})
             return requests.request(req, url,
                         auth=((self.username, self.password)), **kwargs)
         def get_json(self, uri):
             req = self.get_request(uri)
             return json.load(urllib2.urlopen(req))
             r = get_request(uri)
             return r.json()
         def get_interventionsets(self, **kwargs):
             records = self.get_json('interventionsets').get('records')
-...
         def cancel(self, id, **kwargs):
             appointment_id = int(id)
             req = self.get_request('appointments/%s' % appointment_id)
             req.get_method = (lambda: 'DELETE')
             try:
                 fd = urllib2.urlopen(req)
                 none = fd.read()
             except urllib2.HTTPError as e:
             req = self.get_request('appointments/%s' % appointment_id, 'delete')
             if not req.ok():
                 # clicrdv will return a "Bad Request" (HTTP 400) response
                 # when it's not possible to remove an appointment
                 # (for example because it's too late)
                 response = e.read()
                 response = json.loads(response)
                 return {'success': False, 'error': response}
                 return {'success': False, 'error': req.json()}
             return {'success': True}
         def create_appointment(self, intervention, websource, data):
             fields = data.get('fields') or {}
             extra = data.get('extra') or {}
-...
             # optional parameters, if any...
             for fieldname in (fields.keys() + extra.keys() + data.keys()):
                 if fieldname.startswith('clicrdv_fiche_'):
                     appointment['fiche'][fieldname[14:]] = get_data(fieldname) or ''
             req = self.get_request('appointments')
             req.add_data(json.dumps({'appointment': appointment}))
             req.add_header('Content-Type', 'application/json')
             try:
                 fd = urllib2.urlopen(req)
             except urllib2.HTTPError, e:
                     appointment['fiche'][fieldname[14:]] = fields[fieldname] or ''
             req = self.get_request('appointments',
                             data=json.dumps({'appointment': appointment}),
                             headers={'Content-Type': 'application/json'})
             if not req.ok():
                 try:
                     error = json.load(e.fp)[0].get('error')
                     error = req.json().get('error')
                 except:
                     error = 'Unknown error (Passerelle)'
                 return {
-...
+                }
             else:
                 success = True
                 response = json.load(fd)
                 response = req.json()
                 appointment_id = response.get('records')[0].get('id')
                 return {
                     'success': True,

     import re
     import urllib
     import urllib2
     import logging
     import json
     import requests
     from django.utils.translation import ugettext_lazy as _
     from django.db import models
-...
             # unfortunately it lacks a batch API...
             destinations = self.clean_numbers(destinations, self.default_country_code)
             rcpt = ','.join(destinations)
             params = urllib.urlencode({
             params = {
                 'user': self.username,
                 'pass': self.password,
                 'rcpt': rcpt,
                 'data': text,
                 'sender': sender,
                 'qty': self.quality
                 })
+                }
             try:
                 r = urllib2.urlopen(self.URL, params)
                 r = requests.get(self.URL, params=params)
             except Exception, e:
                 logger.error('unable to urlopen %s: %s', self.URL, e)
                 raise MobytError('unable to urlopen %s: %s' % (self.URL, e))
             answer = r.read()
             r.close()
             if answer[:2] != "OK":
                 raise MobytError('MobyT error: %r' % answer)
                 logger.error('unable to open %s: %s', self.URL, e)
                 raise MobytError('unable to open %s: %s' % (self.URL, e))
             if not r.ok():
                 raise MobytError('MobyT error: %r' % r.content)
             return { 'message': 'OK' }

     import re
     import urllib
     import urllib2
     import logging
     import json
     import requests
     from django.utils.translation import ugettext_lazy as _
     from django.db import models
-...
+            }
             ret = {}
             try:
                 stream = urllib.urlopen('%s?%s' % (self.URL, urllib.urlencode(params)))
                 r = requests.get(self.URL, params=params)
             except Exception, e:
                 logger.error('unable to urlopen %s: %s', self.URL, e)
                 raise OVHError('unable to urlopen %s: %s' % (self.URL, e))
             else:
                 result = json.loads(stream.read())
                 if 100 <= result['status'] < 200:
                 result = r.json()
                 if 100 <= r.status_code < 200:
                     credit_left = float(result['creditLeft'])
                     # update credit left
                     OVHSMSGateway.objects.filter(id=self.id) \

     import re
     import urllib
     import urllib2
     import logging
     import json
     import requests
     from django.db import models
     from django.core.urlresolvers import reverse
-...
             destinations = self.clean_numbers(destinations,
                     self.default_country_code, prefix='')
             for dest in destinations:
                 params = urllib.urlencode({
                     'id': self.username,
                     'pass': self.password,
                     'num': number,
                     'sms': text.encode('utf-8'),
                     'flash': '0'
                     })
                 params = {'id': self.username,
                           'pass': self.password,
                           'num': number,
                           'sms': text.encode('utf-8'),
                           'flash': '0'
+                }
                 try:
                     r = urllib2.urlopen('http://sms.oxyd.fr/send.php', params)
                 except Exception, e:
                     # XXX: add proper handling of errors
                     logger.error('urlopen oxyd.fr failed : %s', e)
                     raise OxydError('urlopen oxyd.fr failed : %s' % e)
                 else:
                     line = r.read()
                     code = line.split()[0]
                     if code != '200':
                         logger.error('OXYD error: %r', line)
                         raise OxydError('OXYD error: %r' % line)
                 r.close()
                     r = requests.get('http://sms.oxyd.fr/send.php', params=params)
                 except requests.ConnectionError:
                     logger.error('open oxyd.fr failed : %s', e)
                     raise OxydError('open oxyd.fr failed : %s' % e)
                 if not r.ok():
                     logger.error('OXYD error: %r', r.content)
                     raise OxydError('OXYD error: %r' % r.content)
         def get_sms_left(self, type='standard'):
             raise NotImplementedError

     import json
     from urllib2 import Request, urlopen, HTTPError
     import requests
     # debug (ahem... sort of)
     from config import DEBUG_PATH
-...
     def post(uri, data, base_url=BASE_URL):
         headers = {'Accept': 'application/json',
                    'Content-Type': 'application/json;charset=UTF-8'
+        }
         url = base_url + uri
         r = Request(url)
         r.add_header('Accept', 'application/json')
         r.add_header('Content-Type', 'application/json;charset=UTF-8')
         r.add_data(data)
         try:
             p = urlopen(r)
         except HTTPError as e:
             code = e.code
             out_data = 'read:\n%s' % e.read()
         else:
             code = p.getcode()
             out_data = p.read()
             p.close()
         r = requests.get(url, data=data, headers=headers)
         code = r.status_code
         if DEBUG_PATH:
             f = open(os.path.join(DEBUG_PATH, datetime.now().strftime('%Y%m%d-%H%M%S.txt')), 'a')
             f.write('url: %s\nCODE: %s\nIN\n---\n' % (url, code))
-...
                 f.write('NOT JSON: %s' % data)
             f.write('\n---\nOUT\n---\n')
             try:
                 pprint(json.loads(out_data), f)
                 pprint(r.json(), f)
             except:
                 f.write('(NOT JSON)\n%s' % out_data)
                 f.write('(NOT JSON)\n%s' % r.content)
             f.write('\n---\n')
             f.close()
         return code, out_data
         return code, r.content
     def export_flow(flow, req, base_url=BASE_URL):
         uri = 'exportFlow?flow=%s&application=AsgTeleprocedureApa14' % flow
-...
             "ConciliationInputWS": {
                 "Block": block,
                 "Input": {
                     "Settings": { "Setting": setting, },
                     "Settings": { "Setting": setting, },
                     "Criteria": { "Criterium": criterium },
                     },
                 "Output": { "ReturnDatas": { "returnData": returndata }, },
-...
                 entries = [entries]
             l += entries
         return {'results': l, 'name': name, 'count': count, 'error': False}

     import config
     from pprint import pprint
     import urllib2
     from datetime import datetime
     import json
     import sys
-...
         try:
             code, data = solis.import_flow('ImportIntegrationDemande', dem)
             pprint(json.loads(data))
         except urllib2.HTTPError as e:
             print 'erreur', e.code
             print e.read()
         except:
             print 'erreur', code
             print data
     if __name__ == '__main__':
         for t in sys.argv[1:]:
-...
         dem['Beneficiaire']['dateNaissance'] = dn
         dem = {'ImportInputWSDemandeApa':DEMANDE_APA_MINIMALE}
         return solis.import_flow('ImportIntegrationDemande', dem)

     import json
     from urllib2 import Request, urlopen
     import requests
     from django.db import models
     from passerelle.base.models import BaseResource
-...
         timeout = models.IntegerField(null=True, blank=True)
         def repost(self, data, **kwargs):
             r = Request(self.url)
             r.add_header('Accept', 'application/json')
             r.add_header('Content-Type', 'application/json;charset=UTF-8')
             r.add_data(json.dumps(data))
             headers = {'Accept': 'application/json',
                        'Content-Type': 'application/json;charset=UTF-8'}
             if self.timeout:
                 p = urlopen(r, timeout=self.timeout)
                 r = requests.get(self.url, data=data, timeout=self.timeout)
             else:
                 p = urlopen(r)
             out_data = json.loads(p.read())
             p.close()
                 r = requests.get(self.url, data=data)
             return r.json()
             return out_data
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0001-replace-urllib-calls-by-requests-7898.patch