def prepare_obj(self,
file_like_object,
allowed_exts_url=None,
filename=None):
"""
Подготовка объектов(в основном картинок) для загрузки.
То есть метод позволяет преобразовывать почти из любого формата
"""
# url
parsed_url = None
if isinstance(file_like_object, str):
parsed_url = urlparse(file_like_object)
if parsed_url and parsed_url.hostname:
if allowed_exts_url:
extension = parsed_url.path.split('.')[-1].lower()
is_default_extension = extension not in allowed_exts_url
is_vk_image = 'userapi.com' in parsed_url.hostname
if is_default_extension and not is_vk_image:
raise PWarning(
f"Загрузка по URL доступна только для {' '.join(allowed_exts_url)}"
)
self.public_download_url = file_like_object
elif isinstance(file_like_object, bytes):
if filename:
tmp = NamedTemporaryFile()
tmp.write(file_like_object)
tmp.name = filename
tmp.seek(0)
self.content = tmp
else:
self.content = file_like_object
# path
elif isinstance(file_like_object,
str) and os.path.exists(file_like_object):
with open(file_like_object, 'rb') as file:
file_like_object = file.read()
self.content = file_like_object
elif isinstance(file_like_object, BytesIO):
file_like_object.seek(0)
_bytes = file_like_object.read()
if filename:
tmp = NamedTemporaryFile()
tmp.write(_bytes)
tmp.name = filename
tmp.seek(0)
self.content = tmp
else:
self.content = _bytes
def test_other_field(self) -> None:
cookie_str: str = "abcd=abcd;"
file_content: str = "Hello Word!"
f1 = NamedTemporaryFile(delete=True)
file_name: str = f1.name
f1.write(file_content.encode())
f1.seek(0)
f2 = NamedTemporaryFile(delete=True)
f2.name = file_name # type: ignore
f2.write(file_content.encode())
f2.seek(0)
test_helper: TornadoTestHelper[HTTPResponse] = TornadoTestHelper(
self,
OtherFieldHandler.post,
cookie_dict={"cookie": cookie_str},
file_dict={f1.name: f1.read()},
form_dict={
"a": "1",
"b": "2",
"c": "3"
},
)
content_type, body = self.encode_multipart_formdata(
data={
"a": "1",
"b": "2",
"c": "3"
}, files={file_name: f2.read()})
response: HTTPResponse = self.fetch(
"/api/other_field",
headers={
"cookie": cookie_str,
"Content-Type": content_type,
"content-length": str(len(body))
},
method="POST",
body=body,
)
for resp in [test_helper.post(), response]:
resp = json.loads(resp.body.decode())
assert {
"filename": file_name,
"content": file_content,
"form_a": "1",
"form_b": "2",
"form_c": ["3"],
"cookie": {
"abcd": "abcd"
},
} == resp["data"]
def execute(self, context):
"""
Executes the staging command from the list of srms requested.
"""
if isinstance(self.srmfile, dict):
task_name = self.srmfile['name']
task_parent_dag = self.srmfile['parent_dag']
sbx_xcom = get_task_instance(context, task_name, task_parent_dag)
self.srmfile = sbx_xcom[self.srmkey]
elif not os.path.isfile(self.srmfile) and not hasattr(
self.srms, '__iter__'):
self.srmfile = Variable.get(self.srmfile)
if not os.path.isfile(self.srmfile):
self.status = State.UPSTREAM_FAILED
raise AirflowException(
"Input srmfile doesn't exist and srm list not a list")
self.progress = {'Percent done': 0}
surl_list = srmlist.srmlist(
) #holds all the srms (both from file and list argument )
self.surl_list = self.build_srm_list(surl_list)
try:
self.stage_ID = stager_access.stage(list(self.surl_list))
except xmlrpclib.Fault:
sleep(60)
self.stage_ID = stager_access.stage(list(self.surl_list))
logging.info(
"Successfully sent staging command for " +
stager_access.get_progress()[str(self.stage_ID)]['File count'] +
" files.")
logging.info("StageID= " + str(self.stage_ID))
self.state = State.RUNNING
sleep(120)
try:
self.progress = stager_access.get_progress()[str(self.stage_ID)]
except:
pass
self.started = False
f = NamedTemporaryFile(delete=False)
for i in surl_list:
f.write(bytes(i, encoding='utf8'))
f.close()
if not f:
f.name = ""
while self.still_running():
sleep(120)
if self.state == State.SUCCESS:
return {'srmfile': str(f.name)}
self.state == State.FAILED
return {'srmfile': str(f.name)}
def test_other_field(self, client: TestClient) -> None:
cookie_str: str = "abcd=abcd;"
file_content: str = "Hello Word!"
f1 = NamedTemporaryFile(delete=True)
file_name: str = f1.name
f1.write(file_content.encode())
f1.seek(0)
f2 = NamedTemporaryFile(delete=True)
f2.name = file_name # type: ignore
f2.write(file_content.encode())
f2.seek(0)
test_helper: StarletteTestHelper[Response] = StarletteTestHelper(
client,
other_field_route,
cookie_dict={"cookie": cookie_str},
file_dict={"upload_file": f1},
form_dict={
"a": "1",
"b": "2",
"c": ["3"]
},
)
for resp in [
test_helper.post().json(),
client.post(
"/api/other_field",
data={
"a": "1",
"b": "2",
"c": ["3"]
},
headers={
"cookie": cookie_str
},
files={
"upload_file": f2
},
).json(),
]:
assert {
"filename": file_name.split("/")[-1],
"content": file_content,
"form_a": "1",
"form_b": "2",
"form_c": ["3"],
"cookie": {
"abcd": "abcd"
},
} == resp["data"]
def draw_videos(self):
i = 0
for video in reversed(self.track_videos):
overlay = NamedTemporaryFile(
suffix='.avi',
delete=self.delete
)
# Removes all white spaces and non alphanumeric chars from title
video.options['title'] = re.sub(
'[^\w\.]',
'',
video.options['title']
) + '.webm'
# Trim the video if it needs to be
if (video.options['from'] != 0 or
video.options['end'] - video.options['from'] <
video.options['duration']):
self.editor.trim(
video.options['title'],
overlay.name,
seconds_to_timecode(video.options['from']),
seconds_to_timecode(video.options['duration'])
)
else:
overlay.name = video.options['title']
# Also scale the video down to size
scaled_overlay = NamedTemporaryFile(
suffix='.avi',
delete=self.delete
)
self.editor.scale_video(
overlay.name,
scaled_overlay.name,
percent_to_px(video.options['width'], self.size[0]),
percent_to_px(video.options['height'], self.size[1]),
)
overlay.close()
out = NamedTemporaryFile(suffix='.avi', delete=self.delete)
self.overlay_videos(self.current_video.name, scaled_overlay.name,
video.options, out.name)
scaled_overlay.close()
self.current_video = out
i += 1
def update(self, instance, validated_data):
"""
override update instance method
"""
img_temp = NamedTemporaryFile(delete=True)
img_temp.write(urlopen(validated_data["image_url"]).read())
img_temp.name = f"{validated_data['external_id']}.jpg"
instance.external_id = validated_data["external_id"]
instance.author = validated_data["author"]
instance.image_file = File(img_temp)
instance.save()
img_temp.flush()
return instance
def get():
main = current_app.main
fin_cnt = 3
non_fin_cnt = 7
main.select(fin_cnt, Sector.FINANCIAL)
main.select(non_fin_cnt, Sector.NON_FINANCIAL)
f = NamedTemporaryFile()
f.name = f'{f.name}.csv'
r_file = os.path.join(os.getcwd(), "domain\\service\\porfolio.r")
main.save_returns_matrix_to_csv(f.name)
res = subprocess.check_output(
f'"C:\\Program Files\\R\\R-3.6.0\\bin\\Rscript.exe" "{r_file}" "{f.name}"',
shell=True)
main.reset()
return make_response(matrix_loader(res.decode('utf-8').split('\r\n')))
def decloakToNamedTemporaryFile(filepath, name=None):
retVal = NamedTemporaryFile()
def __del__():
try:
if hasattr(retVal, 'old_name'):
retVal.name = old_name
retVal.close()
except OSError:
pass
retVal.__del__ = __del__
retVal.write(decloak(filepath))
retVal.seek(0)
if name:
retVal.old_name = retVal.name
retVal.name = name
return retVal
def gunzip(filename):
"""Unzip a ``.gz`` file to a temporary file and returns its path."""
if not filename.endswith('.gz'):
#colors.printc("gunzip() error: file must end with .gz", c=1)
return filename
from tempfile import NamedTemporaryFile
import gzip
tmp_file = NamedTemporaryFile(delete=False)
tmp_file.name = os.path.join(os.path.dirname(tmp_file.name),
os.path.basename(filename).replace('.gz',''))
inF = gzip.open(filename, "rb")
outF = open(tmp_file.name, "wb")
outF.write(inF.read())
outF.close()
inF.close()
return tmp_file.name
def create(self, validated_data):
"""
override create instance method
"""
img_temp = NamedTemporaryFile(delete=True)
img_temp.write(urlopen(validated_data["image_url"]).read())
img_temp.name = f"{validated_data['external_id']}.jpg"
instance = Image.objects.create(
external_id=validated_data["external_id"],
author=validated_data["author"],
tags=validated_data["tags"],
image_file=File(img_temp),
)
img_temp.flush()
return instance
def test_other_field(self, client: FlaskClient) -> None:
file_content: str = "Hello Word!"
f1 = NamedTemporaryFile(delete=True)
file_name: str = f1.name
f1.write(file_content.encode())
f1.seek(0)
f2 = NamedTemporaryFile(delete=True)
f2.name = file_name # type: ignore
f2.write(file_content.encode())
f2.seek(0)
flask_test_helper: FlaskTestHelper[Response] = FlaskTestHelper(
client,
other_field_route,
file_dict={"upload_file": f1},
form_dict={
"a": "1",
"b": "2",
"c": "3"
})
client.set_cookie("localhost", "abcd", "abcd")
for resp in [
flask_test_helper.post().get_json(),
client.post("/api/other_field",
data={
"a": "1",
"b": "2",
"upload_file": f2,
"c": "3"
}).get_json(),
]:
assert {
"filename": file_name,
"content": file_content,
"form_a": "1",
"form_b": "2",
"form_c": ["3"],
"cookie": {
"abcd": "abcd"
},
} == resp["data"]
def db_backup(message):
my_id = db.select('users',
"name = '" + TELEGRAM_NAME + "'")[0]['telegram_id']
if (message.from_user.id != my_id):
return
bot.send_chat_action(message.from_user.id, "upload_document")
ps = subprocess.Popen(['pg_dump', DB_URL], stdout=subprocess.PIPE)
output = ps.communicate()[0]
backup_f = NamedTemporaryFile()
backup_f.write(output)
backup_f.name = "backup - " + datetime.now().strftime(
'%Y-%m-%d %H:%M:%S') + ".sql"
backup_f.seek(0)
telebot.types.Message.de_json(
telebot.apihelper._make_request(
API_TOKEN,
'sendDocument',
params={'chat_id': str(message.from_user.id)},
files={'document': backup_f},
method='post'))
def draw_videos(self):
i = 0
for video in reversed(self.track_videos):
overlay = NamedTemporaryFile(suffix='.avi', delete=self.delete)
# Removes all white spaces and non alphanumeric chars from title
video.options['title'] = re.sub('[^\w\.]', '',
video.options['title']) + '.webm'
# Trim the video if it needs to be
if (video.options['from'] != 0
or video.options['end'] - video.options['from'] <
video.options['duration']):
self.editor.trim(
video.options['title'], overlay.name,
seconds_to_timecode(video.options['from']),
seconds_to_timecode(video.options['duration']))
else:
overlay.name = video.options['title']
# Also scale the video down to size
scaled_overlay = NamedTemporaryFile(suffix='.avi',
delete=self.delete)
self.editor.scale_video(
overlay.name,
scaled_overlay.name,
percent_to_px(video.options['width'], self.size[0]),
percent_to_px(video.options['height'], self.size[1]),
)
overlay.close()
out = NamedTemporaryFile(suffix='.avi', delete=self.delete)
self.overlay_videos(self.current_video.name, scaled_overlay.name,
video.options, out.name)
scaled_overlay.close()
self.current_video = out
i += 1
def post(self):
"""POST request handler. Processes form data"""
# check if user uploaded an excel file
uploaded_file = request.files['file']
if uploaded_file and not (uploaded_file.filename.endswith('.xls') or
uploaded_file.filename.endswith('.xlsx')):
flash("Uploaded file is not an .xls or .xlsx file", "error")
return redirect(url_for('index'))
# save file to /tmp folder
temp_file = NamedTemporaryFile()
temp_file_name_w_extension = ntpath.basename(temp_file.name)
temp_file.name = temp_file.name\
.replace(temp_file_name_w_extension, uploaded_file.filename)
uploaded_file.save(temp_file.name)
# get output format
output_format = request.form.get('format')
output_ext = '.' + output_format
# process output format and mime type for downloading
post_process_to = None
mime_type = 'text/html' if output_format == 'html'\
else 'application/text'
if output_format in ('pdf', 'doc'):
post_process_to = output_format
# convert uploaded file to html
temp_html_file = NamedTemporaryFile()
html_file_path = copy(temp_file.name).replace('.xlsx', '')\
.replace('.xls', '') + '.' + 'html'
temp_html_file.name = html_file_path
# TODO: This hard-makes PPP conv to HTML. Change to doc if doc, etc.
out_format = 'html' if output_format == 'pdf' else output_format
''' command_line = \
self._build_ppp_ppp_tool_run_cmd(in_file_path=temp_file.name,
out_format=out_format,
out_file_path=html_file_path)
_, stderr = self._run_background_process(command_line) '''
ppp_resp = self._run_ppp_api(in_file_path=temp_file.name,
out_format=out_format,
out_file_path=html_file_path)
# if ppp.ppp tool wrote something to stderr, we should show it to user
# if stderr:
if not ppp_resp:
flash("STDERR:\n{}".format(ppp_resp), "error")
return redirect(url_for('index'))
# output path now exists and refers to converted html file at /tmp
pdf_doc_file_path = html_file_path
# if output format is PDF or DOC
if post_process_to == 'pdf':
try:
w_p = app_config.WKHTMLTOPDF_PATH_LOCAL
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_pdf(_input=html_file_path,
wkhtmltopdf_path=w_p)
except OSError:
try:
# TODO: This hasn't been fully implementaed
w_p = 'This hasnt been implemented yet. My WKTHMLTOPDF ' \
'is installed globally. This message will throw ' \
'an error.'
# w_p = app_config.WKHTMLTOPDF_PATH_SYSTEM
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_pdf(_input=html_file_path,
wkhtmltopdf_path=w_p)
except FileNotFoundError:
# TODO: download and install a binary
msg = 'PDF conversion is currently not supported for ' \
'this system: {}'.format(platform())
raise Exception(msg)
elif post_process_to == 'doc':
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_doc(_input=html_file_path)
# return file as response attachment, so browser will start download
return send_file(pdf_doc_file_path,
as_attachment=True,
mimetype=mime_type,
attachment_filename=uploaded_file.filename
.replace('.xlsx', output_ext)
.replace('.xls', output_ext))
'''
临时文件来进行操作
'''
from tempfile import TemporaryFile, NamedTemporaryFile
tf = TemporaryFile(dir='') # 实例化出来就可以啦，在运行完之后就会释放，可以用dir来指定目录来进行操作
ntf = NamedTemporaryFile() # 也可以添加前缀和后缀来进行指定吧
ntf.name() # 可以指定目录
def reducer(self, key, values):
# obtain the needed info from the key
modelling_unit, multipliers, lat, lon, timezone = key.split('~')
lat = float(lat)
lon = float(lon)
multipliers = ast.literal_eval(multipliers) # string to dict
multiplier = {}
for i in multipliers:
multiplier[i['deviceId']] = i['multiplier']
columns = [x[0] for x in self.config['hive']['final_table_fields']]
df = pd.DataFrame.from_records(values, index='ts', columns=columns)
energy_type = df.energyType.unique()[0]
grouped = df.groupby('deviceId')
df_new_hourly = None
for device, data in grouped:
if device not in multiplier.keys():
continue
data = data[~data.index.duplicated(keep='last')]
data = data.sort_index()
if df_new_hourly is None:
df_new_hourly = data[['value']] * multiplier[device]
else:
df_new_hourly += data[['value']] * multiplier[device]
weather = df.drop(['value', 'energyType', 'deviceId'], axis=1)
weather = weather[~weather.index.duplicated(keep='last')]
df_new_hourly = df_new_hourly.join(weather)
df_new_hourly = df_new_hourly[self.config['module_config']
['model_features']]
df_new_hourly = df_new_hourly.sort_index()
df_value = df_new_hourly[['value']].resample('H').sum()
df_weather = df_new_hourly[[
"temperature", "windSpeed", "GHI", "windBearing"
]].resample('H').max()
df_new_hourly = df_value.join(df_weather)
if self.config['save_data_debug']:
mongo = MongoClient(self.config['mongodb']['host'],
self.config['mongodb']['port'])
mongo[self.config['mongodb']['db']].authenticate(
self.config['mongodb']['username'],
self.config['mongodb']['password'])
mongo[self.config['mongodb']['db']][
self.config['module_config']['mongo_debug']].replace_one(
{"modelling_unit": modelling_unit}, {
"modelling_unit": modelling_unit,
"multipliers": multipliers,
"df": df_new_hourly.reset_index().to_dict('records'),
"lat": lat,
"lon": lon,
"timezone": timezone
},
upsert=True)
mongo.close()
freq = calculate_frequency(df_new_hourly)
whole_day_index = len(
np.arange(pd.Timedelta('1 days'), pd.Timedelta('2 days'), freq))
df_new_hourly = df_new_hourly.resample(freq).asfreq()
df_new_hourly.index = df_new_hourly.index.tz_localize("UTC")
df_new_hourly.index = df_new_hourly.index.tz_convert(timezone)
count = df_new_hourly.groupby([
df_new_hourly.index.year, df_new_hourly.index.month,
df_new_hourly.index.day
])
complete_days = [
datetime(*day).date() for day, x in count
if x.count()['value'] >= whole_day_index
]
df_new_hourly = df_new_hourly[df_new_hourly.index.tz_localize(
None).floor('D').isin(complete_days)]
# All data for clustering.
df_new_hourly = df_new_hourly.assign(
clustering_values=df_new_hourly.value.rolling(
5, center=True, min_periods=1).mean())
self.increment_counter("M", "O", amount=1)
try:
model = train_gaussian_mixture_model(
df_new_hourly[['value', 'clustering_values']],
"clustering_values", [2, 3, 4], timezone)
structural = model[0][['time', 's', 'dayhour']]
structural = structural.set_index('time')
structural['s'] = pd.to_numeric(structural.s, errors='coerce')
except Exception as e:
if "time" in df_new_hourly:
df_new_hourly.drop("time", axis=1)
mongo = MongoClient(self.config['mongodb']['host'],
self.config['mongodb']['port'])
mongo[self.config['mongodb']['db']].authenticate(
self.config['mongodb']['username'],
self.config['mongodb']['password'])
mongo[self.config['mongodb']['db']][
self.config['module_config']['mongo_error']].replace_one(
{"modellingUnitId": modelling_unit},
{
"modellingUnitId": modelling_unit,
"model": "error in clustering",
#"df": df_new_hourly.reset_index().to_dict('records'),
"multipliers": multipliers,
"lat": lat,
"lon": lon,
"timezone": timezone,
"exception": str(e),
"error": 1
},
upsert=True)
mongo.close()
return
try:
df_new_hourly = df_new_hourly.merge(structural,
how='right',
right_index=True,
left_index=True)
df_new_hourly = df_new_hourly[df_new_hourly.dayhour.isna() ==
False]
df_new_hourly = df_new_hourly[df_new_hourly.s.isna() == False]
count = df_new_hourly.groupby([
df_new_hourly.index.year, df_new_hourly.index.month,
df_new_hourly.index.day
])
complete_days = [
datetime(*day).date() for day, x in count
if x.count()['value'] >= whole_day_index
]
df_new_hourly = df_new_hourly[df_new_hourly.index.tz_localize(
None).floor('D').isin(complete_days)]
self.increment_counter("M", "O", amount=1)
df = prepare_dataframe(model,
df_new_hourly,
"value",
6,
lat,
lon,
timezone=timezone)
except Exception as e:
if "time" in df_new_hourly:
df_new_hourly.drop("time", axis=1)
mongo = MongoClient(self.config['mongodb']['host'],
self.config['mongodb']['port'])
mongo[self.config['mongodb']['db']].authenticate(
self.config['mongodb']['username'],
self.config['mongodb']['password'])
mongo[self.config['mongodb']['db']][
self.config['module_config']['mongo_error']].replace_one(
{"modellingUnitId": modelling_unit}, {
"modellingUnitId": modelling_unit,
"model": "Error preparing dataframe",
"df": df_new_hourly.reset_index().to_dict('records'),
"multipliers": multipliers,
"lat": lat,
"lon": lon,
"timezone": timezone,
"exception": str(e),
"error": 2
},
upsert=True)
mongo.close()
return
try:
e_type = "electricity" if energy_type == "electricityConsumption" else "gas"
df = df.set_index('time')
count = df.groupby([df.index.year, df.index.month, df.index.day])
complete_days = [
datetime(*day).date() for day, x in count
if x.count()['value'] >= whole_day_index
]
df = df[df.index.tz_localize(None).floor('D').isin(complete_days)]
self.increment_counter("M", "O", amount=1)
model_linear = train_linear(model=model,
type=e_type,
dataframe=df,
value_column="value",
n_max=6,
m_max=0,
by_s=False)
#save model to hbase
self.increment_counter("M", "O", amount=1)
model_linear = clean_linear(model_linear)
pickle_model = pickle.dumps(model_linear)
pickle_model = zlib.compress(pickle_model, 9)
model_folder = self.config['module_config']['model_folder']
try:
call(["hadoop", "fs", "-mkdir", "-p", model_folder])
except:
pass
model_file = NamedTemporaryFile()
model_file.name = modelling_unit
with open(model_file.name, 'wb') as f:
f.write(
pickle_model
) # where `stuff` is, y'know... stuff to write (a string)
call([
"hadoop", "fs", "-copyFromLocal", model_file.name, model_folder
])
self.increment_counter("M", "O", amount=1)
except Exception as e:
if "time" in df:
df.drop("time", axis=1)
mongo = MongoClient(self.config['mongodb']['host'],
self.config['mongodb']['port'])
mongo[self.config['mongodb']['db']].authenticate(
self.config['mongodb']['username'],
self.config['mongodb']['password'])
mongo[self.config['mongodb']['db']][
self.config['module_config']['mongo_error']].replace_one(
{"modellingUnitId": modelling_unit},
{
"modellingUnitId": modelling_unit,
"model": "Error training model",
#"df": df_new_hourly.reset_index().to_dict('records'),
"multipliers": multipliers,
"lat": lat,
"lon": lon,
"timezone": timezone,
"exception": str(e),
"error": 3
},
upsert=True)
mongo.close()
return
def post(self):
"""POST request handler. Processes form data"""
# check if user uploaded an excel file
uploaded_file = request.files['file']
if uploaded_file and not (uploaded_file.filename.endswith('.xls')
or uploaded_file.filename.endswith('.xlsx')):
flash("Uploaded file is not an .xls or .xlsx file", "error")
return redirect(url_for('index'))
# save file to /tmp folder
temp_file = NamedTemporaryFile()
temp_file_name_w_extension = ntpath.basename(temp_file.name)
temp_file.name = temp_file.name\
.replace(temp_file_name_w_extension, uploaded_file.filename)
uploaded_file.save(temp_file.name)
# get output format
output_format = request.form.get('format')
output_ext = '.' + output_format
# process output format and mime type for downloading
post_process_to = None
mime_type = 'text/html' if output_format == 'html'\
else 'application/text'
if output_format in ('pdf', 'doc'):
post_process_to = output_format
# convert uploaded file to html
temp_html_file = NamedTemporaryFile()
html_file_path = copy(temp_file.name).replace('.xlsx', '')\
.replace('.xls', '') + '.' + 'html'
temp_html_file.name = html_file_path
# TODO 3: This hard-makes PPP conv to HTML. Change to doc if doc, etc.
command_line = \
self._build_pmix_ppp_tool_run_cmd(in_file_path=temp_file.name,
out_format='html',
out_file_path=html_file_path)
_, stderr = self._run_background_process(command_line)
# if pmix.ppp tool wrote something to stderr, we should show it to user
if stderr:
flash("STDERR:\n{}".format(stderr), "error")
return redirect(url_for('index'))
# output path now exists and refers to converted html file at /tmp
pdf_doc_file_path = html_file_path
# if output format is PDF or DOC
if post_process_to == 'pdf':
try:
w_p = app_config.WKHTMLTOPDF_PATH_LOCAL
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_pdf(_input=html_file_path,
wkhtmltopdf_path=w_p)
except OSError:
try:
# w_p = app_config.WKHTMLTOPDF_PATH_SYSTEM
w_p = 'hello'
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_pdf(_input=html_file_path,
wkhtmltopdf_path=w_p)
except FileNotFoundError:
# TODO 4 - download and install a binary
raise Exception('hello there')
elif post_process_to == 'doc':
pdf_doc_file_name, pdf_doc_file_path, mime_type = \
self._convert_to_doc(_input=html_file_path)
# return file as response attachment, so browser will start download
return send_file(pdf_doc_file_path,
as_attachment=True,
mimetype=mime_type,
attachment_filename=uploaded_file.filename.replace(
'.xlsx', output_ext).replace('.xls', output_ext))
def get_template(self):
template = {
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "CodePipeline for " + str(self.project_name),
"Parameters": {
"Project": {
"Description": "The project code which owns this stack",
"Type": "String"
},
"ProjectDescription": {
"Description": "project description",
"Type": "String"
},
"DeploymentBucketName": {
"Description": "Logging bucket",
"Type": "String"
},
"Image": {
"Description": "Docker image",
"Type": "String"
},
"RepositoryName": {
"Description": "CodeCommit Repository Name",
"Type": "String"
},
"RepositoryBranchName": {
"Description": "CodeCommit Repository Branch Name",
"Type": "String"
},
"BuildServiceRole": {
"Description": "Code pipeline build service role",
"Type": "String"
},
"Subnets": {
"Type": "CommaDelimitedList"
},
"SecurityGroups": {
"Type": "CommaDelimitedList"
},
"VpcId": {
"Type": "String"
},
"BuildProjectName": {
"Type": "String"
},
"EnvironmentCode": {
"Type": "String"
},
"BuildspecFile": {
"Type": "String"
}
},
"Resources": {
"LogGroup": {
"Type": "AWS::Logs::LogGroup",
"DependsOn": "CodeBuildProject",
"Properties": {
"LogGroupName": {
"Fn::Join": [
"",
[
"/aws/codebuild/", {
"Ref": "BuildProjectName"
}
]
]
},
"RetentionInDays": 90
}
},
"CodeBuildProject": {
"Type": "AWS::CodeBuild::Project",
"Properties": {
"Name": {
"Ref": "BuildProjectName"
},
"Description": {
"Ref": "ProjectDescription"
},
"ServiceRole": {
"Ref": "BuildServiceRole"
},
"Artifacts": {
"Type": "CODEPIPELINE"
},
"VpcConfig": {
"VpcId": {
"Ref": "VpcId"
},
"Subnets": {
"Ref": "Subnets"
},
"SecurityGroupIds": {
"Ref": "SecurityGroups"
}
},
"Environment": {
"Type":
"linuxContainer",
"ComputeType":
"BUILD_GENERAL1_SMALL",
"Image": {
"Ref": "Image"
},
"EnvironmentVariables": [{
"Name": "EnvCode",
"Value": {
"Ref": "EnvironmentCode"
}
}]
},
"Source": {
"BuildSpec": {
"Ref": "BuildspecFile"
},
"Type": "CODEPIPELINE"
},
"TimeoutInMinutes":
60,
"Tags": [{
"Key": "Name",
"Value": {
"Fn::Join": ["-", [{
"Ref": "AWS::StackName"
}]]
}
}]
}
},
"Pipeline": {
"Type": "AWS::CodePipeline::Pipeline",
"Properties": {
"RoleArn": {
"Ref": "BuildServiceRole"
},
"ArtifactStore": {
"Type": "S3",
"Location": {
"Ref": "DeploymentBucketName"
}
},
"Stages": [{
"Name":
"Source",
"Actions": [{
"Name":
"SourceAction",
"ActionTypeId": {
"Category": "Source",
"Owner": "AWS",
"Version": "1",
"Provider": "CodeCommit"
},
"OutputArtifacts": [{
"Name":
"CodePipelineSourceOutputArtifact"
}],
"Configuration": {
"BranchName": {
"Ref": "RepositoryBranchName"
},
"RepositoryName": {
"Ref": "RepositoryName"
}
},
"RunOrder":
1
}]
}, {
"Name":
"Build",
"Actions": [{
"Name":
"BuildAction",
"InputArtifacts": [{
"Name":
"CodePipelineSourceOutputArtifact"
}],
"ActionTypeId": {
"Category": "Build",
"Owner": "AWS",
"Version": 1,
"Provider": "CodeBuild"
},
"Configuration": {
"ProjectName": {
"Ref": "CodeBuildProject"
}
},
"OutputArtifacts": [{
"Name":
"CodePipelineBuildOutputArtifact"
}],
"RunOrder":
1
}]
}]
}
}
}
}
f = NamedTemporaryFile(delete=False)
# Save original name (the "name" actually is the absolute path)
original_path = f.name
if self.debug:
print('original_path: ' + str(original_path))
print('path: ' + str(os.path.dirname(original_path)))
# Change the file name to something
f.name = str(os.path.dirname(original_path)) + '/myfilename.json'
with open(f.name, 'w') as file:
file.write(json.dumps(template))
file.close()
if self.debug:
print('##########################')
print('cwd: ' + str(self.cwd))
print('creating template.json')
print('##########################')
if not os.path.exists(self.cwd + '/template.json'):
with open(self.cwd + '/template.json', 'w') as file:
file.write(json.dumps(template))
file.close()
else:
if self.debug:
print('Not creating template.json')
return f.name
