def xdg_cache_home(autocreate=True): """ Get the Pitivi cache directory """ default = os.path.join(GLib.get_user_cache_dir(), "pitivi") path = os.getenv("PITIVI_USER_CACHE_DIR", default) return get_dir(path, autocreate)
def setup_websettings(self): self.webview.props.full_content_zoom = True self.websettings = WebKit.WebSettings() self.websettings.props.html5_local_storage_database_path = \ get_or_create_directory(op.join( GLib.get_user_cache_dir(), 'fogger/%s/db' % self.app.uuid)) self.websettings.props.enable_accelerated_compositing = True self.websettings.props.enable_dns_prefetching = True self.websettings.props.enable_fullscreen = True self.websettings.props.enable_offline_web_application_cache = True self.websettings.props.javascript_can_open_windows_automatically = True self.websettings.props.enable_html5_database = True self.websettings.props.enable_html5_local_storage = True self.websettings.props.enable_hyperlink_auditing = False self.websettings.props.enable_file_access_from_file_uris = True self.websettings.props.enable_universal_access_from_file_uris = True self.websettings.props.enable_site_specific_quirks = True self.websettings.props.enable_spell_checking = True self.websettings.props.enable_webaudio = True self.websettings.props.enable_webgl = True self.websettings.props.enable_page_cache = True self.websettings.props.enable_plugins = True if logger.level == logging.DEBUG: self.websettings.props.enable_developer_extras = True self.webview.set_settings(self.websettings)
def _load_window_state(self): """Load window state from file. """ default_state = { "width": self.win_initial_width, "height": self.win_initial_height, "is_maximized": False, "selected_tab": "stack_id_1" } self.win_state_cache_file = os.path.join( GLib.get_user_cache_dir(), self._get_application_id(), "state.json") if os.path.isfile(self.win_state_cache_file): try: with open(self.win_state_cache_file) as state_file: state_data = json.loads(state_file.read()) except Exception as e: print(e) state_data = default_state else: state_data = default_state self.win_current_width = state_data.get("width", default_state["width"]) self.win_current_height = state_data.get("height", default_state["height"]) self.win_is_maximized = state_data.get("is_maximized", default_state["is_maximized"]) self.current_selected_tab = state_data.get("selected_tab", default_state["selected_tab"])
def setup_webkit_session(self): session = WebKit.get_default_session() cache = get_or_create_directory(op.join( GLib.get_user_cache_dir(), 'fogger', self.app.uuid)) cookie_jar = Soup.CookieJarText.new(op.join(cache, 'WebkitSession'), False) session.add_feature(cookie_jar) session.props.max_conns_per_host = 8
def get_user_icon(user): """Get icon location for user. Args: user (tweepy.models.User): Tweet user reference Returns: str: Location of the icon file """ if 'icon-static' not in Notify.get_server_caps(): return None cache_dir = '{}/bleeter'.format(GLib.get_user_cache_dir()) utils.mkdir(cache_dir) md5 = hashlib.md5(user.profile_image_url) # pylint: disable-msg=E1101 filename = '{}/{}'.format(cache_dir, md5.hexdigest()) if not os.path.exists(filename): try: # twitter results can be Unicode strings, urlretrieve won’t work # with them. urllib.urlretrieve(user.profile_image_url.encode('utf-8'), filename) except IOError: # Fallback to application icon if not os.path.exists('{}/bleeter.png'.format(cache_dir)): shutil.copy(utils.find_app_icon(uri=False), cache_dir) filename = '{}/bleeter.png'.format(cache_dir) icon = GdkPixbuf.Pixbuf.new_from_file(filename) if not (icon.get_width(), icon.get_height()) == (48, 48): icon = icon.scale_simple(48, 48, GdkPixbuf.InterpType.BILINEAR) icon.save(filename, 'png') return 'file://{}'.format(filename)
def xdg_cache_home(*subdirs): """Gets the Pitivi cache directory.""" default_base = os.path.join(GLib.get_user_cache_dir(), "pitivi") base = os.getenv("PITIVI_USER_CACHE_DIR", default_base) path = os.path.join(base, *subdirs) os.makedirs(path, exist_ok=True) return path
def setup_websettings(self): self.webview.props.full_content_zoom = True self.websettings = WebKit.WebSettings() self.websettings.props.html5_local_storage_database_path = \ get_or_create_directory(op.join( GLib.get_user_cache_dir(), 'fogger/%s/db' % self.app.uuid)) self.websettings.props.enable_accelerated_compositing = True self.websettings.props.enable_dns_prefetching = True self.websettings.props.enable_fullscreen = True self.websettings.props.enable_offline_web_application_cache = True self.websettings.props.javascript_can_open_windows_automatically = True self.websettings.props.enable_html5_database = True self.websettings.props.enable_html5_local_storage = True self.websettings.props.enable_hyperlink_auditing = False self.websettings.props.enable_file_access_from_file_uris = True self.websettings.props.enable_universal_access_from_file_uris = True self.websettings.props.enable_site_specific_quirks = True self.websettings.props.enable_spell_checking = True self.websettings.props.enable_webaudio = True self.websettings.props.enable_webgl = True self.websettings.props.enable_page_cache = True self.websettings.props.enable_plugins = True if logger.level == logging.DEBUG: self.websettings.props.enable_developer_extras = True # Change user-agent if USERAGENT environment variable is present. # e.g. add to launcher : # Exec=/usr/bin/env USERAGENT="iPad" /opt/extras.ubuntu.com/fogger/bin/fogger uuid useragent = os.getenv('USERAGENT') if useragent: self.websettings.set_property('user-agent', useragent) self.webview.set_settings(self.websettings)
def area(filename=None): """ Take a screen shot of an area and save it to a specific filename Using GNOME Shell Screenshot Interface. :param filename: output filename :type filename: str """ if not filename: filename = path.join(GLib.get_user_cache_dir(), path.basename(NamedTemporaryFile().name)) bus = Gio.bus_get_sync(Gio.BusType.SESSION, None) screen_proxy = Gio.DBusProxy.new_sync(bus, Gio.DBusProxyFlags.NONE, None, GNOMEScreenshot.interface, GNOMEScreenshot.path, GNOMEScreenshot.interface, None) x, y, width, height = screen_proxy.call_sync('SelectArea', None, Gio.DBusCallFlags.NONE, -1, None).unpack() args = GLib.Variant('(iiiibs)', (x, y, width, height, False, filename ) ) screenshot = screen_proxy.call_sync('ScreenshotArea', args, Gio.DBusCallFlags.NONE, -1, None) success, filename = screenshot.unpack() if success: return filename return None
def store_backup(self, gfile): cache_dir = os.path.join(GLib.get_user_cache_dir(), const.SHORT_NAME, "backup") if not os.path.exists(cache_dir): os.makedirs(cache_dir) current_time = GLib.DateTime.new_now_local().format("%F_%T") basename = os.path.splitext(gfile.get_basename())[0] backup_name = basename + "_backup_" + current_time + ".kdbx" backup = Gio.File.new_for_path(os.path.join(cache_dir, backup_name)) def callback(gfile, result): try: gfile.copy_finish(result) except GLib.Error as err: logging.warning("Could not save database backup: %s", err.message) gfile.copy_async( backup, Gio.FileCopyFlags.NONE, GLib.PRIORITY_DEFAULT, None, None, None, callback, )
def _save_selected_subtitle (self, filename=None): cursor = Gdk.Cursor.new (Gdk.CursorType.WATCH) self._dialog.get_window ().set_cursor (cursor) model, rows = self._tree_view.get_selection ().get_selected_rows () if rows: subtitle_iter = model.get_iter (rows[0]) subtitle_id = model.get_value (subtitle_iter, 3) subtitle_format = model.get_value (subtitle_iter, 1) if not filename: bpath = GLib.get_user_cache_dir() + sep bpath += 'xplayer' + sep directory = Gio.file_new_for_path (bpath + 'subtitles' + sep) if not directory.query_exists (None): directory.make_directory_with_parents (None); subtitle_file = Gio.file_new_for_path (self._filename) movie_name = subtitle_file.get_basename ().rpartition ('.')[0] filename = directory.get_uri () + sep filename += movie_name + '.' + subtitle_format thread = DownloadThread (self._model, subtitle_id) thread.start () GObject.idle_add (self._save_subtitles, thread, filename) self._progress.set_text (_(u'Downloading the subtitles…')) GLib.timeout_add (350, self._progress_bar_increment, thread) else: #warn user! pass
def _load_window_state(self): """Load window state from file. """ default_state = { "width": self.win_initial_width, "height": self.win_initial_height, "is_maximized": False, } self.win_state_cache_file = os.path.join(GLib.get_user_cache_dir(), APPLICATION_ID, "state.json") if os.path.isfile(self.win_state_cache_file): try: with open(self.win_state_cache_file, "r", encoding="UTF-8") as state_file: state_data = json.loads(state_file.read()) except Exception as e: print(e) state_data = default_state else: state_data = default_state self.win_current_width = state_data.get("width", default_state["width"]) self.win_current_height = state_data.get("height", default_state["height"]) self.win_is_maximized = state_data.get("is_maximized", default_state["is_maximized"])
def _clean_background_dir(self): cache_path = GLib.get_user_cache_dir() background_images_dir = os.path.join(cache_path, "com.endlessm.photos", "background_images") # If directory doesn't exist yet, just return. It will get created # when user first sets a background image if not os.path.isdir(background_images_dir): return files = os.listdir(background_images_dir) # Sort all background image filenames by last modified timestamp decorated = [ (filename, os.path.getmtime(os.path.join(background_images_dir, filename))) for filename in files ] sorted_files = sorted(decorated, key=lambda file_tuple: file_tuple[1], reverse=True) # Delete all background images except the most recent 5 [ os.remove(os.path.join(background_images_dir, filename[0])) for filename in sorted_files[5:] ]
def get_pix(self, filename, size=None): if filename is None: return None mimetype = mimetypes.guess_type(filename)[0] if mimetype is None or not mimetype.startswith("image/"): return None if filename not in self._data: self._data[filename] = {} if size in self._data[filename]: pix = self._data[filename][size] else: try: h = hashlib.sha1(('%f%s' % (os.path.getmtime(filename), filename)).encode()).hexdigest() tmp_cache_path = GLib.get_user_cache_dir() + '/cs_backgrounds/' if not os.path.exists(tmp_cache_path): os.mkdir(tmp_cache_path) cache_filename = tmp_cache_path + h + "v2" if os.path.exists(cache_filename): # load from disk cache try: with open(cache_filename, "r") as cache_file: pix = pickle.load(cache_file) tmp_img = Image.open(BytesIO(pix[0])) pix[0] = self._image_to_pixbuf(tmp_img) except Exception, detail: print "Failed to load cache file: %s: %s" % (cache_filename, detail) pix = None else: if mimetype == "image/svg+xml":
def get_issues_list(repository): """ Get a list of open issues on a repository. """ cache_dir = path.join(GLib.get_user_cache_dir(), "IconRequests", "") cache_file = path.join(cache_dir, "{0}.json".format(repository.replace("/", "-"))) if not path.exists(cache_dir): makedirs(cache_dir) issues_list = [] url_data = {"state": "open", "per_page": str(ISSUES_PER_PAGE), "page": "1"} base_uri = "https://api.github.com/repos/{0}/issues?".format(repository) for page in range(1, NB_PAGES + 1): url_data["page"] = str(page) try: query = requests.get(base_uri + urlencode(url_data)) issues_list.extend(query.json()) except requests.exceptions.ConnectionError: issues_list = [] break if len(issues_list) != 0 and not isinstance(issues_list[0], str): if path.exists(cache_file): remove(cache_file) with open(cache_file, 'w') as file_object: json.dump(issues_list, file_object, sort_keys=True, indent=4) file_object.close() else: if path.exists(cache_file): with open(cache_file, 'r') as file_object: issues_list = json.load(file_object) file_object.close() return issues_list
def get_pix(self, filename, size=None): if filename is None: return None mimetype = mimetypes.guess_type(filename)[0] if mimetype is None or not mimetype.startswith("image/"): return None if filename not in self._data: self._data[filename] = {} if size in self._data[filename]: pix = self._data[filename][size] else: try: h = hashlib.sha1(('%f%s' % (os.path.getmtime(filename), filename)).encode()).hexdigest() tmp_cache_path = GLib.get_user_cache_dir() + '/cs_backgrounds/' if not os.path.exists(tmp_cache_path): os.mkdir(tmp_cache_path) cache_filename = tmp_cache_path + h + "v2" if os.path.exists(cache_filename): # load from disk cache try: with open(cache_filename, "r") as cache_file: pix = pickle.load(cache_file) tmp_img = Image.open(BytesIO(pix[0])) pix[0] = self._image_to_pixbuf(tmp_img) except Exception, detail: print "Failed to load cache file: %s: %s" % ( cache_filename, detail) pix = None else: if mimetype == "image/svg+xml":
def area(filename: str = None) -> str: """ Take a screen shot of an area and save it to a specific filename Using GNOME Shell Screenshot Interface. :param filename: output filename :type filename: str """ if not filename: filename = path.join(GLib.get_user_cache_dir(), path.basename(NamedTemporaryFile().name)) bus = Gio.bus_get_sync(Gio.BusType.SESSION, None) screen_proxy = Gio.DBusProxy.new_sync(bus, Gio.DBusProxyFlags.NONE, None, GNOMEScreenshot.interface, GNOMEScreenshot.path, GNOMEScreenshot.interface, None) x, y, width, height = screen_proxy.call_sync('SelectArea', None, Gio.DBusCallFlags.NONE, -1, None).unpack() args = GLib.Variant('(iiiibs)', (x, y, width, height, False, filename ) ) screenshot = screen_proxy.call_sync('ScreenshotArea', args, Gio.DBusCallFlags.NONE, -1, None) success, filename = screenshot.unpack() return filename if success else None
def do_startup(self): Gtk.Application.do_startup(self) self.create_menu() mpd_host = os.getenv('MPD_HOST', 'localhost') parts = re.split('@', mpd_host, 2) if (len(parts) > 1): self.mpd_pass = parts[0] self.mpd_server = parts[1] else: self.mpd_pass = '' self.mpd_server = parts[0] self.mpd_port = os.getenv('MPD_PORT', 6600) self.mpd_stream_uri = 'http://' + self.mpd_server + ':' + str(self.mpd_port) + '/' self.mpc = MPDClient() self.mpc.timeout = 10 threading.Thread(target=self.connect).start() self.lastfm_key = os.getenv('LASTFM_KEY', 'e4dffe2a256bbd37e24ad001c36836a2') self.lastfm_secret = os.getenv('LASTFM_SECRET', '') self.cache_dir = os.path.join(GLib.get_user_cache_dir(), 'zmpc') if not os.path.exists(self.cache_dir): os.makedirs(self.cache_dir) self.stream = Stream(self.mpd_stream_uri)
def _save_selected_subtitle(self, filename=None): cursor = Gdk.Cursor.new(Gdk.CursorType.WATCH) self._dialog.get_window().set_cursor(cursor) model, rows = self._tree_view.get_selection().get_selected_rows() if rows: subtitle_iter = model.get_iter(rows[0]) subtitle_id = model.get_value(subtitle_iter, 3) subtitle_format = model.get_value(subtitle_iter, 1) if not filename: bpath = GLib.get_user_cache_dir() + sep bpath += 'xplayer' + sep directory = Gio.file_new_for_path(bpath + 'subtitles' + sep) if not directory.query_exists(None): directory.make_directory_with_parents(None) subtitle_file = Gio.file_new_for_path(self._filename) movie_name = subtitle_file.get_basename().rpartition('.')[0] filename = directory.get_uri() + sep filename += movie_name + '.' + subtitle_format thread = DownloadThread(self._model, subtitle_id) thread.start() GObject.idle_add(self._save_subtitles, thread, filename) self._progress.set_text(_(u'Downloading the subtitles…')) GLib.timeout_add(350, self._progress_bar_increment, thread) else: #warn user! pass
def __init__(self) -> None: self._paths = {} # type: Dict[str, PathTuple] self.profile = '' self.profile_separation = False self.custom_config_root = None # type: Optional[Path] if os.name == 'nt': if gajim.IS_PORTABLE: application_path = Path(sys.executable).parent self.config_root = self.cache_root = self.data_root = \ application_path.parent / 'UserData' else: # Documents and Settings\[User Name]\Application Data\Gajim self.config_root = self.cache_root = self.data_root = \ Path(os.environ['appdata']) / 'Gajim' else: self.config_root = Path(GLib.get_user_config_dir()) / 'gajim' self.cache_root = Path(GLib.get_user_cache_dir()) / 'gajim' self.data_root = Path(GLib.get_user_data_dir()) / 'gajim' import pkg_resources basedir = Path(pkg_resources.resource_filename("gajim", ".")) source_paths = [ ('DATA', basedir / 'data'), ('STYLE', basedir / 'data' / 'style'), ('EMOTICONS', basedir / 'data' / 'emoticons'), ('GUI', basedir / 'data' / 'gui'), ('ICONS', basedir / 'data' / 'icons'), ('HOME', Path.home()), ('PLUGINS_BASE', basedir / 'data' / 'plugins'), ] for path in source_paths: self.add(*path)
def __init__(self, scale=1): super().__init__() self._scale = scale self.cache_dir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cache_dir): try: Gio.file_new_for_path(self.cache_dir).make_directory(None) except Exception as err: logger.warn("Error: %s, %s", err.__class__, err) return Gst.init(None) self._discoverer = GstPbutils.Discoverer.new(Gst.SECOND) self._discoverer.connect('discovered', self._discovered_cb) self._discoverer.start() self._discoverer_items = {} self._media_art = None try: self._media_art = MediaArt.Process.new() except Exception as err: logger.warn("Error: %s, %s", err.__class__, err)
def __open_tmp_file(self, bytes_buffer, filename): cache_dir = os.path.join(GLib.get_user_cache_dir(), const.SHORT_NAME, "tmp") file_path = os.path.join(cache_dir, filename) window = self.__unlocked_database.window if not os.path.exists(cache_dir): os.makedirs(cache_dir) gfile = Gio.File.new_for_path(file_path) def callback(gfile, result): try: gfile.replace_contents_finish(result) except GLib.Error as err: logging.debug("Could not load attachment: %s", err.message) window.send_notification(_("Could not load attachment")) else: Gtk.show_uri(window, gfile.get_uri(), Gdk.CURRENT_TIME) contents = GLib.Bytes.new(bytes_buffer) gfile.replace_contents_bytes_async( contents, None, False, Gio.FileCreateFlags.PRIVATE | Gio.FileCreateFlags.REPLACE_DESTINATION, None, callback, )
def get_cache_dir(): cache_dir = os.path.join(GLib.get_user_cache_dir(), "cozy") if not os.path.exists(cache_dir): os.makedirs(cache_dir) return cache_dir
def get_data_file(): folder = os.path.join(GLib.get_user_cache_dir(), "photo-face-tagger") filepath = os.path.join(folder, "faces.db") try: os.makedirs(folder) except FileExistsError: pass return filepath
def _website_data_manager(self): from os import path as P print("Creating WebsiteDataManager...") app_id = self.application.get_application_id() cache_dir = P.join(GLib.get_user_cache_dir(), "revolt", app_id) data_dir = P.join(GLib.get_user_data_dir(), "revolt", app_id) return WebKit2.WebsiteDataManager(base_cache_directory=cache_dir, base_data_directory=data_dir)
def get_lockfile(name): cachedir = GLib.get_user_cache_dir() if not os.path.exists(cachedir): try: os.mkdir(cachedir) except OSError as e: if e.errno != errno.EEXIST: raise return os.path.join(cachedir, "%s-%s" % (name, os.getuid()))
def __init__(self, **kwargs): super().__init__(**kwargs) self.filename = Path(GLib.get_user_cache_dir()) self.filename = self.filename / CACHE_FILE self.settings = Gio.Settings.new('com.github.yursan9.Arkan') if self.filename.exists(): self._populate()
def cache_directory(self): """Get directory which contains Music private data. :returns: private store path :rtype: str """ return GLib.build_pathv( GLib.DIR_SEPARATOR_S, [GLib.get_user_cache_dir(), "gnome-music", "db"])
def xdg_get_cache_home(): if os.name == "nt": from gi.repository import GLib return glib2fsn(GLib.get_user_cache_dir()) data_home = os.getenv("XDG_CACHE_HOME") if data_home: return os.path.abspath(data_home) else: return os.path.join(os.path.expanduser("~"), ".cache")
def xdg_get_cache_home(): if os.name == "nt": from gi.repository import GLib return glib2fsnative(GLib.get_user_cache_dir()) data_home = os.getenv("XDG_CACHE_HOME") if data_home: return os.path.abspath(data_home) else: return os.path.join(os.path.expanduser("~"), ".cache")
def __init__(self): GObject.GObject.__init__(self) try: self.cacheDir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cacheDir): Gio.file_new_for_path(self.cacheDir).make_directory(None) except Exception as e: logger.warn("Error: %s", e) self.default_icon = DefaultIcon()
def get_cache_dir(): """ Creates the cache dir if it doesn't exist :return: The path to the own cache dir """ cache_dir = os.path.join(GLib.get_user_cache_dir(), "cozy") if not os.path.exists(cache_dir): os.makedirs(cache_dir) return cache_dir
def init(): program = 'hermelin' dirs["conf"] = os.path.join(GLib.get_user_config_dir(), program) dirs["db"] = os.path.join(dirs["conf"], 'db') dirs["cache"] = os.path.join(GLib.get_user_cache_dir(), program) dirs["avatar"] = os.path.join(dirs["cache"], 'avatar') dirs["data"] = [os.path.join(d, program) for d in ['/usr/local/share', '/usr/share', GLib.get_user_data_dir()]] dirs["data"].append(os.path.abspath('./data')) dirs["theme"] = os.path.join(dirs["conf"], 'theme') dirs["ext"] = os.path.join(dirs["conf"], 'ext') config = getconf();
def __init__(self, scale=1): GObject.GObject.__init__(self) self._scale = scale self.cache_dir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cache_dir): try: Gio.file_new_for_path(self.cache_dir).make_directory(None) except Exception as err: logger.warn("Error: %s, %s", err.__class__, err) return
def init(): program = "hotot" dirs["conf"] = os.path.join(GLib.get_user_config_dir(), program) dirs["db"] = os.path.join(dirs["conf"], "db") dirs["cache"] = os.path.join(GLib.get_user_cache_dir(), program) dirs["avatar"] = os.path.join(dirs["cache"], "avatar") dirs["data"] = [os.path.join(d, program) for d in ["/usr/local/share", "/usr/share", GLib.get_user_data_dir()]] dirs["data"].append(os.path.abspath("./data")) dirs["theme"] = os.path.join(dirs["conf"], "theme") dirs["ext"] = os.path.join(dirs["conf"], "ext") config = getconf()
class PixCache(object): def __init__(self): self._data = {} def get_pix(self, filename, size=None): try: mimetype = get_mimetype(filename) if not mimetype.startswith("image/"): print "Not trying to convert %s : not a recognized image file" % filename return None except Exception, detail: print "Failed to detect mimetype for %s: %s" % (filename, detail) return None if filename not in self._data: self._data[filename] = {} if size in self._data[filename]: pix = self._data[filename][size] else: try: h = hashlib.sha1(('%f%s' % (os.path.getmtime(filename), filename)).encode()).hexdigest() tmp_cache_path = GLib.get_user_cache_dir() + '/cs_backgrounds/' if not os.path.exists(tmp_cache_path): os.mkdir(tmp_cache_path) cache_filename = tmp_cache_path + h if os.path.exists(cache_filename): (width, height) = Image.open(filename).size else: if mimetype == "image/svg+xml": tmp_pix = GdkPixbuf.Pixbuf.new_from_file(filename) tmp_fp, tmp_filename = tempfile.mkstemp() os.close(tmp_fp) tmp_pix.savev(tmp_filename, "png", [], []) img = Image.open(tmp_filename) os.unlink(tmp_filename) else: img = Image.open(filename) img = apply_orientation(img) (width, height) = img.size if img.mode != 'RGB': img = img.convert('RGB') if size: img.thumbnail((size, size), Image.ANTIALIAS) img = imtools.round_image(img, {}, False, None, 3, 255) img = imtools.drop_shadow(img, 4, 4, background_color=(255, 255, 255, 0), shadow_color=0x444444, border=8, shadow_blur=3, force_background_color=False, cache=None) # Convert Image -> Pixbuf (save to file, GTK3 is not reliable for that) img.save(cache_filename, "png") pix = [GdkPixbuf.Pixbuf.new_from_file(cache_filename), width, height] except Exception, detail: print "Failed to convert %s: %s" % (filename, detail) pix = None if pix: self._data[filename][size] = pix
def __init__(self): GObject.GObject.__init__(self) try: self.cacheDir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cacheDir): Gio.file_new_for_path(self.cacheDir).make_directory(None) except Exception as e: logger.warn("Error: %s", e) # Prepare default icons self.make_default_icon(is_loading=False) self.make_default_icon(is_loading=True)
def __init__(self): super().__init__() # FIXME: async self.cache_dir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cache_dir): try: Gio.file_new_for_path(self.cache_dir).make_directory(None) except GLib.Error as error: logger.warning("Error: {}, {}".format(error.domain, error.message)) return
def init(): global _dot_dir, _xdg_config_dir, _xdg_data_dir, _xdg_cache_dir _dot_dir = os.getenv("HOME") + "/.flowblade/" _xdg_config_dir = os.path.join(GLib.get_user_config_dir(), "flowblade") _xdg_data_dir = os.path.join(GLib.get_user_data_dir(), "flowblade") _xdg_cache_dir = os.path.join(GLib.get_user_cache_dir(), "flowblade") global _xdg_prefs_file_exists, _dot_prefs_file_exists _dot_prefs_file_exists = os.path.exists(_dot_dir + "prefs") _xdg_prefs_file_exists = os.path.exists(_xdg_config_dir + "/prefs")
def init(): global _init_error force_dot_dir = False # Get user folder locations global _dot_dir, _xdg_config_dir, _xdg_data_dir, _xdg_cache_dir # Dot folder _dot_dir = os.getenv("HOME") + "/.flowblade/" # XDG folders _xdg_config_dir = os.path.join(GLib.get_user_config_dir(), "flowblade") _xdg_data_dir = os.path.join(GLib.get_user_data_dir(), "flowblade") _xdg_cache_dir = os.path.join(GLib.get_user_cache_dir(), "flowblade") # Testing print _xdg_config_dir print _xdg_data_dir print _xdg_cache_dir # Make sure XDG dirs data is available and usable by trying to create XDG folders try: _maybe_create_xdg_dirs() except Exception as e: _init_error = "Could not create XDG folders: " + str(e) force_dot_dir = True # Determine if this a clean install or do we need to copy files fron dot dir to XDG dirs # We think existance of prefs files will tell us what the state of the system is. _dot_prefs_file_exists = os.path.exists(_dot_dir + "prefs" ) _xdg_prefs_file_exists = os.path.exists(_xdg_config_dir + "/prefs") # If previous install exits and no data in XDG dirs, we need to copy existing data. if _dot_prefs_file_exists == True and _xdg_prefs_file_exists == False: print "userfolders.init(): .flowblade/ data exists, we need to copy to XDG folders." global _copy_needed _copy_needed = True else: print "XDG user data exists." # Set folders and maybe create them global _user_dirs # If we could not create XDG dirs, we will use dot dirs if force_dot_dir == True: print "userfolders.init(): UNABLE TO CREATE XDG FOLDERS! Usinf .flowblade dir forced!" global _dot_dir_was_forced _dot_dir_was_forced = True _user_dirs = USING_DOT_DIRS _maybe_create_dot_dirs() return #_user_dirs = USING_DOT_DIRS # Testing _user_dirs = USING_XDG_DIRS
def open(self): "Open the DB (if needed)" if self.db is None: doc_db_path = os.path.join(GLib.get_user_cache_dir(), 'gnome-builder', 'jedi', 'girdoc.db') try: os.makedirs(os.path.dirname(doc_db_path)) except: pass self.db = sqlite3.connect(doc_db_path) self.cursor = self.db.cursor() # Create the tables if they don't exist to prevent exceptions later on self.cursor.execute('CREATE TABLE IF NOT EXISTS doc (symbol text, library_version text, doc text, gir_file text)') self.cursor.execute('CREATE TABLE IF NOT EXISTS girfiles (file text, last_modified integer)')
def __init__(self): GObject.GObject.__init__(self) try: self.cacheDir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cacheDir): Gio.file_new_for_path(self.cacheDir).make_directory(None) except Exception as e: logger.warn("Error: %s", e) # Prepare default icons self.make_default_icon(is_loading=False) self.make_default_icon(is_loading=True) self.connect('thread-added', self.worker)
def __init__(self): self.logLookupErrors = False self.requested_uris = {} self.cacheDir = os.path.join(GLib.get_user_cache_dir(), "media-art") self._keybuilder_funcs = [ lambda artist, album: "album-" + self._normalize_and_hash(artist) + "-" + self._normalize_and_hash(album), lambda artist, album: "album-" + self._normalize_and_hash(album) + "-" + self._normalize_and_hash(None), ] try: Gio.file_new_for_path(self.cacheDir).make_directory(None) except: pass
def __init__(self): super().__init__() self._media_art = MediaArt.Process.new() # FIXME: async self.cache_dir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cache_dir): try: Gio.file_new_for_path(self.cache_dir).make_directory(None) except GLib.Error as error: logger.warning( "Error: {}, {}".format(error.domain, error.message)) return
def __init__(self): self.cache_path = GLib.get_user_cache_dir() + "/gnome-reader/" if not os.path.exists(self.cache_path): os.mkdir(self.cache_path) print(self.cache_path) self.name = "" # os.path.basename(file_path) self.file_path = "" self.opf_path = "" self.toc_path = "" self.chapters = {} self._loaded = False
def get_cache_dir(): ret = "" try: # We don't want to depend on glib for virt-install from gi.repository import GLib ret = GLib.get_user_cache_dir() except ImportError: pass if not ret: ret = os.environ.get("XDG_CACHE_HOME") if not ret: ret = os.path.expanduser("~/.cache") return os.path.join(ret, "virt-manager")
def __init__(self): try: self.cacheDir = os.path.join(GLib.get_user_cache_dir(), 'media-art') if not os.path.exists(self.cacheDir): Gio.file_new_for_path(self.cacheDir).make_directory(None) except Exception as e: logger.warn("Error: %s", e) try: self.thread_queue = Queue() for i in range(WORKER_THREADS): t = Thread(target=self.worker, args=(i,)) t.setDaemon(True) t.start() except Exception as e: logger.warn("Error: %s", e)
def __on_apply(self, *__): from ...models import BackupJSON try: paraphrase = self.paraphrase_widget.entry.get_text() if not paraphrase: paraphrase = " " output_file = path.join(GLib.get_user_cache_dir(), path.basename(NamedTemporaryFile().name)) status = GPG.get_default().decrypt_json(self._filename, paraphrase, output_file) if status.ok: BackupJSON.import_file(output_file) self.destroy() else: self.__send_notification(_("There was an error during the import of the encrypted file.")) except AttributeError: Logger.error("[GPG] Invalid JSON file.")
def load_contents_async_callback(self, file, result, data=None): try: success, contents, etag_out = file.load_contents_finish(result) except GLib.Error: self.clear_image() return if contents: cache_name = GLib.build_filenamev([GLib.get_user_cache_dir(), "cinnamon-screensaver-albumart-temp"]) cache_file = Gio.File.new_for_path(cache_name) cache_file.replace_contents_async(contents, None, False, Gio.FileCreateFlags.REPLACE_DESTINATION, self.cancellable, self.on_file_written)
def __init__(self): self.logLookupErrors = False self.requested_uris = {} self.cacheDir = os.path.join(GLib.get_user_cache_dir(), 'media-art') self.frame_cache = {} self.frame_lock = threading.Lock() self._keybuilder_funcs = [ lambda artist, album: 'album-%s-%s' % ( self._normalize_and_hash(artist), self._normalize_and_hash(album)), lambda artist, album: 'album-%s-%s' % ( self._normalize_and_hash(album), self._normalize_and_hash(None)) ] try: Gio.file_new_for_path(self.cacheDir).make_directory(None) except: pass
def find_app_icon(uri=True): """Find suitable bleeter application icon. Args: uri (bool): Return a URI for the path Returns: str: Path to the application icon """ icon_locations = [ '{}/bleeter.png'.format(os.path.abspath(sys.path[0])), '{}/bleeter/bleeter.png'.format(GLib.get_user_cache_dir()), '{}/share/pixmaps/bleeter.png'.format(sys.prefix), ] for icon in icon_locations: if os.path.exists(icon): return '{}{}'.format('file://' if uri else '', icon) raise EnvironmentError('Can’t find application icon!')
def xdg_cache_home(): return os.path.join(GLib.get_user_cache_dir(), "flowblade")
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*- ### BEGIN LICENSE # Copyright (C) 2012 Andrew Starr-Bochicchio <*****@*****.**> # This program is free software: you can redistribute it and/or modify it # under the terms of the GNU General Public License version 3, as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranties of # MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR # PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program. If not, see <http://www.gnu.org/licenses/>. ### END LICENSE import os from gi.repository import GLib homeDir = os.environ.get('HOME') confDir = os.path.join(GLib.get_user_config_dir(), 'typecatcher/') cacheDir = os.path.join(GLib.get_user_cache_dir(), 'typecatcher/') fontDir = os.path.join(homeDir, '.fonts/typecatcher/')
def xdg_cache_home(autocreate=True): """Get the Pitivi cache directory""" return get_dir(os.path.join(GLib.get_user_cache_dir(), "pitivi"), autocreate)