def main(): loglevel = logging.WARN if len(sys.argv) == 2 and sys.argv[1] == '-d': loglevel = logging.INFO logging.basicConfig(level=loglevel, format='%(asctime)s %(levelname)s %(message)s', datefmt='%F %T') save_config_path('udevedu', 'hooks') hooks_dir = load_first_config('udevedu', 'hooks') hooks = load_hooks(hooks_dir) try: context = pyudev.Context() monitor = pyudev.Monitor.from_netlink(context) while True: try: for args in monitor: # args is (action, device) for h in hooks: spawn_partial(process_hook, h, args) except IOError as e: if e.errno == errno.EINTR: continue logging.warn('Recovering from IOError, continue polling') logging.exception(e) except KeyboardInterrupt: logging.warn('User interrupt, exiting')
def get_default_config_dir(filename=None): """ :param filename: if None, only the config path is returned, if provided, a path including the filename will be returned :type filename: string :returns: a file path to the config directory and optional filename :rtype: string """ if windows_check(): appDataPath = os.environ.get("APPDATA") if not appDataPath: import _winreg hkey = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders") appDataReg = _winreg.QueryValueEx(hkey, "AppData") appDataPath = appDataReg[0] _winreg.CloseKey(hkey) if filename: return os.path.join(appDataPath, "deluge", filename) else: return os.path.join(appDataPath, "deluge") else: from xdg.BaseDirectory import save_config_path try: if filename: return os.path.join(save_config_path("deluge"), filename) else: return save_config_path("deluge") except OSError, e: log.error("Unable to use default config directory, exiting... (%s)", e) sys.exit(1)
def main(): loglevel = logging.WARN if len(sys.argv) == 2 and sys.argv[1] == '-d': loglevel = logging.INFO logging.basicConfig( level=loglevel, format='%(asctime)s %(levelname)s %(message)s', datefmt='%F %T' ) save_config_path('udevedu', 'hooks') hooks_dir = load_first_config('udevedu', 'hooks') hooks = load_hooks(hooks_dir) try: context = pyudev.Context() monitor = pyudev.Monitor.from_netlink(context) while True: try: for args in monitor: # args is (action, device) for h in hooks: spawn_partial(process_hook, h, args) except IOError as e: if e.errno == errno.EINTR: continue logging.warn('Recovering from IOError, continue polling') logging.exception(e) except KeyboardInterrupt: logging.warn('User interrupt, exiting')
def ProfileFilenamePassage(self): """ Obtains a valid profile filename (non-root user) If profile name is not already set (e.g.: default.conf) the user is asked for a profile name. (root user) Profile name and path are already set to "/etc/calise" and "default.conf" NOTE: pn ~ ProfileName """ pn = None defaultPath = os.path.join( save_config_path(__LowerName__), 'default' + '.conf') if not os.path.isfile(defaultPath): pn = 'default' if pn is None and os.getuid() != 0: while True: pn = raw_input(customWrap(_( "Please, enter a name for a new profile (use \'default\' " "to overwrite the default profile)") + ": ")) if pn != pn + os.path.dirname(pn) or pn == "": fprnt(_("Please retry and enter a valid name.")) fprnt(_( "Since it\'ll be a filename, chars not supported by " "your os will raise an error") + '\n') time.sleep(1.5) elif os.listdir(save_config_path(__LowerName__)).\ count(pn + ".conf") > 0: dummy = query_yes_no(customWrap(_( "A profile file with the same name already exists, " "overwrite?")), 'no') if dummy == 'yes': break else: break sys.stdout.write('\n') self.configpath = os.path.join( save_config_path(__LowerName__), pn + '.conf') elif os.getuid() == 0: pn = __LowerName__ configpath = os.path.join('/', 'etc', pn + '.conf') if os.path.isfile(configpath): dummy = query_yes_no(customWrap(_( "A global profile already exists, overwrite?")), 'no') if dummy == 'no': sys.exit(11) self.configpath = configpath pn = None else: self.configpath = os.path.join( save_config_path(__LowerName__), pn + '.conf') return pn
def main(): loglevel = logging.WARN if len(sys.argv) == 2 and sys.argv[1] == "-d": loglevel = logging.INFO logging.basicConfig(level=loglevel, format="%(asctime)s %(levelname)s %(message)s", datefmt="%F %T") save_config_path("udevedu", "hooks") hooks_dir = load_first_config("udevedu", "hooks") hooks = [] # Load all hooks for fname in sorted(glob.glob(os.path.join(hooks_dir, "*.py"))): if not os.path.isfile(fname): continue logging.info("Loading source %s", fname) mod = os.path.splitext(os.path.basename(fname))[0] try: hooks.append(imp.load_source("udevedu.hooks.%s" % mod, fname)) except Exception as e: logging.error("Loading of %s failed", fname) logging.exception(e) for h in hooks: if hasattr(h, "init"): try: h.init() except Exception as e: logging.error("Initialization of %s failed", h.__file__) logging.exception(e) try: context = pyudev.Context() monitor = pyudev.Monitor.from_netlink(context) while True: try: for args in monitor: # args is (action, device) for h in hooks: spawn_partial(process_hook, h, args) except IOError as e: if e.errno == errno.EINTR: continue logging.warn("Recovering from IOError, continue polling") logging.exception(e) except KeyboardInterrupt: logging.warn("User interrupt, exiting")
def __init__(self, plugin_dir=None): self.config = SafeConfigParser() config_path = save_config_path(self.APP_NAME) self.config_file = os.path.join(config_path, self.APP_NAME + ".conf") self.config.read(self.config_file) this_dir = os.path.abspath(os.path.dirname(__file__)) self.plugin_dir = plugin_dir or os.path.join(this_dir, self._default_dir) places = [ self.plugin_dir, ] [ places.append(os.path.join(path, self.APP_NAME, "evaluators")) for path in xdg_data_dirs ] PluginManagerSingleton.setBehaviour([ ConfigurablePluginManager, VersionedPluginManager, ]) self.manager = PluginManagerSingleton.get() self.manager.setConfigParser(self.config, self.write_config) self.manager.setPluginInfoExtension("expr-plugin") self.manager.setPluginPlaces(places) self.manager.collectPlugins()
def main(): global rpc APP_NAME = 'bch-interlinker' NEW_TIP_CHECK_INTERVAL_SECONDS = 5 config_path = save_config_path(APP_NAME) cache_path = save_cache_path(APP_NAME) db_path = path.join(cache_path, 'db') config_file_path = path.join(config_path, 'config.ini') config = configparser.ConfigParser() config.read(config_file_path) rpc = AuthServiceProxy("http://%s:%s@%s:%s" % (config['daemon']['user'], config['daemon']['password'], config['daemon']['host'], config['daemon']['port'])) logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%d/%m/%y %H:%M:%S %Z') logger = logging.getLogger(APP_NAME) logger.setLevel(logging.DEBUG) tip_id = '' while True: possibly_new_tip_id = rpc.getbestblockhash() if possibly_new_tip_id == tip_id: sleep(NEW_TIP_CHECK_INTERVAL_SECONDS) continue tip_id = possibly_new_tip_id logger.info('new block "%s"', tip_id) with shelve.open(db_path) as db: new_interlink = interlink(tip_id, db) logger.debug('new interlink "%s"', new_interlink) logger.info('mtr hash "%s"', new_interlink.hash().hex()) logger.info('velvet tx "%s"', send_velvet_tx(new_interlink.hash()))
def main(): config = configparser.ConfigParser() config_path = save_config_path("qrdisplay") config_filename = path.join(config_path, "config") if not path.isfile(config_filename): print("Creating the config file") ssid = raw_input("SSID: ") key = getpass.getpass("Key: ") config['WIFI'] = { 'ssid': ssid, 'key': key } with open(config_filename, 'w') as config_file: config.write(config_file) sys.exit(0) else: config.read(config_filename) ssid = config['WIFI']['ssid'] key = config['WIFI']['key'] GPIO.setmode(GPIO.BCM) wifi.display_qr_code(ssid, key) wifi_button = Button(5) wifi_button.when_pressed = wifi.create_event_callback(ssid, key) midnight = True while True: if midnight: wifi.display_qr_code(ssid, key) # Wait an additional hour to prevent a fast refresh time.sleep(3600) time.sleep(3600) midnight = datetime.now().hour == 0
def get_default_config_dir(filename=None): """ :param filename: if None, only the config directory path is returned, if provided, a path including the filename will be returned :type filename: string :returns: a file path to the config directory and optional filename :rtype: string """ if os.access(DEFAULT_CONFIG_PATH, os.F_OK): return DEFAULT_CONFIG_PATH user_config_path = os.path.join(os.path.expanduser("~/.config"), "mirror") if not os.access(user_config_path, os.F_OK): return DEFAULT_CONFIG_PATH try: from xdg.BaseDirectory import save_config_path config_path = save_config_path("mirror") except: config_path = user_config_path if not filename: filename = '' return os.path.join(config_path, filename)
def get_default_config_dir(filename=None): """ :param filename: if None, only the config path is returned, if provided, a path including the filename will be returned :type filename: string :returns: a file path to the config directory and optional filename :rtype: string """ if windows_check(): def save_config_path(resource): app_data_path = os.environ.get('APPDATA') if not app_data_path: try: import winreg except ImportError: import _winreg as winreg # For Python 2. hkey = winreg.OpenKey( winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders') app_data_reg = winreg.QueryValueEx(hkey, 'AppData') app_data_path = app_data_reg[0] winreg.CloseKey(hkey) return os.path.join(app_data_path, resource) else: from xdg.BaseDirectory import save_config_path if not filename: filename = '' try: return decode_bytes(os.path.join(save_config_path('deluge'), filename)) except OSError as ex: log.error('Unable to use default config directory, exiting... (%s)', ex) sys.exit(1)
def do_first_run(): if platform.system() in ('Windows', 'Microsoft'): auth_path = os.path.join(os.environ['APPDATA'], 'deluge') else: try: from xdg.BaseDirectory import save_config_path except ImportError: return auth_path = save_config_path('deluge') auth_path = os.path.join(auth_path, 'auth') if not os.path.isfile(auth_path): return with open(auth_path, 'rb') as f: filedata = f.read().split('\n')[0].split(':') if len(filedata) < 2: return username, password = filedata[:2] plugin.set_setting('ip', '127.0.0.1') plugin.set_setting('port', '58846') plugin.set_setting('username', username) plugin.set_setting('password', password)
def __init__(self): """ Initialize the PluginManager including: - plugin configuration directory - plugin search locations """ self.config_path = save_config_path("yasibo") self.config_file = os.path.join(self.config_path, "plugins.conf") places = [] [places.append(os.path.join(path, "yasibo", "plugins")) for path in xdg_data_dirs] # dev location places.append("%s/../plugins" % os.path.dirname(os.path.abspath(__file__))) PluginManagerSingleton.setBehaviour([ConfigurablePluginManager, VersionedPluginManager]) self.manager = PluginManagerSingleton.get() locator = self.manager.getPluginLocator() locator.setPluginInfoExtension("yasibo-plugin") self.manager.setPluginPlaces(places) self.config = SafeConfigParser() self.config.read(self.config_file) self.manager.setConfigParser(self.config, self.save) self.manager.collectPlugins() log.debug("Config file: %s" % self.config_file)
def _read_config(self): config_path = os.path.join(save_config_path('tunedmode'), 'tunedmode.ini') self.config.read_dict(CONFIG_DEFAULTS) self.config.read(config_path) if not os.path.isfile(config_path): with open(config_path, 'w') as config_file: self.config.write(config_file)
def __init__(self, filename): '''Initialize config object''' assert (filename is not None) OrderedDict.__init__(self) path = save_config_path(XDG_DIRECTORY) self.path = join(path, filename) if not isinstance(self.path, str) or not exists(self.path): raise MissingConfigFile(self.path) self.load()
def checkCalibrationNeed(suffix='.conf', default='default'): defName = default defConf = '%s%s' % ( os.path.join(save_config_path(__LowerName__), defName), suffix) sysConf = '%s%s' % ( os.path.join(os.path.join('/', 'etc', __LowerName__)), suffix) if not os.path.isfile(defConf) and not os.path.isfile(sysConf): options.settings['configure'] = True return options.settings['configure']
def __init__(self, filename): '''Initialize config object''' assert(filename is not None) OrderedDict.__init__(self) path = save_config_path(XDG_DIRECTORY) self.path = join(path, filename) if not isinstance(self.path, str) or not exists(self.path): raise MissingConfigFile(self.path) self.load()
def checkCalibrationNeed(suffix='.conf', default='default'): defName = default defConf = '%s%s' % (os.path.join(save_config_path(__LowerName__), defName), suffix) sysConf = '%s%s' % (os.path.join(os.path.join('/', 'etc', __LowerName__)), suffix) if not os.path.isfile(defConf) and not os.path.isfile(sysConf): options.settings['configure'] = True return options.settings['configure']
def __init__(self, app): GObject.__init__(self) self.app = app self._config = ConfigParser() self._filename = os.path.join(save_config_path("garmon"), "config") self._config.read(self._filename) self._dialog = _PrefsDialog() self._watches = []
def __init__(self): from xdg.BaseDirectory import save_config_path, save_data_path # TODO: Should we use save_config_path or load_first_config? self.config_dir = save_config_path('coinbox') self.data_dir = save_data_path('coinbox') # TODO: the default locale directory should be determined in a better way # some package it in the egg as resources (yuck) # some have a $prefix set up, and from that determine the path to $prefix/share/locale # some have it in the data directory self.locale_dir = '/usr/share/locale'
def __init__(self, version, pkgdatadir, icondir): self.version = version self.datadir = pkgdatadir self.icondir = icondir self.udev_path = self.datadir + '/udev/' self.target_dir = '/etc/udev/rules.d/' self.profile_path = os.path.join(save_config_path('oversteer'), 'profiles') self.device_manager = None if not os.path.isdir(self.udev_path): self.udev_path = None
def _get_local_auth(self): auth_file = "" username = password = "" if platform.system() in ('Windows', 'Microsoft'): appDataPath = os.environ.get("APPDATA") if not appDataPath: try: import winreg except ImportError: import _winreg as winreg hkey = winreg.OpenKey( winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders" ) appDataReg = winreg.QueryValueEx(hkey, "AppData") appDataPath = appDataReg[0] winreg.CloseKey(hkey) auth_file = os.path.join(appDataPath, "deluge", "auth") else: from xdg.BaseDirectory import save_config_path try: auth_file = os.path.join(save_config_path("deluge"), "auth") except OSError: return username, password if os.path.exists(auth_file): for line in open(auth_file): if line.startswith("#"): # This is a comment line continue line = line.strip() try: lsplit = line.split(":") except Exception: continue if len(lsplit) == 2: username, password = lsplit elif len(lsplit) == 3: username, password, level = lsplit else: continue if username == "localclient": return (username, password) return ("", "")
def _init_config(self): """ Initialize configuration parser and the filename that the parser will write to. """ # TODO: use GSettings instead self._config = SafeConfigParser() # read config from the first found config file filename = self.package + ".conf" config_file = self._find_config_file(filename) if config_file: self.debug("Loading configuration from %s", config_file) self._config.read(config_file) # always write config to save_config_path self._config_file = os.path.join(save_config_path(self._package), filename)
def main(): """Read the config, creating it if necessary, then loop on (re)starting the bot""" config_path = os.path.join(save_config_path("notifybot"), "rc.conf") if not os.path.exists(config_path): new_config(config_path) with open(config_path) as f: config = json.load(f) while True: try: start_bot(config["user"], config["password"]) except KeyboardInterrupt: break except Exception as e: print "Got Exception %s, retrying in 10s" % e time.sleep(10)
def clear_config(): """Remove configuration section from files on disk.""" config_dir = save_config_path('snapcraft') filename = os.path.join(config_dir, 'snapcraft.cfg') parser = ConfigParser() if os.path.exists(filename): parser.read(filename) api_endpoint = os.environ.get( 'UBUNTU_SSO_API_ROOT_URL', UBUNTU_SSO_API_ROOT_URL) location = urlparse(api_endpoint).netloc parser.remove_section(location) with open(filename, 'w') as fd: parser.write(fd)
def __init__(self, plugin_dir=None): self.config = SafeConfigParser() config_path = save_config_path(self.APP_NAME) self.config_file = os.path.join(config_path, self.APP_NAME + ".conf") self.config.read(self.config_file) this_dir = os.path.abspath(os.path.dirname(__file__)) self.plugin_dir = plugin_dir or os.path.join(this_dir, self._default_dir) places = [self.plugin_dir] [places.append(os.path.join(path, self.APP_NAME, "evaluators")) for path in xdg_data_dirs] PluginManagerSingleton.setBehaviour([ConfigurablePluginManager, VersionedPluginManager]) self.manager = PluginManagerSingleton.get() self.manager.setConfigParser(self.config, self.write_config) self.manager.setPluginInfoExtension("expr-plugin") self.manager.setPluginPlaces(places) self.manager.collectPlugins()
def get_default_config_dir(filename=None): """ :param filename: if None, only the config directory path is returned, if provided, a path including the filename will be returned :type filename: string :returns: a file path to the config directory and optional filename :rtype: string """ from xdg.BaseDirectory import save_config_path if not filename: filename = '' try: return os.path.join(save_config_path("mirror"), filename) except OSError, e: log.error("Unable to use default config directory, exiting... (%s)", e) sys.exit(1)
def _get_local_auth(self): username = password = "" if platform.system() in ('Windows', 'Microsoft'): app_data_path = os.environ.get("APPDATA") if not app_data_path: from six.moves import winreg hkey = winreg.OpenKey( winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", ) app_data_reg = winreg.QueryValueEx(hkey, "AppData") app_data_path = app_data_reg[0] winreg.CloseKey(hkey) auth_file = os.path.join(app_data_path, "deluge", "auth") else: from xdg.BaseDirectory import save_config_path try: auth_file = os.path.join(save_config_path("deluge"), "auth") except OSError: return username, password if os.path.exists(auth_file): for line in open(auth_file): if line.startswith("#"): # This is a comment line continue line = line.strip() try: lsplit = line.split(":") except Exception: continue if len(lsplit) == 2: username, password = lsplit elif len(lsplit) == 3: username, password, level = lsplit else: continue if username == "localclient": return username, password return "", ""
def _get_local_auth(self): username = password = '' if platform.system() in ('Windows', 'Microsoft'): app_data_path = os.environ.get('APPDATA') if not app_data_path: from six.moves import winreg hkey = winreg.OpenKey( winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders', ) app_data_reg = winreg.QueryValueEx(hkey, 'AppData') app_data_path = app_data_reg[0] winreg.CloseKey(hkey) auth_file = os.path.join(app_data_path, 'deluge', 'auth') else: from xdg.BaseDirectory import save_config_path try: auth_file = os.path.join(save_config_path('deluge'), 'auth') except OSError: return username, password if os.path.exists(auth_file): for line in open(auth_file): if line.startswith('#'): # This is a comment line continue line = line.strip() try: lsplit = line.split(':') except Exception: continue if len(lsplit) == 2: username, password = lsplit elif len(lsplit) == 3: username, password, level = lsplit else: continue if username == 'localclient': return username, password return '', ''
def _get_local_auth(self): auth_file = "" username = password = "" if platform.system() in ('Windows', 'Microsoft'): appDataPath = os.environ.get("APPDATA") if not appDataPath: import _winreg hkey = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders") appDataReg = _winreg.QueryValueEx(hkey, "AppData") appDataPath = appDataReg[0] _winreg.CloseKey(hkey) auth_file = os.path.join(appDataPath, "deluge", "auth") else: from xdg.BaseDirectory import save_config_path try: auth_file = os.path.join(save_config_path("deluge"), "auth") except OSError, e: return username, password
def get_default_config_dir(filename=None): """ :param filename: if None, only the config directory path is returned, if provided, a path including the filename will be returned :type filename: string :returns: a file path to the config directory and optional filename :rtype: string """ try: from xdg.BaseDirectory import save_config_path config_path = save_config_path("mirror") except: config_path = os.path.join(os.path.expanduser("~/.config"), "mirror") if not filename: filename = '' return os.path.join(config_path, filename)
def save_config(data): """Store current configuration to disk.""" config_dir = save_config_path('snapcraft') filename = os.path.join(config_dir, 'snapcraft.cfg') parser = ConfigParser() if os.path.exists(filename): parser.read(filename) api_endpoint = os.environ.get( 'UBUNTU_SSO_API_ROOT_URL', UBUNTU_SSO_API_ROOT_URL) location = urlparse(api_endpoint).netloc if not parser.has_section(location): parser.add_section(location) for key, value in data.items(): parser.set(location, key, str(value)) with open(filename, 'w') as fd: parser.write(fd)
def get_localhost_auth(): try: from xdg.BaseDirectory import save_config_path except ImportError: return (None, None) path = os.path.join(save_config_path("deluge"), "auth") if not os.path.exists(path): return (None, None) with open(path) as f: for line in f: if line.startswith("#"): continue line = line.strip() lsplit = line.split(":") if len(lsplit) in (2, 3): username, password = lsplit[:2] if username == "localclient": return (username, password) return (None, None)
def events_path() -> str: """Path where user event definitions are loaded from. They can be .py or .txt files. """ return save_config_path('agenda')
import json import os import sys from xdg.BaseDirectory import save_config_path from tordl import engines CFG_DIR = os.path.join( os.path.expanduser('~'), save_config_path('torrentdl') ) CFG_FILE = os.path.join(CFG_DIR, 'config.json') CFG_ENGINES_FILE = os.path.join(CFG_DIR, 'engines.py') CFG_HISTORY_FILE = os.path.join(CFG_DIR, 'search_history.txt') SEARCH_ENGINES = ['Zooqle', 'TPB', 'Lime', '1337x', 'Glo', 'KAT', 'Solid'] TORRENT_CLIENT_CMD = 'qbittorrent %s' BROWSER_CMD = 'firefox %s' HISTORY_MAX_LENGTH = 100 PAGE_NUM_DOWNLOAD = 1 REQUEST_TIMEOUT = 5 AGGREGATE_SAME_MAGNET_LINKS = True FETCH_MISSING_MAGNET_LINKS = False FETCH_MAGNET_LINKS_CONCURRENCE = 20 def mk_cfg(): mod = sys.modules[__name__] attrs = dir(mod) omit = ( 'os',
def write(self): """写入config文件,路径由xdg决定""" filename = os.path.join(save_config_path("gmusic"), "config") with open(filename, "w") as configfile: self.config.write(configfile)
def make_new_config(config_path): import getpass user = raw_input("Please enter the Jabber ID for your bot: ") while True: attempt1 = getpass.getpass("Please enter the Jabber password: "******"Please confirm the Jabber password: "******"Please enter your download directory: ") with open(config_path, "wb") as f: json.dump({ "user": user, "password": password, "max_parallel_downloads": 3, "download_directory": dl_dir }, indent = 4, fp = f) print("config saved in %s" % config_path) if __name__ == "__main__": config_path = os.path.join(save_config_path("plowbot"), "plowbotrc") if not os.path.exists(config_path): make_new_config(config_path) with open(config_path) as f: config = json.load(f) bot = PlowBot(**config) t = threading.Thread(target = bot.download_loop) t.daemon = True bot.serve_forever(connect_callback = lambda: t.start())
def __init__(self): self._create_window() # Setup a ConfigParser which will be used by the Yapsy plugin manager to # remember which plugins are activated. The function # xdg.BaseDirectory.save_config_path() function is used to get the path # for the configuration file. You may want to instead iterate over the # xdg.BaseDirectory.xdg_config_dirs if your application installs default # configuration files into system directories. See # http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html # for more information on the XDG specifications. self.config = SafeConfigParser() config_path = save_config_path(self.APP_NAME) self.config_file = os.path.join(config_path, self.APP_NAME + ".conf") logging.debug("Reading configuration file: %s" % self.config_file) self.config.read(self.config_file) # Build a list of directories which may contain plugins. This will # include the 'plugins' folder where this file resides as well as every # directory in xdg.BaseDirectory.xdg_data_dirs. This way users can # install plugins in something like ~/.local/yapsy-gtk-example/plugins # but your installer could also install those plugins to something like # /usr/share/yapsy-gtk-example/plugins. You'll see Yapsy checking each # of these directories if logging is set to logging.DEBUG this_dir = os.path.abspath(os.path.dirname(__file__)) plugin_dir = os.path.join(this_dir,'plugins') places = [plugin_dir,] [places.append(os.path.join(path, self.APP_NAME, "plugins")) for path in xdg_data_dirs] # The singleton versino of the Yapsy plugin manager is used rather than # passing around a PluginManager instance. Prior to getting the # singleton instance, some "plugin manager decorators" are installed to: # 1. Automatically save active and non-active plugins to the config file # 2. Ensure only the newest versions of plugins are used. # This call to setBehaviour() must occur before getting the singleton # instance. PluginManagerSingleton.setBehaviour([ ConfigurablePluginManager, VersionedPluginManager, ]) # Get singleton instance manager = PluginManagerSingleton.get() # I like to give the manager a reference to the application class so # that plugins can connect to signals and access windows through # the manager singleton. manager.app = self # Give manager the config file and a callback function to call when it # changes the config (eg. when a plugin is activated or deactivated). manager.setConfigParser(self.config, self.write_config) # Setup a file extension for plugin information files. In this it's # just ".plugin" but you may want to do something specific to your # application like ".myapp-plugin" manager.setPluginInfoExtension("plugin") # Pass the manager the list of plugin directories manager.setPluginPlaces(places) # CollectPlugins is a shortcut for locatePlugins() and loadPlugins(). manager.collectPlugins() # Now that the plugins have been collected, the plugin widget can # be refreshed to display all installed plugins. self._plugin_list.refresh()
def __init__(self, application, model, argv): self.app = application self.locale = '' self.check_permissions = True self.device_manager = self.app.device_manager self.device = None self.grab_input = False self.test = None self.linear_chart = None self.performance_chart = None self.combined_chart = None self.button_setup_step = False self.button_config = [-1] * 9 self.button_config[0] = [-1] self.pressed_button_count = 0 signal.signal(signal.SIGINT, self.sig_int_handler) self.config_path = save_config_path('oversteer') self.load_preferences() self.profile_path = os.path.join(self.config_path, 'profiles') if not os.path.isdir(self.profile_path): os.makedirs(self.profile_path, 0o700) self.ui = GtkUi(self, argv) self.ui.set_app_version(self.app.version) self.ui.set_app_icon( os.path.join(self.app.icondir, 'org.berarma.Oversteer.svg')) self.ui.set_languages(self.languages) self.ui.set_language(self.locale) self.ui.set_check_permissions(self.check_permissions) self.populate_window() if self.app.args.profile is not None: self.ui.set_profile(self.app.args.profile) self.model = None if model.device is not None: model.set_ui(self.ui) self.models = { model.device.get_id(): model, } else: self.models = {} if model.device is not None: self.ui.set_device_id(model.device.get_id()) self.change_device(model.device.get_id()) self.ui.update() Thread(target=self.input_thread, daemon=True).start() self.ui.start() if self.app.args.command: if not model.get_start_app_manually(): self.start_app() else: self.ui.enable_start_app() self.ui.main()
def __init__(self): self._create_window() # Setup a ConfigParser which will be used by the Yapsy plugin manager to # remember which plugins are activated. The function # xdg.BaseDirectory.save_config_path() function is used to get the path # for the configuration file. You may want to instead iterate over the # xdg.BaseDirectory.xdg_config_dirs if your application installs default # configuration files into system directories. See # http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html # for more information on the XDG specifications. self.config = SafeConfigParser() config_path = save_config_path(self.APP_NAME) self.config_file = os.path.join(config_path, self.APP_NAME + ".conf") logging.debug("Reading configuration file: %s" % self.config_file) self.config.read(self.config_file) # Build a list of directories which may contain plugins. This will # include the 'plugins' folder where this file resides as well as every # directory in xdg.BaseDirectory.xdg_data_dirs. This way users can # install plugins in something like ~/.local/yapsy-gtk-example/plugins # but your installer could also install those plugins to something like # /usr/share/yapsy-gtk-example/plugins. You'll see Yapsy checking each # of these directories if logging is set to logging.DEBUG this_dir = os.path.abspath(os.path.dirname(__file__)) plugin_dir = os.path.join(this_dir, 'plugins') places = [ plugin_dir, ] [ places.append(os.path.join(path, self.APP_NAME, "plugins")) for path in xdg_data_dirs ] # The singleton versino of the Yapsy plugin manager is used rather than # passing around a PluginManager instance. Prior to getting the # singleton instance, some "plugin manager decorators" are installed to: # 1. Automatically save active and non-active plugins to the config file # 2. Ensure only the newest versions of plugins are used. # This call to setBehaviour() must occur before getting the singleton # instance. PluginManagerSingleton.setBehaviour([ ConfigurablePluginManager, VersionedPluginManager, ]) # Get singleton instance manager = PluginManagerSingleton.get() # I like to give the manager a reference to the application class so # that plugins can connect to signals and access windows through # the manager singleton. manager.app = self # Give manager the config file and a callback function to call when it # changes the config (eg. when a plugin is activated or deactivated). manager.setConfigParser(self.config, self.write_config) # Setup a file extension for plugin information files. In this it's # just ".plugin" but you may want to do something specific to your # application like ".myapp-plugin" manager.setPluginInfoExtension("plugin") # Pass the manager the list of plugin directories manager.setPluginPlaces(places) # CollectPlugins is a shortcut for locatePlugins() and loadPlugins(). manager.collectPlugins() # Now that the plugins have been collected, the plugin widget can # be refreshed to display all installed plugins. self._plugin_list.refresh()
import json import os import sys from xdg.BaseDirectory import save_config_path from tordl import engines CFG_DIR = os.path.join(os.path.expanduser('~'), save_config_path('torrentdl')) CFG_FILE = os.path.join(CFG_DIR, 'config.json') CFG_ENGINES_FILE = os.path.join(CFG_DIR, 'engines.py') CFG_HISTORY_FILE = os.path.join(CFG_DIR, 'search_history.txt') SEARCH_ENGINES = [ '1337x', 'BTDB', 'Glo', 'KAT', 'Lime', 'Nyaa', 'Solid', 'TGx', 'TPB', 'Zooqle' ] TORRENT_CLIENT_CMD = 'qbittorrent %s' BROWSER_CMD = 'firefox %s' HISTORY_MAX_LENGTH = 100 PAGE_NUM_DOWNLOAD = 1 REQUEST_TIMEOUT = 5 AGGREGATE_SAME_MAGNET_LINKS = True FETCH_MISSING_MAGNET_LINKS = False FETCH_MAGNET_LINKS_CONCURRENCE = 20 USE_EXCLUDE_SEARCH = True EXCLUDE_SEARCH_DELIMITER = '::-'
import logging import os import configparser from xdg.BaseDirectory import save_config_path, load_config_paths logger = logging.getLogger(__name__) config_dir = save_config_path('python-magnatune') AUTHORIZED_OPTIONS = {'verbose': False, 'quiet': False, 'format': 'ogg', 'dlformat': 'web', 'login': None, 'extract': None} def setdefault_from_config(args): config = {} for f in load_config_paths('python-magnatune', 'config.ini'): logger.debug('Reading form config file: %s', f) parser = configparser.ConfigParser() try: parser.read(f) for option, value in parser['magnatune'].items(): if option not in AUTHORIZED_OPTIONS: logger.warning('Option "%s" in config file %s will be ignored', option, f) else: config.setdefault(option, value) except configparser.Error as e: logger.warning("Error while reading the config file %s, ignoring :\n%s", f, e)
def _credentials_file(self): """Path to per-user file with SSO credentials""" return os.path.join( save_config_path('ubuntu-image'), 'credentials.ini')
from os import path import math import configparser from itertools import chain, zip_longest, filterfalse from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException from xdg.BaseDirectory import save_cache_path, save_config_path APP_NAME = 'bch-interlinker' config_path = save_config_path(APP_NAME) config_file_path = path.join(config_path, 'config.ini') config = configparser.ConfigParser() config.read(config_file_path) chunk = lambda n, iterable: (filterfalse(lambda x: x == (), chunk) for chunk in (zip_longest(*[iter(iterable)]*n, fillvalue=()))) rpc = AuthServiceProxy("http://%s:%s@%s:%s" % (config['daemon']['user'], config['daemon']['password'], config['daemon']['host'], config['daemon']['port'])) def nice_batch(reqs): chunks = chunk(100000, reqs) return chain.from_iterable(rpc.batch_(r) for r in chunks) def command_for_height_range(cmd, range_): return nice_batch([cmd, h] for h in range_) def block_hashes_with_height(range_): return command_for_height_range('getblockhash', range_) def blocks_with_height(range_): return nice_batch(['getblock', h] for h in block_hashes_with_height(range_))
def run(self, argv): parser = argparse.ArgumentParser( prog=argv[0], description=_("Oversteer - Steering Wheel Manager")) parser.add_argument('command', nargs='*', help=_("Run as command's companion")) parser.add_argument('--device', help=_("Device path")) parser.add_argument('--list', action='store_true', help=_("list connected devices")) parser.add_argument('--mode', help=_("set the compatibility mode")) parser.add_argument('--range', type=int, help=_("set the rotation range [40-900]")) parser.add_argument('--combine-pedals', type=int, dest='combine_pedals', help=_("combine pedals [0-2]")) parser.add_argument('--autocenter', type=int, help=_("set the autocenter strength [0-100]")) parser.add_argument('--ff-gain', type=int, help=_("set the FF gain [0-100]")) parser.add_argument('--spring-level', type=int, help=_("set the spring level [0-100]")) parser.add_argument('--damper-level', type=int, help=_("set the damper level [0-100]")) parser.add_argument('--friction-level', type=int, help=_("set the friction level [0-100]")) parser.add_argument('--ffb-leds', action='store_true', default=None, help=_("enable FFBmeter leds")) parser.add_argument('--no-ffb-leds', dest='ffb_leds', action='store_false', default=None, help=_("disable FFBmeter leds")) parser.add_argument('--center-wheel', action='store_true', default=None, help=_("center wheel")) parser.add_argument('--no-center-wheel', dest='center_wheel', action='store_false', default=None, help=_("don't center wheel")) parser.add_argument('--start-manually', action='store_true', default=None, help=_("run command manually")) parser.add_argument('--no-start-manually', dest='start_manually', action='store_false', default=None, help=_("don't run command manually")) parser.add_argument('-p', '--profile', help=_("load settings from a profile")) parser.add_argument('-g', '--gui', action='store_true', help=_("start the GUI")) parser.add_argument('--debug', action='store_true', help=_("enable debug output")) parser.add_argument('--version', action='store_true', help=_("show version")) args = parser.parse_args(argv[1:]) argc = len(sys.argv[1:]) if args.version: print("Oversteer v" + self.version) sys.exit(0) if args.debug: argc -= 1 else: logging.disable(level=logging.INFO) device_manager = DeviceManager() device_manager.start() if args.list: argc -= 1 devices = device_manager.get_devices() print(_("Devices found:")) for device in devices: print(" {}: {}".format(device.dev_name, device.name)) sys, exit(0) if args.device is not None: argc -= 1 if os.path.exists(args.device): device = device_manager.get_device( os.path.realpath(args.device)) if not device.check_permissions(): print( _(("You don't have the required permissions to change your " + "wheel settings. You can fix it yourself by copying the {} " + "file to the {} directory and rebooting.").format( self.udev_file, self.target_dir))) else: device = device_manager.first_device() model = Model(device) if args.profile is not None: profile_file = os.path.join(save_config_path('oversteer'), 'profiles', args.profile + '.ini') if not os.path.exists(profile_file): print(_("This profile doesn't exist.")) sys.exit(2) model.load(profile_file) if args.start_manually is not None: model.set_start_app_manually(args.start_manually) start_gui = args.gui or argc == 0 or (model.get_start_app_manually() and args.command) if device is None and not start_gui: print(_("No device available.")) sys.exit(1) if args.mode is not None: model.set_mode(args.mode) if args.range is not None: model.set_range(args.range) if args.combine_pedals is not None: model.set_combine_pedals(args.combine_pedals) if args.autocenter is not None: model.set_autocenter(args.autocenter) if args.ff_gain is not None: model.set_ff_gain(args.ff_gain) if args.spring_level is not None: model.set_spring_level(args.spring_level) if args.damper_level is not None: model.set_damper_level(args.damper_level) if args.friction_level is not None: model.set_friction_level(args.friction_level) if args.ffb_leds is not None: model.set_ffb_leds(1 if args.ffb_leds else 0) if args.center_wheel is not None: model.set_center_wheel(1 if args.center_wheel else 0) if args.start_manually is not None: model.set_start_app_manually(1 if args.start_manually else 0) if start_gui: self.args = args self.device_manager = device_manager Gui(self, model, argv)
def load(self): """读入config""" self.config.read(os.path.join(save_config_path("gmusic"), "config"))