Beispiel #1
0
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)
Beispiel #2
0
 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)
Beispiel #3
0
    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"])
Beispiel #4
0
 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
Beispiel #5
0
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)
Beispiel #6
0
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
Beispiel #7
0
    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,
        )
Beispiel #10
0
    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
Beispiel #11
0
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)
Beispiel #12
0
    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"])
Beispiel #13
0
    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:]
        ]
Beispiel #14
0
    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":
Beispiel #15
0
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
Beispiel #16
0
    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":
Beispiel #17
0
    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
Beispiel #18
0
  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)
Beispiel #19
0
    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
Beispiel #20
0
    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,
        )
Beispiel #23
0
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
Beispiel #25
0
 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)
Beispiel #26
0
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()))
Beispiel #27
0
    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()
Beispiel #28
0
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 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"])
Beispiel #30
0
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")
Beispiel #31
0
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()
Beispiel #33
0
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
Beispiel #34
0
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();
Beispiel #35
0
    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
Beispiel #36
0
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()
    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
Beispiel #38
0
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)
Beispiel #40
0
    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
Beispiel #41
0
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")
Beispiel #42
0
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
Beispiel #43
0
 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)')
Beispiel #44
0
    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)
Beispiel #45
0
    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
Beispiel #46
0
    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
Beispiel #47
0
    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
Beispiel #48
0
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")
Beispiel #49
0
    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.")
Beispiel #51
0
    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
Beispiel #53
0
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!')
Beispiel #54
0
def xdg_cache_home():
    return os.path.join(GLib.get_user_cache_dir(), "flowblade")
Beispiel #55
0
# -*- 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/')
Beispiel #56
0
def xdg_cache_home(autocreate=True):
    """Get the Pitivi cache directory"""
    return get_dir(os.path.join(GLib.get_user_cache_dir(), "pitivi"), autocreate)