Testing path to see if it exists in the focus option
193295
function( nspath ) {
		var found = true,
			nsparts = nspath.split( rpathsplit ),
			focus = render.options.focus;

		// Allow single path string
		if ( munit.isString( focus ) ) {
			focus = [ focus ];
		}

		// If set, only add modules that belong on the focus path(s)
		if ( munit.isArray( focus ) && focus.length ) {
			found = false;

			focus.forEach(function( fpath ) {
				var fparts = fpath.split( rpathsplit ),
					i = -1, l = Math.min( fparts.length, nsparts.length );

				// Check that each namespace of the focus path
				// exists inside the modules path
				for ( ; ++i < l; ) {
					if ( fparts[ i ] !== nsparts[ i ] ) {
						return;
					}
				}

				// Paths line up
				found = true;
			});
		}

		return found;
	}
305038
function moduleExistsAtPath(modPath) {
	for (var i = 0; i < CODE_EXTENSIONS.length; i += 1) {
		var fileName = 'index' + CODE_EXTENSIONS[i];
		var filePath = path.join(modPath, fileName);

		if (fs.existsSync(filePath)) {
			return true;
		}
	}

	return false;
}
780568
function resolvePath(path, options, callback) {
        if (!callback) {
            callback = options;
            options = {};
        }
        
        var alreadyRooted = options.alreadyRooted;
        var checkSymlinks = options.checkSymlinks === undefined 
            ? true : options.checkSymlinks;
        var isHome        = false;
        
        if (checkSymlinks === undefined)
            checkSymlinks = true;
        if (path.substr(0, 2) == "~/") {
            isHome = true;
            path = process.env.HOME + path.substr(1);
        }
        else if (!alreadyRooted) 
            path = join(root, path);

        if (checkSymlinks && fsOptions.checkSymlinks && !alreadyRooted) 
            fs.realpath(path, check);
        else check(null, path);

        function check(err, path) {
            if (err) return callback(err);
            
            if (!options.nocheck) {
                if (!(path === base || path.substr(0, root.length) === root)
                  && !isHome) {
                    err = new Error("EACCESS: '" + path + "' not in '" + root + "'");
                    err.code = "EACCESS";
                    return callback(err);
                }
            }
            callback(null, path);
        }
    }
389428
def check_existance(f):
    """"""
    if not opath.isfile(f):
        logging.error("Nanoget: File provided doesn't exist or the path is incorrect: {}".format(f))
        sys.exit("File provided doesn't exist or the path is incorrect: {}".format(f))
1339273
def _should_ignore(self, path):
        
        for ignore in self.options.ignores:
            if fnmatch.fnmatch(path, ignore):
                return True
        return False
901537
def assertpath(path_, msg='', **kwargs):
    
    if NO_ASSERTS:
        return
    if path_ is None:
        raise AssertionError('path is None! %s' % (path_, msg))
    if path_ == '':
        raise AssertionError('path=%r is the empty string! %s' % (path_, msg))
    if not checkpath(path_, **kwargs):
        raise AssertionError('path=%r does not exist! %s' % (path_, msg))
843472
function getExistsSync(path, exts) {
    for (var i=0,len=exts.length; i<len; i++) {
        if (fs.existsSync(path + exts[i])) {
            return path + exts[i];
        }
    }
    return false;
}
784763
function getIncludePath(path, options) {
  var includePath;
  var filePath;
  var views = options.views;

  // Abs path
  if (path.charAt(0) == '/') {
    includePath = exports.resolveInclude(path.replace(/^\/*/,''), options.root || '/', true);
  }
  // Relative paths
  else {
    // Look relative to a passed filename first
    if (options.filename) {
      filePath = exports.resolveInclude(path, options.filename);
      if (fs.existsSync(filePath)) {
        includePath = filePath;
      }
    }
    // Then look in any views directories
    if (!includePath) {
      if (Array.isArray(views) && views.some(function (v) {
        filePath = exports.resolveInclude(path, v, true);
        return fs.existsSync(filePath);
      })) {
        includePath = filePath;
      }
    }
    if (!includePath) {
      throw new Error('Could not find the include file "' +
          options.escapeFunction(path) + '"');
    }
  }
  return includePath;
}
449868
function checkPath(name, path) {
      helpers.exists(path, function (exist) {
        if (!exist) {
          callback(new Error(name + ' was not found (' + path + ')')); return;
        }
        progress.set(name);
      });
    }
416011
def check(self, init_if_missing=False):
        
        for d in self.path_overrides + [self.inputdir]:            
            if os.path.exists(d):
                self.allpaths.append(d)
        if len(self.allpaths) > 0:
            return(True)

        if init_if_missing:
            os.makedirs(self.inputdir)
            return True
166684
def exists(self, relpath, rsc=None, useFilepath=None):
        
        path = self.find(relpath, rsc, useFilepath)
        if path.startswith(':'):
            return QtCore.QResource(path).isValid()
        else:
            return os.path.exists(path)
210232
function lookup (path) {
  if (!path || typeof path !== 'string') {
    return false
  }

  // get the extension ("ext" or ".ext" or full path)
  var extension = extname('x.' + path)
    .toLowerCase()
    .substr(1)

  if (!extension) {
    return false
  }

  return exports.types[extension] || false
}
265058
function({options}, succeed, skip) {
    // Default to `options.target` if "true"
    if (typeof options.unless_exists === 'boolean' && options.target) {
      options.unless_exists = options.unless_exists ? [options.target] : null;
    }
    return each(options.unless_exists).call((unless_exists, next) => {
      return this.fs.exists({
        target: unless_exists
      }, (err, {exists}) => {
        if (exists) {
          this.log({
            message: `File exists ${unless_exists}, skipping`,
            level: 'INFO',
            module: 'nikita/misc/conditions'
          });
          return skip();
        } else {
          this.log({
            message: `File doesnt exists ${unless_exists}, continuing`,
            level: 'DEBUG',
            module: 'nikita/misc/conditions'
          });
          return next();
        }
      });
    }).next(succeed);
  }
1319371
def check_path(path, create=False):
    
    if not os.path.exists(path):
        if create:
            os.makedirs(path)
            return os.path.exists(path)
        else:
            return False

    return True
1139973
def exists(self, full_path):
        """"""
        if path.exists(self.new_path(full_path)):
            return self.new_path(full_path)
1077790
def __validate_and_fix_path(path, check_file=False, check_dir=False):
    """"""
    # pylint: disable=superfluous-parens
    if path is None:
        return path
    else:
        if not (os.path.isfile(path) if check_file else False) \
                and not (os.path.isdir(path) if check_dir else False):
            raise SystemExit('Path `%s` does not exist' % path)
        if not os.path.isabs(path):
            path = os.path.abspath(os.path.join(os.path.abspath(os.curdir), path))

    return path
865444
def _inform_if_path_does_not_exist(path):
    
    expanded_path = get_expanded_path(path)
    if not os.path.exists(expanded_path):
        print('Could not find custom path at: {}'.format(expanded_path))