def upload_dir(dir, posts=[], outdir=None):
print("Going into {}".format(dir))
if outdir is None:
outdir = dir
for f in Path(dir).glob("*"):
if f.suffix == '.md':
print("Processing {}".format(f.name))
rss.append(process(f, posts, outdir))
elif f.is_file():
print("Examining {}".format(f.name))
storage.upload_file(f, outdir)
def generate_podcast(news_items, news_date, podcast_fn):
item_template = t.load(jinja2.Environment(), "item.ssml")
items = []
for item in news_items:
logging.info('processing %s' % item['title'])
item_ssml = item_template.render(item)
item_hash = hashlib.md5(item_ssml.encode('utf8')).hexdigest()
blob_name = os.path.join(TEMP_FOLDER, '%s.wav' % item_hash)
if not os.path.exists(blob_name):
raw_data = ssml_to_audio_ibm(item_ssml, format='audio/wav')
# raw_data = ssml_to_audio(item_ssml, format='audio/wav')
with open(blob_name, 'wb') as f:
f.write(raw_data)
logging.info('saved %s' % blob_name)
items.append(blob_name)
news_date_parsed = datetime.datetime.strptime(news_date, "%Y-%m-%d")
intro_file = os.path.join(TEMP_FOLDER, "intro_%s.wav" % news_date)
goodbye_file = os.path.join(TEMP_FOLDER, "goodbye.wav")
if not os.path.exists(intro_file):
open(intro_file, "wb").write(
ssml_to_audio_google(
t.load(jinja2.Environment(),
"intro.ssml").render(news_date=news_date_parsed),
format='audio/wav'))
if not os.path.exists(goodbye_file):
open(goodbye_file, "wb").write(
ssml_to_audio_google(t.load(jinja2.Environment(),
"goodbye.ssml").render(),
format='audio/wav'))
final = pydub.AudioSegment.empty()
final += pydub.AudioSegment.from_mp3(intro_file)
for item in items:
final += pydub.AudioSegment.from_mp3(
'resources/Everythings_Nice_Sting.mp3')
final += pydub.AudioSegment.from_wav(item)
final += pydub.AudioSegment.from_mp3(goodbye_file)
logging.info('saving %s' % podcast_fn)
final.export(podcast_fn, format="mp3")
logging.info('uploading...')
storage.upload_file(BUCKET_NAME, podcast_fn, podcast_fn)
def upload_file():
if request.method == 'POST':
# Validate file
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files.get('file')
if file.filename == '':
flash('No file selected for uploading')
return redirect(request.url)
if not (file and storage.allowed_file(
file.filename, app.config['ALLOWED_EXTENSIONS'])):
flash('File is of illegal filetype')
return redirect(request.url)
# Upload to cloud storage
public_url = storage.upload_file(file.read(), file.filename,
file.content_type)
# Start recognition
recognized_text = speech_api.audio_to_text(file.filename)
if (len(recognized_text) > 0):
flash(recognized_text)
return redirect('/')
def upload_file(file):
if not file:
return None
public_url = storage.upload_file(file.read(), file.filename,
file.content_type)
return public_url
def upload():
logger.log_text('Request for /upload')
uploaded_file = request.files.get('file')
datastore.insert(datastore_client, uploaded_file)
if not uploaded_file:
return 'No file uploaded.', 400
return storage.upload_file(storage_client, uploaded_file)
def upload_file(file):
if not file:
return None
public_url = storage.upload_file(
file.read(),
"videos/{}".format(file.filename),
file.content_type
)
return public_url
def upload_image_file(stream, filename, content_type):
if not stream:
return None
bucket_filepath = storage.upload_file(stream, filename, content_type)
logging.info("Uploaded file %s as %s.", filename, bucket_filepath)
blobstore_filename = '/gs{}'.format(bucket_filepath)
blob_key = blobstore.create_gs_key(blobstore_filename)
img_url = images.get_serving_url(blob_key, secure_url=True)
return img_url
def upload_image_file(file):
"""
Upload the user-uploaded file to Google Cloud Storage and retrieve its
publicly-accessible URL.
"""
if not file:
return None
public_url = storage.upload_file(file.read(), file.filename,
file.content_type)
return public_url
def upload_image_file(file, is_marker=False):
"""
Upload the user-uploaded file to Google Cloud Storage and retrieve its
publicly-accessible URL.
"""
if not file:
return None
if is_marker:
file_resize = image_resize(file)
public_url = storage.upload_file(file_resize.read(), file.filename,
file.content_type)
else:
public_url = storage.upload_file(file.read(), file.filename,
file.content_type)
current_app.logger.info("Uploaded file %s as %s.", file.filename,
public_url)
return public_url
def main():
os.chdir(config['data_dir'])
posts = [p for p in Path(INPUT).glob("*.md")]
posts.sort()
posts.reverse()
storage.upload_text("index.html", generate_index(posts))
storage.upload_text("refresh.html", generate_refresh())
upload_dir(INPUT, posts, OUTPUT)
upload_dir("css")
upload_dir("js")
upload_dir("404")
ico = Path(config['data_dir'] + "/favicon.ico")
if ico.exists():
print("Examining favicon.ico")
storage.upload_file(ico, "")
if stats.articles_updated != 0:
print("Examining rss.xml")
storage.upload_text("rss.xml", rss.generate())
def upload_video_file(stream, filename, content_type):
if not stream:
return None
bucket_filepath = storage.upload_file(stream, filename, content_type)
logging.info("Uploaded file %s as %s.", filename, bucket_filepath)
bucket = bucket_filepath[bucket_filepath.find("/") +
1:bucket_filepath.rfind("/")]
filename = bucket_filepath[bucket_filepath.rfind("/") + 1:]
file_url = "https://" + "sd-lstm.appspot.com" + ".storage.googleapis.com/" + filename
return file_url
def upload_image_file(img):
"""
Upload the user-uploaded file to Google Cloud Storage and retrieve its
publicly-accessible URL.
"""
if not img:
return None
public_url = storage.upload_file(img.read(), img.filename,
img.content_type)
current_app.logger.info('Uploaded file %s as %s.', img.filename,
public_url)
return public_url
def train_modell():
request_json = request.get_json()
parameter_runid = request_json['runid']
parameter_postalcode = request_json['postalcode']
parameter_horizon = request_json['horizon']
# if parameter_postalcode == '1010' and parameter_horizon == '2':
# data = model_cloudsql.getdata(0, 10)
# elif parameter_postalcode == '1020' and parameter_horizon == '2':
# data = model_cloudsql.getdata(10, 20)
# elif parameter_postalcode == '1030' and parameter_horizon == '2':
# data = model_cloudsql.getdata(20, 30)
# elif parameter_postalcode == '1040' and parameter_horizon == '2':
# data = model_cloudsql.getdata(30, 40)
# elif parameter_postalcode == '1050' and parameter_horizon == '2':
# data = model_cloudsql.getdata(40, 50)
# else:
# data = model_cloudsql.getdata(0, 100)
# ds_dataframe = pandas.DataFrame(data)
time.sleep(120)
dataframe = get_data()
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
model = datascience.trainmodel(dataframe)
serialized_model = datascience.serialize_model(model)
storage.create_bucket(parameter_runid)
storage_file_name = parameter_runid + '_' + parameter_postalcode + '_' + parameter_horizon + '.p'
storage_file_url = storage.upload_file(serialized_model, storage_file_name,
parameter_runid)
model_datastore.update(storage_file_url, parameter_runid,
parameter_postalcode, parameter_horizon)
return "success"
def upload_file(file, album):
folder = "albums/" + album + "/"
img = None
if album == "covers":
folder = "covers/"
if allowed_file(file.filename):
saved_file_name = storage.upload_file(file,
folder,
app.config['UPLOAD_BUCKET'],
is_dev=app.config['IS_DEV'])
img = Image(url=saved_file_name, album=album)
img.put()
flash('Uploaded photo to album %s' % album)
logging.info('Uploaded photo to album %s' % album)
else:
flash('File extension not supported')
logging.warning('File extension not supported for file %s' %
file.filename)
raise Exception("File extension not supported")
return img
def upload_file_to_gs():
user = users.get_current_user()
if not user:
return redirect(url_for('.main'))
filename = "fail"
if request.method == 'POST':
# check if the post request has the file part
if 'image' not in request.files:
return redirect(url_for('.main'))
file = request.files['image']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
return redirect(url_for('.main'))
if file and allowed_file(file.filename):
filename = file.filename
logger = logging.getLogger(__name__)
logger.error(filename)
filename = upload_file(file.read(), filename, file.content_type, user.user_id())
else:
return redirect(url_for('.main'))
return " <title>File Uploaded</title>" + filename + '''
