Ejemplo n.º 1
0
 def request(self, method, route, params=None, json=None, user_auth=False):
     host = "https://api.twitter.com"
     headers = {"User-Agent": self.user_agent}
     auth = None
     # TODO: Ability to choose app or user auth
     if user_auth:
         auth = OAuthHandler(self.consumer_key, self.consumer_secret)
         auth.set_access_token(self.access_token, self.access_token_secret)
         auth = auth.apply_auth()
     else:
         headers["Authorization"] = f"Bearer {self.bearer_token}"
     # TODO: log.debug
     with self.session.request(
         method, host + route, params=params, json=json, headers=headers,
         auth=auth
     ) as response:
         # TODO: log.debug
         if response.status_code in (400, 403):
             print(response.status_code)
             # TODO: Handle
         elif response.status_code != 200:
             print(response.status_code)
             # TODO: Handle
         # TODO: Handle rate limits
         return response.json()
Ejemplo n.º 2
0
 def request(self, method, route, params=None, json=None, user_auth=False):
     host = "https://api.twitter.com"
     headers = {"User-Agent": self.user_agent}
     auth = None
     if user_auth:
         auth = OAuthHandler(self.consumer_key, self.consumer_secret)
         auth.set_access_token(self.access_token, self.access_token_secret)
         auth = auth.apply_auth()
     else:
         headers["Authorization"] = f"Bearer {self.bearer_token}"
     log.debug(f"Making API request: {method} {host + route}\n"
               f"Parameters: {params}\n"
               f"Headers: {headers}\n"
               f"Body: {json}")
     with self.session.request(method,
                               host + route,
                               params=params,
                               json=json,
                               headers=headers,
                               auth=auth) as response:
         log.debug("Received API response: "
                   f"{response.status_code} {response.reason}\n"
                   f"Headers: {response.headers}\n"
                   f"Content: {response.content}")
         if response.status_code == 400:
             raise BadRequest(response)
         if response.status_code == 401:
             raise Unauthorized(response)
         if response.status_code == 403:
             raise Forbidden(response)
         # Handle 404?
         if response.status_code == 429:
             if self.wait_on_rate_limit:
                 reset_time = int(response.headers["x-rate-limit-reset"])
                 sleep_time = reset_time - int(time.time()) + 1
                 if sleep_time > 0:
                     log.warning("Rate limit exceeded. "
                                 f"Sleeping for {sleep_time} seconds.")
                     time.sleep(sleep_time)
                 return self.request(method, route, params, json, user_auth)
             else:
                 raise TooManyRequests(response)
         if response.status_code >= 500:
             raise TwitterServerError(response)
         if not 200 <= response.status_code < 300:
             raise HTTPException(response)
         return response.json()
Ejemplo n.º 3
0
class Stream(object):

    host = 'stream.twitter.com'

    def __init__(self, consumer_key, consumer_key_secret, oauth_token, oauth_token_secret, listener, timeout=5.0, retry_count = None,retry_time = 10.0, snooze_time = 5.0, buffer_size=1500, headers=None):
        self.auth = OAuthHandler(consumer_key, consumer_key_secret)#BasicAuthHandler(username, password)
        self.auth.set_access_token(oauth_token, oauth_token_secret)
        self.running = False
        self.timeout = timeout
        self.retry_count = retry_count
        self.retry_time = retry_time
        self.snooze_time = snooze_time
        self.buffer_size = buffer_size
        self.listener = listener
        self.api = API()
        self.headers = headers or {}
        self.body = None

    def _run(self):
        # setup
        #self.auth.apply_auth(None, None, self.headers, None)
        self.auth.apply_auth(self.url, "POST", self.headers, self.params)

        # enter loop
        error_counter = 0
        conn = None
        exception = None
        while self.running:
            if self.retry_count and error_counter > self.retry_count:
                # quit if error count greater than retry count
                break
            try:
                conn = httplib.HTTPConnection(self.host)
                conn.connect()
                conn.sock.settimeout(self.timeout)
                conn.request('POST', self.url, self.body, headers=self.headers)
                resp = conn.getresponse()
                if resp.status != 200:
                    if self.listener.on_error(resp.status) is False:
                        break
                    error_counter += 1
                    sleep(self.retry_time)
                else:
                    error_counter = 0
                    self._read_loop(resp)
            except timeout:
                if self.listener.on_timeout() == False:
                    break
                if self.running is False:
                    break
                conn.close()
                sleep(self.snooze_time)
            except Exception, exception:
                # any other exception is fatal, so kill loop
                break

        # cleanup
        self.running = False
        if conn:
            conn.close()

        if exception:
            raise exception