def get_image_list(): images_path = WindowsPath('./images/StarWars/cards') filenames = [] for name in images_path.glob('*.png'): filenames.append(name) return filenames
def resource_serving(file): target_path = Path(BASE_DIR.joinpath("styles"), file) if target_path.exists() and not target_path.is_dir(): return send_file(target_path.open(mode="rb"), attachment_filename=target_path.name) abort(404)
def get(): path = os.path.sep.join((os.path.dirname(os.path.abspath(__file__)), 'mocked_grading.html')) if platform.system() == 'Windows': path = WindowsPath(path) else: path = PosixPath(path) url = path.as_uri() return session.get(url)
def get_subdirlist(cls, path: str): """ Return list of subdirectories :param path: base pathname as r'string' :return: list of subdirectories """ wpath = WindowsPath(path) return [f.name for f in wpath.iterdir() if f.is_dir()]
def process_binary(self, binary): if isinstance(binary, list): return print("Processing {}".format(binary)) binary = Binary(binary) target_file = WindowsPath( self.target, f"unxutils-{binary.name_without_extension}.json") target_content = single_binary_content(self.source_json, binary) target_file.write_text(json.dumps(target_content, indent=2))
def separate(source: WindowsPath = WindowsPath('unxutils.json'), target: WindowsPath = WindowsPath('bucket')): source = WindowsPath(source) source_data = source.read_text() source_json = json.loads(source_data) binary_writer = BinaryWriter(source_json, target) with ThreadPoolExecutor() as executor: futures = executor.map(binary_writer.process_binary, source_json['bin']) for _ in futures: pass
def path_settings(directory): dest = os.getcwd() if system() == 'Windows': appdata = WindowsPath(os.getenv('APPDATA')) dest = appdata.joinpath(directory) else: dest = PosixPath('/etc').joinpath(directory) dest.mkdir(parents = True, exist_ok = True) return dest
def bu_uncatalogued_photos(tranche, source_dir_path: WindowsPath, destination_dir: WindowsPath, backup_options: BackupOptions): for t in tranche: src = WindowsPath(source_dir_path, t) options_list = ["-archW" ] + backup_options_to_rsync_options(backup_options) home = WindowsPath.home() cmd_list = cygwin.rsync_cmd(options_list, home, src, destination_dir) # buph_logger.info("bu_catalogued_photos %s" %(" ".join(cmd_list))) if try_popen(cmd_list, str(WindowsPath.home())) != 0: raise Exception("try_popen returns rc != 0")
def actually_send(s: socket.socket, file: pathlib.WindowsPath): size = file.stat().st_size progress = get_progress_bar( f'{Fore.GREEN}Sending {file.name}{Fore.RESET}', size) with open(str(file.absolute()), 'rb') as f: for _ in progress: bytes_read = f.read(BUFFER_SIZE) if not bytes_read: break s.sendall(bytes_read) progress.update(len(bytes_read)) s.close()
def tree_add(self, path_object: WindowsPath, parentDir, n=0): line = self.indentSpace * n fixedName = path_object.name.replace("_", " ") fixedName = re.sub(r'.md$', '', fixedName) fixedName = fixedName.title() pathName = re.sub(r'.md$', '', path_object.name) if path_object.is_file(): fileContent = self.fileSign.replace("%s", fixedName) + '\n' fileContent = fileContent.replace('%path', parentDir + pathName) self.tree += line + fileContent + '\n' return False elif path_object.is_dir(): self.tree += line + self.dirSign.replace("%s", fixedName) + '\n' return True
def request_api(student_comments: pd.Series, endpoint: str, num_batches: int = 50, save: bool = True, folder: WindowsPath = None) -> pd.Series: """Sends student comments to the LUIS.ai API in batches and saves the intemediate results into the OUTPUT folder Keyword arguments student_comments -- the pd.Series that contains the student comments in natural language endpoint -- the luis endpoint num_batches -- the number of batches into which the comments would be grouped and sent to the api save -- a boolean that saves the raw json response to local disk folder -- a location to which to save the response data, defaults to /OUTPUT/LUIS/ """ if save and folder is None: folder = Path.cwd().joinpath('OUTPUT').joinpath('LUIS') for i, batch in enumerate(np.array_split(student_comments, num_batches)): print(f'Processing batch {i} of {num_batches}:') luis_result = batch.apply(lambda x: requests.get(f'{endpoint}{x}')) # Saving the results to pickle filename = f'luis_result_{str(i).zfill(4)}' luis_result.to_pickle(folder.joinpath(filename)) print(f'Saved to {folder.joinpath(filename)}.')
def make_correct_path(root_path, file_path): if platform.system() == 'Windows': path = WindowsPath(root_path).joinpath(file_path) return path else: path = PurePosixPath(root_path).joinpath(file_path) return path
def _find_path(given_path: str, system="posix"): """Turn given path into a proper path for given system. Parameters ---------- given_path : str Path to be converted system : str, optional System type for getting the path, 'posix' or 'windows' Returns ------- Path Generated path obj for locating certain directory Raises ------ ValueError If system offered is not suppported """ if system == "posix": given_path = PosixPath(given_path) elif system == "windows": given_path = WindowsPath(given_path) else: raise ValueError(f"system {system} is not supported") return given_path
def test_logfile_path_expanduser(self, mock_open, mock_stdout): with patch.dict(os.environ, {"USERPROFILE": "C:\\foo"}): self.subject(["streamlink", "--logfile", "~\\bar"]) self.write_file_and_assert(mock_mkdir=WindowsPath("C:\\foo").mkdir, mock_write=mock_open("C:\\foo\\bar", "a").write, mock_stdout=mock_stdout)
def test_logfile_path_absolute(self, mock_open, mock_stdout): self.subject(["streamlink", "--logfile", "C:\\foo\\bar"]) self.write_file_and_assert( mock_mkdir=WindowsPath("C:\\foo").mkdir, mock_write=mock_open("C:\\foo\\bar", "a").write, mock_stdout=mock_stdout )
def normalize(path): if type(path) is PurePosixPath: normalized_path = PurePosixPath() elif type(path) is PureWindowsPath: normalized_path = PureWindowsPath() elif type(path) is PosixPath: normalized_path = PosixPath() elif type(path) is WindowsPath: normalized_path = WindowsPath() # remove anchor (necessary for Windows UNC paths) and convert to relative path if path.is_absolute(): path = path.relative_to(path.anchor) for p in path.parts: if p == '.': continue if p == '..': normalized_path = normalized_path.parent continue normalized_path /= p return normalized_path
def _get_rf_location(sub_path): rf = RfactorPlayer(only_version=True) rf_path = rf.location / sub_path if not rf_path.exists(): logging.error('Could not locate rF2 Setups directory in %s', rf_path.as_posix()) return return str(WindowsPath(rf_path))
def tree_add(self, path_object: WindowsPath, n=0, last=False): if n > 0: if last: self.tree += '│' + (' │' * (n - 1)) + ' └────' + path_object.name else: self.tree += '│' + (' │' * (n - 1)) + ' ├────' + path_object.name else: if last: self.tree += '└' + ('──' * 2) + path_object.name else: self.tree += '├' + ('──' * 2) + path_object.name if path_object.is_file(): self.tree += '\n' return False elif path_object.is_dir(): self.tree += '/\n' return True
def main(): parser = argparse.ArgumentParser( description= "Extract the pixel shader HLSL from a Yakuza .pso or .fxo file") parser.add_argument("yakuza_file", help="The file to extract from.", type=windows_path_arg) parser.add_argument( "-o", help="The file to output. Defaults to \"ORIGINAL_FILE.pxo.hlsl\"") parser.add_argument( "-i", help="Ignore compilation errors for disassembled shader", action="store_true", dest="ignore") args = parser.parse_args() if not args.o: args.o = args.yakuza_file.with_suffix(args.yakuza_file.suffix + ".hlsl") output_path = WindowsPath(args.o) yk_file = import_yakuza_shader_file(args.yakuza_file) shader_assembly = decompile_shader(yk_file.get_pixel_shader_data()) print(shader_assembly) dp = DisassemblyParser(shader_assembly) pg = ProgramGenerator() program = pg.build_program(dp.declarations, dp.instructions, dp.input_semantics, dp.output_semantics, dp.global_flags) try: flags = (1 << 11) | (1 << 21) | (1 << 15) compile_shader(program.get_disassembled_shader(), "DISASSEMBLED_SHADER", flags) except DXCallError as e: if not args.ignore: reraise( e, "Got error when compiling disassembled shader, use -i to ignore." + "\n{}") with output_path.open("w") as f: f.write(program.get_disassembled_shader())
def direction_ergodic(self, path_object: WindowsPath, parentDir, n=0): dir_file: list = list(path_object.iterdir()) dir_file.sort(key=lambda x: x.name.lower()) for item in dir_file: if self.ignore_judge(item.name): if self.tree_add(item, parentDir, n): self.direction_ergodic(item, parentDir + item.name + "/", n + 1)
def refold_dir(path: pathlib.WindowsPath, newer_path: pathlib.WindowsPath): for p in path.iterdir(): if p.is_dir(): refold_dir(p, newer_path) else: if not checkdir(p): # 下层无目录,则为最底层目录,移动 shutil.move(p, newer_path) return
def import_yakuza_shader_file(path: WindowsPath) -> 'YkShaderFile': byte_data = None with path.open("rb") as f: byte_data = bytearray(f.read()) if not byte_data or len(byte_data) < 4: raise YkError(f"Couldn't open {path} and extract >4 bytes.") return FirstPossibleOf([YkPixelShaderFile, YkEffectShaderFile], [YkError])(byte_data)
def listup_content_path() -> List[Path]: parent = WindowsPath('D:/aozorabunko/cards') files = list(parent.glob('**/*.html')) # 適当にピック RAND_MAX = 300 DOUBLE_PICK_THR = 10 count = 0 until = randrange(1, RAND_MAX) pickup_files = [] for file in files: if until == count: until = randrange(1, RAND_MAX) if until % DOUBLE_PICK_THR == 0: # たまには2つ連続で取りたい until = 1 pickup_files.append(file) count = 0 count += 1 return pickup_files
def open_in_browser(): maps_file_path = Path(str(path.cwd()) + '/places.html') if maps_file_path.exists(): try: browser.open_new_tab(str(maps_file_path)) # print("Opening browser...") except browser.Error: print('Something went wrong...') else: print('File, places.html has not been created!')
def warehouse(): if platform.system() == 'Windows': out_dir = Path(WindowsPath.home() / "Documents" / "Data") out_dir.mkdir(parents=True, exist_ok=True) else: # out_dir = Path(Path.home() / "Documents" / "Data") out_dir = Path("/mnt/c/Users/morris/Documents/Data") out_dir.mkdir(parents=True, exist_ok=True) return out_dir
def checksubProcess(): command = 'ls -ltr' # output = subprocess.check_output(['C:\\Program Files\\Git\\git-bash.exe','-c', command]) cmd = "find . -maxdepth 1 -type f -name '*Resume*' | awk '{print $0}'" dirForShell = WindowsPath(r'C:\Users\Ranjit\Downloads') output = subprocess.run(['C:\Program Files\Git\\bin\\bash.exe', '-c', cmd], capture_output=True, cwd=dirForShell) print(output.stdout.decode()) print(os.listdir(dirForShell))
def _libcmark(): system = platform.system() if system == 'Darwin': return 'libcmark.dylib' if system == 'Windows': binary_dependencies = WindowsPath(__file__).parents[1] / 'binary_dependencies' return str(binary_dependencies / 'cmark.dll') return 'libcmark.so'
def load_estimators(path: WindowsPath) -> List[Tuple]: """ Returns a list of estimators for the VotingClassifier """ estimator_list = [] for suffix in ['*.joblib', '*.sav']: for filepath in path.glob(suffix): print(f'Loading {filepath.name}') estimator_list.append((filepath.stem, load(filepath))) return estimator_list
def save_artist_json(self): """ Save artist json objects to file for logging/testing. """ fixture_path = WindowsPath(base_dir / r'test/fixtures') with open(fixture_path / 'spotify_artists.json', 'w') as f: json.dump(self.artist_response, f) with open(fixture_path / 'spotify_track_ids.json', 'w') as f: json.dump(self.track_response, f)
def direction_ergodic(self, path_object: WindowsPath, n=0): dir_file: list = list(path_object.iterdir()) dir_file.sort(key=lambda x: x.name.lower()) dir_file = [f for f in filter(self.filter_file, dir_file)] for i, item in enumerate(dir_file): if i + 1 == len(dir_file): if self.tree_add(item, n, last=True): self.direction_ergodic(item, n + 1) else: if self.tree_add(item, n, last=False): self.direction_ergodic(item, n + 1)
def run_exercice(num_ex: str): """This function runs exercice num_ex""" print("Running exercice n°", num_ex) ex_path = WindowsPath("./metarch/exercices/exercice1/" + num_ex + ".py") t = Path(".") all_python_files_in_subdirs = list(t.glob("**/*.py")) if ex_path in all_python_files_in_subdirs: print(os.system(str(ex_path))) pass