Returns True if an item with this location is present as a multifile object without children.
        For this implementation, this means that there is a file with the appropriate name but without extension

        :param location:
        :return:
483464
def is_multifile_object_without_children(self, location: str) -> bool:
        
        # (1) Find the base directory and base name
        if isdir(location):  # special case: parent location is the root folder where all the files are.
            return len(self.find_multifile_object_children(location)) == 0
        else:
            # TODO same comment than in find_multifile_object_children
            if exists(location):
                # location is a file without extension. We can accept that as being a multifile object without children
                return True
            else:
                return False
209184
def is_dir_url(link):
    # type: (Link) -> bool
    
    link_path = url_to_path(link.url_without_fragment)
    return os.path.isdir(link_path)
417608
def is_file(self):
        
        if not isinstance(self.host_list, basestring):
            return False
        return os.path.exists(self.host_list)
237992
public boolean isDirectory() {
        if (this.file != null) {
            return this.file.isDirectory();
        }

        if (this.header != null) {
            if (this.header.linkFlag == TarHeader.LF_DIR) {
                return true;
            }

            if (this.header.name.toString().endsWith("/")) {
                return true;
            }
        }

        return false;
    }
577309
def has_open_file(self, file_object):
        
        return (file_object in [wrappers[0].get_object()
                                for wrappers in self.open_files if wrappers])
1102764
def _locate_file(f, base_dir):
    
    if base_dir == None:
        return f
    file_name = os.path.join(base_dir, f)
    real = os.path.realpath(file_name)
    #print_v('- Located %s at %s'%(f,real))
    return real
659742
def _copy_if_necessary(self, local_path, overwrite):
        
        local_path = abspath(local_path)
        if not exists(local_path):
            raise MissingLocalFile(local_path)
        elif not self.copy_local_files_to_cache:
            return local_path
        else:
            cached_path = self.cached_path(local_path)
            if exists(cached_path) and not overwrite:
                return cached_path
            copy2(local_path, cached_path)
            return cached_path
1205748
@Override
    public boolean hasLocation(JavaFileManager.Location location) {
        proc.debug(DBG_FMGR, "hasLocation: location: %s\n", location);
        return stdFileManager.hasLocation(location);
    }
432300
def isignored(self, relpath, directory=False):
    """"""
    relpath = self._relpath_no_dot(relpath)
    if directory:
      relpath = self._append_trailing_slash(relpath)
    return self.ignore.match_file(relpath)
772225
def has_ext(path_name, *, multiple=None, if_all_ext=False):
    
    base = os.path.basename(path_name)
    count = base.count(EXT)

    if not if_all_ext and base[0] == EXT and count != 0:
        count -= 1

    if multiple is None:
        return count >= 1
    elif multiple:
        return count > 1
    else:
        return count == 1
1308976
def is_file_excluded(filename, excludes):
    
    # check if you need to exclude this file
    return any([exclude and re.match(exclude, filename) is not None
                for exclude in excludes])
714169
def isFile(self):
        
        try:
            filetype = file
        except NameError:
            filetype = io.IOBase

        return self._wrap(type(self.obj) is filetype)
655701
def dir_has_index?(relative_path)
      relative_path << "/" unless relative_path.end_with? "/"
      regex = %r!^#{Regexp.escape(relative_path)}#{INDEX_REGEX}!i
      (site.pages + site.static_files).any? { |file| file.url =~ regex }
    end
1183880
def unpack_location(location):
    
    coordinates = None
    placeable = None
    if isinstance(location, Placeable):
        placeable, coordinates = location.top()

    elif isinstance(location, tuple):
        placeable, coordinates = location

    else:
        raise ValueError(
            'Location should be (Placeable, (x, y, z)) or Placeable'
        )
    return (placeable, Vector(coordinates))
994783
def _HasFile(self, file_name):
    """"""
    if self._zip:
      return file_name in self._zip.namelist()
    else:
      file_path = os.path.join(self._path, file_name)
      return os.path.exists(file_path) and os.path.isfile(file_path)
557220
def file_exists(self) -> bool:
        
        cfg_path = self.file_path
        assert cfg_path

        return path.isfile(cfg_path)
466046
public static boolean containsLogFiles(File location) {
        if (location == null) {
            return false;
        }

        location = checkKnownType(location);

        if (isFile(location)) {
            try {
                // Is a WBL file.
                if (new OneFileBrowserImpl(location).getProcessId() != null) {
                    return true;
                }
            } catch (IllegalArgumentException ex) {
                // Fall through, can't use as a WBL file.
            }
            return false;
        }

        if (location.isDirectory()) {
            // Contains WBL files.
            LogRepositoryBrowserImpl browser = new LogRepositoryBrowserImpl(location, new String[] { location.getName() });
            if (browser.findNext((File) null, -1) != null) {
                return true;
            }

            // Its directories contain WBL files
            File[] wblDirs = location.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    return pathname.isDirectory() && new LogRepositoryBrowserImpl(pathname, new String[] { pathname.getName() }).findNext((File) null, -1) != null;
                }
            });
            if (wblDirs.length > 0) {
                return true;
            }
        }

        for (File file : new File[] {
                                      location,
                                      getChild(location, LogRepositoryBrowserImpl.DEFAULT_LOCATION),
                                      getChild(location, LogRepositoryBrowserImpl.TRACE_LOCATION) }) {
            // Contains Instance directories
            if (file.isDirectory()) {
                MainLogRepositoryBrowserImpl fileBrowser = new MainLogRepositoryBrowserImpl(file);
                if (fileBrowser.findByMillis(-1) != null) {
                    return true;
                }
            }
        }

        return false;
    }