def got_account_cb (o, r, password, func): account = o.create_account_finish (r) # Put the password in our credentials store try: os.makedirs (os.path.join (GLib.get_user_config_dir (), "phoenix")) except: pass authfile = os.path.join (GLib.get_user_config_dir (), "phoenix", "auth") f = open (authfile, "a+") f.write (account.get_path_suffix() + " " + password + "\n") func(account)
def __checkbutton_auto_start_toggled_cb(self, button): auto_start_dir = path.join(GLib.get_user_config_dir(), "autostart") if not path.isdir(auto_start_dir): os.makedirs(auto_start_dir) link_file = path.join(GLib.get_user_config_dir(), "autostart/ibus.desktop") ibus_desktop = path.join(os.getenv("IBUS_PREFIX"), "share/applications/ibus.desktop") # unlink file try: os.unlink(link_file) except: pass if self.__checkbutton_auto_start.get_active(): os.symlink(ibus_desktop, link_file)
def _show_warning_dialog(self): """Shows a warning dialog it this is the first time the extension is used, and returns True if the user has pressed OK.""" # Check if this is the first time the extension is used conf_dir = GLib.get_user_config_dir() # get "~/.config" path conf_file = os.path.join(conf_dir, ".nautilus-admin-warn-shown") if os.path.exists(conf_file): return True else: # Show the warning dialog self._setup_gettext(); dialog = Gtk.MessageDialog(self.window, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK_CANCEL, gettext("CAUTION!")) msg = gettext("Running the File Manager or the Text Editor with Administrator " "privileges <b>is dangerous</b>! <b>You can easily destroy your " "system if you are not careful!</b>\n" "Proceed only if you know what you are doing and understand the risks.") dialog.format_secondary_markup(msg) response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.OK: # Mark the dialog as shown try: if not os.path.isdir(conf_dir): os.makedirs(conf_dir) open(conf_file, "w").close() # create an empty file except: pass return True else: return False
def on_add_app(self, popup): app_dialog = AppChooserDialog() app_dialog.set_transient_for(self.list_box.get_toplevel()) app_dialog.show_all() response = app_dialog.run() if response == Gtk.ResponseType.OK: selected_app = app_dialog.get_selected_app() desktop_file_dir = selected_app.get_filename() desktop_file_name = self.find_free_basename(os.path.basename(desktop_file_dir)) if desktop_file_name is None: return user_autostart_dir = os.path.join(GLib.get_user_config_dir(), "autostart") user_desktop_file = os.path.join(user_autostart_dir, desktop_file_name) try: shutil.copyfile(desktop_file_dir, user_desktop_file) except IOError: print "Failed to copy desktop file %s" % desktop_file_name app = AutostartApp(user_desktop_file, user_position=os.path.dirname(user_desktop_file)) app.enabled = True app.save_mask.add_item("all") app.queue_save() row = AutostartRow(app) self.add_row(row) row.show_all() app_dialog.destroy()
def ensure_user_autostart_dir(self): user_autostart_dir = os.path.join(GLib.get_user_config_dir(), "autostart") if not os.path.isdir(user_autostart_dir): try: os.makedirs(user_autostart_dir) except: print "Could not create autostart dir: %s" % user_autostart_dir
def xdg_config_home(autocreate=True): """ Get the directory for storing the user's pitivi configuration """ default = os.path.join(GLib.get_user_config_dir(), "pitivi") path = os.getenv("PITIVI_USER_CONFIG_DIR", default) return get_dir(path, autocreate)
def import_old_xml_store(self): import xml.etree.ElementTree as et userdir = os.getenv('GNOME22_USER_DIR') if userdir: filename = os.path.join(userdir, 'gedit/gedit-tools.xml') else: filename = os.path.join(GLib.get_user_config_dir(), 'gedit/gedit-tools.xml') if not os.path.isfile(filename): return print("External tools: importing old tools into the new store...") xtree = et.parse(filename) xroot = xtree.getroot() for xtool in xroot: for i in self.tree.tools: if i.name == xtool.get('label'): tool = i break else: tool = Tool(self.tree) tool.name = xtool.get('label') tool.autoset_filename() self.tree.tools.append(tool) tool.comment = xtool.get('description') tool.shortcut = xtool.get('accelerator') tool.applicability = xtool.get('applicability') tool.output = xtool.get('output') tool.input = xtool.get('input') tool.save_with_script(xtool.text)
def getConfigFile(self): try: from gi.repository import GLib configdirs = [GLib.get_user_config_dir()] + GLib.get_system_config_dirs() for configdir in configdirs: config = os.path.join(configdir, 'mtsend', 'mtsend.ini') print("Looking for configuration file %s" % config) if os.path.exists(config): break assert(os.path.exists(config)) except: try: config = os.path.join(os.environ['XDG_CONFIG_HOME'], 'mtsend', 'mtsend.ini'); print("Looking for configuration file %s" % config) assert(os.path.exists(config)); except: try: config = os.path.join(os.environ['HOME'], '.config', 'mtsend', 'mtsend.ini') print("Looking for configuration file %s" % config) assert(os.path.exists(config)); except: try: config = os.path.join(os.environ['HOME'], '.mtsendrc') print("Looking for configuration file %s" % config) assert(os.path.exists(config)) except: config = 'mtsend.ini' print("Looking for configuration file %s" % config) if os.access(config, os.R_OK): print("Using configuration file %s" % config) else: raise Exception('Configuration file doesn\'t exist or is not readable') return config
def check_backend(): force_ini = os.path.exists(os.path.join(GLib.get_user_config_dir(), "meld", "use-rc-prefs")) if force_ini: # TODO: Use GKeyfileSettingsBackend once available (see bgo#682702) print("Using a flat-file settings backend is not yet supported") return None return None
def __init__(self, appinfo, autostart_desktop_filename="", exec_cmd="", extra_exec_args=""): if appinfo: self._desktop_file = appinfo.get_filename() self._autostart_desktop_filename = autostart_desktop_filename or os.path.basename(self._desktop_file) self._create_file = False elif autostart_desktop_filename: self._desktop_file = None self._autostart_desktop_filename = autostart_desktop_filename self._create_file = True else: raise Exception("Need either an appinfo or a file name") self._exec_cmd = exec_cmd self._extra_exec_args = " %s\n" % extra_exec_args user_autostart_dir = os.path.join(GLib.get_user_config_dir(), "autostart") if not os.path.isdir(user_autostart_dir): try: os.makedirs(user_autostart_dir) except: logging.critical("Could not create autostart dir: %s" % user_autostart_dir) self._user_autostart_file = os.path.join(user_autostart_dir, self._autostart_desktop_filename) if self._desktop_file: logging.debug("Found desktop file: %s" % self._desktop_file) logging.debug("User autostart desktop file: %s" % self._user_autostart_file)
def do_gtk_bookmarks(self): if self.showGTKBookmarks: bookmarksFile = os.path.join(GLib.get_user_config_dir(), "gtk-3.0", "bookmarks") if not os.path.exists(bookmarksFile): bookmarksFile = os.path.join(GLib.get_home_dir(), ".gtk-bookmarks") if not os.path.exists(bookmarksFile): return bookmarks = [] with open(bookmarksFile, "r") as f: for line in f: #line = line.replace('file://', '') line = line.rstrip() if not line: continue parts = line.split(' ', 1) if len(parts) == 2: path, name = parts elif len(parts) == 1: path = parts[0] name = os.path.basename(os.path.normpath(path)) bookmarks.append((name, path)) for name, path in bookmarks: name = unquote(name) currentbutton = easyButton("folder", self.iconsize, [name], -1, -1) currentbutton.connect("clicked", self.launch_gtk_bookmark, path) currentbutton.show() self.placesBtnHolder.pack_start(currentbutton, False, False, 0)
def get_config_dir(): """ Returns ~/.config, %APPDATA% or whatever has user set as configuration directory. """ if is_portable(): return os.environ["XDG_CONFIG_HOME"] if IS_WINDOWS and not IS_XP: try: import windows return windows.get_unicode_home() except Exception: pass confdir = GLib.get_user_config_dir() if confdir is None or IS_XP: if IS_WINDOWS: if "LOCALAPPDATA" in os.environ: # W7 and later confdir = os.environ["LOCALAPPDATA"] elif "APPDATA" in os.environ: # XP from ctypes import cdll os_encoding = 'cp' + str(cdll.kernel32.GetACP()) confdir = os.environ["APPDATA"].decode(os_encoding) else: # 95? :D confdir = os.path.expanduser("~/.config") else: # Linux confdir = os.path.expanduser("~/.config") return confdir
def __init__(self): GObject.GObject.__init__(self) self.icons = {} self.count = 0 # Some apps don't put a default icon in the default theme folder, so we will search all themes # def createTheme(d): # theme = Gtk.IconTheme() # theme.set_custom_theme(d) # return theme # This takes to much time and there are only a very few applications that use icons from different themes #self.themes = map( createTheme, [d for d in os.listdir("/usr/share/icons") if os.path.isdir(os.path.join("/usr/share/icons", d))]) self.defaultTheme = Gtk.IconTheme.get_default() #defaultKdeTheme = createTheme("kde.default") # Setup and clean up the temp icon dir configDir = GLib.get_user_config_dir() self.iconDir = os.path.join(configDir, "mintmenu") if not os.path.exists(self.iconDir): os.makedirs(self.iconDir) contents = os.listdir(self.iconDir) for fn in contents: os.remove(os.path.join(self.iconDir, fn)) self.defaultTheme.append_search_path(self.iconDir) # Themes with the same content as the default them aren't needed #self.themes = [theme for theme in self.themes if theme.list_icons() != defaultTheme.list_icons()] #self.themes = [self.defaultTheme, defaultKdeTheme] self.themes = [self.defaultTheme]
def __init__(self, **kwargs): super(HistoryCombo, self).__init__(**kwargs) if sys.platform == "win32": pref_dir = os.path.join(os.getenv("APPDATA"), "Meld") else: pref_dir = os.path.join(GLib.get_user_config_dir(), "meld") if not os.path.exists(pref_dir): os.makedirs(pref_dir) self.history_file = os.path.join(pref_dir, "history.ini") self.config = configparser.RawConfigParser() if os.path.exists(self.history_file): self.config.read(self.history_file) self.set_model(Gtk.ListStore(str, str)) rentext = Gtk.CellRendererText() rentext.props.width_chars = 60 rentext.props.ellipsize = Pango.EllipsizeMode.END self.pack_start(rentext, True) self.add_attribute(rentext, 'text', 0) self.connect('notify::history-id', lambda *args: self._load_history()) self.connect('notify::history-length', lambda *args: self._load_history())
def get_autostart(filename, defaults=None): if not defaults: defaults = {} autostart = os.path.join(GLib.get_user_config_dir(), 'autostart') if not os.path.exists(autostart): os.makedirs(autostart) keyfile = GLib.KeyFile.new() dirs = [autostart] for directory in (GLib.get_system_config_dirs()): dirs.append(os.path.join(directory, 'autostart')) try: keyfile.load_from_dirs(filename, dirs, GLib.KeyFileFlags.KEEP_TRANSLATIONS) except GLib.Error: pass for key in defaults.keys(): try: if keyfile.get_value("Desktop Entry", key) is None: keyfile.set_value("Desktop Entry", key, defaults[key]) except GLib.Error: keyfile.set_value("Desktop Entry", key, defaults[key]) return keyfile
def set_locations(self, datadir): self.locations = [] if platform.platform() != 'Windows': for d in self.get_xdg_data_dirs(): self.locations.append(os.path.join(d, 'gedit', 'plugins', 'externaltools', 'tools')) self.locations.append(datadir) # self.locations[0] is where we save the custom scripts if platform.platform() == 'Windows': toolsdir = os.path.expanduser('~/gedit/tools') else: userdir = os.getenv('GNOME22_USER_DIR') if userdir: toolsdir = os.path.join(userdir, 'gedit/tools') else: toolsdir = os.path.join(GLib.get_user_config_dir(), 'gedit/tools') self.locations.insert(0, toolsdir); if not os.path.isdir(self.locations[0]): os.makedirs(self.locations[0]) self.tree = ToolDirectory(self, '') self.import_old_xml_store() else: self.tree = ToolDirectory(self, '')
def do_activate(self): if platform.platform() == 'Windows': userdir = os.path.expanduser('~/gedit/latex') else: userdir = os.path.join(GLib.get_user_config_dir(), 'gedit/latex') #check if running from srcdir and if so, prefer that for all data files me = os.path.realpath(os.path.dirname(__file__)) if os.path.exists(os.path.join(me, "..", "configure.ac")): sysdir = os.path.abspath(os.path.join(me, "..", "data")) else: sysdir = self.plugin_info.get_data_dir() Resources().set_dirs(userdir, sysdir) #The following is needed to support gedit 3.12 new menu api. #It adds menus and shortcuts here. #Actions and toolbar construction are still done in windowactivatable.py. self._tool_preferences = ToolPreferences() self._tool_preferences.connect("tools-changed", self._on_tools_changed) self.add_latex_menu() self.add_latex_tools_menu() self.init_tools()
def save(self): if self.user_equals_system(): old_app = self.app self.app = os.path.join(self.system_position, self.basename) os.remove(old_app) self.key_file = GLib.KeyFile.new() if self.key_file.load_from_file(self.app, KEYFILE_FLAGS): self.load() self.save_done_success() return False try: key_file = GLib.KeyFile.new() if self.user_position == None: self.user_position = os.path.join(GLib.get_user_config_dir(), "autostart") self.path = os.path.join(self.user_position, self.basename) key_file.load_from_file(os.path.join(self.system_position, self.basename), KEYFILE_FLAGS) else: key_file.load_from_file(self.path, KEYFILE_FLAGS) except: key_file.set_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_TYPE, "Application") key_file.set_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_EXEC, "/bin/false") if "enabled" in self.save_mask.contents: key_file.set_boolean(D_GROUP, "X-GNOME-Autostart-enabled", self.enabled) if "no-display" in self.save_mask.contents: key_file.set_boolean(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_NO_DISPLAY, self.no_display) if "hidden" in self.save_mask.contents: key_file.set_boolean(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_HIDDEN, self.hidden) if "name" in self.save_mask.contents: locale = self.get_locale() if locale: key_file.set_locale_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_NAME, locale, self.name) else: key_file.set_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_NAME, self.name) if "comment" in self.save_mask.contents: locale = self.get_locale() if locale: key_file.set_locale_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_COMMENT, locale, self.comment) else: key_file.set_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_COMMENT, self.comment) if "command" in self.save_mask.contents: key_file.set_string(D_GROUP, GLib.KEY_FILE_DESKTOP_KEY_EXEC, self.command) if "delay" in self.save_mask.contents: key_file.set_string(D_GROUP, "X-GNOME-Autostart-Delay", self.delay) key_file.save_to_file(self.path) self.app = self.path self.key_file = key_file self.save_done_success() return False
def get_app_config_directory (self): data_dir = GLib.get_user_config_dir() app_dir = data_dir+"/test-app" if not os.path.isdir(app_dir): os.mkdir (app_dir) return app_dir
def get_config_dir(): """Return the directory where the user's config is stored. This varies depending on platform.""" config_dir = os.path.join(GLib.get_user_config_dir(), "gaphor") os.makedirs(config_dir, exist_ok=True) return config_dir
def start_load_config(self): confdir = GLib.get_user_config_dir() if not confdir: confdir = os.path.expanduser("~/.config") conffile = os.path.join(confdir, "syncthing", "config.xml") if not os.path.isfile(conffile): print "Couldn't find config file." f = Gio.file_new_for_path(conffile) f.load_contents_async(None, self.finish_load_config)
def __init__(self, assistant): Page.__init__(self, assistant) config_dir = GLib.get_user_config_dir() self.repositories = os.path.join( config_dir, 'baserock-installer', 'repos') self.worker = None self.idle_id = 0 self.download_completed = False self.title, box = self.start_section('Downloading Release') text = self.create_text( 'Depending on your internet connection, this may take ' 'some time. You will, however, get a Baserock system that ' 'provides a traceable and controlled runtime or development ' 'environment. Among many other things, this helps in ' 'spotting, diagnosing and fixing problems as at any time ' 'it is clear how exactly the system is configured.') box.pack_start(text, False, False, 0) grid = Gtk.Grid() grid.set_column_spacing(12) grid.set_row_spacing(6) grid.show() box.pack_start(grid, False, True, 0) label = Gtk.Label('Current File:') label.set_halign(Gtk.Align.START) label.show() grid.attach(label, 0, 1, 1, 1) self.item_progress = Gtk.ProgressBar() self.item_progress.set_hexpand(True) self.item_progress.show() grid.attach(self.item_progress, 0, 2, 1, 1) label = Gtk.Label('Total:') label.set_halign(Gtk.Align.START) label.show() grid.attach(label, 0, 3, 1, 1) self.total_progress = Gtk.ProgressBar() self.total_progress.show() grid.attach(self.total_progress, 0, 4, 1, 1) self.numbers_label = Gtk.Label() self.numbers_label.set_halign(Gtk.Align.START) self.numbers_label.show() grid.attach(self.numbers_label, 0, 5, 1, 1) self.downloader = FileDownload() self.downloader.connect('download-error', self.download_error) self.downloader.connect('download-progress', self.download_progress) self.downloader.connect('download-finished', self.download_finished) self.downloader.excluded_mime_types.add('text/html') self.reset()
def __edit_lua_cb(self, widget): import shutil path = os.path.join(GLib.get_user_config_dir(), "ibus", "libpinyin") os.path.exists(path) or os.makedirs(path) path = os.path.join(path, "user.lua") if not os.path.exists(path): src = os.path.join(pkgdatadir, "user.lua") shutil.copyfile(src, path) os.system("xdg-open %s" % path)
def __edit_symbol_cb(self, widget, filename): import shutil path = os.path.join(GLib.get_user_config_dir(), "ibus", "libzhuyin") os.path.exists(path) or os.makedirs(path) path = os.path.join(path, filename) if not os.path.exists(path): src = os.path.join(pkgdatadir, filename) shutil.copyfile(src, path) os.system("xdg-open %s" % path)
def get_config_dir(): """ Returns ~/.config, %APPDATA% or whatever has user set as configuration directory. """ confdir = GLib.get_user_config_dir() if confdir is None: confdir = os.path.expanduser("~/.config") return confdir
def on_menu_button_clicked(self, widget): if self.advanced_mode: self.mode_button.set_label(AdvancedMode) self.on_normal_mode() else: self.mode_button.set_label(NormalMode) self.on_advanced_mode() touch(os.path.join(GLib.get_user_config_dir(), ".cs_no_default")) return True
def start_load_config(self): confdir = GLib.get_user_config_dir() if not confdir: confdir = os.path.expanduser('~/.config') conffile = os.path.join(confdir, 'syncthing', 'config.xml') if not os.path.isfile(conffile): log.error('start_load_config: Couldn\'t find config file.') f = Gio.file_new_for_path(conffile) f.load_contents_async(None, self.finish_load_config)
def xdg_get_config_home(): if os.name == "nt": from gi.repository import GLib return glib2fsn(GLib.get_user_config_dir()) data_home = os.getenv("XDG_CONFIG_HOME") if data_home: return os.path.abspath(data_home) else: return os.path.join(os.path.expanduser("~"), ".config")
def do_activate(self): # Initialize snippets library library = Library() if platform.system() == 'Windows': snippetsdir = os.path.expanduser('~/gedit/snippets') else: snippetsdir = os.path.join(GLib.get_user_config_dir(), 'gedit/snippets') library.set_dirs(snippetsdir, self.system_dirs())
def do_activate(self): self._path = os.path.dirname(__file__) if not self._path in sys.path: sys.path.insert(0, self._path) commands.Commands().set_dirs([ os.path.join(GLib.get_user_config_dir(), 'gedit/commander/modules'), os.path.join(self.plugin_info.get_data_dir(), 'modules') ])
gettext.install('pyfbdown', localedir=get_correct_path('locale')) authors_ = ["Youssef Sourani <*****@*****.**>"] version_ = "1.0" copyright_ = "Copyright © 2020 Youssef Sourani" comments_ = "Facebook Videos Downloader" website_ = "https://github.com/yucefsourani/pyfbdown" translators_ = "Arabic Yucef Sourani" appname = "pyfbdown" appwindowtitle = "PyFBDown" appid = "com.github.yucefsourani.pyfbdown" icon_ = get_correct_path("pixmaps/com.github.yucefsourani.pyfbdown.png") if not os.path.isfile(icon_): icon_ = None default_metadata_file_name = os.path.join(GLib.get_user_config_dir(), "pyfbdown.json") def get_metadata_info(): if not os.path.isfile(default_metadata_file_name): default_metadata_dict = json.loads(default_metadata) with open(default_metadata_file_name, "w", encoding="utf-8") as mf: json.dump(default_metadata_dict, mf, indent=4) return get_metadata_info() try: with open(default_metadata_file_name, encoding="utf-8") as mf: result = json.load(mf) except Exception as e: print(e) return False
def get_user_autostart_files(): return glob.glob( os.path.join(GLib.get_user_config_dir(), "autostart", "*.desktop"))
it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. OCRFeeder is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 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 OCRFeeder. If not, see <http://www.gnu.org/licenses/>. """ OCRFEEDER_STUDIO_COMMENTS = 'The complete OCR suite.' # DIRECTORIES USER_CONFIG_DIR = os.path.join(GLib.get_user_config_dir(), OCRFEEDER_COMPACT_NAME) DEFAULT_SYSTEM_APP_DIR = os.path.join('/usr/local', 'share', 'ocrfeeder') APP_DIR = DEFAULT_SYSTEM_APP_DIR RESOURCES_DIR = APP_DIR # If the path does not exist (devel setup) set the # APP_DIR and RESOURCES_DIR to local paths _dirname = os.path.abspath(os.path.dirname(__file__)) if not os.path.exists(APP_DIR) or not _dirname.startswith('/usr/local'): APP_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) RESOURCES_DIR = os.path.join(APP_DIR, '../../resources') RESOURCES_DIR = os.path.abspath(RESOURCES_DIR) # I18N DEFAULT_LANGUAGES = os.environ.get('LANGUAGE', '').split(':')
from gi.repository import GLib, GObject import util import prefs day = datetime.timedelta(1, 0, 0) EXPIRE_TIME = 30 * day DEFAULT_GROUP_CODE = "Warpinator" KEYFILE_GROUP_NAME = "warpinator" KEYFILE_CODE_KEY = "code" KEYFILE_UUID_KEY = "connect_id" CONFIG_FILE_NAME = ".group" CONFIG_FOLDER = os.path.join(GLib.get_user_config_dir(), "warpinator") singleton = None def get_singleton(): global singleton if singleton == None: singleton = AuthManager() return singleton class AuthManager(GObject.Object): __gsignals__ = {
# You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA import os from ConfigParser import ConfigParser from gi.repository import Gtk, GLib, Gio, Gdk import ui.style from ui.window import Window from fakegarmin import FakeGarmin from garmin import Garmin from devicequeue import GarminQueue CONFIG_PATH = os.path.join(GLib.get_user_config_dir(), 'fuga', 'fuga.ini') class Fuga(Gtk.Application): def __init__(self): Gtk.Application.__init__(self, application_id='com.jonnylamb.Fuga', flags=Gio.ApplicationFlags.FLAGS_NONE) GLib.set_application_name('Fuga') self.connect('activate', self.activate_cb) self.config = self.create_config() ui.style.setup()
def missing_host_key(self, client, hostname, key): host_key_fingerprint = 'sha256:' + base64.b64encode(hashlib.new('sha256', key.asbytes()).digest()).decode('utf-8') host_keys = paramiko.hostkeys.HostKeys() host_keys_modified = False known_hosts_file = self.application.config.get('ssh_known_hosts_file', os.path.join(GLib.get_user_config_dir(), 'king-phisher', 'known_hosts')) if os.access(known_hosts_file, os.R_OK): host_keys.load(known_hosts_file) if host_keys.lookup(hostname): if host_keys.check(hostname, key): self.logger.debug("accepting known ssh host key {0} {1} {2}".format(hostname, key.get_name(), host_key_fingerprint)) return self.logger.warning("ssh host key does not match known value for {0}".format(hostname)) dialog = HostKeyWarnDialog(self.application, hostname, key) if dialog.interact() != Gtk.ResponseType.ACCEPT: raise errors.KingPhisherAbortError('bad ssh host key for ' + hostname) else: dialog = HostKeyAcceptDialog(self.application, hostname, key) if dialog.interact() != Gtk.ResponseType.ACCEPT: raise errors.KingPhisherAbortError('unknown ssh host key not accepted by the user for ' + hostname) host_keys.add(hostname, key.get_name(), key) host_keys_modified = True if host_keys_modified: try: host_keys.save(known_hosts_file) os.chmod(known_hosts_file, 0o600) except (IOError if its.py_v2 else PermissionError): self.logger.warning('failed to save the known_hosts file and set its permissions')
class GrammalecteConfig(DictConfig): """ A Grammalecte configuration for a given document. This configuration inherits from user and system configuration, if available. :Example: >>> config = GrammalecteConfig() >>> config.get_value(GrammalecteConfig.ANALYZE_WAIT_TICKS) 12 >>> config.set_value("top/sub", ["zero", {"1st": "1", "other": "yes"}]) >>> config.get_value("top/sub/1/other") 'yes' """ __gtype_name__ = "GrammalecteConfig" ############ # ALL CONFIGURATION CONSTANTS ARE HERE ############ LOCALE_DIR = "locale-dir" ANALYZE_OPTIONS = "analyze-options" AUTO_ANALYZE_ACTIVE = "auto-analyze-active" ANALYZE_PARALLEL_COUNT = "analyze-parallel-count" ANALYZE_WAIT_TICKS = "analyze-wait-ticks" IGNORED_RULES = "ign-rules" IGNORED_ERRORS = "ign-errors" CONCAT_LINES = "concat-lines" __DEFAULT_CONFIG = { ANALYZE_OPTIONS: {}, AUTO_ANALYZE_ACTIVE: False, ANALYZE_PARALLEL_COUNT: 1, ANALYZE_WAIT_TICKS: 12, IGNORED_RULES: [], IGNORED_ERRORS: [], CONCAT_LINES: True, } __GEDIT_CONFIG_FILE = "/gedit/grammalecte.conf" __SYSTEM_CONFIG_FILE = "/etc" + __GEDIT_CONFIG_FILE __USER_CONFIG_FILE = GLib.get_user_config_dir() + __GEDIT_CONFIG_FILE __globalInstance: Optional[DictConfig] = None def __init__(self, selfConfig: Optional[SelfConfigContainer] = None) -> None: """ Initialize the plugin configuration. :param selfConfig: (optional) the selfConfig container. """ # Initialize global instance if GrammalecteConfig.__globalInstance is None: defaultConfig = DictConfig(GrammalecteConfig.__DEFAULT_CONFIG) systemConfig = DictConfig( GrammalecteConfig.__SYSTEM_CONFIG_FILE, defaultConfig) GrammalecteConfig.__globalInstance = DictConfig( GrammalecteConfig.__USER_CONFIG_FILE, systemConfig) # Initialize local instance DictConfig.__init__( self, selfConfig, GrammalecteConfig.__globalInstance) @staticmethod def terminate() -> None: """ Terminate usage of all configurations. This will save global configuration files if needed. """ if GrammalecteConfig.__globalInstance is not None: GrammalecteConfig.__globalInstance.save() GrammalecteConfig.__globalInstance = None
def save_screensaver_autostart(self): filename = os.path.join(GLib.get_user_config_dir(), 'autostart', 'screensaver-settings.desktop') autostart = self.get_screensaver_autostart() autostart.save_to_file(filename)
import os import xml.dom.minidom import gi gi.require_version('Gtk', '3.0') gi.require_version('MateMenu', '2.0') from gi.repository import GLib, Gtk, Gdk, GdkPixbuf print("user data dir: " + GLib.get_user_data_dir()) print("user config dir: " + GLib.get_user_config_dir())
# -*- coding: utf-8 -*- # SPDX-FileCopyrightText: 2016-2022 Mufeed Ali <*****@*****.**> # SPDX-License-Identifier: GPL-3.0-or-later """utils contains a few global variables and essential functions.""" import logging import os import traceback from gi.repository import GLib RES_PATH = "/com/github/fushinari/Wordbook" CONFIG_DIR = os.path.join(GLib.get_user_config_dir(), "wordbook") CONFIG_FILE = os.path.join(CONFIG_DIR, "wordbook.conf") DATA_DIR = os.path.join(GLib.get_user_data_dir(), "wordbook") CDEF_DIR = os.path.join(DATA_DIR, "cdef") WN_DIR = os.path.join(DATA_DIR, "wn") logging.basicConfig( format= "%(asctime)s - [%(levelname)s] [%(threadName)s] (%(module)s:%(lineno)d) %(message)s" ) LOGGER = logging.getLogger() def boot_to_str(boolean): """Convert boolean to string for configuration parser.""" if boolean is True: return "yes" return "no"
def xdg_config_home(): return os.path.join(GLib.get_user_config_dir(), "flowblade")
def save_light_locker_autostart(self): filename = os.path.join(GLib.get_user_config_dir(), 'autostart', 'light-locker.desktop') autostart = self.get_light_locker_autostart() autostart.save_to_file(filename)
def get_user_config_dir(): """Like g_get_user_config_dir(), but always unicode""" d_fs = GLib.get_user_config_dir() return filename_to_unicode(d_fs)
#!/usr/bin/python3 import os import json import time import re from gi.repository import GLib, GObject, Gtk CONFIG_DIR = os.path.join(GLib.get_user_config_dir(), 'sticky') CONFIG_PATH = os.path.join(CONFIG_DIR, 'notes.json') SAVE_DELAY = 3 backup_file_name = re.compile(r"\Abackup-[0-9]{10,}\.json$", re.IGNORECASE) class FileHandler(GObject.Object): @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, return_type=bool, arg_types=(str, ), accumulator=GObject.signal_accumulator_true_handled) def group_changed(self, group_name): pass @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST, return_type=bool, accumulator=GObject.signal_accumulator_true_handled) def lists_changed(self): pass def __init__(self, settings):