Python BaseDirectory.load_data_paths方法代码示例

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def _cache_database():
    global globs, magic, aliases, inheritance, _cache_uptodate

    _cache_uptodate = True

    aliases = {}  # Maps alias Mime types to canonical names
    inheritance = defaultdict(set)  # Maps to sets of parent mime types.

    # Load aliases
    for path in BaseDirectory.load_data_paths(os.path.join("mime", "aliases")):
        with open(path, "r") as f:
            for line in f:
                alias, canonical = line.strip().split(None, 1)
                aliases[alias] = canonical

    # Load filename patterns (globs)
    globs = GlobDB()
    for path in BaseDirectory.load_data_paths(os.path.join("mime", "globs2")):
        globs.merge_file(path)
    globs.finalise()

    # Load magic sniffing data
    magic = MagicDB()
    for path in BaseDirectory.load_data_paths(os.path.join("mime", "magic")):
        magic.merge_file(path)
    magic.finalise()

    # Load subclasses
    for path in BaseDirectory.load_data_paths(os.path.join("mime", "subclasses")):
        with open(path, "r") as f:
            for line in f:
                sub, parent = line.strip().split(None, 1)
                inheritance[sub].add(parent)

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def _cache_database():
    global exts, globs, literals, magic, aliases, inheritance, _cache_uptodate

    _cache_uptodate = True

    exts = {}       # Maps extensions to types
    globs = []      # List of (glob, type) pairs
    literals = {}   # Maps literal names to types
    aliases = {}    # Maps alias Mime types to canonical names
    inheritance = defaultdict(set) # Maps to sets of parent mime types.
    magic = MagicDB()

    def _import_glob_file(path):
        """Loads name matching information from a MIME directory."""
        with open(path) as f:
          for line in f:
            if line.startswith('#'): continue
            line = line[:-1]

            type_name, pattern = line.split(':', 1)
            mtype = lookup(type_name)

            if pattern.startswith('*.'):
                rest = pattern[2:]
                if not ('*' in rest or '[' in rest or '?' in rest):
                    if rest not in exts:
                        exts[rest] = mtype
                    continue
            if '*' in pattern or '[' in pattern or '?' in pattern:
                globs.append((pattern, mtype))
            else:
                literals[pattern] = mtype

    for path in BaseDirectory.load_data_paths(os.path.join('mime', 'globs')):
        _import_glob_file(path)
    for path in BaseDirectory.load_data_paths(os.path.join('mime', 'magic')):
        magic.mergeFile(path)

    # Sort globs by length
    globs.sort(key=lambda x: len(x[0]) )
    
    # Load aliases
    for path in BaseDirectory.load_data_paths(os.path.join('mime', 'aliases')):
        with open(path, 'r') as f:
            for line in f:
                alias, canonical = line.strip().split(None, 1)
                aliases[alias] = canonical
    
    # Load subclasses
    for path in BaseDirectory.load_data_paths(os.path.join('mime', 'subclasses')):
        with open(path, 'r') as f:
            for line in f:
                sub, parent = line.strip().split(None, 1)
                inheritance[sub].add(parent)

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
    def handler_manager(self, src=None):
        # Activate window of running instance, if any
        try:
            screen = Wnck.Screen.get_default()
            screen.force_update()
            for window in screen.get_windows():
                if window.get_class_instance_name() == "boincmgr":
                    window.activate(time.time())
                    return
        finally:
            window = None
            screen = None
            Wnck.shutdown()

        # Launch via desktop
        for desktop in xdg.load_data_paths(osp.join("applications", "boinc-manager.desktop")):
            Gio.DesktopAppInfo.new_from_filename(desktop).launch([], None)
            return

        # Launch via executable
        try:
            subprocess.Popen(["boincmgr"], cwd="/var/lib/boinc-client")
            return
        except OSError:
            pass

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def get_data_file(filename, package=PACKAGE_NAME):
	"""
	Return path to @filename if it exists
	anywhere in the data paths, else raise ResourceLookupError.
	"""
	data_paths = []
	try:
		from . import version_subst
	except ImportError:
		first_datadir = os.path.abspath("%s/../data" % (os.path.dirname(__file__)))
	else:
		first_datadir = os.path.join(version_subst.DATADIR, package)

	data_paths.append(first_datadir)
	for data_path in base.load_data_paths(package):
		if not data_path in data_paths:
			data_paths.append(data_path)

	for direc in data_paths:
		file_path = os.path.join(direc, filename)
		if os.path.exists(file_path):
			return file_path
	if package == PACKAGE_NAME:
		raise ResourceLookupError("Resource %s not found" % filename)
	else:
		raise ResourceLookupError("Resource %s in package %s not found" %
			(filename, package))

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
	def on_checkautostart_toggled(self, widget):
		KUPFER_DESKTOP = "kupfer.desktop"
		AUTOSTART_KEY = "X-GNOME-Autostart-enabled"
		autostart_dir = base.save_config_path("autostart")
		autostart_file = os.path.join(autostart_dir, KUPFER_DESKTOP)
		if not os.path.exists(autostart_file):
			desktop_files = list(base.load_data_paths("applications",
				KUPFER_DESKTOP))
			if not desktop_files:
				self.output_error("Installed kupfer desktop file not found!")
				return
			desktop_file_path = desktop_files[0]
			# Read installed file and modify it
			dfile = desktop.DesktopEntry(desktop_file_path)
			executable = dfile.getExec()
			## append no-splash
			if "--no-splash" not in executable:
				executable += " --no-splash"
			dfile.set("Exec", executable)
		else:
			dfile = desktop.DesktopEntry(autostart_file)
		activestr = str(bool(widget.get_active())).lower()
		self.output_debug("Setting autostart to", activestr)
		dfile.set(AUTOSTART_KEY, activestr)
		## remove the format specifiers
		executable = dfile.getExec().replace("%F", "")
		dfile.set("Exec", executable)
		dfile.write(filename=autostart_file)

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def get_runnable_entries():
    directories = list(BaseDirectory.load_data_paths('applications'))
    try:
        cachemt = path.getmtime(dmenu_cache)
    except FileNotFoundError:
        pass
    else:
        if all(path.getmtime(directory) <= cachemt
               for directory
               in directories):
            with suppress(EOFError):
                with open(dmenu_cache, 'rb') as fp:
                    while True:
                        yield pickle.load(fp)
            return
    yield from cacher(sorted((entry
                              for entry
                              in (DesktopEntry(path.join(dirpath, filename))
                                  for directory in directories
                                  for dirpath, _, filenames in walk(directory)
                                  for filename in filenames
                                  if filename.endswith('.desktop'))
                              if entry.getType() == 'Application' and
                                 entry.hasKey('Exec') and
                                 'true' not in {entry.getNoDisplay(),
                                                entry.getHidden()}),
                             key=lambda entry: entry.getName().casefold()))

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def get_last_end_date(workspace_id):
    """Retrieve the last "end date" (for report queries) for a workspace.

    :param workspace_id: ID of workspace to retrieve last end date for.
    :type workspace_id: str | int
    :return: Last used end date for the workspace or ``None`` if no end date has been stored yet.
    :rtype: None | datetime.datetime
    :raises OSError: If a data file exists, but cannot be read.
    :raises json.JSONDecodeError: If the data file is corrupt (contains invalid JSON data).
    :raises ValueError: If the data file is corrupt (contains invalid date which cannot be parsed).
    :raises OverflowError: If the data file is corrupt (contains invalid date which cannot be parsed).
    """
    # See http://stackoverflow.com/q/1450957
    workspace_id = str(workspace_id)

    for data_dir in BaseDirectory.load_data_paths(APP_SHORTNAME):
        path = os.path.join(data_dir, END_DATES_FILENAME)

        if not os.path.isfile(path):
            continue

        with open(path, "r") as fh:
            data = json.load(fh)

        if workspace_id in data:
            return dateutil.parser.parse(data[workspace_id])

            # Else try the next data file.

    # No data files yet.
    return None

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def _getXdgApplicationFiles():
	"""Provide a list of the application files, with full paths.
	Specification: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html"""
	files = []
	# Loop over the directories in $XDG_DATA_DIRS (essentially; see xdg doc)
	for directory in BaseDirectory.load_data_paths("applications"):
		files.extend([os.path.join(directory,filename) for filename in os.listdir(directory)])
	return files

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def get_previous_ads_file():
    folder = next(BaseDirectory.load_data_paths(DATA_FOLDER_NAME))
    files = sorted(os.listdir(folder), reverse=True)
    if len(files) == 0:
        return None

    newest_file = files[0]
    filepath = os.path.join(folder, newest_file)
    return filepath

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def find_desktop_entry(cmd):
    desktop_files = []
    desktop_dirs = list(BaseDirectory.load_data_paths('applications'))
    for d in desktop_dirs:
        desktop_files += [DesktopEntry.DesktopEntry(os.path.join(d, name)) for name in os.listdir(d) if name.endswith(".desktop")]

    matches = [entry for entry in desktop_files if cmd.lower() in entry.getName().lower()]

    return matches[0]

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def app_data_directory(name):
    '''
    Get the root application data directory.
    Look for sibling data folder to detect non installed run
    '''
    path = os.path.abspath(os.path.join(os.path.dirname(__file__),'..', 'data'))
    if (os.path.exists(path)):
        return path
    else:
        paths = BaseDirectory.load_data_paths(name)
        return paths[0]

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def getPrograms():
    return {
        desktop.getName() : desktop
        for desktop in (
            DesktopEntry(dfile)
            for dfile in itertools.chain(*(
                glob(os.path.join(path, '*.desktop'))
                for path in BaseDirectory.load_data_paths('applications')
            ))
        ) if not desktop.getHidden()
    }

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
 def _generic():
     entries = OrderedDict()
     seen = set()
     for mapps in itertools.chain(BaseDirectory.load_data_paths("applications/mimeapps.list"),
                                  BaseDirectory.load_data_paths("applications/defaults.list")):
         if mapps in seen:
             continue
         seen.add(mapps)
         with open(mapps) as mf:
             for l in mf:
                 if l.startswith(mimetype):
                     filenames = l.split("=")[1].strip().split(";")
                     for dfile in filenames:
                         if dfile:
                             dpath = BaseDirectory.load_data_paths("applications", dfile)
                             dpath = list(dpath)
                             if dpath:
                                 entry = DesktopEntry.DesktopEntry(dpath[0])
                                 entries[dfile] = entry
     return entries.values()

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
def getPrograms():
    return {
        name + ((" - " + generic) if generic else ""): desktop
        for name, generic, desktop in (
            (desktop.getName(), desktop.getGenericName(), desktop) for desktop in (
                DesktopEntry(dfile)
                for dfile in itertools.chain(*(
                    glob(os.path.join(path, '*.desktop'))
                    for path in BaseDirectory.load_data_paths('applications')
                ))
            ) if not desktop.getHidden()
        )
    }

# 需要导入模块: from xdg import BaseDirectory [as 别名]
# 或者: from xdg.BaseDirectory import load_data_paths [as 别名]
 def _load(self):
     "Loads comment for current language. Use get_comment() instead."
     resource = os.path.join('mime', self.media, self.subtype + '.xml')
     for path in BaseDirectory.load_data_paths(resource):
         doc = minidom.parse(path)
         if doc is None:
             continue
         for comment in doc.documentElement.getElementsByTagNameNS(FREE_NS, 'comment'):
             lang = comment.getAttributeNS(XML_NAMESPACE, 'lang') or 'en'
             goodness = 1 + (lang in xdg.Locale.langs)
             if goodness > self._comment[0]:
                 self._comment = (goodness, _get_node_data(comment))
             if goodness == 2: return