def upload_summaries(oh_user, summaries, file_name, existing_file_id):
temp_dir, file = write_json_data_to_tmp_file(f'garmin-health-api-{file_name}.json', summaries)
api.upload_aws(file, create_metadata(file_name), oh_user.get_access_token(), project_member_id=oh_user.oh_id, max_bytes=MAX_FILE_BYTES)
if existing_file_id:
api.delete_file(oh_user.get_access_token(), file_id=existing_file_id)
os.remove(file)
os.rmdir(temp_dir)
def add_jawbone_data(oh_member, data, endpoint):
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'tags': ['Jawbone'],
'updated_at': str(datetime.utcnow()),
}
if endpoint == 'moves':
metadata['description'] = ('Jawbone "moves" data, including steps, '
'calories, and activity')
metadata['tags'].append('steps')
elif endpoint == 'sleeps':
metadata['description'] = ('Jawbone "sleeps" data, including time, '
'duration, and depth estimates.')
metadata['tags'].append('sleep')
elif endpoint == 'heartrates':
metadata['description'] = ('Jawbone "heartrates" data, including '
'resting heartrates')
metadata['tags'].append('heartrate')
out_file = os.path.join(
tmp_directory,
'jawbone-{}-data.json'.format(endpoint))
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename='jawbone-{}-data.json'.format(endpoint))
with open(out_file, 'w') as json_file:
json.dump(data, json_file)
json_file.flush()
api.upload_aws(out_file, metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('added new jawbone {} file for {}'.format(
endpoint, oh_member.oh_id))
def fetch_googlefit_data(oh_id):
'''
Fetches all of the googlefit data for a given user
'''
print("Started googlefit update task")
try:
current_dt = datetime.utcnow()
oh_member = OpenHumansMember.objects.get(oh_id=oh_id)
gf_member = oh_member.googlefit_member
oh_access_token = oh_member.get_access_token()
gf_access_token = gf_member.get_access_token()
basenames_to_ids = get_existing_basenames_to_ids(oh_member)
filesmonth = get_googlefit_data(oh_access_token, gf_access_token, current_dt)
for fn, month in filesmonth:
api.upload_aws(fn, create_metadata(month),
oh_access_token,
project_member_id=oh_id)
basename = os.path.basename(fn)
if basename in basenames_to_ids:
file_id_to_delete = basenames_to_ids[basename]
api.delete_file(oh_access_token, file_id=file_id_to_delete)
gf_member.last_updated = arrow.now().format()
gf_member.save()
except Exception as e:
import traceback
print("Fetching googlefit data failed: {}".format(e))
print(traceback.format_exc())
# queue to retry later
fetch_googlefit_data.apply_async(args=[oh_id], countdown=3600)
raise
def process_file(dfile, access_token, member, metadata, taxonomy):
try:
verify_ubiome(dfile)
tmp_directory = tempfile.mkdtemp()
base_filename = dfile['basename'].replace('.zip', '')
taxonomy_file = base_filename + '.taxonomy.json'
raw_filename = temp_join(tmp_directory, taxonomy_file)
metadata = {
'description': 'uBiome 16S taxonomy data, JSON format.',
'tags': ['json', 'uBiome', '16S']
}
with open(raw_filename, 'w') as raw_file:
json.dump(taxonomy, raw_file)
raw_file.flush()
api.upload_aws(raw_filename,
metadata,
access_token,
base_url=OH_BASE_URL,
project_member_id=str(member['project_member_id']))
except:
api.message("uBiome integration: A broken file was deleted",
"While processing your uBiome file "
"we noticed that your file does not conform "
"to the expected specifications and it was "
"thus deleted. Email us as [email protected] if "
"you think this file should be valid.",
access_token,
base_url=OH_BASE_URL)
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(dfile['id']),
base_url=OH_BASE_URL)
raise
def bundle(handler, model):
"""Create a compressed tarball containing the notebook document.
Parameters
----------
handler : tornado.web.RequestHandler
Handler that serviced the bundle request
model : dict
Notebook model from the configured ContentManager
"""
redirect_url = os.getenv("JH_BUNDLE_REDIRECT",
"http://127.0.0.1:5000/shared")
try:
access_token = os.getenv('OH_ACCESS_TOKEN')
ohmember = api.exchange_oauth2_member(access_token)
project_member_id = ohmember['project_member_id']
notebook_filename = model['name']
api.delete_file(access_token,
project_member_id,
file_basename=notebook_filename)
print('deleted old_file')
notebook_content = nbformat.writes(model['content']).encode('utf-8')
upload_notebook(notebook_content, notebook_filename, access_token,
project_member_id)
handler.redirect(redirect_url)
except:
print('whopsy, something went wrong')
handler.finish(("Your upload failed. "
"Please restart your notebook server "
"and try again."))
def upload_summaries(oh_user, summaries, file_name, month, existing_file_id):
fn = write_json_data_to_tmp_file(f'garmin-health-api-{file_name}-{month}.json', summaries)
api.upload_aws(fn, create_metadata(file_name, month),
oh_user.get_access_token(),
project_member_id=oh_user.oh_id,
max_bytes=MAX_FILE_BYTES)
if existing_file_id:
api.delete_file(oh_user.get_access_token(), file_id=existing_file_id)
def iterate_member_files(self, ohmember):
client_info = ProjectConfiguration.objects.get(id=1).client_info
ohmember_data = api.exchange_oauth2_member(
ohmember.get_access_token(**client_info))
files = ohmember_data['data']
for f in files:
fname = f['basename']
if not fname.endswith('.zip') and not fname.endswith('.json'):
api.delete_file(ohmember.access_token,
ohmember.oh_id,
file_id=f['id'])
def process_file(dfile, access_token, member, metadata):
try:
vcf_metadata = verify_vcf(dfile)
except:
api.message("VCF integration: A broken file was deleted",
"While processing your VCF file "
"we noticed that your file does not conform "
"to the expected specifications and it was "
"thus deleted. Email us as [email protected] if "
"you think this file should be valid.",
access_token,
base_url=OH_BASE_URL)
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(dfile['id']),
base_url=OH_BASE_URL)
raise
try:
tmp_directory = tempfile.mkdtemp()
base_filename = dfile['basename']
# Save raw 23andMe genotyping to temp file.
if base_filename.endswith('.gz'):
base_filename = base_filename[0:-3]
elif base_filename.endswith('.bz2'):
base_filename = base_filename[0:-4]
meta_filename = base_filename + '.metadata.json'
raw_filename = temp_join(tmp_directory, meta_filename)
metadata = {'description': 'VCF file metadata', 'tags': ['vcf']}
with open(raw_filename, 'w') as raw_file:
json.dump(vcf_metadata, raw_file)
raw_file.flush()
api.upload_aws(raw_filename,
metadata,
access_token,
base_url=OH_BASE_URL,
project_member_id=str(member['project_member_id']))
except:
api.message("VCF integration: File could not be uploaded",
"Something went wrong when processing your "
"file. Please try to upload it again. "
"Please email us as [email protected] if "
"this keeps happening.",
access_token,
base_url=OH_BASE_URL)
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(dfile['id']),
base_url=OH_BASE_URL)
raise
def process_file(dfile, access_token, member, metadata):
infile_suffix = dfile['basename'].split(".")[-1]
tf_in = tempfile.NamedTemporaryFile(suffix="." + infile_suffix)
tf_in.write(requests.get(dfile['download_url']).content)
tf_in.flush()
tmp_directory = tempfile.mkdtemp()
filename_base = '23andMe-genotyping'
raw_23andme = clean_raw_23andme(tf_in)
raw_23andme.seek(0)
vcf_23andme = vcf_from_raw_23andme(raw_23andme)
# Save raw 23andMe genotyping to temp file.
raw_filename = filename_base + '.txt'
metadata = {
'description': '23andMe full genotyping data, original format',
'tags': ['23andMe', 'genotyping'],
'creation_date': arrow.get().format(),
}
with open(temp_join(tmp_directory, raw_filename), 'w') as raw_file:
raw_23andme.seek(0)
shutil.copyfileobj(raw_23andme, raw_file)
raw_file.flush()
with open(temp_join(tmp_directory, raw_filename), 'r+b') as raw_file:
upload_new_file(raw_file, access_token,
str(member['project_member_id']), metadata)
# Save VCF 23andMe genotyping to temp file.
vcf_filename = filename_base + '.vcf.bz2'
metadata = {
'description': '23andMe full genotyping data, VCF format',
'tags': ['23andMe', 'genotyping', 'vcf'],
'creation_date': arrow.get().format()
}
with bz2.BZ2File(temp_join(tmp_directory, vcf_filename), 'w') as vcf_file:
vcf_23andme.seek(0)
for i in vcf_23andme:
vcf_file.write(i.encode())
with open(temp_join(tmp_directory, vcf_filename), 'r+b') as vcf_file:
upload_new_file(vcf_file, access_token,
str(member['project_member_id']), metadata)
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(dfile['id']))
def test_delete_file__invalid_access_token(self):
with self.assertRaises(Exception):
response = delete_file(
access_token=ACCESS_TOKEN_INVALID,
project_member_id='59319749',
all_files=True)
assert response.json() == {"detail": "Invalid token."}
def replace_fitbit(oh_member, fitbit_data):
print("replace function started")
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'description': 'Fitbit data.',
'tags': ['Fitbit', 'activity', 'steps'],
'updated_at': str(datetime.utcnow()),
}
out_file = os.path.join(tmp_directory, 'fitbit-data.json')
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
deleter = api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="fitbit-data.json")
print("delete response")
print(deleter)
print("trying to write to file")
with open(out_file, 'w') as json_file:
print("inside open file")
# json.dump(fitbit_data, json_file)
json_file.write(json.dumps(fitbit_data))
# print(json.dump(fitbit_data, json_file))
print("dumped, trying to flush")
json_file.flush()
print("attempting add response")
addr = api.upload_aws(out_file,
metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
print("add response")
print(addr)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def fetch_googlefit_data(oh_id, send_email=False):
'''
Fetches all of the googlefit data for a given user
'''
print("Started googlefit update task")
try:
current_dt = datetime.utcnow()
oh_member = OpenHumansMember.objects.get(oh_id=oh_id)
if not hasattr(oh_member, 'googlefit_member'):
print("No googlefit connection exists for member")
return
gf_member = oh_member.googlefit_member
oh_access_token = oh_member.get_access_token()
gf_access_token = gf_member.get_access_token()
basenames_to_ids = get_existing_basenames_to_ids(oh_member)
filesmonth = get_googlefit_data(oh_access_token, gf_access_token,
current_dt)
for fn, month in filesmonth:
api.upload_aws(fn,
create_metadata(month),
oh_access_token,
project_member_id=oh_id,
max_bytes=MAX_FILE_BYTES)
basename = os.path.basename(fn)
if basename in basenames_to_ids:
file_id_to_delete = basenames_to_ids[basename]
api.delete_file(oh_access_token, file_id=file_id_to_delete)
gf_member.last_updated = arrow.now().format()
gf_member.save()
if send_email and len(filesmonth) > 0:
send_first_success_email(oh_id, oh_access_token)
elif send_email and len(filesmonth) == 0:
send_first_no_data_email(oh_id, oh_access_token)
except Exception as e:
import traceback
print("Fetching googlefit data failed: {}".format(e))
print(traceback.format_exc())
# queue to retry later
fetch_googlefit_data.apply_async(args=[oh_id], countdown=3600)
raise
def remove_jawbone(request):
if request.method == 'POST' and request.user.is_authenticated:
try:
oh_member = request.user.oh_member
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename='jawbone-moves-data.json')
messages.info(request, 'Your Jawbone account has been removed')
jawbone_account = request.user.oh_member.datasourcemember
jawbone_account.delete()
except:
jawbone_account = request.user.oh_member.datasourcemember
jawbone_account.delete()
messages.info(request, ('Something went wrong, please '
're-authorize us on Open Humans'))
logout(request)
return redirect('/')
return redirect('/dashboard')
def remove_nokia(request):
if request.method == "POST" and request.user.is_authenticated:
try:
oh_member = request.user.oh_member
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="nokia_data")
messages.info(request, "Your Withings/Nokia account has been removed")
nokia_account = request.user.oh_member.nokia_member
nokia_account.delete()
except:
nokia_account = request.user.oh_member.nokia_member
nokia_account.delete()
messages.info(request, ("Something went wrong, please"
"re-authorize us on Open Humans"))
logout(request)
return redirect('/')
return redirect('/dashboard')
def remove_googlefit(request):
if request.method == "POST" and request.user.is_authenticated:
try:
openhumansmember = request.user.openhumansmember
api.delete_file(openhumansmember.access_token,
openhumansmember.oh_id,
file_basename="googlefit-data.json")
messages.info(request, "Your GoogleFit account has been removed")
googlefit_account = request.user.openhumansmember.googlefit_member
googlefit_account.delete()
except:
googlefit_account = request.user.openhumansmember.googlefit_member
googlefit_account.delete()
messages.info(request, ("Something went wrong, please"
"re-authorize us on Open Humans"))
#logout(request)
return redirect('/')
return redirect('/')
def remove_moves(request):
if request.method == "POST" and request.user.is_authenticated:
try:
oh_member = request.user.oh_member
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="moves-storyline-data.json")
messages.info(request, "Your Moves account has been removed")
moves_account = request.user.oh_member.datasourcemember
moves_account.delete()
except:
moves_account = request.user.oh_member.datasourcemember
moves_account.delete()
messages.info(request, ("Something went wrong, please"
"re-authorize us on Open Humans"))
logout(request)
return redirect('/')
return redirect('/dashboard')
def upload_user_dailies(garmin_user_id, user_map, existing_file_id):
min_date = earliest_date(user_map)
fn = write_jsonfile_to_tmp_dir('garmin-dailies.json', user_map)
oh_user = get_oh_user_from_garmin_id(garmin_user_id)
api.upload_aws(fn,
create_metadata(),
oh_user.get_access_token(),
project_member_id=oh_user.oh_id,
max_bytes=MAX_FILE_BYTES)
oh_user.garmin_member.last_updated = datetime.now()
if not oh_user.garmin_member.earliest_available_data or \
(oh_user.garmin_member.earliest_available_data and min_date < oh_user.garmin_member.earliest_available_data.replace(tzinfo=None)):
oh_user.garmin_member.earliest_available_data = min_date
oh_user.garmin_member.save()
if existing_file_id:
api.delete_file(oh_user.get_access_token(), file_id=existing_file_id)
def write_new_tweets(oh_member, twitter_api, month, new_data):
existing_files = api.exchange_oauth2_member(
oh_member.get_access_token(),
all_files=True)
old_data = None
file_id = None
for dfile in existing_files['data']:
if dfile['basename'] == 'twitter-data-{}.json'.format(month):
old_data = requests.get(dfile['download_url']).json()
file_id = dfile['id']
break
if old_data:
old_data['tweets'] = new_data['tweets'] + old_data['tweets']
old_data['likes'] = new_data['likes'] + old_data['likes']
else:
old_data = {'tweets': new_data['tweets'], 'likes': new_data['likes'],
'followers': [], 'following': []}
if month == str(datetime.datetime.today())[:7]:
me = twitter_api.me()
old_data['followers'].append(
{'timestamp': str(datetime.datetime.today()),
'value': me.followers_count})
old_data['following'].append(
{'timestamp': str(datetime.datetime.today()),
'value': me.friends_count})
with tempfile.TemporaryFile() as f:
js = json.dumps(old_data)
js = str.encode(js)
f.write(js)
f.flush()
f.seek(0)
api.upload_stream(
f, "twitter-data-{}.json".format(month),
metadata={
"description": "Twitter Data",
"tags": ["Twitter"]
}, access_token=oh_member.get_access_token())
if file_id:
api.delete_file(
oh_member.get_access_token(),
project_member_id=oh_member.oh_id,
file_id=file_id)
def process_file(dfile, access_token, member, metadata):
infile_suffix = dfile['basename'].split(".")[-1]
tf_in = tempfile.NamedTemporaryFile(suffix="." + infile_suffix)
tf_in.write(requests.get(dfile['download_url']).content)
tf_in.flush()
tmp_directory = tempfile.mkdtemp()
filename_base = 'Location History.json'
location_data = get_json(tf_in)
if location_data:
location_json = json.loads(location_data)
output_file = tmp_directory + '/' + filename_base
with open(output_file, 'w') as raw_file:
json.dump(location_json, raw_file)
metadata = {
'description': 'Google Location History JSON',
'tags': ['google location history', 'gps'],
'creation_date': arrow.get().format(),
}
api.upload_aws(output_file,
metadata,
access_token,
base_url=OH_BASE_URL,
project_member_id=str(member['project_member_id']))
get_semantic_data(tf_in, tmp_directory, member, access_token)
else:
api.message("Google Location History: A broken file was deleted",
"While processing your Google Location History file "
"we noticed that your file does not conform "
"to the expected specifications and it was "
"thus deleted. Please make sure you upload "
"the right file:\nWe expect the file to be a "
"single json file "
"or a .zip file as downloaded from Google Takeout."
" Please "
"do not alter the original file, as unexpected "
"additions can invalidate the file.",
access_token,
base_url=OH_BASE_URL)
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(dfile['id']),
base_url=OH_BASE_URL)
def replace_datasource(oh_member, source_data):
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'description': 'Dummy data for demo.',
'tags': ['demo', 'dummy', 'test'],
'updated_at': str(datetime.utcnow()),
}
out_file = os.path.join(tmp_directory, 'dummy-data.json')
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="dummy-data.json")
with open(out_file, 'w') as json_file:
json.dump(source_data, json_file)
json_file.flush()
api.upload_aws(out_file,
metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def replace_moves(oh_member, moves_data):
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'description': 'Moves GPS maps, locations, and steps data.',
'tags': ['GPS', 'Moves', 'steps'],
'updated_at': str(datetime.utcnow()),
}
out_file = os.path.join(tmp_directory, 'moves-storyline-data.json')
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="moves-storyline-data.json")
with open(out_file, 'w') as json_file:
json.dump(moves_data, json_file)
json_file.flush()
api.upload_aws(out_file,
metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def replace_rescuetime(oh_member, rescuetime_data):
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'description': 'RescueTime productivity data.',
'tags': ['Rescuetime', 'productivity'],
'updated_at': str(datetime.utcnow()),
}
out_file = os.path.join(tmp_directory, 'rescuetime.json')
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="rescuetime.json")
with open(out_file, 'w') as json_file:
json.dump(rescuetime_data, json_file)
json_file.flush()
api.upload_aws(out_file,
metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def process_github(oh_id):
"""
Update the github file for a given OH user
"""
try:
logger.debug('Starting github processing for {}'.format(oh_id))
oh_member = OpenHumansMember.objects.get(oh_id=oh_id)
oh_access_token = oh_member.get_access_token(
client_id=settings.OPENHUMANS_CLIENT_ID,
client_secret=settings.OPENHUMANS_CLIENT_SECRET)
#github_data = get_existing_github_data(oh_access_token)#
github_member = oh_member.datasourcemember
github_access_token = github_member.get_access_token(
client_id=settings.GITHUB_CLIENT_ID,
client_secret=settings.GITHUB_CLIENT_SECRET)
#print("OH access token: {}".format(oh_access_token))
gh_file = gh_api.get_github_data(oh_access_token, github_access_token)
existing_file_ids = get_existing_file_ids(oh_member)
print(existing_file_ids)
api.upload_aws(gh_file,
create_file_metadata(),
oh_access_token,
project_member_id=oh_id,
max_bytes=MAX_FILE_BYTES)
for id in existing_file_ids:
api.delete_file(oh_access_token, file_id=id)
github_member.last_updated = arrow.now().format()
github_member.save()
except Exception as e:
import traceback
print("Fetching github data failed: {}".format(e))
print(traceback.format_exc())
# queue to retry later
process_github.apply_async(args=[oh_id], countdown=4 * 3600)
raise
def process_target(data_file, access_token, member, metadata):
try:
tf = tempfile.NamedTemporaryFile(suffix=".gz")
tf_out = tempfile.NamedTemporaryFile(prefix="ftdna-",
suffix=".csv",
mode="w+b")
print("downloading ftdna file from oh")
tf.write(requests.get(data_file['download_url']).content)
tf.flush()
print('read ftdna file')
with gzip.open(tf.name, "rt", newline="\n") as ftdna_file:
for line in ftdna_file:
if valid_line(line):
tf_out.write(line.encode('ascii'))
tf_out.flush()
tf_out.seek(0)
print('cleaned file')
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(data_file['id']))
print('deleted old')
upload_new_file(tf_out, access_token, str(member['project_member_id']),
data_file['metadata'])
except:
print('delete broken file')
api.delete_file(access_token,
str(member['project_member_id']),
file_id=str(data_file['id']))
api.message(
"A broken file was deleted",
"While processing your FamilyTreeDNA file "
"we noticed that your file does not conform "
"to the expected specifications and it was "
"thus deleted. Please make sure you upload "
"the right file:\nWe expect the file to be a "
"single, - gzipped (ends in .gz) - file as "
"you can download from FamilyTreeDNA. Please "
"do not alter or unzip this file, as unexpected additions "
"also invalidate the file.", access_token)
def replace_twitter(oh_member, twitter_data):
# delete old file and upload new to open humans
tmp_directory = tempfile.mkdtemp()
metadata = {
'description':
'Twitter activity feed, repository contents and stars data.',
'tags': ['demo', 'Twitter', 'test'],
'updated_at': str(datetime.utcnow()),
}
out_file = os.path.join(tmp_directory, 'twitter-data.json')
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="twitter-data.json")
with open(out_file, 'w') as json_file:
json.dump(twitter_data, json_file)
json_file.flush()
api.upload_aws(out_file,
metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def replace_nokia(oh_member, nokia_data):
"""
Delete any old file and upload new
"""
tmp_directory = tempfile.mkdtemp()
metadata = {
'tags': ['nokiahealthdata', 'health', 'measure'],
'description': 'File with Nokia Health data',
'updated_at': str(datetime.utcnow()),
}
filename = 'nokiahealthdata.json'
out_file = os.path.join(tmp_directory, filename)
logger.debug('deleted old file for {}'.format(oh_member.oh_id))
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename=filename)
with open(out_file, 'w') as json_file:
json.dump(nokia_data, json_file)
json_file.flush()
api.upload_aws(out_file, metadata,
oh_member.access_token,
project_member_id=oh_member.oh_id)
logger.debug('uploaded new file for {}'.format(oh_member.oh_id))
def process_source(oh_id):
oh_member = OpenHumansMember.objects.get(oh_id=oh_id)
OUT_DIR = os.environ.get('OUT_DIR')
metadata = {
'description': 'Imputed genotypes from Imputer',
'tags': ['genomics'],
'updated_at': str(datetime.utcnow()),
}
oh_access_token = oh_member.get_access_token(
client_id=settings.OPENHUMANS_CLIENT_ID,
client_secret=settings.OPENHUMANS_CLIENT_SECRET)
# this works below
try:
api.delete_file(oh_member.access_token,
oh_member.oh_id,
file_basename="member.imputed.vcf.bz2")
except FileNotFoundError:
logger.info('New Source File')
api.upload_aws('{}/{}/member.imputed.vcf.bz2'.format(OUT_DIR, oh_id),
metadata,
oh_access_token,
project_member_id=oh_member.oh_id,
max_bytes=256000000)
def delete_oh_file(access_token, file_name):
"""
Deletes any files belonging to an OH user and projet, whose base file name matches the given file name.
:param access_token: The project access token for the given member.
:param file_name: The name of the file to be deleted from OpenHumans (all matching filenames will be deleted).
:return: boolean. True if successful, else False
"""
try:
deletion_response = delete_file(access_token, file_basename=file_name)
if deletion_response.status_code == 200:
return True
else:
print(
f'An error was encountered trying to delete file {file_name}')
return False
except:
print(f'An error was encountered trying to delete file {file_name}')
return False
def test_delete_file__valid_access_token(self):
response = delete_file(access_token=ACCESS_TOKEN,
project_member_id='59319749',
all_files=True)
self.assertEqual(response.status_code, 200)
def test_delete_file__expired_access_token(self):
response = delete_file(access_token=ACCESS_TOKEN_EXPIRED,
all_files=True,
project_member_id='59319749')
assert response.json() == {"detail": "Expired token."}