def testStoring(self): c1 = conf.Conf('salseeg') servers = c1.servers interval = c1.refreshInterval c1.write() c2 = conf.Conf('salseeg') self.assertEqual(interval, c2.refreshInterval) self.assertEqual(servers, c2.servers)
def __init__(self): path = os.path.expanduser('~') # print path; p, user = os.path.split(path) # print "user = {}\n".format(user); self.needToRebuildMenu = True self.user = user self.conf = conf.Conf(self.user) self.daemon = None self.start_deamon() self.icons = IconCache() # self.ind = appindicator.Indicator("ping-indicator-applet", LOGO, appindicator.CATEGORY_APPLICATION_STATUS) self.ind = appindicator.Indicator("ping-indicator-applet", LOGO, appindicator.CATEGORY_COMMUNICATIONS) self.ind.set_status(appindicator.STATUS_ACTIVE) self.menu = gtk.Menu() sep = gtk.SeparatorMenuItem() pref_item = gtk.MenuItem() pref_item.add(gtk.Label("Preferences")) pref_item.connect("activate", self.show_prefs) item = gtk.MenuItem() item.add(gtk.Label("exit")) item.connect("activate", self.exit) self.menu.append(sep) self.menu.append(pref_item) self.menu.append(item) self.menu.show_all() self.ind.set_menu(self.menu) self.gtkTimer = gtk.timeout_add(UPDATE_TIMEOUT, self.update)
def __init__(self): # Threading HTTP-Server self.conf = conf.Conf('wiera.conf') local_server_manager_port = self.conf.get('local_server_port') local_server_manager_ping_interval = self.conf.get('ping_interval') applications_port = self.conf.get('applications_port') #LocalServerList #not instance self.local_server_manager = localServerManager.LocalServerManager( local_server_manager_port, local_server_manager_ping_interval) #web server # self.web_server = wieraWebUserInterface.WieraWebUserInterface(self, 8080) #policy manager self.policy_manager = policyManager.PolicyManager() self.request_lock = threading.Lock() if self.conf.get('ui_command') == True: self.user_input_thread = threading.Thread(target=self._ui_handler) self.user_input_thread.daemon = True self.user_input_thread.start() #web server #Thrift server self.applications_server = threading.Thread( target=self._run_applications_server, args=([ applications_port, ])) self.applications_server.daemon = True self.applications_server.start()
class GoogleMap: obj_conf = conf.Conf() def __init__(self): return def check_compound_code(self, lat, lng, compound_code): # 为啥写这个方法……因为维基百科给出的东京坐标太大了……7700万个点超过了5G存储的限制 ## 检查是否在范围内并输出样例代码 # curr_latlon = TiteLation.tile2latlon(self.x, y, self.obj_conf.zoom) # next_latlon = TiteLation.tile2latlon(self.x + 1, y + 1, self.obj_conf.zoom) # if False is self.obj_googlemap.check_compound_code(curr_latlon['lat'], curr_latlon['lon'], 'Tokyo, Japan') \ # and False is self.obj_googlemap.check_compound_code(next_latlon['lat'], next_latlon['lon'], 'Tokyo, Japan'): # continue # # 输出东京范围内的数据 # print(self.x, y) # continue s = requests.Session() s.mount('https://', HTTPAdapter(max_retries=10)) ret = (s.get(self.obj_conf.googleMapTileCheckApi.format( lat, lng, self.obj_conf.googleMapKey), timeout=(3.05, 27))) return -1 is not str( ret.json()['plus_code']['compound_code']).find(compound_code)
def _get_advmenu(self): items = [] if conf.Conf().networking: items.append(("Networking", "Configure appliance networking")) if self.installer.available: items.append(("Install", "Install to hard disk")) plugin_map = {} for path in self.pluginManager.path_map: plug = self.pluginManager.path_map[path] if os.path.dirname(path) == PLUGIN_PATH: if isinstance(plug, plugin.Plugin) and hasattr( plug.module, 'run'): items.append((plug.module_name.capitalize(), str(plug.module.__doc__))) elif isinstance(plug, plugin.PluginDir): items.append( (plug.module_name.capitalize(), plug.description)) plugin_map[plug.module_name.capitalize()] = plug items.append(("Reboot", "Reboot the appliance")) items.append(("Shutdown", "Shutdown the appliance")) items.append(("Quit", "Quit the configuration console")) return items, plugin_map
def _get_public_ipaddr(cls): publicip_cmd = conf.Conf().publicip_cmd if publicip_cmd: try: return executil.getoutput(publicip_cmd) except executil.ExecError, e: pass
def main(args): #example for running code: python main.py -jid test -confFile ./data/default_scan_only.conf print "main.py::main()" parser = argparse.ArgumentParser() parser.add_argument( "-jid", "--jid", help="enter job ID" ) #job id to make a folder to store all the data for a specific job parser.add_argument( "-confFile", "--confFile", help="enter the configuration file") #path to configuration file args = parser.parse_args() print 'jobId:', args.jid, 'configfile:', args.confFile #make a results directory to store job results resultsDirName = args.jid os.makedirs(resultsDirName) #make a file list to store all the files to be moved to the results folder fileList = [] #copy the config file cpConfFileName = args.jid + '_in_conf_file' cpConfFile = open(cpConfFileName, 'wb') with open(args.confFile, 'rb') as handler: for line in handler: cpConfFile.write(line) cpConfFile.close() fileList.append(cpConfFileName) #make a config object confObj = conf.Conf() confDict = confObj.read(args.confFile) ############ #Have a PWM file and want to scan it across a fasta file and then apply sequence coverage ############ if confDict['job.type']['type'] == 'motifPwmScanCov': print 'motif_pwm scanning and coverage operation' motif_pwm_scan_cov.callMotifPwmScanCov(args, confDict, fileList) #move files to results folder for outFile in fileList: shutil.move(outFile, resultsDirName) exit() ############ #Have a PWM file and want to scan it across a file only ############ if confDict['job.type']['type'] == 'pwmScan': print 'motif pwm scanning only' motif_pwm_scan_only.callMotifPwmScanOnly(args, confDict, fileList) #move files to results folder for outFile in fileList: shutil.move(outFile, resultsDirName) exit() ############### #EXIT ############### exit()
def _get_public_ipaddr(cls): publicip_cmd = conf.Conf().publicip_cmd if publicip_cmd: command = subprocess.run(publicip_cmd, stdout=PIPE) if command.returncode == 0: return command.stdout return None
def _get_public_ipaddr(cls): publicip_cmd = conf.Conf().publicip_cmd if publicip_cmd: command = subprocess.run(shlex.split(publicip_cmd), stdout=PIPE, encoding='utf-8') if command.returncode == 0: return command.stdout.strip() return None
def __init__(self, conf_dir, db_conf=dict(), check_conf_change=False, debug=False): self._conf_dir = conf_dir self._db_conf = dict() self._db_conf.update(db_conf) self._check_conf_change = check_conf_change self._debug = debug self._title_pat = re.compile(ur'<title>(.+?)</title>', flags=re.IGNORECASE) self._conf = conf.Conf(self._conf_dir, 'page_judge.conf', 'asyn_judge.conf') self._conn = None self.db_conn()
def file_new_cb(self, action): """Start new file of config data""" if self.check_dirty(): return self.tree_model.clear() self.has_data = False self.dirty = False self.filename = "" self.config_data = conf.Conf() self.config_data.setup_defaults()
def lint_files(paths, lint_error, conf=conf.Conf(), printpaths=True): def lint_file(path, kind, jsversion): def import_script(import_path, jsversion): # The user can specify paths using backslashes (such as when # linting Windows scripts on a posix environment. import_path = import_path.replace('\\', os.sep) import_path = os.path.join(os.path.dirname(path), import_path) return lint_file(import_path, 'js', jsversion) def _lint_error(*args): return lint_error(normpath, *args) normpath = fs.normpath(path) if normpath in lint_cache: return lint_cache[normpath] if printpaths: print normpath contents = fs.readfile(path) lint_cache[normpath] = _Script() script_parts = [] if kind == 'js': script_parts.append((None, jsversion or conf['default-version'], contents)) elif kind == 'html': assert jsversion is None for script in _findhtmlscripts(contents, conf['default-version']): # TODO: Warn about foreign languages. if not script['jsversion']: continue if script['type'] == 'external': other = import_script(script['src'], script['jsversion']) lint_cache[normpath].importscript(other) elif script['type'] == 'inline': script_parts.append((script['pos'], script['jsversion'], script['contents'])) else: assert False, 'Invalid internal script type %s' % \ script['type'] else: assert False, 'Unsupported file kind: %s' % kind _lint_script_parts(script_parts, lint_cache[normpath], _lint_error, conf, import_script) return lint_cache[normpath] lint_cache = {} for path in paths: ext = os.path.splitext(path)[1] if ext.lower() in ['.htm', '.html']: lint_file(path, 'html', None) else: lint_file(path, 'js', None)
def __init__(self, filename=""): gtk.Window.__init__(self) self.set_position(gtk.WIN_POS_CENTER) self.set_title('Setup CUPSPY printers') self.connect('delete-event', self.delete_event_cb) self.set_size_request(550, 200) vbox = gtk.VBox() self.add(vbox) self.create_ui() vbox.pack_start(self.ui.get_widget('/Menubar'), expand=False) vbox.pack_start(self.ui.get_widget('/Toolbar'), expand=False) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) vbox.pack_start(sw) self.tree_model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING) self.tree_model.connect('row-inserted', inserted_cb, self) self.tree_model.connect('row-deleted', deleted_cb, self) self.tree_view = gtk.TreeView(self.tree_model) self.tree_view.set_reorderable(True) self.tree_view.connect('row-activated', activated_cb, self) rend = gtk.CellRendererToggle() col = self.tree_view.insert_column_with_attributes(-1, "Default", rend, active=0) col.set_resizable(True) rend = gtk.CellRendererText() col = self.tree_view.insert_column_with_attributes(-1, "Name", rend, text=1) col.set_resizable(True) rend = gtk.CellRendererText() col = self.tree_view.insert_column_with_attributes(-1, "Description", rend, text=2) col.set_resizable(True) sw.add(self.tree_view) status = gtk.Statusbar() vbox.pack_end(status, expand=False) self.dirty = False self.has_data = False self.filename = "" self.config_data = conf.Conf() if len(filename) != 0: self.load_file(filename) else: self.config_data.setup_defaults()
def __init__(self): confFilePath = os.path.dirname(__file__) + "/gapp.ini" self.conf = conf.Conf(confFilePath) if len(sys.argv) > 1: if sys.argv[1] == 'stop': self.stop() elif sys.argv[1] == 'restart': self.restart() else: self.start() else: self.start()
def __init__(self, title=None, width=60, height=20): self.width = width self.height = height self.console = dialog.Dialog(dialog="dialog") self.console.add_persistent_args(["--no-collapse"]) self.console.add_persistent_args(["--ok-label", "Select"]) self.console.add_persistent_args(["--cancel-label", "Back"]) self.console.add_persistent_args(["--colors"]) if conf.Conf().copy_paste: self.console.add_persistent_args(["--no-mouse"]) if title: self.console.add_persistent_args(["--backtitle", title])
def apply_prefs(self, obj): buf = self.pref_tree.get_widget("hosts__textview").get_buffer() text = buf.get_text(buf.get_start_iter(), buf.get_end_iter()) scale = self.pref_tree.get_widget("interval__hscale") c = conf.Conf(self.user) c.set_servers(text) c.refreshInterval = int(scale.get_value()) c.write() self.restart_timer(c.refreshInterval) self.restart_deamon() self.close_prefs(obj) self.needToRebuildMenu = True
def conf(self): cw = conf.Conf(self.path, self.solver) try: self.solver = cw.solver try: f = open(self.path + "/settings/solver", "w") f.writelines([ self.solver[0] + "\n", self.solver[1] + "\n", self.solver[2] ]) f.close() except IsADirectoryError: pass except AttributeError: pass
def _get_default_nic(cls): def _validip(ifname): ip = ifutil.get_ipconf(ifname)[0] if ip and not ip.startswith('169'): return True return False ifname = conf.Conf().default_nic if ifname and _validip(ifname): return ifname for ifname in cls._get_filtered_ifnames(): if _validip(ifname): return ifname return None
def _get_filtered_ifnames(): ifnames = [] for ifname in netinfo.get_ifnames(): if ifname.startswith(('lo', 'tap', 'br', 'natbr', 'tun', 'vmnet', 'veth', 'wmaster')): continue ifnames.append(ifname) # handle bridged LXC where br0 is the default outward-facing interface defifname = conf.Conf().default_nic if defifname and defifname.startswith('br'): ifnames.append(defifname) bridgedif = executil.getoutput('brctl', 'show', defifname).split('\n')[1].split('\t')[-1] ifnames.remove(bridgedif) ifnames.sort() return ifnames
class OpenSearch: obj_conf = conf.Conf() client = Client(obj_conf.opensearchAccessKeyId, obj_conf.opensearchAccessKeySecret, obj_conf.opensearchAPI) index_doc = IndexDoc(client, obj_conf.opensearchAppId) def __init__(self): return def insert(self, parsed_cyber_data): # 解析数据 parsed_items = self.parse(parsed_cyber_data) for item in parsed_items: # 插入表 self.index_doc.add(item, self.obj_conf.opensearchTable) return def parse(self, parsed_cyber_data): parsed_items = [] for i in range(0, self.obj_conf.shard): for j in range(0, self.obj_conf.shard): loc = str(parsed_cyber_data[i][j]["lon"]) + " " + str( parsed_cyber_data[i][j]["lat"]) parsed_items.append({ "id": loc, "loc": loc, "elevation": int(float(parsed_cyber_data[i][j]["elevation"]) * 100), }) return parsed_items def insertDrain(self, points): for k in points: data = points[k] item = { "id": str(data['lng']) + " " + str(data['lat']), "loc": str(data['lng']) + " " + str(data['lat']), "total": data['total'], "name": data['name'] } print(self.index_doc.add(item, self.obj_conf.opensearchTable)) return
def init(self, args): logger.info("action: init") path = (Path(args.path) if args.path else Path()) path = path.expanduser().resolve().joinpath("autorerename.conf.ini") if path.exists(): print("It already exists.") return EXIT_ERROR cf = conf.Conf() cf.path = path cf.rule_db_path.parent.mkdir(parents=True, exist_ok=True) cf.actlog_path.parent.mkdir(parents=True, exist_ok=True) conf.save_conf(cf) print("Create repositiory at {}".format(cf.path))
class Basic: obj_conf = conf.Conf() def __init__(self): return @classmethod def get_elevation(self, loc_lat, loc_lng): req = None while req is None: try: req = requests.get( self.obj_conf.googleMapElevationApi.format( loc_lat, loc_lng, self.obj_conf.googleMapKey)) except: print("Except") req_json = req.json() return req_json['results'][0]
def execute(cmd): '''用命令提示符执行命令 Args: cmd: 执行的命令 Returns: 执行的结果 ''' import conf result = '' p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) for line in p.stdout.readlines(): result += line.decode(conf.Conf().get('encoding')) return result
def get_suggestions(self, term, maxitems, ranked, checked): """ queries sphinx indexer and returns the labels that start with - prefix (or containing - infix) the incomming term """ """ or False and a (errorcode,error str) tuple """ # here we ignore maxitems, but term must be present if term == None or term == '': result = [ ] # NOTE: here on error we return empty list - error messages have no meaning here else: # transform search term for search term = term.decode("utf_8") # convert to unicode # connect to DB according to conf.txt confobj = conf.Conf() params = json.loads(confobj.provideConfParams()) conn = ast.literal_eval(params['connectionstring']) db = MySQLdb.connect(**conn) cursor = db.cursor() if ranked == 'true': #do some ranking to results according to their backlinks print "checked:" + checked if (checked == '0'): sqlcmd = "SELECT label FROM autosuggest WHERE MATCH(%s) order by howmanyurid desc, apuricount desc limit 0, 2" else: sqlcmd = "SELECT label FROM autosuggest WHERE MATCH(%s) and nodeindex=" + checked + "order by howmanyurid desc, apuricount desc limit 0, 2" else: if (checked == '0'): sqlcmd = "SELECT label FROM alphabetical WHERE MATCH(%s) order by label asc limit 0, 150" else: sqlcmd = "SELECT label FROM alphabetical WHERE MATCH(%s) and nodeindex=" + checked + "order by label asc limit 0, 150" """replace error prone chars /,(,)," """ term = term.replace('(', '\(') term = term.replace(')', '\)') term = term.replace('"', '\"') term = term.replace('/', '\/') cursor.execute(sqlcmd, ('*' + term + '*')) result = list(cursor.fetchall()) print "result: ", result db.close() # as we don't have anything else to do here, we return a succeded defer sucdefer = defer.succeed( result) # result will be passed to any callback attached # return the defered return sucdefer
def __init__( self ): self.qapp = None self.qtui = None self.jobs = {} self.threadQueue = queue.Queue() self.hotkeyQueue = queue.Queue() self.conf = conf.Conf() self.activeOnHeard = True self.kb = Controller() ## *** all this keyboard stuff should go in a submodule later... self.kbListener = pynput.keyboard.Listener( on_press=self.kbListenerOnRelease, on_release=self.kbListenerOnRelease, ) self.kbListener.start()
def show_prefs(self, obj): self.pref_tree = gtk.glade.XML(UI_DIR + "conf.glade", "dialog1") window = self.pref_tree.get_widget("dialog1") # window.connect("delete_event", gtk.main_quit) c = conf.Conf(self.user) data_file = data_exch.Data_Exch(self.user) data = data_file.read() text = "" for host, dalay in data: text += host + "\n" tw = self.pref_tree.get_widget("hosts__textview") buf = tw.get_buffer() buf.set_text(text) scale = self.pref_tree.get_widget("interval__hscale") scale.set_value(c.refreshInterval) self.pref_tree.get_widget("cancel__button").connect( "clicked", self.close_prefs) self.pref_tree.get_widget("ok__button").connect( "clicked", self.apply_prefs) window.show_all()
def get_provenanceInfo(self): """ queries the sphinx indexer and returns various data """ """ or False and a (errorcode,error str) tuple """ sqlcmd = '' #jsonresult = '{}' jsonresult = collections.OrderedDict() confobj = conf.Conf() params = json.loads(confobj.provideConfParams()) conn = ast.literal_eval(params['connectionstring']) db = MySQLdb.connect(**conn) cursor = db.cursor() sqlcmd = "select node, howmanyuris from provenance where match(%s) order by howmanyuris desc limit 0, 1000" q = 'http:*' cursor.execute(sqlcmd, q) result = cursor.fetchall() totaluris = 0 if (result != None): flagstart = 'true' for row in result: if (flagstart == 'true'): jsonresult[u"nodes"] = [] jsonresult[u"nodesindex"] = [] jsonresult[u"howmanyuris"] = [] flagstart = 'false' jsonresult[u"nodes"].append(row[2]) jsonresult[u"nodesindex"].append(row[0]) jsonresult[u"howmanyuris"].append(row[3]) totaluris += row[3] jsonresult[u"totaluris"] = str(totaluris) print "Number of rows returned: %d" % cursor.rowcount db.close() j = json.dumps(jsonresult) # as we don't have anything else to do here, we return a succeded defer sucdefer = defer.succeed( j) # result will be passed to any callback attached # return the defered return sucdefer
def read(self): c = conf.Conf(self.user) if os.path.exists(self.filename): t = int(time.time()) delays = [] if t - int(os.path.getmtime(self.filename)) < ( 2 * c.refreshInterval / 1000): f = open(self.filename, "r") for line in f: parts = line.strip().split(':') if len(parts) > 1: delays.append((parts[0], float(parts[1]))) f.close() else: # indicating deamon died ind = t % 4 delays.append(("no", 0.1)) delays.append(("fresh", 0.1)) delays.append(("data", 0.1)) delays.append(("found", 0.1)) host, data = delays[ind] delays[ind] = (host, 10000) return delays return False
def load_file(self, filename): """Load up a config file""" self.config_data = conf.Conf() try: self.config_data.parse_conf_file(filename) self.filename = filename defptr = self.config_data.default_printer() plist = self.config_data.list_printers() self.tree_model.clear() for p in plist: isdef = p == defptr inf = self.config_data.get_attribute_value(p, 'printer-info') if not inf: inf = "" self.tree_model.append((isdef, p, inf)) self.dirty = False self.has_data = True except conf.ConfError as msg: error_dlg(msg.args[0]) self.filename = "" self.config_data.setup_defaults() self.dirty = False self.has_data = False
def _ifconf_default(self): conf.Conf().set_default_nic(self.ifname) return "ifconf"