def is_valid(self) -> bool: """ is directory path, vrd filepath, url, name valid """ return is_valid_filepath(self.directory, platform='auto') and \ is_valid_filepath(self.vrd_filename, platform='auto') and \ is_valid_filepath(self.url_path, platform='posix') and \ self.url_path.startswith('/') and \ '' != self.name
def setUser(parent, changesample: bool = True): # Make sure the base path exists and set it if it doesn't if not os.path.exists(parent.basepath): parent.basepath = setBasepath(parent) # Prompt user to enter a username entry, accepted = QtWidgets.QInputDialog().getText( parent, 'Change User', 'Enter user name:') # Make sure the chosen username is valid testpath = os.path.join(parent.basepath, entry, '') if accepted and entry != '' and pathvalidate.is_valid_filepath( testpath, platform='Windows'): userpath = testpath parent.user = entry # If the username is invalid, retry creation elif accepted and not pathvalidate.is_valid_filepath( testpath, platform='Windows'): QtWidgets.QMessageBox.warning(parent, 'Alert', 'User name contains invalid characters for folder creation.') setUser(parent, False) # If no username is entered, exit elif entry == '': setUser(parent, False) userpath = os.path.join(parent.basepath, parent.user, '') if not os.path.exists(userpath): os.makedirs(userpath) # Update parent variables parent.user = entry # Update user label text parent.userLabel.setText(entry) # Update the config file parent.config['Default']['user'] = entry with open(parent.configfile, 'w') as cfg: parent.config.write(cfg) # Run the sample entry dialog if changing samples if changesample: setSample(parent) else: samplepath = os.path.join(parent.basepath, parent.user, parent.user, '') if not os.path.exists(samplepath) and pathvalidate.is_valid_filepath( testpath, platform='Windows'): os.makedirs(samplepath)
def setSample(parent): # Make sure basepath is valid and exists if not os.path.exists(parent.basepath) or not pathvalidate.is_valid_filepath( parent.basepath, platform='Windows'): setBasepath(parent) # Make sure userpath is valid and exists userpath = os.path.join(parent.basepath, parent.user, '') if not os.path.exists(userpath) or not pathvalidate.is_valid_filepath( userpath, platform='Windows'): setUser(parent, False) # Prompt user to enter sample name entry, accepted = QtWidgets.QInputDialog().getText( parent, 'Change Sample', 'Enter sample name:') testpath = os.path.join(userpath, entry, '') if accepted and entry != '' and pathvalidate.is_valid_filepath( testpath, platform='Windows'): samplepath = testpath elif accepted: QtWidgets.QMessageBox.warning( parent, 'Alert', 'Sample name contains invalid characters for folder creation.') setSample(parent) elif not accepted and os.path.exists(os.path.join(userpath, parent.sample)): return elif not accepted: setSample(parent) else: return # Make the sample directory if it's valid and doesn't already exist if not os.path.exists(testpath) and pathvalidate.is_valid_filepath( testpath, platform='Windows'): os.makedirs(testpath) # Update the parent variable parent.sample = entry # Update the sample label text parent.sampleLabel.setText(entry) # Update the config file parent.config['Default']['sample'] = parent.sample with open(parent.configfile, 'w') as cfg: parent.config.write(cfg)
def test_normal_max_len(self, value, platform, max_len, expected): if expected is None: validate_filepath(value, platform=platform, max_len=max_len) assert is_valid_filepath(value, platform=platform, max_len=max_len) else: with pytest.raises(expected): validate_filepath(value, platform=platform, max_len=max_len)
def test_normal_pathlike(self, value, replace_text, expected): sanitized_name = sanitize_filepath(value, replace_text) assert sanitized_name == expected assert is_pathlike_obj(sanitized_name) validate_filepath(sanitized_name) assert is_valid_filepath(sanitized_name)
def test_normal_pathlike(self, value, replace_text, expected): sanitized_name = sanitize_filepath(value, replace_text) assert sanitized_name == expected assert is_pathlike_obj(sanitized_name) validate_filepath(sanitized_name) assert is_valid_filepath(sanitized_name)
def test_normal_auto_platform_linux(self, value, expected): if isinstance(expected, str): sanitized = sanitize_filepath(value, platform="auto") assert is_valid_filepath(sanitized, platform="auto") else: with pytest.raises(expected): sanitize_filepath(value, platform="auto")
def test_normal_rel_path(self, test_platform, value, expected): if expected is None: validate_filepath(value, platform=test_platform) assert is_valid_filepath(value, platform=test_platform) else: with pytest.raises(expected): validate_filepath(value, platform=test_platform)
def test_normal_auto_platform_linux(self, value, expected): if expected is None: validate_filepath(value, platform="auto") assert is_valid_filepath(value, platform="auto") else: with pytest.raises(expected): validate_filepath(value, platform="auto")
def test_minmax_len(self, value, min_len, max_len, expected): if expected is None: validate_filepath(value, min_len=min_len, max_len=max_len) assert is_valid_filepath(value, min_len=min_len, max_len=max_len) else: with pytest.raises(expected): validate_filepath(value, min_len=min_len, max_len=max_len)
def test_minmax_len(self, value, min_len, max_len, expected): if expected is None: validate_filepath(value, min_len=min_len, max_len=max_len) assert is_valid_filepath(value, min_len=min_len, max_len=max_len) else: with pytest.raises(expected): validate_filepath(value, min_len=min_len, max_len=max_len)
def test_exception_reserved_name(self, value, platform, expected): with pytest.raises(expected) as e: print(platform, value) validate_filepath(value, platform=platform) assert e.value.reusable_name is False assert e.value.reserved_name assert not is_valid_filepath(value, platform=platform)
def test_normal_max_len(self, value, platform, max_len, expected): if expected is None: validate_filepath(value, platform=platform, max_len=max_len) assert is_valid_filepath(value, platform=platform, max_len=max_len) return with pytest.raises(expected): validate_filepath(value, platform=platform, max_len=max_len)
def test_exception_reserved_name(self, value, platform, expected): with pytest.raises(expected) as e: print(platform, value) validate_filepath(value, platform=platform) assert e.value.reusable_name is False assert e.value.reserved_name assert not is_valid_filepath(value, platform=platform)
def test_normal_multibyte(self, test_platform, value, replace_text, expected): sanitized_name = sanitize_filepath(value, replace_text, platform=test_platform) assert sanitized_name == expected validate_filepath(sanitized_name, platform=test_platform) assert is_valid_filepath(sanitized_name, platform=test_platform)
def test_normal_str(self, platform, value, replace_text, expected): sanitized_name = sanitize_filepath(value, platform=platform, replacement_text=replace_text) assert sanitized_name == expected assert isinstance(sanitized_name, str) validate_filepath(sanitized_name, platform=platform) assert is_valid_filepath(sanitized_name, platform=platform)
def test_locale_jp(self, locale): from faker import Factory fake = Factory.create(locale=locale, seed=1) for _ in range(100): filepath = fake.file_path() validate_filepath(filepath, platform="linux") assert is_valid_filepath(filepath, platform="linux")
def test_locale_jp(self, locale): from faker import Factory fake = Factory.create(locale=locale, seed=1) for _ in range(100): filepath = fake.file_path() validate_filepath(filepath) assert is_valid_filepath(filepath)
def export(export_path, default_album, library_path, edited): """ Export all photos, organized by album """ export_path = os.path.expanduser(export_path) library_path = os.path.expanduser(library_path) if library_path else None if library_path is not None: photosdb = osxphotos.PhotosDB(library_path) else: photosdb = osxphotos.PhotosDB() photos = photosdb.photos() for p in photos: if not p.ismissing: albums = p.albums if not albums: albums = [default_album] for album in albums: click.echo(f"exporting {p.original_filename} in album {album}") # make sure no invalid characters in destination path (could be in album name) album_name = sanitize_filepath(album, platform="auto") # create destination folder, if necessary, based on album name dest_dir = os.path.join(export_path, album_name) # verify path is a valid path if not is_valid_filepath(dest_dir, platform="auto"): sys.exit(f"Invalid filepath {dest_dir}") # create destination dir if needed if not os.path.isdir(dest_dir): os.makedirs(dest_dir) filename = p.original_filename # export the photo but only if --edited, photo has adjustments, and # path_edited is not None (can be None if edited photo is missing) if edited and p.hasadjustments and p.path_edited: # export edited version # use original filename with _edited appended but make sure suffix is # same as edited file edited_filename = f"{pathlib.Path(filename).stem}_edited{pathlib.Path(p.path_edited).suffix}" exported = p.export(dest_dir, edited_filename, edited=True) click.echo(f"Exported {edited_filename} to {exported}") # export unedited version exported = p.export(dest_dir, filename) click.echo(f"Exported {filename} to {exported}") else: click.echo(f"Skipping missing photo: {p.original_filename} in album {album}")
def WinPathValidator(path): """ Path validator function that checks for OS appropiate paths Parameters ---------- path : String string of directory or file path Returns ------- Boolean returns if a path is valid or not """ return pathvalidate.is_valid_filepath(path)
def WinFileValidator(file): """ file name validator function that checks for OS appropiate paths Parameters ---------- path : String string of directory or file path Returns ------- Boolean returns if a file name is valid or not """ return pathvalidate.is_valid_filepath(file)
def is_filepath(val): """This function check if data type of value or not. Parameters ---------- value : value for which we want to check data type Returns ---------- datatype: a binary value based on data type of the given input argument is filepath or not """ val = val.lstrip('/') return is_valid_filepath(val) and (val.find('/') != -1 or val.find('\\') != -1)
def process_each_msg(self, each, keyword_dict): new_msg = [] sentences = each.split("\n") for each_sentence in sentences: each_sentence = each_sentence.strip('\t\n\r\f\v').strip().lower() tokens = each_sentence.split(" ") new_tokens = [] for tok in tokens: tok = tok.strip("\t\n\r\f\v.:',;") if tok == "": continue # print("tok = '%s'" % tok) if tok.isalpha(): ### check keyword category = self.check_keyword(tok, keyword_dict) if category: tok = "<keyword category=" + category + ">" + tok + "</keyword>" new_tokens.append(tok) else: ### check types # if "(" in tok: # if re.match('([a-z0-9]+(_?))+[a-z0-9]*\([a-z0-9, ]*\)\Z', tok): # tok = "<function>" + tok + "</function>" # ---------------------- # TODO: argument list check, the original argument checks are problematic '[a-z0-9, ]*' # it cannot match foo(int *) # for now, just check if the tok is in shape of 'identifier(.*)' # ---------------------- if "(" in tok and tok.endswith(")"): parts = tok[:-1].split("(") if parts[0].isidentifier(): tok = "<function>" + tok + "</function>" # print(" |- " + tok) elif "." in tok: # if re.match('([a-z0-9]+(_?)(/)?)?([a-z0-9]+(_?))+[a-z0-9]*.[ch]\Z', tok): # tok = "<file_name>" + tok + "</file_name>" if is_valid_filepath(tok): _, f_ext = os.path.splitext(tok) if f_ext == ".c" or f_ext == ".h" or f_ext == ".cpp" or f_ext == ".hpp": tok = "<file_name>" + tok + "</file_name>" # elif re.match('([a-z0-9]+_)+[a-z0-9]*\Z', tok): # tok = "<variable>"+tok+"</variable>" elif tok.isidentifier(): tok = "<variable>" + tok + "</variable>" new_tokens.append(tok) new_msg.append(new_tokens) return new_msg
def export(export_path, default_album, library_path): export_path = os.path.expanduser(export_path) library_path = os.path.expanduser(library_path) if library_path else None if library_path is not None: photosdb = osxphotos.PhotosDB(library_path) else: photosdb = osxphotos.PhotosDB() photos = photosdb.photos() for p in photos: if not p.ismissing: albums = p.albums if not albums: albums = [default_album] for album in albums: click.echo(f"exporting {p.filename} in album {album}") # make sure no invalid characters in destination path (could be in album name) album_name = sanitize_filepath(album, platform="auto") # create destination folder, if necessary, based on album name dest_dir = os.path.join(export_path, album_name) # verify path is a valid path if not is_valid_filepath(dest_dir, platform="auto"): sys.exit(f"Invalid filepath {dest_dir}") # create destination dir if needed if not os.path.isdir(dest_dir): os.makedirs(dest_dir) # export the photo if p.hasadjustments: # export edited version exported = p.export(dest_dir, edited=True) edited_name = pathlib.Path(p.path_edited).name click.echo(f"Exported {edited_name} to {exported}") # export unedited version exported = p.export(dest_dir) click.echo(f"Exported {p.filename} to {exported}") else: click.echo(f"Skipping missing photo: {p.filename}")
def generate_paths(self, dir_prefix: str, vrd_prefix: str, url_prefix: str): """ generate directory path, vrd filepath, url for named publication """ if not os.path.isdir(dir_prefix): raise ValueError(f'pub dir not found: {dir_prefix}') if not os.path.isdir(vrd_prefix): raise ValueError(f'vrd dir not found: {vrd_prefix}') if not is_valid_filepath(url_prefix, platform='posix'): raise ValueError(f'url prefix invalid: {url_prefix}') if not url_prefix.endswith('/'): url_prefix = url_prefix + '/' slug_name = slugify(self.name) safe_name = sanitize_filename(slug_name, platform='auto') safe_name_url = sanitize_filename(slug_name, platform='posix') self.directory = os.path.join(dir_prefix, safe_name) self.vrd_filename = os.path.join(vrd_prefix, f'{safe_name}.vrd') self.url_path = url_prefix + safe_name_url
def test_normal_multibyte(self, value, replace_text, expected): sanitized_name = sanitize_filepath(value, replace_text) assert sanitized_name == expected validate_filepath(sanitized_name) assert is_valid_filepath(sanitized_name)
def test_normal_reserved_name_used_valid_place(self, value, platform): validate_filepath(value, platform=platform) assert is_valid_filepath(value, platform=platform)
def test_normal_reserved_name(self, value, test_platform, expected): filename = sanitize_filepath(value, platform=test_platform) assert filename == expected assert is_valid_filepath(filename, platform=test_platform)
def test_normal_win(self, value): platform = "windows" validate_filepath(value, platform=platform) assert is_valid_filepath(value, platform=platform)
def _is_url_base_valid(self) -> bool: return is_valid_filepath( self._url_base, platform='posix') and self._url_base.startswith('/')
def test_normal_reserved_name(self, value, platform, expected): validate_filepath(value, platform=platform) assert is_valid_filepath(value, platform=platform)
def test_normal(self, value): validate_filepath(value, platform="windows") assert is_valid_filepath(value, platform="windows")
def test_exception_invalid_win_char(self, value, platform): with pytest.raises(InvalidCharError): validate_filepath(value, platform=platform) assert not is_valid_filepath(value, platform=platform)
def test_normal_space_or_period_at_tail(self, platform, value): validate_filepath(value, platform=platform) assert is_valid_filepath(value, platform=platform)
def test_exception(self, value, expected): with pytest.raises(ValidationError) as e: validate_filepath(value) assert e.value.reason == ErrorReason.MALFORMED_ABS_PATH assert not is_valid_filepath(value)
def test_normal_reserved_name(self, value, test_platform, expected): filename = sanitize_filepath(value, platform=test_platform) assert filename == expected assert is_valid_filepath(filename, platform=test_platform)
def test_exception_type(self, value, expected): with pytest.raises(expected): sanitize_filepath(value) assert not is_valid_filepath(value)
def test_exception(self, value, expected): with pytest.raises(expected): validate_filepath(value) assert not is_valid_filepath(value)
def test_exception_invalid_win_char(self, value, platform): with pytest.raises(InvalidCharError): validate_filepath(value, platform=platform) assert not is_valid_filepath(value, platform=platform)
def test_exception(self, value, expected): with pytest.raises(expected): validate_filepath(value) assert not is_valid_filepath(value)
def test_normal_space_or_period_at_tail(self, platform, value): validate_filepath(value, platform=platform) assert is_valid_filepath(value, platform=platform)
def test_normal(self, value): validate_filepath(value) assert is_valid_filepath(value)
def is_valid_filepath(filepath): """ returns True if a filepath is valid otherwise False """ return pathvalidate.is_valid_filepath(filepath, platform="macos")
def test_normal_str(self, platform, value, replace_text, expected): sanitized_name = sanitize_filepath(value, platform=platform, replacement_text=replace_text) assert sanitized_name == expected assert isinstance(sanitized_name, six.text_type) validate_filepath(sanitized_name, platform=platform) assert is_valid_filepath(sanitized_name, platform=platform)
def test_normal_multibyte(self, value, platform): validate_filepath(value, platform) assert is_valid_filepath(value, platform=platform)
def test_exception_type(self, value, expected): with pytest.raises(expected): sanitize_filepath(value) assert not is_valid_filepath(value)