def gen_folder_listing(path):
l = os.listdir(path)
s = '<?xml version="1.0"?>\n<folder-listing>\n'
for i in l:
objpath = os.path.join(path, i)
if os.path.isdir(objpath):
args = (i, unix2bluetime(os.stat(objpath)[stat.ST_CTIME]))
s += ' <folder name="%s" created="%s" />' % args
else:
args = (i, unix2bluetime(os.stat(objpath)[stat.ST_CTIME]),
os.stat(objpath)[stat.ST_SIZE])
s += ' <file name="%s" created="%s" size="%s" />' % args
s += "</folder-listing>\n"
if sys.version_info.major < 3:
s = unicode(s)
return s
python类ST_CTIME的实例源码
def get_latest_h5(self):
dirpath = self.data_dir
entries1 = (os.path.join(dirpath, fn) for fn in os.listdir(dirpath)) # get all entries in the directory w/ stats
entries2 = ((os.stat(path), path) for path in entries1)
entries3 = ((stat[ST_CTIME], path) # leave only regular files, insert creation date
for stat, path in entries2 if S_ISREG(stat[ST_MODE]) and path[-4:]=='hdf5')
#NOTE: on Windows `ST_CTIME` is a creation date but on Unix it could be something else
#NOTE: use `ST_MTIME` to sort by a modification date
paths_sorted = []
for cdate, path in sorted(entries3):
paths_sorted.append(path)
#print time.ctime(cdate), os.path.basename(path)
if len(paths_sorted) > 0:
self.latest_h5_path = paths_sorted[-1]
if self.verbose:
print('This simulations has been analyzed, latest data in ' + self.latest_h5_path)
else:
self.latest_h5_path = None
if self.verbose:
print('This simulation has never been analyzed')
def updateDisplay(self, file_list):
""""""
for path in file_list:
file_stats = os.stat(path)
creation_time = time.strftime(
"%m/%d/%Y %I:%M %p",
time.localtime(file_stats[stat.ST_CTIME]))
modified_time = time.strftime(
"%m/%d/%Y %I:%M %p",
time.localtime(file_stats[stat.ST_MTIME]))
file_size = file_stats[stat.ST_SIZE]
if file_size > 1024:
file_size = file_size / 1024.0
file_size = "%.2f KB" % file_size
self.file_list.append(FileInfo(path,
creation_time,
modified_time,
file_size))
self.olv.SetObjects(self.file_list)
def getctime(self):
st = self.statinfo
if not st:
self.restat()
st = self.statinfo
return st[ST_CTIME]
def get_file_info(system, path, verbose=False):
fullpath = get_fullpath(system, path)
if fullpath == IO_ERROR:
return IO_ERROR
result = {}
if system.startswith('/'): # local or sub
if can_read(system, path):
# TODO platform-specific
stats = os.stat(fullpath)
stm = stats.st_mode
result['type'] = get_file_type_char(stat.S_IFMT(stm))
result['permissions'] = '%o' % (stat.S_IMODE(stm))
result['UID'] = stats[stat.ST_UID]
result['GID'] = stats[stat.ST_GID]
result['ATIME'] = stats[stat.ST_ATIME]
result['MTIME'] = stats[stat.ST_MTIME]
result['CTIME'] = stats[stat.ST_CTIME] # actually mtime on UNIX, TODO
else:
if verbose:
log.info('File \'%s\' is not accessible.' % (fullpath))
result['type'] = None
result['permissions'] = None
result['UID'] = None
result['GID'] = None
result['ATIME'] = None
result['MTIME'] = None
result['CTIME'] = None
return result
else: # SSH/FTP/TFTP/HTTP
# TODO NOT IMPLEMENTED
return IO_ERROR
def _set_owls_eagle(self):
self.dimensionality = 3
self.refine_by = 2
self.parameters["HydroMethod"] = "sph"
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
self._unit_base = self._get_uvals()
self._unit_base['cmcm'] = 1.0 / self._unit_base["UnitLength_in_cm"]
self.current_redshift = self.parameters["Redshift"]
self.omega_lambda = self.parameters["OmegaLambda"]
self.omega_matter = self.parameters["Omega0"]
self.hubble_constant = self.parameters["HubbleParam"]
if self.domain_left_edge is None:
self.domain_left_edge = np.zeros(3, "float64")
self.domain_right_edge = np.ones(
3, "float64") * self.parameters["BoxSize"]
nz = 1 << self.over_refine_factor
self.domain_dimensions = np.ones(3, "int32") * nz
self.cosmological_simulation = 1
self.periodicity = (True, True, True)
prefix = os.path.abspath(
os.path.join(os.path.dirname(self.parameter_filename),
os.path.basename(self.parameter_filename).split(".", 1)[0]))
suffix = self.parameter_filename.rsplit(".", 1)[-1]
if self.parameters["NumFiles"] > 1:
self.filename_template = "%s.%%(num)i.%s" % (prefix, suffix)
else:
self.filename_template = self.parameter_filename
self.file_count = self.parameters["NumFilesPerSnapshot"]
def _parse_parameter_file(self):
# Read all parameters.
simu = self._read_log_simu()
param = self._read_parameter()
# Set up general information.
self.filename_template = self.parameter_filename
self.file_count = 1
self.parameters.update(param)
self.particle_types = ('halos')
self.particle_types_raw = ('halos')
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
# Set up geometrical information.
self.refine_by = 2
self.dimensionality = 3
nz = 1 << self.over_refine_factor
self.domain_dimensions = np.ones(self.dimensionality, "int32") * nz
self.domain_left_edge = np.array([0.0, 0.0, 0.0])
# Note that boxsize is in Mpc but particle positions are in kpc.
self.domain_right_edge = np.array([simu['boxsize']] * 3) * 1000
self.periodicity = (True, True, True)
# Set up cosmological information.
self.cosmological_simulation = 1
self.current_redshift = param['z']
self.omega_lambda = simu['lambda0']
self.omega_matter = simu['omega0']
cosmo = Cosmology(self.hubble_constant,
self.omega_matter, self.omega_lambda)
self.current_time = cosmo.hubble_time(param['z']).in_units('s')
def _parse_parameter_file(self):
with open(self.parameter_filename, "rb") as f:
hvals = fpu.read_cattrs(f, header_dt)
hvals.pop("unused")
self.dimensionality = 3
self.refine_by = 2
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
prefix = ".".join(self.parameter_filename.rsplit(".", 2)[:-2])
self.filename_template = "%s.%%(num)s%s" % (prefix, self._suffix)
self.file_count = len(glob.glob(prefix + ".*" + self._suffix))
# Now we can set up things we already know.
self.cosmological_simulation = 1
self.current_redshift = (1.0 / hvals['scale']) - 1.0
self.hubble_constant = hvals['h0']
self.omega_lambda = hvals['Ol']
self.omega_matter = hvals['Om']
cosmo = Cosmology(self.hubble_constant,
self.omega_matter, self.omega_lambda)
self.current_time = cosmo.hubble_time(self.current_redshift).in_units("s")
self.periodicity = (True, True, True)
self.particle_types = ("halos")
self.particle_types_raw = ("halos")
self.domain_left_edge = np.array([0.0,0.0,0.0])
self.domain_right_edge = np.array([hvals['box_size']] * 3)
nz = 1 << self.over_refine_factor
self.domain_dimensions = np.ones(3, "int32") * nz
self.parameters.update(hvals)
def _parse_parameter_file(self):
"""
Parses the parameter file and establishes the various
dictionaries.
"""
self._parse_header_file()
# Let's read the file
hfn = os.path.join(self.output_dir, 'Header')
self.unique_identifier = int(os.stat(hfn)[ST_CTIME])
# the 'inputs' file is now optional
self._parse_cparams()
self._parse_fparams()
def getctime(self):
st = self.statinfo
if not st:
self.restat()
st = self.statinfo
return st[ST_CTIME]
def add_file(self, filepath, misc_prop=None):
"""Manually add files to the files list, and get all its file
properties.
Keyword arguments:
filepath -- path to file
misc_prop -- add a miscellaneous property
"""
if not os.path.isfile(filepath):
print(filepath + " is not a file.")
return
fp_rel = filepath[self.__path_len:]
try:
stat = os.stat(filepath)
except:
return
file_props = {}
file_props['size'] = stat[ST_SIZE]
file_props['adate'] = stat[ST_ATIME]
file_props['mdate'] = stat[ST_MTIME]
file_props['cdate'] = stat[ST_CTIME]
file_props['name'] = fp_rel
file_props['fullpath'] = filepath
file_props['misc'] = misc_prop
self.__files.append(file_props)
self.__filecount += 1
def fileDetails(file):
name = os.path.basename(file)
f_stat = os.stat(file)
size = f_stat[stat.ST_SIZE]
ctime = f_stat[stat.ST_CTIME]
md5sum = ""
return (name, size, ctime, md5sum)
def add_file(self, filepath, misc_prop=None):
"""Add a file to the file repo.
Keyword arguments:
filepath -- path to file
misc_props -- string to add as a 'misc' property to file
"""
if not path.isfile(filepath):
print(filepath + " is not a file.")
exit(1)
fp_rel = filepath[self.__path_len:]
try:
filestat = stat(filepath)
except:
return
file_props = {}
file_props['size'] = filestat[ST_SIZE]
file_props['adate'] = filestat[ST_ATIME]
file_props['mdate'] = filestat[ST_MTIME]
file_props['cdate'] = filestat[ST_CTIME]
file_props['name'] = fp_rel
file_props['fullpath'] = filepath
file_props['misc'] = misc_prop
self.__file_list.append(file_props)
self.__filecount += 1
def path_copy(Oldpath,Newpath):
os.chdir(Oldpath)
fromdir = Oldpath
todir = Newpath
for root,dirs,files in os.walk(fromdir):
for filename in files:
path=os.path.join(root,filename)
shutil.copyfile(path,'%s/%s'%(todir,filename))
#stat1=os.stat(os.path.join(fromdir,filename))
#os.utime(os.path.join(todir,filename),(stat1[ST_CTIME], stat1[ST_MTIME]))
return True
def file_info (self, file_name=""):
if file_name != "":
file_stats = os.stat(file_name)
# create a dictionary to hold file info
file_info = {
'fname': file_name,
'fsize': file_stats[stat.ST_SIZE],
'f_lm': time.strftime("%d/%m/%Y %I:%M:%S %p", time.localtime(file_stats[stat.ST_MTIME])),
'f_la': time.strftime("%d/%m/%Y %I:%M:%S %p", time.localtime(file_stats[stat.ST_ATIME])),
'f_ct': time.strftime("%d/%m/%Y %I:%M:%S %p", time.localtime(file_stats[stat.ST_CTIME]))
}
print
print("file name = %(fname)s" % file_info)
print("file size = %(fsize)s bytes" % file_info)
print("last modified = %(f_lm)s" % file_info)
print("last accessed = %(f_la)s" % file_info)
print("creation time = %(f_ct)s" % file_info)
print
if stat.S_ISDIR(file_stats[stat.ST_MODE]):
print("This a directory")
else:
print("This is not a directory")
print
print("A closer look at the os.stat(%s) tuple:" % file_name)
print(file_stats)
print
print("The above tuple has the following sequence:")
print("""st_mode (protection bits), st_ino (inode number),
st_dev (device), st_nlink (number of hard links),
st_uid (user ID of owner), st_gid (group ID of owner),
st_size (file size, bytes), st_atime (last access time, seconds since epoch),
st_mtime (last modification time), st_ctime (time of creation, Windows)""")
else:
print("No File Detected , hence Exiting !")
def _parse_parameter_file(self):
self.refine_by = 2
with h5py.File(self.parameter_filename, "r") as f:
for key in f.attrs.keys():
v = parse_h5_attr(f, key)
if key == "con_args":
v = v.astype("str")
self.parameters[key] = v
self._with_parameter_file_open(f)
# if saved, restore unit registry from the json string
if "unit_registry_json" in self.parameters:
self.unit_registry = UnitRegistry.from_json(
self.parameters["unit_registry_json"])
# reset self.arr and self.quan to use new unit_registry
self._arr = None
self._quan = None
for dim in ["length", "mass", "pressure",
"temperature", "time", "velocity"]:
cu = "code_" + dim
if cu not in self.unit_registry:
self.unit_registry.add(
cu, 1.0, getattr(dimensions, dim))
if "code_magnetic" not in self.unit_registry:
self.unit_registry.add("code_magnetic", 1.0,
dimensions.magnetic_field)
# if saved, set unit system
if "unit_system_name" in self.parameters:
unit_system = self.parameters["unit_system_name"]
del self.parameters["unit_system_name"]
else:
unit_system = "cgs"
# reset unit system since we may have a new unit registry
self._assign_unit_system(unit_system)
# assign units to parameters that have associated unit string
del_pars = []
for par in self.parameters:
ustr = "%s_units" % par
if ustr in self.parameters:
if isinstance(self.parameters[par], np.ndarray):
to_u = self.arr
else:
to_u = self.quan
self.parameters[par] = to_u(
self.parameters[par], self.parameters[ustr])
del_pars.append(ustr)
for par in del_pars:
del self.parameters[par]
for attr in self._con_attrs:
setattr(self, attr, self.parameters.get(attr))
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
def _parse_parameter_file(self):
"""
Parses the parameter file and establishes the various
dictionaries.
"""
f = open(self.parameter_filename, "r")
# get dimension from first block name
b0, fn0 = f.readline().strip().split()
level0, left0, right0 = get_block_info(b0, min_dim=0)
root_blocks = get_root_blocks(b0)
f.close()
self.dimensionality = left0.size
self.periodicity = \
ensure_tuple(np.ones(self.dimensionality, dtype=bool))
fh = h5py.File(os.path.join(self.directory, fn0), "r")
self.domain_left_edge = fh.attrs["lower"]
self.domain_right_edge = fh.attrs["upper"]
# all blocks are the same size
ablock = fh[list(fh.keys())[0]]
self.current_time = ablock.attrs["time"][0]
gsi = ablock.attrs["enzo_GridStartIndex"]
gei = ablock.attrs["enzo_GridEndIndex"]
self.ghost_zones = gsi[0]
self.root_block_dimensions = root_blocks
self.active_grid_dimensions = gei - gsi + 1
self.grid_dimensions = ablock.attrs["enzo_GridDimension"]
self.domain_dimensions = root_blocks * self.active_grid_dimensions
fh.close()
self.periodicity += (False, ) * (3 - self.dimensionality)
# WIP hard-coded for now
self.refine_by = 2
self.cosmological_simulation = 0
self.gamma = 5. / 3.
self.particle_types = ()
self.particle_types_raw = self.particle_types
self.unique_identifier = \
str(int(os.stat(self.parameter_filename)[stat.ST_CTIME]))
def _parse_parameter_file(self):
if self.parameter_filename.startswith("http"):
sdf_class = HTTPSDFRead
else:
sdf_class = SDFRead
self.sdf_container = sdf_class(self.parameter_filename,
header=self.sdf_header)
# Reference
self.parameters = self.sdf_container.parameters
self.dimensionality = 3
self.refine_by = 2
try:
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
except:
self.unique_identifier = time.time()
if self.domain_left_edge is None or self.domain_right_edge is None:
R0 = self.parameters['R0']
if 'offset_center' in self.parameters and self.parameters['offset_center']:
self.domain_left_edge = np.array([0, 0, 0], dtype=np.float64)
self.domain_right_edge = np.array([
2.0 * self.parameters.get("R%s" % ax, R0) for ax in 'xyz'],
dtype=np.float64)
else:
self.domain_left_edge = np.array([
-self.parameters.get("R%s" % ax, R0) for ax in 'xyz'],
dtype=np.float64)
self.domain_right_edge = np.array([
+self.parameters.get("R%s" % ax, R0) for ax in 'xyz'],
dtype=np.float64)
self.domain_left_edge *= self.parameters.get("a", 1.0)
self.domain_right_edge *= self.parameters.get("a", 1.0)
nz = 1 << self.over_refine_factor
self.domain_dimensions = np.ones(3, "int32") * nz
if "do_periodic" in self.parameters and self.parameters["do_periodic"]:
self.periodicity = (True, True, True)
else:
self.periodicity = (False, False, False)
self.cosmological_simulation = 1
self.current_redshift = self.parameters.get("redshift", 0.0)
self.omega_lambda = self.parameters["Omega0_lambda"]
self.omega_matter = self.parameters["Omega0_m"]
if "Omega0_fld" in self.parameters:
self.omega_lambda += self.parameters["Omega0_fld"]
if "Omega0_r" in self.parameters:
# not correct, but most codes can't handle Omega0_r
self.omega_matter += self.parameters["Omega0_r"]
self.hubble_constant = self.parameters["h_100"]
self.current_time = units_2HOT_v2_time * self.parameters.get("tpos", 0.0)
mylog.info("Calculating time to be %0.3e seconds", self.current_time)
self.filename_template = self.parameter_filename
self.file_count = 1
def _parse_parameter_file(self):
self._determine_structure()
self._determine_axes()
if self.parameter_filename.startswith("InMemory"):
self.unique_identifier = time.time()
else:
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
# Determine dimensionality
self.dimensionality = self.naxis
self.geometry = "cartesian"
# Sometimes a FITS file has a 4D datacube, in which case
# we take the 4th axis and assume it consists of different fields.
if self.dimensionality == 4:
self.dimensionality = 3
self._determine_wcs()
self.domain_dimensions = np.array(self.dims)[:self.dimensionality]
if self.dimensionality == 2:
self.domain_dimensions = np.append(self.domain_dimensions,
[int(1)])
domain_left_edge = np.array([0.5]*3)
domain_right_edge = np.array([float(dim)+0.5 for dim in self.domain_dimensions])
if self.dimensionality == 2:
domain_left_edge[-1] = 0.5
domain_right_edge[-1] = 1.5
self.domain_left_edge = domain_left_edge
self.domain_right_edge = domain_right_edge
# Get the simulation time
try:
self.current_time = self.parameters["time"]
except:
mylog.warning("Cannot find time")
self.current_time = 0.0
pass
# For now we'll ignore these
self.periodicity = (False,)*3
self.current_redshift = self.omega_lambda = self.omega_matter = \
self.hubble_constant = self.cosmological_simulation = 0.0
self._determine_nprocs()
# Now we can set up some of our parameters for convenience.
for k, v in self.primary_header.items():
self.parameters[k] = v
# Remove potential default keys
self.parameters.pop('', None)
def _parse_parameter_file(self):
handle = h5py.File(self.parameter_filename, mode="r")
hvals = {}
hvals.update((str(k), v) for k, v in handle["/Header"].attrs.items())
hvals["NumFiles"] = hvals["NumFilesPerSnapshot"]
hvals["Massarr"] = hvals["MassTable"]
self.dimensionality = 3
self.refine_by = 2
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
# Set standard values
self.current_time = self.quan(hvals["Time_GYR"], "Gyr")
self.domain_left_edge = np.zeros(3, "float64")
self.domain_right_edge = np.ones(3, "float64") * hvals["BoxSize"]
nz = 1 << self.over_refine_factor
self.domain_dimensions = np.ones(3, "int32") * nz
self.cosmological_simulation = 1
self.periodicity = (True, True, True)
self.current_redshift = hvals["Redshift"]
self.omega_lambda = hvals["OmegaLambda"]
self.omega_matter = hvals["Omega0"]
self.hubble_constant = hvals["HubbleParam"]
self.parameters = hvals
prefix = os.path.abspath(
os.path.join(os.path.dirname(self.parameter_filename),
os.path.basename(self.parameter_filename).split(".", 1)[0]))
suffix = self.parameter_filename.rsplit(".", 1)[-1]
self.filename_template = "%s.%%(num)i.%s" % (prefix, suffix)
self.file_count = len(glob.glob(prefix + "*" + self._suffix))
if self.file_count == 0:
raise YTException(message="No data files found.", ds=self)
self.particle_types = ("FOF", "SUBFIND")
self.particle_types_raw = ("FOF", "SUBFIND")
# To avoid having to open files twice
self._unit_base = {}
self._unit_base.update(
(str(k), v) for k, v in handle["/Units"].attrs.items())
handle.close()
def _parse_parameter_file(self):
self.unique_identifier = \
int(os.stat(self.parameter_filename)[stat.ST_CTIME])
# code-specific parameters
for t in self._handle['Info']:
info_category = self._handle['Info'][t]
for v in info_category.dtype.names: self.parameters[v] = info_category[v]
# shortcut for self.parameters
parameters = self.parameters
# reset 'Model' to be more readable
if parameters['Model'] == 1:
parameters['Model'] = 'Hydro'
elif parameters['Model'] == 2:
parameters['Model'] = 'MHD'
elif parameters['Model'] == 3:
parameters['Model'] = 'ELBDM'
else:
parameters['Model'] = 'Unknown'
# simulation time and domain
self.current_time = parameters['Time'][0]
self.dimensionality = 3 # always 3D
self.domain_left_edge = np.array([0.,0.,0.], dtype='float64')
self.domain_right_edge = parameters['BoxSize'].astype('float64')
self.domain_dimensions = parameters['NX0'].astype('int64')
# periodicity
periodic = parameters['Opt__BC_Flu'][0] == 0
self.periodicity = (periodic,periodic,periodic)
# cosmological parameters
if parameters['Comoving']:
self.cosmological_simulation = 1
self.current_redshift = 1.0/self.current_time - 1.0
self.omega_matter = parameters['OmegaM0']
self.omega_lambda = 1.0 - self.omega_matter
# default to 0.7 for old data format
self.hubble_constant = parameters.get('Hubble0', 0.7)
else:
self.cosmological_simulation = 0
self.current_redshift = 0.0
self.omega_matter = 0.0
self.omega_lambda = 0.0
self.hubble_constant = 0.0
# make aliases to some frequently used variables
if parameters['Model'] == 'Hydro' or parameters['Model'] == 'MHD':
self.gamma = parameters["Gamma"]
# default to 0.6 for old data format
self.mu = parameters.get('MolecularWeight', 0.6)
# old data format (version < 2210) does not contain any information of code units
self.parameters.setdefault('Opt__Unit', 0)
def make_file_dict_python(filename):
"""Create the data dictionary using a Python call to os.lstat
We do this on Windows since Python's implementation is much better
than the one in cmodule.c Eventually, we will move to using
this on all platforms since CPUs have gotten much faster than
they were when it was necessary to write cmodule.c
"""
try:
statblock = os.lstat(filename)
except os.error:
return {'type':None}
data = {}
mode = statblock[stat.ST_MODE]
if stat.S_ISREG(mode): type_ = 'reg'
elif stat.S_ISDIR(mode): type_ = 'dir'
elif stat.S_ISCHR(mode):
type_ = 'dev'
s = statblock.st_rdev
data['devnums'] = ('c',) + (s >> 8, s & 0xff)
elif stat.S_ISBLK(mode):
type_ = 'dev'
s = statblock.st_rdev
data['devnums'] = ('b',) + (s >> 8, s & 0xff)
elif stat.S_ISFIFO(mode): type_ = 'fifo'
elif stat.S_ISLNK(mode):
type_ = 'sym'
data['linkname'] = os.readlink(filename)
elif stat.S_ISSOCK(mode): type_ = 'sock'
else: raise C.UnknownFileError(filename)
data['type'] = type_
data['size'] = statblock[stat.ST_SIZE]
data['perms'] = stat.S_IMODE(mode)
data['uid'] = statblock[stat.ST_UID]
data['gid'] = statblock[stat.ST_GID]
data['inode'] = statblock[stat.ST_INO]
data['devloc'] = statblock[stat.ST_DEV]
data['nlink'] = statblock[stat.ST_NLINK]
if os.name == 'nt':
global type
if type(filename) == unicode:
attribs = win32file.GetFileAttributesW(filename)
else:
attribs = win32file.GetFileAttributes(filename)
if attribs & winnt.FILE_ATTRIBUTE_REPARSE_POINT:
data['type'] = 'sym'
data['linkname'] = None
if not (type_ == 'sym' or type_ == 'dev'):
# mtimes on symlinks and dev files don't work consistently
data['mtime'] = long(statblock[stat.ST_MTIME])
data['atime'] = long(statblock[stat.ST_ATIME])
data['ctime'] = long(statblock[stat.ST_CTIME])
return data
def scan_files(self, recursive=True):
"""Scans the directory for files and populates the files list and
linebs. It is not a particularly fast implementation.
Keyword arguments:
recursive -- define whether scan should be recursive or not
(default True)
"""
self.__filecount = 0
self.__files = []
if recursive:
for root, dirs, files in os.walk(self.__path, topdown=True):
for name in files:
fp = os.path.join(root, name)
fp_rel = fp[self.__path_len:]
if (fp_rel[0] == '.'):
continue
try:
stat = os.stat(fp)
except:
continue
file_props = {}
file_props['size'] = stat[ST_SIZE]
file_props['adate'] = stat[ST_ATIME]
file_props['mdate'] = stat[ST_MTIME]
file_props['cdate'] = stat[ST_CTIME]
file_props['name'] = fp_rel
file_props['fullpath'] = fp
file_props['misc'] = None
self.__files.append(file_props)
self.__filecount += 1
else:
for f in os.scandir(self.__path):
fp_rel = f.name
fp = os.path.join(self.__path, fp_rel)
if (fp_rel[0] == '.'):
continue
if f.is_dir():
continue
#try:
# stat = os.stat(fp)
#except:
# continue
file_props = {}
file_props['size'] = f.stat()[ST_SIZE]
file_props['adate'] = f.stat()[ST_ATIME]
file_props['mdate'] = f.stat()[ST_MTIME]
file_props['cdate'] = f.stat()[ST_CTIME]
file_props['name'] = fp_rel
file_props['fullpath'] = fp
file_props['misc'] = None
self.__files.append(file_props)
self.__filecount += 1
def scan_files(self):
"""Scans the directory for files and populates the file list and
linebs.
"""
self.__filecount = 0
self.__pfilecount = 0
pintot = len(self.__pinned_filenames)
if pintot != 0:
temp_pinned_filenames = list(self.__pinned_filenames)
else:
temp_pinned_filenames = False
for root, dirs, files in walk(self.__path, topdown=True):
for name in files:
fp = path.join(root, name)
fp_rel = fp[self.__path_len:]
if (fp_rel[0] == '.'):
continue
try:
filestat = stat(fp)
except:
continue
file_props = {}
file_props['size'] = filestat[ST_SIZE]
file_props['adate'] = filestat[ST_ATIME]
file_props['mdate'] = filestat[ST_MTIME]
file_props['cdate'] = filestat[ST_CTIME]
file_props['name'] = fp_rel
file_props['fullpath'] = fp
file_props['misc'] = None
file_props['tags'] = None
if temp_pinned_filenames:
if name in temp_pinned_filenames:
temp_pinned_filenames.remove(name)
self.__pfile_list.append(file_props)
self.__pfilecount += 1
continue
self.__file_list.append(file_props)
self.__filecount += 1
continue
# if name in self.pinned_filenames:
# self.__pfile_list.append(file_props)
# self.__pfilecount += 1
# else:
# self.__file_list.append(file_props)
# self.__filecount += 1
self.__file_list.append(file_props)
self.__filecount += 1
