def getOauthClient(c_id, c_secret, oauth_call_back):
try:
ACCESS_TOKEN = SET_ACCESS_TOKEN
REFRESH_TOKEN = SET_REFRESH_TOKEN
auth2_client = fitbit.Fitbit(c_id, c_secret, oauth2=True, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN, system=None)
except BaseException as e:
print("Got exception: {}".format(str(e)))
server = Oauth2.OAuth2Server(client_id=c_id, client_secret=c_secret, redirect_uri=oauth_call_back)
server.browser_authorize()
ACCESS_TOKEN = str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN = str(server.fitbit.client.session.token['refresh_token'])
auth2_client = fitbit.Fitbit(c_id, c_secret, oauth2=True, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN, system=None)
return auth2_client
def getFitbitClient():
CLIENT_ID = '22DRGH'
CLIENT_SECRET = '5990430b77b9de227dbdf758b075a868'
try:
keys = loads(open("keys.json", 'r').read())
except FileNotFoundError:
server = Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
server.browser_authorize()
keys = dict()
token = server.fitbit.client.session.token
keys['access_token'] = str(token['access_token'])
keys['refresh_token'] = str(token['refresh_token'])
save_keys_to_file(server.fitbit.client.session.token)
auth2_client = fitbit.Fitbit(CLIENT_ID,
CLIENT_SECRET,
refresh_cb=save_keys_to_file,
oauth2=True,
access_token=keys['access_token'],
refresh_token=keys['refresh_token'])
return auth2_client
def MakeAPICall(URL, TokenURI, AccToken,RefToken):
#Start the request
request = urllib2.Request(URL) # relies on Access token for ID
#Add Access token in header
request.add_header('Authorization', 'Bearer ' + AccToken)
#Fire off the request
context = ssl._create_unverified_context() # development - bypass SSL certs
try:
response = urllib2.urlopen(request, context=context)
FullResponse = response.read()
json_response = json.loads(FullResponse) # response in JSON format
# client to access Fitbit information
client_key, client_secret = GetClient()
client = fitbit.Fitbit(client_id=client_key,
client_secret=client_secret,
access_token=AccToken,
refresh_token=RefToken)
return (True, json_response, client)
#Catch errors (e.g. A 401 error that signifies the need for a new access token)
except urllib2.URLError as e:
print "HTTP error: ", str(e.code)
print "HTTP Error Message: ", e.read()
if (e.code == 401) and (e.read().find("Access token invalid or expired") != -1):
GetNewAccessToken(TokenURI, RefToken) # use Refresh token to obtain new Access token
return False, "Refreshed"
return False, "Error"
def import_user_fitbit_history_via_api(user, start_date, end_date):
fitbit_user = UserFitbit.objects.get(user=user)
fitbit_api = fitbit.Fitbit(
client_id=settings.FITBIT_CONSUMER_KEY,
client_secret=settings.FITBIT_CONSUMER_SECRET,
access_token=fitbit_user.access_token,
expires_at=fitbit_user.expires_at,
refresh_token=fitbit_user.refresh_token,
refresh_cb=fitbit_user.refresh_cb,
)
query_dates = pd.date_range(start=start_date, end=end_date).date
for query_date in query_dates:
api_response = fitbit_api.get_sleep(query_date)
valid_data = api_response.get('sleep')
if not valid_data:
# if the response doesn't contain valid data, no sense to continue
continue
for datum in valid_data:
data = {
'user': user.id,
'start_time': datum['startTime'],
'end_time': datum['endTime']
}
serializer = FitbitResponseSleepActivitySerializer(data=data)
serializer.is_valid()
serializer.save()
def __init__(
self,
client_id,
client_secret,
min_steps_for_entry_to_be_active=20,
max_contiguous_non_active_entries_for_continuous_session=3,
min_consecutive_active_entries_to_count_as_activity=10,
):
server = Oauth2.OAuth2Server(client_id, client_secret)
server.browser_authorize()
ACCESS_TOKEN = str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN = str(
server.fitbit.client.session.token['refresh_token'])
self._client = fitbit.Fitbit(
client_id,
client_secret,
oauth2=True,
access_token=ACCESS_TOKEN,
refresh_token=REFRESH_TOKEN,
)
self._min_steps_for_entry_to_be_active = min_steps_for_entry_to_be_active
self._max_contiguous_non_active_entries_for_continuous_session = \
max_contiguous_non_active_entries_for_continuous_session
self._min_consecutive_active_entries_to_count_as_activity = \
min_consecutive_active_entries_to_count_as_activity
def client_create_or_refresh(self):
# refresh if client is already created.
if self.auth2_client is not None:
print("Client refreshing is started.")
encoded = base64.b64encode(
bytes(f"{self.client_id}:{self.client_secret}".encode(
"utf8"))).decode("utf8")
headers = {
"Authorization": f"Basic {encoded}",
"Content-Type": "application/x-www-form-urlencoded",
}
body = {
"grant_type": "refresh_token",
"refresh_token": self.refresh_token
}
r = requests.post("https://api.fitbit.com/oauth2/token",
headers=headers,
data=body).json()
print(
f"Previous access_token: {self.access_token}, previous refresh_token: "
f"{self.refresh_token}")
self.access_token = r["access_token"]
self.refresh_token = r["refresh_token"]
print(f"New access_token: {self.access_token}, new refresh_token: "
f"{self.refresh_token}")
self.auth2_client = fitbit.Fitbit(
self.client_id,
self.client_secret,
oauth2=True,
access_token=self.access_token,
refresh_token=self.refresh_token,
)
def get_authorized_client() -> fitbit.Fitbit:
"""
Using the defined environment variables for the various Fitbit tokens,
creates an authorized Fitbit client for a user's credentials.
:return: Authorized Fitbit client
"""
if os.getenv('TEST_LEVEL') == 'local':
with open(r'C:\Users\devni\PycharmProjects\fitnick\fitnick\base\fitbit_access_key.txt', 'r') as f:
access_key = f.read().strip()
with open(r'C:\Users\devni\PycharmProjects\fitnick\fitnick\base\fitbit_refresh_token.txt', 'r') as f:
refresh_token = f.read().strip()
else:
access_key = os.getenv('FITBIT_ACCESS_KEY')
refresh_token = os.getenv('FITBIT_REFRESH_TOKEN')
authorized_client = fitbit.Fitbit(
os.environ['FITBIT_CONSUMER_KEY'],
os.environ['FITBIT_CONSUMER_SECRET'],
access_key,
refresh_token
)
if authorized_client.sleep:
# If the client isn't authorized, this method will return NoneType
return authorized_client
else:
print(
'Authorization failed - check your refresh token, and ensure'
+ 'your environment variables are set correctly.')
exit()
def __init__(self, verbose=None):
""" Set up connection details """
if not verbose:
log_level = logging.INFO
else:
log_level = logging.DEBUG
stdout_handler = logging.StreamHandler(sys.stdout)
logging.basicConfig(level=log_level, handlers=[stdout_handler])
self.logger = logging.getLogger(name="fitbit-mongodb-loader")
# Connect to FitBit
key = os.environ["FITBIT_KEY"]
secret = os.environ["FITBIT_SECRET"]
access_token = os.environ["FITBIT_ACCESS_TOKEN"]
refresh_token = os.environ["FITBIT_REFRESH_TOKEN"]
self.fitbit_client = fitbit.Fitbit(key,
secret,
access_token=access_token,
refresh_token=refresh_token)
# Create MongoDB connectION
mongodb_client = MongoClient()
self.db = mongodb_client.fitbit
# Empty vars -- need to be filled by child class
self.collection_name = None
self.document_key = None
self.timestamp_key = None
self.request_args = {}
def get_json(start_date, stop_date):
# we've got the plain text id and secret in a text file for jerry rigging
in_file = open(r"fitbit_client_keys.txt", "r")
app_info = in_file.readlines()
CLIENT_ID = app_info[0].strip()
CLIENT_SECRET = app_info[1].strip()
server = gather.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
# using oauth2 to access
print(CLIENT_ID)
server.browser_authorize()
# getting all of our tokens
USER_ID = server.fitbit.client.session.token['user_id']
ACCESS_TOKEN = server.fitbit.client.session.token['access_token']
REFRESH_TOKEN = server.fitbit.client.session.token['refresh_token']
# authd client is the actual Fitbit object we'll use to gather information
authd_client = fitbit.Fitbit(USER_ID,
CLIENT_SECRET,
oauth2=True,
access_token=ACCESS_TOKEN,
refresh_token=REFRESH_TOKEN)
# Here, we're having collect_daily_activity_data get each of our daily values (each listed in activities)
# and putting them into JSON format so we can use it in our website
df = collect_daily_activity_data(authd_client, date, activities,
start_date, stop_date)
json_format = df.to_json()
return json_format
def get_heartrate(access_token, refresh_token):
fitbit_client = fitbit.Fitbit(config.get('fitbit', 'CLIENT_ID'),
config.get('fitbit', 'CLIENT_SECRET'),
access_token=access_token,
refresh_token=refresh_token)
TODAY = dt.now()
DATE = TODAY.strftime('%Y-%m-%d')
response = fitbit_client.intraday_time_series('activities/heart',
base_date=DATE,
detail_level='1min')
metrics = map(
lambda x: {
'time':
int(
time.mktime(
dt.strptime(DATE + ' ' + x['time'], '%Y-%m-%d %H:%M:%S').
timetuple())),
'value':
int(x['value']),
'name':
'heartrate'
}, response['activities-heart-intraday']['dataset'])
post_mackerel(metrics)
# return metrics
return response['activities-heart-intraday']['dataset'][-1]
def __init__(self, base_date, data_type):
# find .env automagically by walking up directories until it's found
dotenv_path = find_dotenv()
# load up the entries as environment variables
load_dotenv(dotenv_path)
client_id = os.environ.get("CLIENT_ID")
client_secret = os.environ.get("CLIENT_SECRET")
access_token = os.environ.get("ACCESS_TOKEN")
refresh_token = os.environ.get("REFRESH_TOKEN")
expires_at = float(os.environ.get("EXPIRES_AT"))
self.authd_client = fitbit.Fitbit(
client_id, client_secret,
access_token=access_token,
refresh_token=refresh_token,
expires_at=expires_at)
self.base_date = base_date
self.data_type = data_type
file_name = "{}_{}.json".format(
self.data_type, str(self.base_date.date()))
project_dir = '/Users/rbussman/Projects/sleep-bit'
raw_dir = os.path.join(project_dir, 'data', 'raw')
self.file_path = os.path.join(raw_dir, file_name)
def authenticate():
server = Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
server.browser_authorize()
ACCESS_TOKEN = str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN = str(server.fitbit.client.session.token['refresh_token'])
auth2_client = fitbit.Fitbit(CLIENT_ID, CLIENT_SECRET, oauth2=True, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN)
auth2_client.sleep()
yesterday = str((datetime.datetime.now() - datetime.timedelta(days=1)).strftime("%Y%m%d"))
yesterday2 = str((datetime.datetime.now() - datetime.timedelta(days=1)).strftime("%Y-%m-%d"))
today = str(datetime.datetime.now().strftime("%Y%m%d"))
fit_statsHR = auth2_client.intraday_time_series('activities/heart', base_date=yesterday2, detail_level='1sec')
time_list = []
val_list = []
for i in fit_statsHR['activities-heart-intraday']['dataset']:
val_list.append(i['value'])
time_list.append(i['time'])
heartdf = pd.DataFrame({'Heart Rate':val_list,'Time':time_list})
heartdf.to_csv('/Users/anthony/Downloads/python-fitbit-master/Heart/heart'+ \
yesterday+'.csv', \
columns=['Time','Heart Rate'], header=True, \
index = False)
def accessAPI():
#Client ID & Secret is given to us from the FitBit website
CLIENT_ID = r'22DFZ8'
CLIENT_SECRET = r'9e72de768392860b178fe36968c788e3'
#Establish authentication with Fitbit
server = Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
server.browser_authorize()
#Save these if new access or refresh is needed
ACCESS_TOKEN = str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN = str(server.fitbit.client.session.token['refresh_token'])
#Connection
auth2_client = fitbit.Fitbit(CLIENT_ID, CLIENT_SECRET, oauth2=True, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN)
#calls data and saves into dataframe
fit_statsHR = auth2_client.intraday_time_series('activities/heart', base_date=today2, detail_level='1sec')
#reads the dictionary format and iterates through the dictionary values
time_list = []
val_list = []
for i in fit_statsHR['activities-heart-intraday']['dataset']:
val_list.append(i['value'])
time_list.append(i['time'])
heartdf = pd.DataFrame({'HR':val_list,'Time':time_list})
heartdf.to_csv('data/rawHR/' + 'HR_' + today + '.csv', columns=['Time','HR'], header=True, index = False)
print("File saved")
def steps(self):
a_cl = fitbit.Fitbit(
config.C_KEY,
config.C_SECRET,
system="en-GB",
resource_owner_key=config.resource_owner_key,
resource_owner_secret=config.resource_owner_secret)
days = a_cl.time_series('activities/steps',
period='max').get('activities-steps')
if days:
first_tracked = False
days_json = []
for d in days:
print d, type(d)
if first_tracked:
d_datetime = datetime.datetime.strptime(
d['dateTime'], '%Y-%m-%d')
# if weekend
if d_datetime.weekday() in (5, 6):
line_color = '#c77e24'
else:
line_color = '#abc123'
days_json.append({
'min': 1000,
'date': d['dateTime'],
'steps': d['value'],
'lineColor': line_color
})
elif int(d['value']) > 0:
first_tracked = True
days_json_str = json.dumps(days_json)
return self.serve_template('steps.html', days=days_json_str)
def get_client():
with open('tokens.json') as token_file:
tokens = json.load(token_file)
return fitbit.Fitbit(tokens["KEY"], tokens["SECRET"],
access_token = tokens["ACCESS"],
refresh_token = tokens["REFRESH"],
refresh_cb = refresh_tokens)
def listaPacientes():
if request.method == 'POST':
paciente = Paciente.query.filter_by(name=request.form['nomePacienteBusca']).first()
if paciente:
med = ProfSaude.query.filter_by(id=paciente.ProfSaude_id).first()
#Função para chamar os dados do fitbit da conta do paciente
auth2_client=fitbit.Fitbit(CLIENT_ID,CLIENT_SECRET,oauth2=True,access_token=paciente.access_token,refresh_token=paciente.refresh_token)
data = str(date.today().strftime("%Y-%m-%d"))
oneDayData = auth2_client.time_series('activities/steps', base_date=data, period = '30d')
for x in oneDayData['activities-steps']:
datefit = x['dateTime']
value = x['value']
dados = DadosFit(Paciente_id=paciente.id ,date=datefit,steps=value)
db.session.merge(dados) #adiciona ou atualiza novo usuário no banco de dados usando merge para evitar duplicatade primary keys
db.session.commit() #atualiza banco de dados
dadosFitbit = []
for u in db.session.query(DadosFit).all():
if paciente.id == u.__dict__['Paciente_id'] :
dadosFitbit.append(u.__dict__)
metas = []
for u in db.session.query(Metas).all():
if paciente.id == u.__dict__['Paciente_id'] :
metas.append(u.__dict__)
exercicios = []
for u in db.session.query(Exercicios).all():
if paciente.id == u.__dict__['Paciente_id'] :
exercicios.append(u.__dict__)
return render_template('dadosPaciente.html', nomePaciente=paciente.name, pesoPaciente=paciente.weight, idadePaciente=paciente.age, alturaPaciente=paciente.height, medResp=med.name, dadosFitbit=dadosFitbit, metas=metas, exercicios=exercicios)
else:
return render_template('usuarioNaoEncontrado.html')
return render_template('listaPacientes.html')
def refresh_steps(cfg_file, engine, db_df):
print("REFRESHING STEPS...")
parser = configparser.ConfigParser()
parser.read(cfg_file)
consumer_key = parser.get('fitbit', 'consumer_key')
consumer_secret = parser.get('fitbit', 'consumer_secret')
access_token = parser.get('fitbit', 'access_token')
refresh_token = parser.get('fitbit', 'refresh_token')
expires_at = parser.get('fitbit', 'expires_at')
auth_client = fitbit.Fitbit(
consumer_key,
consumer_secret,
access_token=access_token,
refresh_token=refresh_token,
expires_at=float(expires_at),
refresh_cb=(lambda x: persist_fitbit_refresh_token(x, cfg_file)))
[date_start, date_end] = get_target_date_endpoints('steps', db_df)
steps = auth_client.time_series('activities/steps',
base_date=date_start,
end_date=date_end)
date_values = [[pd.to_datetime(val['dateTime']), val['value']]
for val in steps['activities-steps']]
updated_df = insert_values(date_values, 'steps', db_df)
updated_df[['steps']] = updated_df[['steps']].apply(pd.to_numeric)
with engine.connect() as conn, conn.begin():
updated_df.to_sql('fitness', conn, if_exists='replace')
return updated_df
def signupPaciente():
form = RegisterForm_Paciente()
if form.validate_on_submit():
hashed_password = generate_password_hash(form.password.data, method='sha256') #geração da hash de segurança
# integração com o fitbit.
CLIENT_ID = '22BMBD'
CLIENT_SECRET = '41bf164e37513442e8fc5c3f36f3d876'
#Solicitação de código de acesso para o cliente
server=Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
server.browser_authorize()
ACCESS_TOKEN=str(server.fitbit.client.session.token['access_token'])
REFRESH_TOKEN=str(server.fitbit.client.session.token['refresh_token'])
auth2_client=fitbit.Fitbit(CLIENT_ID,CLIENT_SECRET,oauth2=True,access_token=ACCESS_TOKEN,refresh_token=REFRESH_TOKEN,expires_at=3153600)
new_user = Paciente(ProfSaude_id=current_user.id ,username=form.username.data,email=form.email.data,password=hashed_password, name=form.name.data ,age=form.age.data,weight=form.weight.data,height=form.height.data, access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN)
db.session.add(new_user) #adiciona novo usuário no banco de dados
db.session.commit() #atualiza banco de dados
flash('Cadastro bem-sucedido')
return redirect('/dashboard')
return render_template('signupPaciente.html', form=form)
def get_and_save_weight(cls):
authd_client = fitbit.Fitbit(
settings.FITBIT_CONSUMER_KEY,
settings.FITBIT_CONSUMER_SECRET,
user_key=settings.FITBIT_USER_KEY,
user_secret=settings.FITBIT_USER_SECRET
)
weight = authd_client.get_bodyweight()
# {u'weight': [{u'date': u'2014-03-29', u'logId': 1396089789000, u'bmi': 22.38, u'weight': 165, u'time': u'10:43:09'}, {u'date': u'2014-03-29', u'logId': 1396097620000, u'bmi': 22.41, u'weight': 165.3, u'time': u'12:53:40'}]}
fat = authd_client.get_bodyfat()
# {u'fat': [{u'date': u'2014-03-29', u'logId': 1396089789000, u'fat': 16.9, u'time': u'10:43:09'}, {u'date': u'2014-03-29', u'logId': 1396097620000, u'fat': 16.9, u'time': u'12:53:40'}]}
try:
last_update = cls.objects.order_by("-when")[0]
except:
last_update = None
if len(weight) > 0 and len(weight["weight"]) > 0:
last_weight = weight["weight"][-1]
last_fat = fat["fat"][-1]
# 2014-03-29 10:43:09
last_time = datetime.datetime.fromtimestamp(
time.mktime(time.strptime("%s %s" % (last_weight["date"], last_weight["time"]), "%Y-%m-%d %H:%M:%S"))
)
if not last_update or last_time != last_update.when:
cls.objects.create(when=last_time, weight=last_weight["weight"], body_fat_percent=last_fat["fat"])
def main(_=None):
parser = argparse.ArgumentParser(description='Fitbit Scraper')
parser.add_argument('--id', metavar='clientId', dest='clientId', required=True,
help="client-id of your Fitbit app")
parser.add_argument('--secret', metavar='clientSecret', dest='clientSecret', required=True,
help="client-secret of your Fitbit app")
parser.add_argument('--out', metavar='outDir', dest='outDir', required=True,
help="output data destination folder")
parser.add_argument('--start', dest='startDate', default='2016-01-01',
help="Date from which to start the forward scraping. Defaults to 2016-01-01")
#parser.add_argument('--limit', type=int, dest='limit', default=400,
# help="maximum number of days to scrape")
args = parser.parse_args()
clientId = args.clientId
clientSecret = args.clientSecret
dumpDir = Path(args.outDir)
startDate = args.startDate
#limit = args.limit
server = Oauth2.OAuth2Server(clientId, clientSecret)
server.browser_authorize()
ACCESS_TOKEN = server.oauth.session.token['access_token']
REFRESH_TOKEN = server.oauth.session.token['refresh_token']
client = fitbit.Fitbit(clientId, clientSecret, oauth2=True,
access_token=ACCESS_TOKEN, refresh_token=REFRESH_TOKEN)
scrapeFromDateOnward(startDate, dumpDir, client)
def get_token(self):
tokens = open(token_file).read()
token_dict = literal_eval(tokens)
self.access_token = token_dict['access_token']
self.refresh_token = token_dict['refresh_token']
self.authd_client = fitbit.Fitbit(self.client_id, self.client_secret
, access_token = self.access_token, refresh_token = self.refresh_token, refresh_cb = update_token)
def main():
p_file = Path(__file__)
p_work = Path(p_file.parent)
CLIENT_ID = ''
CLIENT_SECRET = ''
#各トークンをファイルから取得
ACCESS_TOKEN, REFRESH_TOKEN = openFile.funcGetToken(p_work)
client = fitbit.Fitbit(CLIENT_ID,
CLIENT_SECRET,
access_token=ACCESS_TOKEN,
refresh_token=REFRESH_TOKEN,
system="ja-JP")
# アップロード用の体重リストをCSVから取得
lst_wight_log = openFile.funcGetWeightList(p_work)
for idx, line in enumerate(lst_wight_log):
cell = openFile.funcGetList2str(line).split(",")
if 3 <= len(cell):
print("\t→" + cell[0])
client.body(date=cell[0], data={"weight": cell[1], "fat": cell[2]})
def LogFitBitSession(session):
duration = CalcDuration(session)
if duration:
authd_client = fitbit.Fitbit(
GetConfig('consumer_key'),
GetConfig('consumer_secret'),
resource_owner_key=GetConfig('user_key'),
resource_owner_secret=GetConfig('user_secret'))
if authd_client:
authd_client.sleep()
ret = authd_client.log_activity({
'activityId':
'16030',
'manualCalories':
'0',
'startTime':
duration['startTime'],
'durationMillis':
duration['millis'],
'date':
duration['date']
})
if int(ret['activityLog']['activityId']) == 16030:
return True
return False
def getSleepDataByDate(date):
tokenfile = "user_settings.txt"
z = fitbit.Fitbit()
# Try to read existing token pair
try:
token = json.load(open(tokenfile))
except IOError:
# If not generate a new file
# Get the authorization URL for user to complete in browser.
auth_url = z.GetAuthorizationUri()
print "Please visit the link below and approve the app:\n %s" % auth_url
# Set the access code that is part of the arguments of the callback URL FitBit redirects to.
access_code = raw_input(
"Please enter code (from the URL you were redirected to): ")
# Use the temporary access code to obtain a more permanent pair of tokens
token = z.GetAccessToken(access_code)
# Save the token to a file
json.dump(token, open(tokenfile, 'w'))
# Sample API call
response = z.ApiCall(token, '/1.2/user/-/sleep/date/' + date + '.json')
# Token is part of the response. Note that the token pair can change when a refresh is necessary.
# So we replace the current token with the response one and save it.
token = response['token']
json.dump(token, open(tokenfile, 'w'))
# Do something with the response
return response['sleep']
def GetFitbitClient(self):
"""Returns an authenticated fitbit client object"""
logging.debug("Creating Fitbit client")
credentials = json.load(open(self.fitbitCredsFile))
client = fitbit.Fitbit(**credentials)
logging.debug("Fitbit client created")
return client
def __init__(self):
self.server = Oauth2.OAuth2Server(CLIENT_ID, CLIENT_SECRET)
# print(ACCESS_TOKEN, REFRESH_TOKEN)
self.auth2_client = fitbit.Fitbit(CLIENT_ID,
CLIENT_SECRET,
oauth2=True,
access_token=ACCESS_TOKEN,
refresh_token=REFRESH_TOKEN)
def GetFitbitClient(self):
"""Returns an authenticated fitbit client object"""
logging.debug("Creating Fitbit client")
credentials = json.load(open(self.fitbitCredsFile))
client = fitbit.Fitbit(**credentials)
client.get_sleep_v12 = types.MethodType(get_sleep_v12, client)
logging.debug("Fitbit client created")
return client
def fetch_fitbit_sleep_data(string_date):
client = fitbit.Fitbit(FITBIT_CONSUMER_KEY,
FITBIT_CONSUMER_SECRET,
resource_owner_key=FITBIT_USER_KEY,
resource_owner_secret=FITBIT_USER_SECRET,
user_id=FITBIT_USER_ID,
system="ja-JP")
return client.sleep(string_date)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Fitbit sensor."""
config_path = hass.config.path(FITBIT_CONFIG_FILE)
if os.path.isfile(config_path):
config_file = config_from_file(config_path)
if config_file == DEFAULT_CONFIG:
request_app_setup(hass, config, add_devices, config_path,
discovery_info=None)
return False
else:
config_file = config_from_file(config_path, DEFAULT_CONFIG)
request_app_setup(hass, config, add_devices, config_path,
discovery_info=None)
return False
if "fitbit" in _CONFIGURING:
get_component("configurator").request_done(_CONFIGURING.pop("fitbit"))
import fitbit
access_token = config_file.get("access_token")
refresh_token = config_file.get("refresh_token")
if None not in (access_token, refresh_token):
authd_client = fitbit.Fitbit(config_file.get("client_id"),
config_file.get("client_secret"),
access_token=access_token,
refresh_token=refresh_token)
if int(time.time()) - config_file.get("last_saved_at", 0) > 3600:
authd_client.client.refresh_token()
authd_client.system = authd_client.user_profile_get()["user"]["locale"]
dev = []
for resource in config.get("monitored_resources",
FITBIT_DEFAULT_RESOURCE_LIST):
dev.append(FitbitSensor(authd_client, config_path, resource,
hass.config.temperature_unit ==
TEMP_CELSIUS))
add_devices(dev)
else:
oauth = fitbit.api.FitbitOauth2Client(config_file.get("client_id"),
config_file.get("client_secret"))
redirect_uri = "{}{}".format(hass.config.api.base_url,
FITBIT_AUTH_CALLBACK_PATH)
fitbit_auth_start_url, _ = oauth.authorize_token_url(
redirect_uri=redirect_uri,
scope=["activity", "heartrate", "nutrition", "profile",
"settings", "sleep", "weight"])
hass.wsgi.register_redirect(FITBIT_AUTH_START, fitbit_auth_start_url)
hass.wsgi.register_view(FitbitAuthCallbackView(hass, config,
add_devices, oauth))
request_oauth_completion(hass)
def getDailyWeight():
authd_client = fitbit.Fitbit(config.CLIENT_ID,
config.CLIENT_SECRET,
access_token=config.ACCESS_TOKEN,
refresh_token=config.REFRESH_TOKEN,
system="")
weight_data = authd_client.get_bodyweight(getYesterday())["weight"][0]
return (weight_data["date"], weight_data["bmi"], weight_data["weight"])
