def fetch_spacex_last_launch(images_dir: Path) -> None: response: Response = requests.get( 'https://api.spacexdata.com/v4/launches/latest') response.raise_for_status() images: list = response.json()['links']['flickr']['original'] for image_number, image_url in enumerate(images): ext: str = get_file_extension(image_url) save_pictures('spacex{}.{}'.format(image_number, ext), image_url, images_dir)
def get_hubble_image(foto_id: int, images_dir: Path) -> None: response: Response = requests.get( 'http://hubblesite.org/api/v3/image/{}'.format(foto_id)) response.raise_for_status() picture_link: str = response.json()['image_files'][-1]['file_url'] picture_link = picture_link.replace('//', 'https://') ext: str = get_file_extension(picture_link) filename: str = 'hubble{}.{}'.format(foto_id, ext) save_pictures(filename, picture_link, images_dir)
def analyze_file_code_convention(filename=''): ''' This RESTful API analyze file ''' # TODO!!!!!! if util.get_file_extension(filename) == 'py': log_path = util.py_file_code_convention_analysis('test.py') fp_log = open(log_path, 'r') content = fp_log.read() fp_log.close() return content
def burst_pdf(**kwargs): """ A task that creates a sub-folder next to a PDF file and extracts all pages from the PDF as PNG files into the sub-folder. """ from flask_app import app from filesystem_manager import get_abs_path, get_burst_path, get_file_data from filesystem_manager import delete_dir, make_dirs, path_exists from filesystem_sync import delete_folder from imagemagick import imagemagick_burst_pdf from models import Folder from util import get_file_extension (src,) = _extract_parameters(["src"], **kwargs) burst_folder_rel = get_burst_path(src) # Ensure src is a PDF if get_file_extension(src) not in app.config["PDF_FILE_TYPES"]: app.log.warn("Cannot burst non-PDF file: " + src) return # See if the burst folder already exists (in the database and on disk) db_folder = app.data_engine.get_folder(folder_path=burst_folder_rel) if db_folder is not None and db_folder.status == Folder.STATUS_ACTIVE: # Wipe the folder, old images, data, and uncache the old images delete_folder(db_folder, None, app.data_engine, None, app.log) deleted_ids = app.data_engine.list_image_ids(db_folder) for image_id in deleted_ids: app.image_engine._uncache_image_id(image_id) # See if the burst folder already exists (just on disk) if path_exists(burst_folder_rel, require_directory=True): # Wipe the folder and old images delete_dir(burst_folder_rel, recursive=True) # Create the burst folder and burst pdf_data = get_file_data(src) if pdf_data is not None: make_dirs(burst_folder_rel) burst_folder_abs = get_abs_path(burst_folder_rel) if not imagemagick_burst_pdf(pdf_data, burst_folder_abs, app.config["PDF_BURST_DPI"]): app.log.warn("Failed to burst PDF: " + src) else: app.log.warn("Cannot burst PDF, file not found: " + src)
def __init__(self, src, db_id=-1, page=None, iformat=None, template=None, width=None, height=None, align_h=None, align_v=None, rotation=None, flip=None, top=None, left=None, bottom=None, right=None, crop_fit=None, size_fit=None, fill=None, quality=None, sharpen=None, overlay_src=None, overlay_size=None, overlay_pos=None, overlay_opacity=None, icc_profile=None, icc_intent=None, icc_bpc=None, colorspace=None, strip=None, dpi=None, tile_spec=None): self._version = self.__class__.class_version self._filename = filepath_normalize(src) self._filename_ext = get_file_extension(self._filename) self._db_id = db_id self._page = page self._format = self._no_blank(iformat) self._template = self._no_blank(template) self._width = width self._height = height self._align_h = self._no_blank(align_h) self._align_v = self._no_blank(align_v) self._rotation = rotation self._flip = self._no_blank(flip) self._top = top self._left = left self._bottom = bottom self._right = right self._crop_fit = crop_fit self._size_fit = size_fit self._fill = self._no_blank(fill) self._quality = quality self._sharpen = sharpen self._overlay_src = self._no_blank(overlay_src) self._overlay_size = overlay_size self._overlay_pos = self._no_blank(overlay_pos) self._overlay_opacity = overlay_opacity self._icc_profile = self._no_blank(icc_profile) self._icc_intent = self._no_blank(icc_intent) self._icc_bpc = icc_bpc self._colorspace = self._no_blank(colorspace) self._strip = strip self._dpi_x = dpi self._dpi_y = dpi self._tile = tile_spec self._round_floats()
def get_track(self, track) -> None: tracks = self.urlService.get_track_request(track) models = tracks.json()['models'] for i in models: chal_slug = i.get('slug') sub_domain = i.get('track').get('slug') if chal_slug is None: raise Exception("Chal_slug:" + str(chal_slug)) sub_domain_string = "Domain: " + sub_domain print(track + " " + sub_domain_string + chal_slug.rjust(70 - len(sub_domain_string))) sub_id = self.get_submissions(chal_slug) code = False if sub_id: result = self.get_code(chal_slug, sub_id) code = result['code'] lang = result['language'] if code: ext = get_file_extension(track, lang) self.create_code_file(track, sub_domain, chal_slug, code, ext)
def file_extension_filter(filename): """ A template filter to return the file extension of a file name. """ return get_file_extension(filename)
def auto_sync_existing_file(rel_path, data_manager, task_manager, anon_history=True, burst_pdf='auto', _db_session=None): """ Returns the database record for an image file that is known to exist, creating a new record or un-deleting an old record if required, and always returning a value. This method creates anonymous image history entries when anon_history is True. If the current user should be recorded against an action, the caller should set anon_history to False and manually add a history record. The bursting of PDF files is also initiated here. By default, a PDF file will be burst if no burst folder already exists. Setting burst_pdf to False disables this, or setting burst_pdf to True will force it to be burst again. Raises a DoesNotExistError if the image path is in fact invalid. Raises a SecurityError if the image path is outside of IMAGES_BASE_DIR. Raises a DBError if the database record cannot be created. """ db_own = (_db_session is None) db_session = _db_session or data_manager.db_get_session() db_error = False try: # Get (or create) db record for the file on_create = on_image_db_create_anon_history if anon_history \ else on_image_db_create db_image = data_manager.get_or_create_image( rel_path, on_create, _db_session=db_session ) if not db_image: # Not expected raise DBError('Failed to add image to database: ' + rel_path) # Burst PDF if we need to # TODO This would be better in on_image_db_create if we can get a task_manager without # importing the one from flask_app. Needs to be compatible with the task server. if burst_pdf and app.config['PDF_BURST_TO_PNG']: can_burst = get_file_extension(rel_path) in app.config['PDF_FILE_TYPES'] if can_burst: if burst_pdf == 'auto': burst_pdf = not path_exists( get_burst_path(rel_path), require_directory=True ) if burst_pdf: burst_pdf_file(rel_path, task_manager) if db_image.status == Image.STATUS_ACTIVE: # The normal case return db_image else: # We need to undelete the database record db_image.status = Image.STATUS_ACTIVE if anon_history: on_image_db_create_anon_history(db_image) else: on_image_db_create(db_image) # Check whether the file's folder needs to be undeleted too if db_image.folder.status == Folder.STATUS_DELETED: auto_sync_existing_folder( db_image.folder.path, data_manager, _db_session=db_session ) return db_image except: db_error = True raise finally: if db_own: try: if db_error: db_session.rollback() else: db_session.commit() finally: db_session.close()