python-yahooapi/yahooapi.py at master · dkempiners/python-yahooapi · GitHub

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
import os
import time

from rauth import OAuth2Service


class ClientKey(object):
    def __init__(self, client_id, client_secret):
        self.client_id = client_id
        self.client_secret = client_secret

    @classmethod
    def from_file(cls, key_file):
        with open(key_file, "r") as f:
            keys = f.read().splitlines()

        if len(keys) != 2:
            raise RuntimeError("Incorrect number of keys found")

        return cls(*keys)


class Token(object):
    def __init__(self, access_token=None, refresh_token=None):
        self.access_token = access_token
        self.refresh_token = refresh_token
        self.expiration_time = 0

    @property
    def expires_in(self):
        return self.expiration_time - time.time()

    @property
    def is_expired(self):
        return self.expires_in <= 0

    def get(self, oauth_service):
        if self.refresh_token:
            data = {
                "refresh_token": self.refresh_token,
                "redirect_uri": "oob",
                "grant_type": "refresh_token",
            }
        else:
            data = {
                "code": self._get_code(oauth_service),
                "redirect_uri": "oob",
                "grant_type": "authorization_code",
            }

        self._get_token(oauth_service, data)

    def _get_code(self, oauth_service):
        params = {
            "redirect_uri": "oob",
            "response_type": "code",
        }
        authorize_url = oauth_service.get_authorize_url(**params)

        print "Sign in here: " + str(authorize_url)
        return raw_input("Enter code: ")

    def _get_token(self, oauth_service, data):
        raw_token = oauth_service.get_raw_access_token(data=data)

        parsed_token = raw_token.json()
        self.access_token = parsed_token["access_token"]
        self.refresh_token = parsed_token["refresh_token"]
        self.expiration_time = time.time() + parsed_token["expires_in"]

    @classmethod
    def from_file(cls, token_file):
        with open(token_file, "r") as f:
            token = f.read().strip()

        if len(token.splitlines()) != 1:
            raise RuntimeError("Incorrect token format")

        return cls(refresh_token=token)

    def save(self, token_file):
        with open(token_file, "w") as f:
            f.write(self.refresh_token)


class YahooAPI(object):
    def __init__(self, keyfile, tokenfile=None,
                 base_url="https://fantasysports.yahooapis.com",
                 request_period=0):

        self.key = ClientKey.from_file(keyfile)

        self.tokenfile = tokenfile
        if self.tokenfile and os.path.exists(self.tokenfile):
            self.token = Token.from_file(self.tokenfile)
        else:
            self.token = Token()

        self.oauth = OAuth2Service(
            client_id=self.key.client_id,
            client_secret=self.key.client_secret,
            name="yahoo",
            authorize_url="https://api.login.yahoo.com/oauth2/request_auth",
            access_token_url="https://api.login.yahoo.com/oauth2/get_token",
            base_url=base_url,
        )

        self.session = None

        self._update_token()

        self.session = self.oauth.get_session(self.token.access_token)

        self.last_request = time.time()
        self.request_period = request_period

    def _update_token(self):
        self.token.get(self.oauth)

        if self.tokenfile:
            self.token.save(self.tokenfile)

        if self.session:
            self.session.access_token = self.token.access_token

    def request(self, request_str, params={}):
        """get json instead of xml like this params={'format': 'json'}"""

        tdiff = max(0, time.time() - self.last_request)
        if tdiff >= 0 and tdiff < self.request_period:
            time.sleep(self.request_period - tdiff)

        self.last_request = time.time()

        # refresh access token 60 seconds before it expires
        if self.token.expires_in < 60:
            self._update_token()

        return self.session.get(url=request_str, params=params)