Python os.path() Examples
The following are 30
code examples of os.path().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
os
, or try the search function
.
Example #1
Source File: runtime.py From godot-mono-builds with MIT License | 9 votes |
def setup_runtime_cross_template(env: dict, opts: RuntimeOpts, product: str, target: str, host_triple: str, target_triple: str, device_target: str, llvm: str, offsets_dumper_abi: str): CONFIGURE_FLAGS = [ '--target=%s' % target_triple, '--with-cross-offsets=%s.h' % target_triple, '--with-llvm=%s/llvm-%s' % (opts.install_dir, llvm) ] env['_cross-runtime_%s-%s_CONFIGURE_FLAGS' % (product, target)] = CONFIGURE_FLAGS new_offsets_tool_path = '%s/mono/tools/offsets-tool/offsets-tool.py' % opts.mono_source_root old_offsets_tool_path = '%s/tools/offsets-tool-py/offsets-tool.py' % opts.mono_source_root old_offsets_tool = not os.path.isfile(new_offsets_tool_path) offsets_tool_env = None if old_offsets_tool: # Setup old offsets-tool-py if present (new location doesn't require setup) run_command('make', ['-C', '%s/tools/offsets-tool-py' % opts.mono_source_root, 'setup'], name='make offsets-tool-py') # Run offsets-tool in its virtual env virtualenv_vars = source('%s/tools/offsets-tool-py/offtool/bin/activate' % opts.mono_source_root) offsets_tool_env = os.environ.copy() offsets_tool_env.update(virtualenv_vars) build_dir = '%s/%s-%s-%s' % (opts.configure_dir, product, target, opts.configuration) mkdir_p(build_dir) run_command('python3', [ old_offsets_tool_path if old_offsets_tool else new_offsets_tool_path, '--targetdir=%s/%s-%s-%s' % (opts.configure_dir, product, device_target, opts.configuration), '--abi=%s' % offsets_dumper_abi, '--monodir=%s' % opts.mono_source_root, '--outfile=%s/%s.h' % (build_dir, target_triple) ] + env['_%s-%s_OFFSETS_DUMPER_ARGS' % (product, target)], env=offsets_tool_env, name='offsets-tool') # Runtime template setup_runtime_template(env, opts, product, target, host_triple)
Example #2
Source File: io.py From vergeml with MIT License | 7 votes |
def preview_filename(self, path): """Generate a filename for previews, appending a number when the file already exists. """ if not os.path.exists(path): return path pcounter = SourcePlugin._COUNTER if not path in pcounter: pcounter[path] = 1 fname, ext = os.path.splitext(path) counter = pcounter[path] while os.path.exists("{}_{}{}".format(fname, counter, ext)): counter += 1 pcounter[path] = counter return "{}_{}{}".format(fname, counter, ext)
Example #3
Source File: imagenet.py From vergeml with MIT License | 7 votes |
def predict(self, f, k=5, resize_mode='fill'): from keras.preprocessing import image from vergeml.img import resize_image filename = os.path.basename(f) if not os.path.exists(f): return dict(filename=filename, prediction=[]) img = image.load_img(f) img = resize_image(img, self.image_size, self.image_size, 'antialias', resize_mode) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = self.preprocess_input(x) preds = self.model.predict(x) pred = self._decode(preds, top=k)[0] prediction=[dict(probability=np.asscalar(perc), label=klass) for _, klass, perc in pred] return dict(filename=filename, prediction=prediction)
Example #4
Source File: os_utils.py From godot-mono-builds with MIT License | 6 votes |
def mkdir_p(path): if not os.path.exists(path): print('creating directory: ' + path) os.makedirs(path) # Remove files and/or directories recursively
Example #5
Source File: workflow.py From wechat-alfred-workflow with MIT License | 6 votes |
def cache_data(self, name, data): """Save ``data`` to cache under ``name``. If ``data`` is ``None``, the corresponding cache file will be deleted. :param name: name of datastore :param data: data to store. This may be any object supported by the cache serializer """ serializer = manager.serializer(self.cache_serializer) cache_path = self.cachefile('%s.%s' % (name, self.cache_serializer)) if data is None: if os.path.exists(cache_path): os.unlink(cache_path) self.logger.debug('deleted cache file: %s', cache_path) return with atomic_writer(cache_path, 'wb') as file_obj: serializer.dump(data, file_obj) self.logger.debug('cached data: %s', cache_path)
Example #6
Source File: env.py From vergeml with MIT License | 6 votes |
def _validate_split(self, project_dir): """Validate the split configuration for val and test. """ for split in ('val-split', 'test-split'): spltype, splval = parse_split(self._config[split]) if spltype == 'dir': # deal with relative paths path = os.path.join(project_dir, splval) if not os.path.isabs(splval) else splval if not os.path.exists(path): # raise if path does not exist msg = f"Invalid value for option {split} - no such directory: {splval}" suggestion = f"Please set {split} to a percentage, number or directory." raise VergeMLError(msg, suggestion, hint_key=split, hint_type='value', help_topic='split')
Example #7
Source File: imagenet.py From vergeml with MIT License | 6 votes |
def load(self, model_dir, architecture, image_size): from keras.models import load_model from vergeml.sources.features import get_preprocess_input labels_txt = os.path.join(model_dir, "labels.txt") if not os.path.exists(labels_txt): raise VergeMLError("labels.txt not found: {}".format(labels_txt)) model_h5 = os.path.join(model_dir, "model.h5") if not os.path.exists(model_h5): raise VergeMLError("model.h5 not found: {}".format(model_h5)) with open(labels_txt, "r") as f: self.labels = f.read().splitlines() self.model = load_model(model_h5) self.image_size = image_size self.preprocess_input = get_preprocess_input(architecture)
Example #8
Source File: workflow.py From wechat-alfred-workflow with MIT License | 6 votes |
def _delete_directory_contents(self, dirpath, filter_func): """Delete all files in a directory. :param dirpath: path to directory to clear :type dirpath: ``unicode`` or ``str`` :param filter_func function to determine whether a file shall be deleted or not. :type filter_func ``callable`` """ if os.path.exists(dirpath): for filename in os.listdir(dirpath): if not filter_func(filename): continue path = os.path.join(dirpath, filename) if os.path.isdir(path): shutil.rmtree(path) else: os.unlink(path) self.logger.debug('deleted : %r', path)
Example #9
Source File: env.py From vergeml with MIT License | 6 votes |
def _load_trained_model(self): """Load a trained models hyperparameters and results """ train_mod_path = os.path.join(self._config['trainings-dir'], self.trained_model) if not os.path.exists(train_mod_path): raise VergeMLError("Trained model not found: {}".format(self.trained_model)) # Merge data.yaml data_file = os.path.join(self._config['trainings-dir'], self.trained_model, 'data.yaml') if not os.path.exists(data_file): raise VergeMLError("data.yaml file not found for {}: {}".format( self.trained_model, data_file)) doc = load_yaml_file(data_file, 'data file') self._config.update({ 'hyperparameters': doc.get('hyperparameters', {}), 'results': doc.get('results', {}), 'model': doc.get('model') }) self.results = _Results(self, data_file) return data_file
Example #10
Source File: workflow.py From wechat-alfred-workflow with MIT License | 6 votes |
def cachedir(self): """Path to workflow's cache directory. The cache directory is a subdirectory of Alfred's own cache directory in ``~/Library/Caches``. The full path is: ``~/Library/Caches/com.runningwithcrayons.Alfred-X/Workflow Data/<bundle id>`` ``Alfred-X`` may be ``Alfred-2`` or ``Alfred-3``. :returns: full path to workflow's cache directory :rtype: ``unicode`` """ if self.alfred_env.get('workflow_cache'): dirpath = self.alfred_env.get('workflow_cache') else: dirpath = self._default_cachedir return self._create(dirpath)
Example #11
Source File: __init__.py From ALF with Apache License 2.0 | 6 votes |
def import_helper(): from os.path import dirname import imp possible_libs = ["_alf_grammar.win32", "_alf_grammar.ntoarm", "_alf_grammar.ntox86", "_alf_grammar.linux"] found_lib = False for i in possible_libs: fp = None try: fp, pathname, description = imp.find_module(i, [dirname(__file__)]) _mod = imp.load_module("_alf_grammar", fp, pathname, description) found_lib = True break except ImportError: pass finally: if fp: fp.close() if not found_lib: raise ImportError("Failed to load _alf_grammar module") return _mod
Example #12
Source File: unique_objects.py From vergeml with MIT License | 6 votes |
def __call__(self, args, env): samples_dir = env.get('samples-dir') print("Downloading unique objects to {}.".format(samples_dir)) src_dir = self.download_files([_URL], env=env, dir=env.get('cache-dir')) path = os.path.join(src_dir, "ObjectsAll.zip") zipf = zipfile.ZipFile(path, 'r') zipf.extractall(src_dir) zipf.close() for file in os.listdir(os.path.join(src_dir, "OBJECTSALL")): shutil.copy(os.path.join(src_dir, "OBJECTSALL", file), samples_dir) shutil.rmtree(src_dir) print("Finished downloading unique objects.")
Example #13
Source File: android.py From godot-mono-builds with MIT License | 6 votes |
def configure(opts: AndroidOpts, product: str, target: str): env = { 'ANDROID_API_VERSION': get_api_version_or_min(opts, target) } if is_cross(target): import llvm if is_cross_mxe(target): llvm.make(opts, 'llvmwin64') setup_android_cross_mxe_template(env, opts, target, host_arch='x86_64') else: llvm.make(opts, 'llvm64') setup_android_cross_template(env, opts, target, host_arch='x86_64') else: make_standalone_toolchain(opts, target, env['ANDROID_API_VERSION']) setup_android_target_template(env, opts, target) if not os.path.isfile(path_join(opts.mono_source_root, 'configure')): runtime.run_autogen(opts) runtime.run_configure(env, opts, product, target)
Example #14
Source File: cmd_utils.py From godot-mono-builds with MIT License | 6 votes |
def add_base_arguments(parser, default_help): import os from os.path import join as path_join home = os.environ.get('HOME') mono_sources_default = os.environ.get('MONO_SOURCE_ROOT', '') parser.add_argument('--verbose-make', action='store_true', default=False, help=default_help) # --jobs supports not passing an argument, in which case the 'const' is used, # which is the number of CPU cores on the host system. parser.add_argument('--jobs', '-j', nargs='?', const=str(os.cpu_count()), default='1', help=default_help) parser.add_argument('--configure-dir', default=path_join(home, 'mono-configs'), help=default_help) parser.add_argument('--install-dir', default=path_join(home, 'mono-installs'), help=default_help) if mono_sources_default: parser.add_argument('--mono-sources', default=mono_sources_default, help=default_help) else: parser.add_argument('--mono-sources', required=True) parser.add_argument('--mxe-prefix', default='/usr', help=default_help)
Example #15
Source File: os_utils.py From godot-mono-builds with MIT License | 6 votes |
def find_executable(name) -> str: is_windows = os.name == 'nt' windows_exts = os.environ['PATHEXT'].split(ENV_PATH_SEP) if is_windows else None path_dirs = os.environ['PATH'].split(ENV_PATH_SEP) search_dirs = path_dirs + [os.getcwd()] # cwd is last in the list for dir in search_dirs: path = os.path.join(dir, name) if is_windows: for extension in windows_exts: path_with_ext = path + extension if os.path.isfile(path_with_ext) and os.access(path_with_ext, os.X_OK): return path_with_ext else: if os.path.isfile(path) and os.access(path, os.X_OK): return path return ''
Example #16
Source File: features.py From vergeml with MIT License | 6 votes |
def get_custom_architecture(name, trainings_dir, output_layer): from keras.models import load_model, Model name = name.lstrip("@") model = load_model(os.path.join(trainings_dir, name, 'checkpoints', 'model.h5')) try: if isinstance(output_layer, int): layer = model.layers[output_layer] else: layer = model.get_layer(output_layer) except Exception: if isinstance(output_layer, int): raise VergeMLError(f'output-layer {output_layer} not found - model has only {len(model.layers)} layers.') else: candidates = list(map(lambda l: l.name, model.layers)) raise VergeMLError(f'output-layer named {output_layer} not found.', suggestion=did_you_mean(candidates, output_layer)) model = Model(inputs=model.input, outputs=layer.output) return model
Example #17
Source File: __init__.py From vergeml with MIT License | 6 votes |
def load_predictions(env, nclasses): path = os.path.join(env.stats_dir(), "predictions.csv") if not os.path.exists(path): raise FileExistsError(path) with open(path, newline='') as csvfile: y_score = [] y_test = [] csv_reader = csv.reader(csvfile, dialect="excel") for row in csv_reader: assert len(row) == nclasses * 2 y_score.append(list(map(float, row[:nclasses]))) y_test.append(list(map(float, row[nclasses:]))) y_score = np.array(y_score) y_test = np.array(y_test) return y_test, y_score
Example #18
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def clear_settings(self): """Delete workflow's :attr:`settings_path`.""" if os.path.exists(self.settings_path): os.unlink(self.settings_path) self.logger.debug('deleted : %r', self.settings_path)
Example #19
Source File: os_utils.py From godot-mono-builds with MIT License | 5 votes |
def xcrun_find_sdk(sdk_name): import subprocess xcrun_output = subprocess.check_output(['xcrun', '--sdk', sdk_name, '--show-sdk-path']).decode().strip() if xcrun_output.startswith('xcrun: error: SDK "%s" cannot be located' % sdk_name): return '' sdk_path = xcrun_output return sdk_path
Example #20
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def datafile(self, filename): """Path to ``filename`` in workflow's data directory. Return absolute path to ``filename`` within your workflow's :attr:`data directory <Workflow.datadir>`. :param filename: basename of file :type filename: ``unicode`` :returns: full path to file within data directory :rtype: ``unicode`` """ return os.path.join(self.datadir, filename)
Example #21
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def decode(self, text, encoding=None, normalization=None): """Return ``text`` as normalised unicode. If ``encoding`` and/or ``normalization`` is ``None``, the ``input_encoding``and ``normalization`` parameters passed to :class:`Workflow` are used. :param text: string :type text: encoded or Unicode string. If ``text`` is already a Unicode string, it will only be normalised. :param encoding: The text encoding to use to decode ``text`` to Unicode. :type encoding: ``unicode`` or ``None`` :param normalization: The nomalisation form to apply to ``text``. :type normalization: ``unicode`` or ``None`` :returns: decoded and normalised ``unicode`` :class:`Workflow` uses "NFC" normalisation by default. This is the standard for Python and will work well with data from the web (via :mod:`~workflow.web` or :mod:`json`). macOS, on the other hand, uses "NFD" normalisation (nearly), so data coming from the system (e.g. via :mod:`subprocess` or :func:`os.listdir`/:mod:`os.path`) may not match. You should either normalise this data, too, or change the default normalisation used by :class:`Workflow`. """ encoding = encoding or self._input_encoding normalization = normalization or self._normalizsation if not isinstance(text, unicode): text = unicode(text, encoding) return unicodedata.normalize(normalization, text)
Example #22
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def settings_path(self): """Path to settings file within workflow's data directory. :returns: path to ``settings.json`` file :rtype: ``unicode`` """ if not self._settings_path: self._settings_path = self.datafile('settings.json') return self._settings_path
Example #23
Source File: os_utils.py From godot-mono-builds with MIT License | 5 votes |
def globs(pathnames, dirpath='.'): import glob files = [] for pathname in pathnames: files.extend(glob.glob(os.path.join(dirpath, pathname))) return files
Example #24
Source File: os_utils.py From godot-mono-builds with MIT License | 5 votes |
def create_osxcross_wrapper(opts: RuntimeOpts, product: str, target: str, toolchain_path : str): # OSXCROSS toolchain executables use rpath to locate the toolchain's shared libraries. # However, when moving the toolchain without care, the rpaths can be broken. # Since fixing the rpaths can be tedious, we use this wrapper to override LD_LIBRARY_PATH. # The reason we don't just run configure and make with LD_LIBRARY_PATH is because # we want the resulting configuration to be independent from out python scripts. wrapper_src = """#!/bin/bash OSXCROSS_COMMAND=$1; shift; export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:%s"; ${OSXCROSS_COMMAND} "$@"; exit $?; """ % os.path.join(toolchain_path, 'lib') build_dir = os.path.join(opts.configure_dir, '%s-%s-%s' % (product, target, opts.configuration)) wrapper_path = os.path.join(build_dir, 'osxcross_cmd_wrapper.sh') mkdir_p(build_dir) with open(wrapper_path, 'w') as f: f.write(wrapper_src) chmod_plus_x(wrapper_path) return wrapper_path
Example #25
Source File: android.py From godot-mono-builds with MIT License | 5 votes |
def android_autodetect_cmake(opts: AndroidOpts) -> str: from distutils.version import LooseVersion from os import listdir sdk_cmake_basedir = path_join(opts.android_sdk_root, 'cmake') versions = [] for entry in listdir(sdk_cmake_basedir): if os.path.isdir(path_join(sdk_cmake_basedir, entry)): try: version = LooseVersion(entry) versions += [version] except ValueError: continue # Not a version folder if len(versions) == 0: raise BuildError('Cannot auto-detect Android CMake version') lattest_version = str(sorted(versions)[-1]) print('Auto-detected Android CMake version: ' + lattest_version) return lattest_version
Example #26
Source File: android.py From godot-mono-builds with MIT License | 5 votes |
def get_android_libclang_path(opts): if sys.platform == 'darwin': return '%s/toolchains/llvm/prebuilt/darwin-x86_64/lib64/libclang.dylib' % opts.android_ndk_root elif sys.platform in ['linux', 'linux2']: loc = '%s/toolchains/llvm/prebuilt/linux-x86_64/lib64/libclang.so.9svn' % opts.android_ndk_root if os.path.isfile(loc): return loc return '%s/toolchains/llvm/prebuilt/linux-x86_64/lib64/libclang.so.8svn' % opts.android_ndk_root assert False
Example #27
Source File: android.py From godot-mono-builds with MIT License | 5 votes |
def make_standalone_toolchain(opts: AndroidOpts, target: str, api: str): install_dir = path_join(opts.android_toolchains_prefix, opts.toolchain_name_fmt % (target, api)) if os.path.isdir(path_join(install_dir, 'bin')): return # Looks like it's already there, so no need to re-create it command = path_join(opts.android_ndk_root, 'build', 'tools', 'make_standalone_toolchain.py') args = ['--verbose', '--force', '--api=' + api, '--arch=' + AndroidTargetTable.archs[target], '--install-dir=' + install_dir] run_command(command, args=args, name='make_standalone_toolchain')
Example #28
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def workflowfile(self, filename): """Return full path to ``filename`` in workflow's root directory. :param filename: basename of file :type filename: ``unicode`` :returns: full path to file within data directory :rtype: ``unicode`` """ return os.path.join(self.workflowdir, filename)
Example #29
Source File: workflow.py From wechat-alfred-workflow with MIT License | 5 votes |
def start_update(self): """Check for update and download and install new workflow file. .. versionadded:: 1.9 See :ref:`guide-updates` in the :ref:`user-manual` for detailed information on how to enable your workflow to update itself. :returns: ``True`` if an update is available and will be installed, else ``False`` """ import update github_slug = self._update_settings['github_slug'] # version = self._update_settings['version'] version = str(self.version) if not update.check_update(github_slug, version, self.prereleases): return False from background import run_in_background # update.py is adjacent to this file update_script = os.path.join(os.path.dirname(__file__), b'update.py') cmd = ['/usr/bin/python', update_script, 'install', github_slug, version] if self.prereleases: cmd.append('--prereleases') self.logger.debug('downloading update ...') run_in_background('__workflow_update_install', cmd) return True #################################################################### # Keychain password storage methods ####################################################################
Example #30
Source File: os_utils.py From godot-mono-builds with MIT License | 5 votes |
def try_find_libclang(toolchain_path: str = '', llvm_config=''): import sys from subprocess import check_output hint_paths = [] if toolchain_path: libclang = os.path.join(toolchain_path, 'usr', 'lib', 'libclang.dylib') if os.path.isfile(libclang): print('Found libclang at: \'%s\'' % libclang) return libclang if not llvm_config: llvm_config = find_executable('llvm-config') if not llvm_config: print('WARNING: llvm-config not found') return '' elif not os.path.isfile(llvm_config): raise RuntimeError('Specified llvm-config file not found: \'%s\'' % llvm_config) llvm_libdir = check_output([llvm_config, '--libdir']).strip().decode('utf-8') if llvm_libdir: libsuffix = '.dylib' if sys.platform == 'darwin' else '.so' hints = ['libclang', 'clang'] libclang = next((p for p in [os.path.join(llvm_libdir, h + libsuffix) for h in hints] if os.path.isfile(p)), '') if libclang: print('Found libclang at: \'%s\'' % libclang) return libclang return ''