def _read_from_sections(user, collection_url, permission): regex = ConfigParser({'login': user, 'path': collection_url}) for rights in (INITIAL_RIGHTS, settings.DJRADICALE_RIGHTS): for section, values in rights.items(): if not regex.has_section(section): regex.add_section(section) for key, value in values.items(): regex.set( section, key, value % { 'login': re.escape(user), 'path': re.escape(collection_url), }) log.LOGGER.debug("Rights type '%s'" % __name__) for section in regex.sections(): re_user = regex.get(section, 'user') re_collection = regex.get(section, 'collection') log.LOGGER.debug( "Test if '%s:%s' matches against '%s:%s' from section '%s'" % ( user, collection_url, re_user, re_collection, section)) user_match = re.match(re_user, user) if user_match: re_collection = re_collection.format(*user_match.groups()) if re.match(re_collection, collection_url): log.LOGGER.debug("Section '%s' matches" % section) if permission in regex.get(section, 'permission'): return True else: log.LOGGER.debug("Section '%s' does not match" % section) return False
def __init__(self): """클래스의 생성자 입니다. webdriver와 로그인에 사용될 email, password, 어떤 그룹의 신규가입자에게 메세지를 보낼지 결정하는 group_id, 메세지 내용을 담고있는 msg(message) 를 settings.ini에서 읽어와 변수에 저장합니다. """ self.driver = webdriver.Firefox() self.driver.implicitly_wait(30) self.base_url = "https://www.facebook.com/" self.verificationErrors = [] self.accept_next_alert = True from configparser import RawConfigParser from os.path import join, abspath, dirname import codecs settings_path = join(abspath(dirname(__file__)), 'settings.ini') cfg = RawConfigParser() cfg.read_file(codecs.open(settings_path, "r", "utf8")) self.email = cfg.get('setting', "email") self.pw = cfg.get('setting', 'pw') self.group_id = cfg.get('setting', 'group_id') self.group_name = cfg.get('setting', 'group_name')
def send_old_submits(): submits = filter(lambda s:s.startswith("submit-"), os.listdir(os.getenv("PINGUINO_USER_PATH"))) for submit in submits: parser = RawConfigParser() filename = os.path.join(os.getenv("PINGUINO_USER_PATH"), submit) parser.readfp(open(filename, "r")) summary = parser.get("SUBMIT", "summary") details = parser.get("SUBMIT", "details") repo = parser.get("SUBMIT", "repo") environ = parser.get("SUBMIT", "environ") username = parser.get("SUBMIT", "username") password = parser.get("SUBMIT", "password") try: url = 'https://api.github.com/repos/{}/{}/issues'.form session = requests.Session() session.auth = (username, password) issue = {'title': summary, 'body': "{}\n\n{}".format(details, environ), 'labels': ['submitted-from-ide', 'bug', 'v{}'.format(os.environ["PINGUINO_VERSION"][:2]), ], } r = session.post(url, json.dumps(issue)) os.remove(filename) except: pass
def parse_cmake_module(s_in): s_out = [] is_rst_line = False for line in s_in.split('\n'): if is_rst_line: if len(line) > 0: if line[0] != '#': is_rst_line = False else: is_rst_line = False if is_rst_line: s_out.append(line[2:]) if '#.rst:' in line: is_rst_line = True autocmake_entry = '\n'.join(s_out).split('Example autocmake.cfg entry::')[1] autocmake_entry = autocmake_entry.replace('\n ', '\n') buf = StringIO(autocmake_entry) config = RawConfigParser(dict_type=OrderedDict) config.readfp(buf) config_docopt = None config_define = None config_export = None for section in config.sections(): if config.has_option(section, 'docopt'): config_docopt = config.get(section, 'docopt') if config.has_option(section, 'define'): config_define = config.get(section, 'define') if config.has_option(section, 'export'): config_export = config.get(section, 'export') return config_docopt, config_define, config_export
def _start_observing(self): # ``StatsCore`` is the original observant daemon. It seems to have been # replaced more recently by ``vigilant.daemon.Daemon`` # TODO: update for vigilant Daemon # Get vigilant to read its own config config = CParser() config.read(os.path.join(etc_location, 'vigilant.cfg')) # Extract the information we need from the config object lock = str(config.get('daemon', 'lock')) sock = str(config.get('daemon', 'sock')) transport_type = str(config.get('transport', 'type')) host = str(config.get('transport', 'host')) port = int(config.get('transport', 'port')) transport_means = UDPStatsTransport if transport_type == 'udp' else TCPStatsTransport transport = transport_means(host=host, port=port) # Start the daemon self.client = StatsCore.attachOrCreateStatsDaemon(transport, pid=lock, sock=sock) # Tell the daemon who we are self.client.postWatchPid('go-smart-launcher', os.getpid()) # Give it a second to avoid confusion by posting before registered # TODO: tidy this up! time.sleep(1)
def set_environ_vars(cls): if not os.path.exists(os.path.join(os.getenv("PINGUINO_DATA"), "paths.cfg")): logging.error("Missing: "+os.path.join(os.getenv("PINGUINO_DATA"), "paths.cfg")) sys.exit() config_paths = RawConfigParser() config_paths.readfp(open(os.path.join(os.getenv("PINGUINO_DATA"), "paths.cfg"), "r")) #RB20141116 : get the “bitness” of the current OS bitness, linkage = platform.architecture() os.environ["PINGUINO_OS_ARCH"] = bitness if os.name == "posix": #GNU/Linux os.environ["PINGUINO_OS_NAME"] = "linux" #Mac could return posix :/ elif os.name == "os2": #Mac OS X os.environ["PINGUINO_OS_NAME"] = "macosx" elif os.name == "nt": #Windows os.environ["PINGUINO_OS_NAME"] = "windows" #load path from paths.conf os.environ["PINGUINO_USER_PATH"] = os.path.expandvars(os.path.expanduser(config_paths.get("paths-%s"%os.getenv("PINGUINO_OS_NAME"), "user_path"))) os.environ["PINGUINO_INSTALL_PATH"] = os.path.expandvars(os.path.expanduser(config_paths.get("paths-%s"%os.getenv("PINGUINO_OS_NAME"), "install_path"))) os.environ["PINGUINO_USERLIBS_PATH"] = os.path.expandvars(os.path.join(os.getenv("PINGUINO_USER_PATH"), "library_manager"))
def __init__(self, config_path=None): if config_path is None: config_path = 'regexbot.ini' config = RawConfigParser() config.read_dict(DEFAULT_CONFIG) config.read(config_path) self.rtm_token = config.get('regexbot', 'rtm_token') self.channel_flood_cooldown = timedelta(seconds=config.getint('regexbot', 'channel_flood_cooldown')) self.global_flood_cooldown = timedelta(seconds=config.getint('regexbot', 'global_flood_cooldown')) self.max_messages = config.getint('regexbot', 'max_messages') self.max_message_size = config.getint('regexbot', 'max_message_size') self.version = str(config.get('regexbot', 'version')) + '; %s' try: self.version = self.version % Popen(["git","branch","-v","--contains"], stdout=PIPE).communicate()[0].strip() except: self.version = self.version % 'unknown' self._last_message_times = {} self._last_message = datetime.utcnow() self._message_buffer = {} self.ignore_list = [] if config.has_section('ignore'): for k,v in config.items('ignore'): try: self.ignore_list.append(regex.compile(str(v), regex.I)) except Exception, ex: print "Error compiling regular expression in ignore list (%s):" % k print " %s" % v print ex exit(1)
class BCMConfig(): """ Reads configuration information from bcm.ini. Args: username (str): bricklink username password (str): bricklink password wantedfilename (str): path of the wanted list pricefilename (str): path of the previously scrubbed price list reloadpricesfromweb (bool): if true, download and parse all of the price data again and save it to pricefilename. _parser (SafeConfigParser): parser that reads the config file _configfile (str): relative path of the config file """ def __init__(self): # _parser = SafeConfigParser() self._configfile = '../bcm.ini' self._parser = RawConfigParser() self._parser.read(self._configfile) self.username = self._parser.get('bricklink', 'username') self.password = self._parser.get('bricklink', 'password') self.wantedfilename = self._parser.get('filenames', 'wanted') self.pricefilename = self._parser.get('filenames', 'prices') self.reloadpricesfromweb = self._parser.getboolean('options', 'reloadpricesfromweb')
def test(): config = CParser() config.read('./etc/observant/observant.cfg') pid = os.fork() if pid != 0: os.waitpid(pid, 0) else: dump = './.test.out' sockPath = './.test.sock' server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) server.setblocking(0) with open(dump, 'w') as fd: fd.write("test") server.bind(sockPath) server.listen(1) transport = daemon.transportFromConfig(config) lock = str(config.get('daemon', 'lock')) sock = str(config.get('daemon', 'sock')) key = str(config.get('daemon', 'key')) client = StatsCore.attachOrCreateStatsDaemon(key, transport, pid=lock, sock=sock) client.postWatchPid('test', os.getpid()) time.sleep(4) client.postLogMessageForKey('test', 'some random logmessage') time.sleep(4) client.postLogMessageForKey('test', 'some random logmessage') client.close() time.sleep(4) os.remove(dump) server.close() os.unlink(sockPath)
def init(app, config_file): global metadata config = ConfigParser() config.read(config_file) try: filename = config.get('bibtex', 'path') except ConfigParserError: model_path = config.get('main', 'path') filename = os.path.join(model_path, 'library.bib') print("Loading Bibtex metadata from", filename) bib = parse_file(filename) metadata = dict() for entry in bib.entries: key = '/' + bib.entries[entry].fields.get('file', '').replace(':pdf', '')[1:] if 'C$\\backslash$:' in key: key = key.replace('C$\\backslash$:', '') key = key[1:] key = os.path.normpath(key) key = os.path.basename(key) try: citation = pybtex.format_from_file( filename, style='plain', output_backend='text', citations=[entry])[3:] metadata[key] = citation except PybtexError: metadata[key] = filename
def _parse_legacy_config_file(self): """ Parse a legacy configuration file. """ conf = RawConfigParser() conf.read(LEGACY_CONFIG_FILE) styles = self.styles.copy() if conf.has_option('params', 'dm_template'): styles['dm_template'] = conf.get('params', 'dm_template') if conf.has_option('params', 'header_template'): styles['header_template'] = conf.get('params', 'header_template') self.styles.update(styles) if conf.has_option('params', 'logging_level'): self.logging_level = conf.getint('params', 'logging_level') for binding in self.key_bindings: if conf.has_option('keys', binding): custom_key = conf.get('keys', binding) self._set_key_binding(binding, custom_key) palette_labels = [color[0] for color in PALETTE] for label in palette_labels: if conf.has_option('colors', label): custom_fg = conf.get('colors', label) self._set_color(label, custom_fg)
def parse_and_append(self, filename): try: parser = RawConfigParser() parser.read([filename]) if not parser.has_section(sect): return app_categories = parser.get(sect, 'Categories') if not app_categories: return if not any(category in self.PLAYER_CATEGORIES for category in app_categories.split(';')): return # Find out if we need it by comparing mime types app_mime = parser.get(sect, 'MimeType') for needed_type in self.mimetypes: if app_mime.find(needed_type + '/') != -1: app_name = parser.get(sect, 'Name') app_cmd = parser.get(sect, 'Exec') app_icon = parser.get(sect, 'Icon') if not self.__has_sep: self.add_separator() self.apps.append(UserApplication(app_name, app_cmd, app_mime, app_icon)) return except: return
def read_config_file(filename): """ Reads a configuration file to modify the global settings. :param filename: cfg file pathname, read through os.path.normpath """ global LOG_FORMAT, LOG_FILENAME, STATE_REGEX, ZIP_REGEX # Config parser object, load settings for global variables config = RawConfigParser() config.read(path.normpath(filename)) # Sections should be "log" and "validators" for section in config.sections(): # Options for log: format, output # Options for validators: zip_code, state for option in config.options(section): if section == "log" and option == "format": LOG_FORMAT = config.get(section, option) elif section == "log" and option == "output": LOG_FILENAME = config.get(section, option) elif section == "validators" and option == "state": STATE_REGEX = compile(config.get(section, option)) elif section == "validators" and option == "zip_code": ZIP_REGEX = compile(config.get(section, option))
def read_config(self, config): result = [] stack = [config] while 1: config = stack.pop() src = None if isinstance(config, (str, unicode)): src = os.path.relpath(config) _config = RawConfigParser() _config.optionxform = lambda s: s if getattr(config, 'read', None) is not None: _config.readfp(config) path = self.path else: if not os.path.exists(config): log.error("Config file '%s' doesn't exist.", config) sys.exit(1) _config.read(config) path = os.path.dirname(config) for section in reversed(_config.sections()): for key, value in reversed(_config.items(section)): result.append((src, path, section, key, value)) result.append((src, path, section, None, None)) if _config.has_option('global', 'extends'): extends = _config.get('global', 'extends').split() elif _config.has_option('global:global', 'extends'): extends = _config.get('global:global', 'extends').split() else: break stack[0:0] = [ os.path.abspath(os.path.join(path, x)) for x in reversed(extends)] return reversed(result)
def parse_token_file(self, token_file): conf = RawConfigParser() conf.read(token_file) if conf.has_option(SECTION_TOKEN, "oauth_token"): self.oauth_token = conf.get(SECTION_TOKEN, "oauth_token") if conf.has_option(SECTION_TOKEN, "oauth_token_secret"): self.oauth_token_secret = conf.get(SECTION_TOKEN, "oauth_token_secret")
def version(self, root): """Retrieve the release version of the installed browser.""" platform_info = RawConfigParser() with open(os.path.join(root, self.platform_ini), "r") as fp: platform_info.readfp(BytesIO(fp.read())) return "BuildID %s; SourceStamp %s" % ( platform_info.get("Build", "BuildID"), platform_info.get("Build", "SourceStamp"))
def _parse_legacy_token_file(self): conf = RawConfigParser() conf.read(LEGACY_TOKEN_FILE) if conf.has_option(SECTION_TOKEN, "oauth_token"): self.oauth_token = conf.get(SECTION_TOKEN, "oauth_token") if conf.has_option(SECTION_TOKEN, "oauth_token"): self.oauth_token_secret = conf.get(SECTION_TOKEN, "oauth_token_secret")
def settings_from_config(options): """Try to read config file and parse settings. Args: options: parsed NameSpace, with `config` and maybe `acl` values Returns: tuple of S3Config and PyPIConfig objects, or Nones when missing values """ parser = RawConfigParser() if isinstance(options.config, list): config_file = options.config[0] else: config_file = options.config try: parser.read(config_file) except Exception as error: print(error, file=sys.stderr) key = "pypicloud" # config section key if key not in parser.sections(): return None, None s3_conf = None pypi_conf = None s3_required = ("bucket", "access", "secret") pypi_required = ("repository", "username", "password") if all([parser.has_option(key, opt) for opt in s3_required]): if getattr(options, "acl", None): acl = options.acl[0] elif parser.has_option(key, "acl"): acl = parser.get(key, "acl") else: acl = None s3_conf = S3Config( parser.get(key, "bucket"), parser.get(key, "access"), parser.get(key, "secret"), acl, ) if all([parser.has_option(key, opt) for opt in pypi_required]): pypi_conf = PyPIConfig( parser.get(key, "repository"), parser.get(key, "username"), parser.get(key, "password"), ) return s3_conf, pypi_conf
def from_ini_file(cls, cfg_file, no_default=False): lst = cls(no_default) config = RawConfigParser() if config.read([cfg_file]) != []: for section in config.sections(): try: test = config.get(section, 'TEST') except NoOptionError: test = 'lambda(x): True' lst.append(Definition(section, config.get(section, 'MODULE'), eval(test))) return lst
def load_mc_config(self): """Load the configuration from minecraft-control.""" log.debug("Loading minecraft-control settings from {}".format(args.config)) parser = RawConfigParser() with open(self.args.config, "r") as fh: parser.readfp(fh) self.config["host"] = parser.get("tcp-server", "address") self.config["port"] = parser.get("tcp-server", "port") self.config["password"] = parser.get("auth", "password") self.config["method"] = parser.get("auth", "method")
class FactorioLocale: def __init__(self): self.conf = RawConfigParser() self.crap = RawConfigParser() def get_name(self, section, name): return self.conf.get(section, name) or '#%s#%s#' % (section, name) def load(self, csv): conf = RawConfigParser() with open(csv, 'rb') as f: input_bytes = f.read() decoded = input_bytes.decode(chardet.detect(input_bytes)['encoding']) decoded = '[__global__]\n' + decoded conf.read_string(decoded) for sec in conf.sections(): if not self.conf.has_section(sec): self.conf.add_section(sec) self.crap.add_section(sec) for k, v in conf.items(sec): is_crap = False if '__' in v: is_crap = True if not is_crap: if self.conf.has_option(sec, k): if self.conf.get(sec, k).lower() != v.lower(): print('Overwriting locale %s (%r -> %r)' % (k, self.conf.get(sec, k), v)) self.conf.set(sec, k, v) else: if self.crap.has_option(sec, k): print('Overwriting crap locale %s (%r -> %r)' % (k, self.crap.get(sec, k), v)) self.crap.set(sec, k, v) def merge(self): for sec in self.crap.sections(): for k, v in self.crap.items(sec): if not self.conf.has_option(sec, k): print('Using crap locale %s (%r)' % (k, v)) self.conf.set(sec, k, v) def save(self, out): with open(out, 'w') as f: self.conf.write(f)
def read_pypirc(repository=DEFAULT_REPOSITORY, realm=DEFAULT_REALM): """Read the .pypirc file.""" rc = get_pypirc_path() if os.path.exists(rc): config = RawConfigParser() config.read(rc) sections = config.sections() if "distutils" in sections: # let's get the list of servers index_servers = config.get("distutils", "index-servers") _servers = [server.strip() for server in index_servers.split("\n") if server.strip() != ""] if _servers == []: # nothing set, let's try to get the default pypi if "pypi" in sections: _servers = ["pypi"] else: # the file is not properly defined, returning # an empty dict return {} for server in _servers: current = {"server": server} current["username"] = config.get(server, "username") # optional params for key, default in (("repository", DEFAULT_REPOSITORY), ("realm", DEFAULT_REALM), ("password", None)): if config.has_option(server, key): current[key] = config.get(server, key) else: current[key] = default if current["server"] == repository or current["repository"] == repository: return current elif "server-login" in sections: # old format server = "server-login" if config.has_option(server, "repository"): repository = config.get(server, "repository") else: repository = DEFAULT_REPOSITORY return { "username": config.get(server, "username"), "password": config.get(server, "password"), "repository": repository, "server": server, "realm": DEFAULT_REALM, } return {}
def populate_config_dict(config_path): """Load the configuration file into the config_file dictionary A ConfigParser-style configuration file can have multiple sections, but we ignore the section distinction and load the key/value pairs from all sections into a single key/value list. """ try: config_dict = {} parser = RawConfigParser() parser.optionxform = lambda x: x parser.read(config_path) sections = parser.sections() for section in sections: options = parser.options(section) for option in options: config_dict[option] = str(parser.get(section, option)) except Exception as e: logger.warning("Could not load configuration file due to exception. " "Only environment variable equivalents will be used.") return None for key in config_dict.keys(): if config_dict[key] == '': config_dict[key] = None elif isinstance(config_dict[key], str): config_dict[key] = os.path.expanduser(config_dict[key]) return config_dict
def run(): # load the config file global master_config master_config = RawConfigParser() master_config.read(config_directory + MASTER_CONFIG_FILENAME) # set the get-iplayer path global get_iplayer_path if master_config.has_option("General", "get-iplayer_path"): get_iplayer_path = master_config.get("General", "get-iplayer_path") # refresh the get-iplayer cache # print("Refreshing get-iplayer... (this may take some time)") # subprocess.check_output([get_iplayer_path, "--type=all", "--quiet"]) # new BBC rules :-( now we get the programm info externally using a different script # and read that scripts output directly into a hash # global bbc_programmes # bbc_programmes = load_bbc_programmes() # scan for feed config files and process each for root, directories, files in os.walk(config_directory + FEED_CONFIG_DIRECTORY): for filename in files: if filename == ".DS_Store": continue print("about to read config " + filename ) load_feed(filename) print("Finished.") return # stop here, we have processed the feeds # if we have not returned at this point, then no config directory was found, this is a problem print("No config directory found")
def run(): # print a warning about copyright print("WARNING: Do not use the script to produce public podcasts, it is for personal use only.") print("If you publically serve programmes you may be in violation of the BBC's copyright.") # load the config file global master_config master_config = RawConfigParser() master_config.read(config_directory + MASTER_CONFIG_FILENAME) # set the get-iplayer path global get_iplayer_path if master_config.has_option("General", "get-iplayer_path"): get_iplayer_path = master_config.get("General", "get-iplayer_path") # refresh the get-iplayer cache print("Refreshing get-iplayer... (this may take some time)") subprocess.check_output([get_iplayer_path, "--type=all", "--quiet"]) # scan for feed config files and process each for root, directories, files in os.walk(config_directory + FEED_CONFIG_DIRECTORY): for filename in files: load_feed(filename) print("Finished.") return # stop here, we have processed the feeds # if we have not returned at this point, then no config directory was found, this is a problem print("No config directory found")
def _getExtendedConfs(self, conf_filename, conf_data, confs=None): """Return a list of tuple (conf_name, parser, encoding_errors). :param conf_filename: The path and name of the conf file. :param conf_data: Unparsed config data. :param confs: A list of confs that extend filename. :return: A list of confs ordered from extender to extendee. :raises IOError: If filename cannot be read. This method parses the config data and checks for encoding errors. It checks parsed config data for the extends key in the meta section. It reads the unparsed config_data from the extended filename. It passes filename, data, and the working list to itself. """ if confs is None: confs = [] encoding_errors = self._verifyEncoding(conf_data) parser = RawConfigParser() parser.readfp(StringIO(conf_data), conf_filename) confs.append((conf_filename, parser, encoding_errors)) if parser.has_option('meta', 'extends'): base_path = dirname(conf_filename) extends_name = parser.get('meta', 'extends') extends_filename = abspath('%s/%s' % (base_path, extends_name)) extends_data = read_content(extends_filename) self._getExtendedConfs(extends_filename, extends_data, confs) return confs
def load(self, statedir: str = None) -> None: if statedir is None: statedir = self.get_state_dir() statefile = os.path.join(statedir, "state.json") if os.path.exists(statefile): # Load state from JSON file with open(statefile, "rt") as fd: state = json.load(fd) self.projects = state["projects"] return # TODO: remove support for legacy format statefile = os.path.join(statedir, "state") if os.path.exists(statefile): # Load state from legacy .ini file from configparser import RawConfigParser cp = RawConfigParser() cp.read([statefile]) for secname in cp.sections(): if secname.startswith("proj "): name = secname.split(None, 1)[1] fname = cp.get(secname, "fname") self.projects[name] = {"fname": fname} return
def read_merged(self, filenames, encoding=None): cfg = [] for filename in filenames: _cfg = RawConfigParser() _cfg.read(filename) cfg.append(_cfg) for _cfg in cfg: for section in _cfg.sections(): if not self.has_section(section): self.add_section(section) for option in _cfg.options(section): value = _cfg.get(section, option) if ";" in value: current = self.getdefault(section, option, "") if ";" in current: val = [] for v in value.split(";"): if v and v not in val: val.append(v) for v in self.getlist(section, option): if v and v not in val: val.append(v) self.set(section, option, ";".join(val) + ";") continue self.set(section, option, value)
class Options: def __init__(self, name, defaults): load_paths = list(reversed([os.path.join(directory, '%s.cfg' % name) for directory in load_config_paths(name)])) self.save_path = os.path.join(save_config_path(name), '%s.cfg' % name) self.config = RawConfigParser(defaults) self.paths = self.config.read(load_paths) self.section = name if self.config.has_section(name) else 'DEFAULT' def get(self, option): try: return self.config.get(self.section, option) except NoOptionError: return None def set(self, option, value): if value is not None: self.config.set(self.section, option, value) else: self.config.remove_option(self.section, option) defaults = self.config._defaults self.config._defaults = None with open(self.save_path, 'w') as save_file: self.config.write(save_file) self.config._defaults = defaults
def get(self, section, option, default=None): try: return RawConfigParser.get(self, section, option) except NoSectionError: if default is None: raise return default
import os from configparser import RawConfigParser # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) local_config_path = os.path.join(BASE_DIR, 'conf', 'local.conf') config_parser = RawConfigParser() config_parser.read(local_config_path) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config_parser.get('main', 'SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config_parser.getboolean('main', 'DEBUG') ALLOWED_HOSTS = [] SITE_ID = 1 # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions',
from configparser import RawConfigParser def keys_to_upper(conf_section): d = {} for key, value in conf_section.items(): d[key.upper()] = value return d config = RawConfigParser() config.read("/CloudFS/vuohiportal/configs/settings.ini") try: # SSL header = (config.get('SSL', 'SECURE_PROXY_SSL_HEADER_PROTOCOL'), config.get('SSL', 'SECURE_PROXY_SSL_HEADER_VALUE')) SECURE_PROXY_SSL_HEADER = header SECURE_SSL_REDIRECT = config.getboolean('SSL', 'SECURE_SSL_REDIRECT') SESSION_COOKIE_SECURE = config.getboolean('SSL', 'SESSION_COOKIE_SECURE') CSRF_COOKIE_SECURE = config.getboolean('SSL', 'CSRF_COOKIE_SECURE') except ValueError: pass CORS_ALLOW_ALL_ORIGINS = True # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
from bs4 import BeautifulSoup from dateutil.parser import parse import glob import gc import json import MySQLdb as my __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))) configFile = os.path.join(__location__, 'Settings.ini') db_config = RawConfigParser() db_config.read(configFile) db_name = db_config.get('database', 'DATABASE_NAME') db_user = db_config.get('database', 'DATABASE_USER') db_pwd = db_config.get('database', 'DATABASE_PASSWORD') db_host = db_config.get('database', 'DATABASE_HOST') db_port = db_config.get('database', 'DATABASE_PORT') isDEBUG = False # Database SELECT # For every sub-query, the iterable result is appended to a master list of results def bulk_upload(query): success = False try: conn = mysql.connector.connect(user=db_user, password=db_pwd, host=db_host, port=db_port, database=db_name)
type=str, nargs='?', help='Login password or read from config.ini.') arparser.add_argument( '--notify', type=str, default=None, nargs='?', help='Phone number to send a text message summary of results.') args = arparser.parse_args() parser = RawConfigParser() parser.read('config.ini') # Get email/password from config file email = os.getenv('email') or args.user or parser.get(args.config, 'email') password = os.getenv('password') or args.password or parser.get( args.config, 'password') phone = os.getenv('notify') or args.notify or parser.get( args.config, 'notify') if parser.has_option(args.config, 'notify') else None delay = 10 if args.store == 'shoprite': grocery_coupons.shoprite(email, password, phone, delay, onStatus) elif args.store == 'stop_and_shop': grocery_coupons.stop_and_shop(email, password, phone, delay, onStatus) elif args.store == 'acme': grocery_coupons.acme(email, password, phone, delay, onStatus) elif args.store == 'help': print('Usage: client.py [shoprite | acme | stop_and_shop]')
# 获取账号参数 try: configinfo = RawConfigParser() try: configinfo.read(pwd + "OpenCardConfig.ini", encoding="UTF-8") except Exception as e: with open(pwd + "OpenCardConfig.ini", "r", encoding="UTF-8") as config: getConfig = config.read().encode('utf-8').decode('utf-8-sig') with open(pwd + "OpenCardConfig.ini", "w", encoding="UTF-8") as config: config.write(getConfig) try: configinfo.read(pwd + "OpenCardConfig.ini", encoding="UTF-8") except: configinfo.read(pwd + "OpenCardConfig.ini", encoding="gbk") cookies = configinfo.get('main', 'JD_COOKIE') openCardBean = configinfo.getint('main', 'openCardBean') sleepNum = configinfo.getfloat('main', 'sleepNum') record = configinfo.getboolean('main', 'record') onlyRecord = configinfo.getboolean('main', 'onlyRecord') memory = configinfo.getboolean('main', 'memory') printlog = configinfo.getboolean('main', 'printlog') isRemoteSid = configinfo.getboolean('main', 'isRemoteSid') TG_BOT_TOKEN = configinfo.get('main', 'TG_BOT_TOKEN') TG_USER_ID = configinfo.get('main', 'TG_USER_ID') PUSH_PLUS_TOKEN = configinfo.get('main', 'PUSH_PLUS_TOKEN') TG_PROXY_IP = configinfo.get('main', 'TG_PROXY_IP') TG_PROXY_PORT = configinfo.get('main', 'TG_PROXY_PORT') TG_API_HOST = configinfo.get('main', 'TG_API_HOST') QYWX_AM = configinfo.get('main', 'QYWX_AM') Concurrent = configinfo.getboolean('main', 'Concurrent')
'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'aniholo.wsgi.application' # Database # https://docs.djangoproject.com/en/2.1/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': config.get('database_login', 'db_name'), 'USER': config.get('database_login', 'db_user'), 'PASSWORD': config.get('database_login', 'db_pass'), 'HOST': config.get('database_login', 'db_host'), 'PORT': config.get('database_login', 'db_port'), } } # Password validation # https://docs.djangoproject.com/en/2.1/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', },
config = RawConfigParser() config.read('/home/production/settings.ini') # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATES_DIR1 = os.path.join(BASE_DIR, 'templates/dashboard') TEMPLATES_DIR2 = os.path.join(BASE_DIR, 'templates/Ercesscorp') TEMPLATES_DIR3 = os.path.join(BASE_DIR, 'templates') STATIC_DIR = os.path.join(BASE_DIR, 'templates/static') MEDIA_DIR = os.path.join(BASE_DIR, 'media') # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config.get('section', 'secret_key') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = False ALLOWED_HOSTS = ['ercess.com', '127.0.0.1'] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles',
def main(): opts = parse_args() try: config = RawConfigParser() config.read(opts.config_file) config.options("master-public-keys") except NoSectionError: print("ERROR: Non-existant configuration file {}".format( opts.config_file)) return logger = logging.getLogger('ELECTRUMPERSONALSERVER') logger, logfilename = logger_config(logger, config) logger.info('Starting Electrum Personal Server ' + str(SERVER_VERSION_NUMBER)) logger.info('Logging to ' + logfilename) logger.debug("Process ID (PID) = " + str(os.getpid())) rpc_u = None rpc_p = None cookie_path = None try: rpc_u = config.get("bitcoin-rpc", "rpc_user") rpc_p = config.get("bitcoin-rpc", "rpc_password") logger.debug("obtaining auth from rpc_user/pass") except NoOptionError: cookie_path = obtain_cookie_file_path( config.get("bitcoin-rpc", "datadir")) logger.debug("obtaining auth from .cookie") if rpc_u == None and cookie_path == None: return rpc = JsonRpc(host=config.get("bitcoin-rpc", "host"), port=int(config.get("bitcoin-rpc", "port")), user=rpc_u, password=rpc_p, cookie_path=cookie_path, wallet_filename=config.get("bitcoin-rpc", "wallet_filename").strip(), logger=logger) #TODO somewhere here loop until rpc works and fully sync'd, to allow # people to run this script without waiting for their node to fully # catch up sync'd when getblockchaininfo blocks == headers, or use # verificationprogress printed_error_msg = False while bestblockhash[0] == None: try: bestblockhash[0] = rpc.call("getbestblockhash", []) except JsonRpcError as e: if not printed_error_msg: logger.error("Error with bitcoin json-rpc: " + repr(e)) printed_error_msg = True time.sleep(5) try: rpc.call("listunspent", []) except JsonRpcError as e: logger.error(repr(e)) logger.error("Wallet related RPC call failed, possibly the " + "bitcoin node was compiled with the disable wallet flag") return test_keydata = ( "2 tpubD6NzVbkrYhZ4YVMVzC7wZeRfz3bhqcHvV8M3UiULCfzFtLtp5nwvi6LnBQegrkx" + "YGPkSzXUEvcPEHcKdda8W1YShVBkhFBGkLxjSQ1Nx3cJ tpubD6NzVbkrYhZ4WjgNYq2nF" + "TbiSLW2SZAzs4g5JHLqwQ3AmR3tCWpqsZJJEoZuP5HAEBNxgYQhtWMezszoaeTCg6FWGQB" + "T74sszGaxaf64o5s") chain = rpc.call("getblockchaininfo", [])["chain"] try: gaplimit = 5 deterministicwallet.parse_electrum_master_public_key( test_keydata, gaplimit, rpc, chain) except ValueError as e: logger.error(repr(e)) logger.error( "Descriptor related RPC call failed. Bitcoin Core 0.20.0" + " or higher required. Exiting..") return if opts.rescan: rescan_script(logger, rpc, opts.rescan_date) return while True: logger.debug("Checking whether rescan is in progress") walletinfo = rpc.call("getwalletinfo", []) if "scanning" in walletinfo and walletinfo["scanning"]: logger.debug("Waiting for Core wallet rescan to finish") time.sleep(300) continue break import_needed, relevant_spks_addrs, deterministic_wallets = \ get_scriptpubkeys_to_monitor(rpc, config) if import_needed: if not relevant_spks_addrs and not deterministic_wallets: #import = true and no addresses means exit return deterministicwallet.import_addresses( rpc, relevant_spks_addrs, deterministic_wallets, change_param=-1, count=int(config.get("bitcoin-rpc", "initial_import_count"))) logger.info( "Done.\nIf recovering a wallet which already has existing" + " transactions, then\nrun the rescan script. If you're confident" + " that the wallets are new\nand empty then there's no need to" + " rescan, just restart this script") else: txmonitor = transactionmonitor.TransactionMonitor( rpc, deterministic_wallets, logger) if not txmonitor.build_address_history(relevant_spks_addrs): return try: run_electrum_server(rpc, txmonitor, config) except KeyboardInterrupt: logger.info('Received KeyboardInterrupt, quitting')
import os from configparser import RawConfigParser # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) PROJECT_DIR = os.path.dirname(BASE_DIR) local_config_path = os.path.join(BASE_DIR, 'conf', 'local.conf') config = RawConfigParser() config.read(local_config_path) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config.get('main', 'SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config.getboolean('main', 'DEBUG') ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles',
'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'jaintapp.wsgi.application' # Database # https://docs.djangoproject.com/en/2.0/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': config.get('db_pgsql', 'ENGINE'), 'NAME': config.get('db_pgsql', 'NAME'), 'HOST': config.get('db_pgsql', 'HOST'), 'USER': config.get('db_pgsql', 'USER'), 'PASSWORD': config.get('db_pgsql', 'PASSWORD'), } } # Password validation # https://docs.djangoproject.com/en/2.0/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', },
def init(domain): C = [] print(colored("[*]-Searching Censys...", "yellow")) parser = RawConfigParser() parser.read("config.ini") API_URL = "https://www.censys.io/api/v1" UID = parser.get("Censys", "CENSYS_UID") SECRET = parser.get("Censys", "CENSYS_SECRET") if UID == "" or SECRET == "": print(" \__", colored("No Censys API credentials configured", "red")) return [] else: payload = {"query": domain} try: res = requests.post(API_URL + "/search/certificates", json=payload, auth=(UID, SECRET)) if res.status_code == 429: print(" \__", colored("Rate limit exceeded. See https://www.censys.io/account for rate limit details.", "red")) return C C = re.findall("CN=([\w\.\-\d]+)\." + domain, str(res.content)) numberOfPages = re.findall("pages\":\s(\d+)?}", str(res.content)) for page in range(2, int(numberOfPages[0]) + 1): payload = {"query": domain, "page": page} res = requests.post(API_URL + "/search/certificates", json=payload, auth=(UID, SECRET)) tempC = re.findall("CN=([\w\.\-\d]+)\." + domain, str(res.content)) C = C + tempC C = set(C) print(" \__ {0}: {1}".format(colored("Subdomains found", "cyan"), colored(len(C), "yellow"))) return C except KeyError as errk: print(" \__", colored(errk, "red")) return [] except requests.exceptions.RequestException as err: print(" \__", colored(err, "red")) return [] except requests.exceptions.HTTPError as errh: print(" \__", colored(errh, "red")) return [] except requests.exceptions.ConnectionError as errc: print(" \__", colored(errc, "red")) return [] except requests.exceptions.Timeout as errt: print(" \__", colored(errt, "red")) return [] except Exception: print(" \__", colored("Something went wrong!", "red")) return []
allprotocols = [] def normalizedFilename(f): if f == '-': return '<stdin>' return f log(2, 'Reading sync message list') parser = RawConfigParser() parser.read_file(open(options.syncMsgList)) syncMsgList = parser.sections() for section in syncMsgList: if not parser.get(section, "description"): print('Error: Sync message %s lacks a description' % section, file=sys.stderr) sys.exit(1) # Read message metadata. Right now we only have 'segment_capacity' # for the standard segment size used for serialization. log(2, 'Reading message metadata...') msgMetadataConfig = RawConfigParser() msgMetadataConfig.read_file(open(options.msgMetadata)) segmentCapacityDict = {} for msgName in msgMetadataConfig.sections(): if msgMetadataConfig.has_option(msgName, 'segment_capacity'): capacity = msgMetadataConfig.get(msgName, 'segment_capacity') segmentCapacityDict[msgName] = capacity
def getfloat(self, section, option): try: return float(RawConfigParser.get(self, section, option)) except NoOptionError: return None
class MrxsFile(object): def __init__(self, filename): # Split filename dirname, ext = os.path.splitext(filename) if ext != '.mrxs': raise UnrecognizedFile # Parse slidedat self._slidedatfile = os.path.join(dirname, 'Slidedat.ini') self._dat = RawConfigParser() self._dat.optionxform = str try: with open(self._slidedatfile, 'r', encoding="utf-8-sig") as fh: self._have_bom = (fh.read(len(UTF8_BOM)) == UTF8_BOM) if not self._have_bom: fh.seek(0) self._dat.read_file(fh) except IOError: raise UnrecognizedFile # Get file paths self._indexfile = os.path.join( dirname, self._dat.get(MRXS_HIERARCHICAL, 'INDEXFILE')) self._datafiles = [ os.path.join(dirname, self._dat.get('DATAFILE', 'FILE_%d' % i)) for i in range(self._dat.getint('DATAFILE', 'FILE_COUNT')) ] # Build levels self._make_levels() def _make_levels(self): self._levels = {} self._level_list = [] layer_count = self._dat.getint(MRXS_HIERARCHICAL, 'NONHIER_COUNT') for layer_id in range(layer_count): level_count = self._dat.getint(MRXS_HIERARCHICAL, 'NONHIER_%d_COUNT' % layer_id) for level_id in range(level_count): level = MrxsNonHierLevel(self._dat, layer_id, level_id, len(self._level_list)) self._levels[(level.layer_name, level.name)] = level self._level_list.append(level) @classmethod def _read_int32(cls, f): buf = f.read(4) if len(buf) != 4: raise IOError('Short read') return struct.unpack('<i', buf)[0] @classmethod def _assert_int32(cls, f, value): v = cls._read_int32(f) if v != value: raise ValueError('%d != %d' % (v, value)) def _get_data_location(self, record): with open(self._indexfile, 'rb') as fh: fh.seek(MRXS_NONHIER_ROOT_OFFSET) # seek to record table_base = self._read_int32(fh) fh.seek(table_base + record * 4) # seek to list head list_head = self._read_int32(fh) fh.seek(list_head) # seek to data page self._assert_int32(fh, 0) page = self._read_int32(fh) fh.seek(page) # check pagesize self._assert_int32(fh, 1) # read rest of prologue self._read_int32(fh) self._assert_int32(fh, 0) self._assert_int32(fh, 0) # read values position = self._read_int32(fh) size = self._read_int32(fh) fileno = self._read_int32(fh) return (self._datafiles[fileno], position, size) def _zero_record(self, record): path, offset, length = self._get_data_location(record) with open(path, 'r+b') as fh: fh.seek(0, 2) do_truncate = (fh.tell() == offset + length) if DEBUG: if do_truncate: print('Truncating', path, 'to', offset) else: print('Zeroing', path, 'at', offset, 'for', length) fh.seek(offset) buf = fh.read(len(JPEG_SOI)) # print(buf) # exit() if buf != JPEG_SOI: raise IOError('Unexpected data in nonhier image') if do_truncate: fh.truncate(offset) else: fh.seek(offset) fh.write('\0' * length) def _delete_index_record(self, record): if DEBUG: print('Deleting record', record) with open(self._indexfile, 'r+b') as fh: entries_to_move = len(self._level_list) - record - 1 if entries_to_move == 0: return # get base of table fh.seek(MRXS_NONHIER_ROOT_OFFSET) table_base = self._read_int32(fh) # read tail of table fh.seek(table_base + (record + 1) * 4) buf = fh.read(entries_to_move * 4) if len(buf) != entries_to_move * 4: raise IOError('Short read') # overwrite the target record fh.seek(table_base + record * 4) fh.write(buf) def _hier_keys_for_level(self, level): ret = [] for k, _ in self._dat.items(MRXS_HIERARCHICAL): if k == level.key_prefix or k.startswith(level.key_prefix + '_'): ret.append(k) return ret def _rename_section(self, old, new): if self._dat.has_section(old): if DEBUG: print('[%s] -> [%s]' % (old, new)) self._dat.add_section(new) for k, v in self._dat.items(old): self._dat.set(new, k, v) self._dat.remove_section(old) elif DEBUG: print('[%s] does not exist' % old) def _delete_section(self, section): if DEBUG: print('Deleting [%s]' % section) self._dat.remove_section(section) def _set_key(self, section, key, value): if DEBUG: prev = self._dat.get(section, key) print('[%s] %s: %s -> %s' % (section, key, prev, value)) self._dat.set(section, key, value) def _rename_key(self, section, old, new): if DEBUG: print('[%s] %s -> %s' % (section, old, new)) v = self._dat.get(section, old) self._dat.remove_option(section, old) self._dat.set(section, new, v) def _delete_key(self, section, key): if DEBUG: print('Deleting [%s] %s' % (section, key)) self._dat.remove_option(section, key) def _write(self): buf = StringIO() self._dat.write(buf) with open(self._slidedatfile, 'wb') as fh: if self._have_bom: fh.write(UTF8_BOM.encode()) fh.write(buf.getvalue().replace('\n', '\r\n').encode()) def delete_level(self, layer_name, level_name): level = self._levels[(layer_name, level_name)] record = level.record # Zero image data self._zero_record(record) # Delete pointer from nonhier table in index self._delete_index_record(record) # Remove slidedat keys for k in self._hier_keys_for_level(level): self._delete_key(MRXS_HIERARCHICAL, k) # Remove slidedat section self._delete_section(level.section) # Rename section and keys for subsequent levels in the layer prev_level = level for cur_level in self._level_list[record + 1:]: if cur_level.layer_id != prev_level.layer_id: break for k in self._hier_keys_for_level(cur_level): new_k = k.replace(cur_level.key_prefix, prev_level.key_prefix, 1) self._rename_key(MRXS_HIERARCHICAL, k, new_k) self._set_key(MRXS_HIERARCHICAL, prev_level.section_key, prev_level.section) self._rename_section(cur_level.section, prev_level.section) prev_level = cur_level # Update level count within layer count_k = 'NONHIER_%d_COUNT' % level.layer_id count_v = self._dat.getint(MRXS_HIERARCHICAL, count_k) self._set_key(MRXS_HIERARCHICAL, count_k, count_v - 1) # Write slidedat self._write() # Refresh metadata self._make_levels()
import os from configparser import RawConfigParser # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) JSON_PATH = os.path.join(BASE_DIR, 'json') CONF_PATH = os.path.join(BASE_DIR, 'conf') CONFIG = RawConfigParser() CONFIG.read(os.path.join(CONF_PATH, 'local.conf'), encoding='utf-8') # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = CONFIG.get('main', 'SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = CONFIG.getboolean('main', 'DEBUG') ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles',
'2、若一直连不上javbus,请在ini中更新防屏蔽网址\n' '3、找不到AV信息,请在javbus上确认,再修改本地视频文件名,如:\n' ' 1)多余的字母数字:[JAV] [Uncensored] HEYZO 2171 [1080p].mp4 => HEYZO 2171.mp4\n' ' 112314-742-carib-1080p.mp4 => 112314-742.mp4\n' ' Heyzo_HD_0733_full.mp4 => Heyzo_0733.mp4\n' ' 2)多余的横杠:sr-131.mp4 => sr131.mp4\n' ' 3)干扰车牌的分集:Heyzo_0733_01.mp4 => Heyzo_0733啊.mp4\n' ' Heyzo_0733_02.mp4 => Heyzo_0733吧.mp4\n') # 读取配置文件,这个ini文件用来给用户设置 print('\n正在读取ini中的设置...', end='') try: config_settings = RawConfigParser() config_settings.read('【点我设置整理规则】.ini', encoding='utf-8-sig') #################################################################################################################### # 是否 收集nfo bool_nfo = True if config_settings.get("收集nfo", "是否收集nfo?") == '是' else False # 是否 跳过已存在nfo的文件夹,不整理已有nfo的文件夹 bool_skip = True if config_settings.get("收集nfo", "是否跳过已存在nfo的文件夹?") == '是' else False # 自定义 nfo中title的格式 custom_nfo_title = config_settings.get("收集nfo", "nfo中title的格式") # 是否 去除 标题 末尾可能存在的演员姓名 bool_strip_actors = True if config_settings.get("收集nfo", "是否去除标题末尾可能存在的演员姓名?") == '是' else False # 自定义 将系列、片商等元素作为特征,因为emby不会直接在影片介绍页面上显示片商,也不会读取系列set custom_genres = config_settings.get("收集nfo", "额外将以下元素添加到特征中") # 是否 将特征保存到风格中 bool_genre = True if config_settings.get("收集nfo", "是否将特征保存到genre?") == '是' else False # 是否 将 片商 作为特征 bool_tag = True if config_settings.get("收集nfo", "是否将特征保存到tag?") == '是' else False #################################################################################################################### # 是否 重命名 视频 bool_rename_mp4 = True if config_settings.get("重命名影片", "是否重命名影片?") == '是' else False
import qiskit from qiskit import IBMQ, ClassicalRegister, QuantumRegister, QuantumCircuit, execute, Aer from qiskit.backends.ibmq import least_busy from configparser import RawConfigParser # Setup the API key for the real quantum computer. parser = RawConfigParser() parser.read('config.ini') IBMQ.enable_account(parser.get('IBM', 'key')) # Setup 3 qubits. q = QuantumRegister(3) c = ClassicalRegister(3) qc = QuantumCircuit(q, c) # Place the qubits into superposition so the qubits no longer hold a distinct value, but instead are both 0 and 1 at the same time (50% 0, 50% 1). qc.h(q) qc.measure(q, c) # Using the qubits and their random value, form a response. def answer(result): for key in result.keys(): state = key print("The Quantum 8-ball says:") if state == '000': print('It is certain.') elif state == '001': print('Without a doubt.') elif state == '010': print('Yes - deinitely.')
""" import os from configparser import RawConfigParser config = RawConfigParser() config.read('/etc/bg_settings/settings.ini') # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config.get('secrets', 'SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config.getboolean('django', 'DEBUG') ALLOWED_HOSTS = ['*'] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles',
else: available.sync() if __name__ == '__main__': calendars = [] busy_statuses = [] available_statuses = [] config = RawConfigParser() config.read('local.cfg') for section in config.sections(): if section.startswith('caldav'): calendars.append( CalDavCalendar( DAVClient(config.get(section, 'url'), username=config.get(section, 'username'), password=config.get(section, 'password')), SimpleCalEventsIntervals(dateutil.tz.tzlocal()))) elif section.startswith('ics'): calendars.append( IcsCalendar(config.get(section, 'url'), SimpleCalEventsIntervals(dateutil.tz.tzlocal()))) elif section.startswith('slack'): slack = IgnoreDisconnectApi( SimpleSlackApi(SlackClient(config.get(section, 'token')))) busy_statuses.append( SlackStatus(slack, config.get(section, 'busy_text'), config.get(section, 'busy_emoji'))) available_statuses.append( SlackStatus(slack, config.get(section, 'available_text'),
class APIVersionWriter(TemplateFileWriter): """ Provide useful method to write Java files. """ def __init__(self, monolithe_config, api_info): """ Initializes a _JavaSDKAPIVersionFileWriter """ super(APIVersionWriter, self).__init__(package="monolithe.generators.lang.java") self.api_version = api_info["version"] self._api_version_string = SDKUtils.get_string_version(self.api_version) self.api_root = api_info["root"] self.api_prefix = api_info["prefix"] self.monolithe_config = monolithe_config self._output = self.monolithe_config.get_option("output", "transformer") self._name = self.monolithe_config.get_option("name", "transformer") self._class_prefix = "" self._product_accronym = self.monolithe_config.get_option("product_accronym") self._product_name = self.monolithe_config.get_option("product_name") self._url = self.monolithe_config.get_option("url", "transformer") self._package_prefix = self._get_package_prefix(self._url) self._package_name = self._package_prefix + '.' + self._name + '.' + SDKUtils.get_string_version(self.api_version) self._package_subdir = self._package_name.replace('.', '/') self._base_output_directory = "%s/java" % (self._output) self.output_directory = "%s/src/main/java/%s" % (self._base_output_directory, self._package_subdir) self.override_folder = os.path.normpath("%s/__overrides" % self._base_output_directory) self.fetchers_path = "/fetchers/" self.attrs_defaults = RawConfigParser() path = "%s/java/__attributes_defaults/attrs_defaults.ini" % self._output self.attrs_defaults.optionxform = str self.attrs_defaults.read(path) self.attrs_types = RawConfigParser() path = "%s/java/__attributes_defaults/attrs_types.ini" % self._output self.attrs_types.optionxform = str self.attrs_types.read(path) library_info = RawConfigParser() path = "%s/java/__attributes_defaults/library.ini" % self._output library_info.optionxform = str library_info.read(path) self.library_version = library_info.get(self.api_version, "libraryVersion") with open("%s/java/__code_header" % self._output, "r") as f: self.header_content = f.read() def perform(self, specifications): """ """ self._set_enum_list_local_type(specifications) self._write_info() self._write_session() self._write_build_file() task_manager = TaskManager() for rest_name, specification in specifications.items(): task_manager.start_task(method=self._write_model, specification=specification, specification_set=specifications) task_manager.start_task(method=self._write_fetcher, specification=specification, specification_set=specifications) task_manager.wait_until_exit() def _write_session(self): """ Write SDK session file Args: version (str): the version of the server """ base_name = "%sSession" % self._product_accronym filename = "%s%s.java" % (self._class_prefix, base_name) override_content = self._extract_override_content(base_name) self.write(destination=self.output_directory, filename=filename, template_name="session.java.tpl", version=self.api_version, product_accronym=self._product_accronym, class_prefix=self._class_prefix, root_api=self.api_root, name=self._name, api_prefix=self.api_prefix, override_content=override_content, header=self.header_content, version_string=self._api_version_string, package_name=self._package_name) def _write_info(self): """ Write API Info file """ self.write(destination=self.output_directory, filename="SdkInfo.java", template_name="sdkinfo.java.tpl", version=self.api_version, product_accronym=self._product_accronym, class_prefix=self._class_prefix, root_api=self.api_root, api_prefix=self.api_prefix, product_name=self._product_name, name=self._name, header=self.header_content, version_string=self._api_version_string, package_name=self._package_name) def _write_model(self, specification, specification_set): """ Write autogenerate specification file """ filename = "%s%s.java" % (self._class_prefix, specification.entity_name) override_content = self._extract_override_content(specification.entity_name) superclass_name = "RestRootObject" if specification.rest_name == self.api_root else "RestObject" defaults = {} section = specification.entity_name if self.attrs_defaults.has_section(section): for attribute in self.attrs_defaults.options(section): defaults[attribute] = self.attrs_defaults.get(section, attribute) self.write(destination=self.output_directory, filename=filename, template_name="model.java.tpl", specification=specification, specification_set=specification_set, version=self.api_version, name=self._name, class_prefix=self._class_prefix, product_accronym=self._product_accronym, override_content=override_content, superclass_name=superclass_name, header=self.header_content, version_string=self._api_version_string, package_name=self._package_name, attribute_defaults=defaults) return (filename, specification.entity_name) def _write_fetcher(self, specification, specification_set): """ Write fetcher """ destination = "%s%s" % (self.output_directory, self.fetchers_path) base_name = "%sFetcher" % specification.entity_name_plural filename = "%s%s.java" % (self._class_prefix, base_name) override_content = self._extract_override_content(base_name) self.write(destination=destination, filename=filename, template_name="fetcher.java.tpl", specification=specification, specification_set=specification_set, class_prefix=self._class_prefix, product_accronym=self._product_accronym, override_content=override_content, header=self.header_content, name=self._name, version_string=self._api_version_string, package_name=self._package_name) return (filename, specification.entity_name_plural) def _write_build_file(self): """ Write Maven build file (pom.xml) """ self.write(destination=self._base_output_directory, filename="pom.xml", template_name="pom.xml.tpl", version=self.api_version, product_accronym=self._product_accronym, class_prefix=self._class_prefix, root_api=self.api_root, api_prefix=self.api_prefix, product_name=self._product_name, name=self._name, header=self.header_content, version_string=self._api_version_string, package_prefix=self._package_prefix, library_version=self.library_version) def _extract_override_content(self, name): """ """ # find override file specific_override_path = "%s/%s_%s%s.override.java" % (self.override_folder, self.api_version, self._class_prefix, name.title()) generic_override_path = "%s/%s%s.override.java" % (self.override_folder, self._class_prefix, name.title()) final_path = specific_override_path if os.path.exists(specific_override_path) else generic_override_path # Read override from file override_content = None if os.path.isfile(final_path): override_content = open(final_path).read() return override_content def _get_package_prefix(self, url): """ """ hostname_parts = self._get_hostname_parts(url) package_name = "" for index, hostname_part in enumerate(reversed(hostname_parts)): package_name = package_name + hostname_part if index < len(hostname_parts) - 1: package_name = package_name + '.' return package_name def _get_hostname_parts(self, url): """ """ if url.find("http://") != 0: url = "http://" + url hostname = urlparse(url).hostname hostname_parts = hostname.split('.') valid_hostname_parts = [] for hostname_part in hostname_parts: if hostname_part != "www": valid_hostname_parts.append(hostname_part) return valid_hostname_parts def _set_enum_list_local_type(self, specifications): """ This method is needed until get_type_name() is enhanced to include specification subtype and local_name """ for rest_name, specification in specifications.items(): for attribute in specification.attributes: if attribute.type == "enum": enum_type = attribute.local_name[0:1].upper() + attribute.local_name[1:] attribute.local_type = enum_type elif attribute.type == "object": attr_type = "Object" if self.attrs_types.has_option(specification.entity_name, attribute.local_name): type = self.attrs_types.get(specification.entity_name, attribute.local_name) if type: attr_type = type attribute.local_type = attr_type elif attribute.type == "list": if attribute.subtype == "enum": enum_subtype = attribute.local_name[0:1].upper() + attribute.local_name[1:] attribute.local_type = "java.util.List<" + enum_subtype + ">" elif attribute.subtype == "object": attr_subtype = "com.fasterxml.jackson.databind.JsonNode" if self.attrs_types.has_option(specification.entity_name, attribute.local_name): subtype = self.attrs_types.get(specification.entity_name, attribute.local_name) if subtype: attr_subtype = subtype attribute.local_type = "java.util.List<" + attr_subtype + ">" elif attribute.subtype == "entity": attribute.local_type = "java.util.List<com.fasterxml.jackson.databind.JsonNode>" else: attribute.local_type = "java.util.List<String>"
from .base import * if 'TRAVIS' in os.environ: SECRET_KEY = os.environ['SECRET_KEY'] else: from configparser import RawConfigParser config = RawConfigParser() try: config.read(os.path.join(BASE_DIR, 'ecom/config/secrets.ini')) SECRET_KEY = config.get('django', 'SECRET_KEY') except Exception as e: print(f'Error reading secrets.ini: {e}') DEBUG = True ALLOWED_HOSTS = []
PROJECT_NAME = 'jet_demo' production_config = os.path.join('/usr/local/etc', PROJECT_NAME, '{0}.conf'.format(PROJECT_NAME)) development_config = os.path.join(BASE_DIR, 'conf', '{0}.conf'.format(PROJECT_NAME)) config_path = production_config if os.path.exists( production_config) else development_config config.read(config_path) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config.get('common', 'secret_key') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config.getboolean('common', 'debug') ALLOWED_HOSTS = ['*'] LOGIN_REDIRECT_URL = 'home' LOGOUT_REDIRECT_URL = 'home' # Application definition INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages',
if not os.path.exists(conffile): raise Exception("config file " + conffile + " not found") # read config and launch config.read(conffile) client = mqtt.Client() client2 = mqtt.Client() client.on_connect = on_connect client.on_message = on_message username = config.get("agents","username") password = config.get("agents","password") mqttbroker = config.get("agents","mqttbroker") client.username_pw_set(username,password) client.connect(mqttbroker, 1883, 5) client2.username_pw_set(username,password) client2.connect(mqttbroker, 1883, 5) # Blocking call that processes network traffic, dispatches callbacks and # handles reconnecting. # Other loop*() functions are available that give a threaded interface and a # manual interface.
import Adafruit_DHT import time import datetime from rethinkdb import r from configparser import RawConfigParser config = RawConfigParser() config.read('appconfig.ini') r.connect(config.get('rethinkdb', 'host'), config.get('rethinkdb', 'port')).repl() sensor = Adafruit_DHT.DHT11 while True: log_time = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S") humidity, temperature = Adafruit_DHT.read_retry(sensor, 21) print(f"temp: {temperature} hum: {humidity} at {log_time}") r.db('rpi').table(config.get('rethinkdb', 'temp_hum_table')).insert({ 'room_id': 'bedroom_1', 'temp': temperature, 'hum': humidity, 'date': log_time }).run() time.sleep(1)
class Config(object): """ Manages Bonsai configuration environments. Configuration information is pulled from different locations. This class helps keep it organized. Configuration information comes from environment variables, the user `~./.bonsai` file, a local `./.bonsai` file, the `./.brains` file, command line arguments, and finally, parameters overridden in code. An optional `profile` key can be used to switch between different profiles stored in the `~/.bonsai` configuration file. The users active profile is selected if none is specified. Attributes: accesskey: Users access key from the web. (Example: 00000000-1111-2222-3333-000000000001) username: Users login name. url: URL of the server to connect to. (Example: "https://api.bons.ai") brain: Name of the BRAIN to use. predict: True is predicting against a BRAIN, False for training. brain_version: Version number of the brain to use for prediction. proxy: Server name and port number of proxy to connect through. (Example: "localhost:9000") Example Usage: import sys, bonsai_ai config = bonsai_ai.Config(sys.argv) print(config) if config.predict: ... """ def __init__(self, argv=sys.argv, profile=None): """ Construct Config object with program arguments. Pass in sys.argv for command-line arguments and an optional profile name to select a specific profile. Arguments: argv: A list of argument strings. profile: The name of a profile to select. (optional) """ self.accesskey = None self.username = None self.url = None self.use_color = True self.brain = None self.predict = False self.brain_version = 0 self._proxy = None self._retry_timeout_seconds = 300 self._pong_interval_seconds = 15.0 self._network_timeout_seconds = 60 self.verbose = False self.record_file = None self.record_enabled = False self.file_paths = set() self._config_parser = RawConfigParser(allow_no_value=True) self._read_config() self.profile = profile self._parse_env() self._parse_config(_DEFAULT) self._parse_config(profile) self._parse_brains() self._parse_args(argv) # parse args works differently in 2.7 if sys.version_info >= (3, 0): self._parse_legacy(argv) def __repr__(self): """ Prints out a JSON formatted string of the Config state. """ return '{{'\ '\"profile\": \"{self.profile!r}\", ' \ '\"accesskey\": \"{self.accesskey!r}\", ' \ '\"username\": \"{self.username!r}\", ' \ '\"brain\": \"{self.brain!r}\", ' \ '\"url\": \"{self.url!r}\", ' \ '\"use_color\": \"{self.use_color!r}\", ' \ '\"predict\": \"{self.predict!r}\", ' \ '\"brain_version\": \"{self.brain_version!r}\", ' \ '\"proxy\": \"{self.proxy!r}\", ' \ '\"retry_timeout\": \"{self.retry_timeout!r}\", ' \ '\"pong_interval\": \"{self.pong_interval!r}\", ' \ '\"network_timeout\": \"{self.network_timeout!r}\" ' \ '}}'.format(self=self) @property def proxy(self): # shell-local environment vars get top precedence, falling back to # OS-specific registry/configuration values if self._proxy is not None: return self._proxy proxy_dict = getproxies() proxy = proxy_dict.get(_ALL_PROXY, None) http_proxy = proxy_dict.get(_HTTP_PROXY, None) if http_proxy is not None: proxy = http_proxy if self.url is not None: uri = urlparse(self.url) if uri.scheme == 'https': https_proxy = proxy_dict.get(_HTTPS_PROXY, None) if https_proxy is not None: proxy = https_proxy return proxy @proxy.setter def proxy(self, proxy): uri = urlparse(proxy) uri.port self._proxy = proxy @property def record_format(self): """ The log record format, as inferred from the extension of the log filename""" _, fmt = splitext(self.record_file) return fmt @property def retry_timeout(self): return self._retry_timeout_seconds @retry_timeout.setter def retry_timeout(self, value): value = int(value) if value < -1: raise ValueError( 'Retry timeout must be a positive integer, 0, or -1.') self._retry_timeout_seconds = value @property def pong_interval(self): return self._pong_interval_seconds @pong_interval.setter def pong_interval(self, value): value = float(value) if value == 0 or (value >= 1 and value < 240): self._pong_interval_seconds = value else: raise ValueError( 'Pong interval must be equal to 0 (No pongs) or ' 'greater than 1 second and less than 240 seconds.') @property def network_timeout(self): return self._network_timeout_seconds @network_timeout.setter def network_timeout(self, value): value = int(value) if value < 1: raise ValueError( 'Network timeout must be a positive integer.') self._network_timeout_seconds = value def _parse_env(self): ''' parse out environment variables used in hosted containers ''' self.brain = environ.get(_BONSAI_TRAIN_BRAIN, None) headless = environ.get(_BONSAI_HEADLESS, None) if headless == 'True': self.headless = True def _parse_config(self, profile): ''' parse both the '~/.bonsai' and './.bonsai' config files. ''' # read the values def assign_key(key): if self._config_parser.has_option(section, key): if key.lower() == _USE_COLOR.lower(): self.__dict__[key] = self._config_parser.getboolean(section, key) else: self.__dict__[key] = self._config_parser.get(section, key) # get the profile section = _DEFAULT if profile is None: if self._config_parser.has_option(_DEFAULT, _PROFILE): section = self._config_parser.get(_DEFAULT, _PROFILE) self.profile = section else: section = profile assign_key(_ACCESSKEY) assign_key(_USERNAME) assign_key(_URL) assign_key(_PROXY) assign_key(_USE_COLOR) # if url is none set it to default bonsai api url if self.url is None: self.url = _DEFAULT_URL def _parse_brains(self): ''' parse the './.brains' config file Example: {"brains": [{"default": true, "name": "test"}]} ''' data = {} try: with open(_DOT_BRAINS) as file: data = json.load(file) # parse file now for brain in data['brains']: if brain['default'] is True: self.brain = brain['name'] return # except FileNotFoundError: python3 except IOError as e: return def _parse_legacy(self, argv): ''' print support for legacy CLI arguments ''' if sys.version_info >= (3, 0): optional = ArgumentParser( description="", allow_abbrev=False, add_help=False) else: optional = ArgumentParser( description="", add_help=False) optional.add_argument( '--legacy', action='store_true', help='Legacy command line options') optional.add_argument('--train-brain', help=_TRAIN_BRAIN_HELP) optional.add_argument('--predict-brain', help=_PREDICT_BRAIN_HELP) optional.add_argument('--predict-version', help=_PREDICT_VERSION_HELP) optional.add_argument('--recording-file', help=_RECORDING_FILE_HELP) args, remainder = optional.parse_known_args(argv) if args.train_brain is not None: self.brain = args.train_brain self.predict = False if args.predict_version is not None: self.predict = True if args.predict_version == "latest": self.brain_version = 0 else: self.brain_version = int(args.predict_version) def _parse_args(self, argv): ''' parser command line arguments ''' if sys.version_info >= (3, 0): parser = ArgumentParser(allow_abbrev=False) else: parser = ArgumentParser() parser.add_argument( '--accesskey', '--access-key', help=_ACCESS_KEY_HELP) parser.add_argument('--username', help=_USERNAME_HELP) parser.add_argument('--url', help=_URL_HELP) parser.add_argument('--proxy', help=_PROXY_HELP) parser.add_argument('--brain', help=_BRAIN_HELP) parser.add_argument( '--predict', help=_PREDICT_HELP, nargs='?', const='latest', default=None) parser.add_argument('--verbose', action='store_true', help=_VERBOSE_HELP) parser.add_argument('--performance', action='store_true', help=_PERFORMANCE_HELP) parser.add_argument('--log', nargs='+', help=_LOG_HELP) parser.add_argument('--record', nargs=1, default=None, help=_RECORD_HELP) parser.add_argument('--retry-timeout', type=int, help=_RETRY_TIMEOUT_HELP) parser.add_argument('--pong-interval', type=float, help=_PONG_INTERVAL_HELP) parser.add_argument('--network-timeout', type=int, help=_NETWORK_TIMEOUT_HELP) args, remainder = parser.parse_known_args(argv[1:]) if args.accesskey is not None: self.accesskey = args.accesskey if args.username is not None: self.username = args.username if args.url is not None: self.url = args.url if args.proxy is not None: self.proxy = args.proxy if args.brain is not None: self.brain = args.brain if args.verbose: self.verbose = args.verbose log.set_enable_all(args.verbose) if args.performance: # logging::log().set_enabled(true); # logging::log().set_enable_all_perf(true); pass if args.log is not None: for domain in args.log: log.set_enabled(domain) if args.record: self.record_file = args.record[0] self.record_enabled = True if args.retry_timeout is not None: self.retry_timeout = args.retry_timeout if args.pong_interval is not None: self.pong_interval = args.pong_interval if args.network_timeout is not None: self.network_timeout = args.network_timeout brain_version = None if args.predict is not None: if args.predict == "latest": brain_version = 0 else: brain_version = args.predict self.predict = True # update brain_version after all args have been processed if brain_version is not None: brain_version = int(brain_version) if brain_version < 0: raise ValueError( 'BRAIN version number must be' 'positive integer or "latest".') self.brain_version = brain_version def _config_files(self): return [join(expanduser('~'), _DOT_BONSAI), join('.', _DOT_BONSAI)] def _read_config(self): # verify that at least one of the config files exists # as RawConfigParser ignores missing files found = False config_files = self._config_files() for path in config_files: if os.access(path, os.R_OK): found = True break if not found: # Write empty .bonsai to disk if no file is found self._write_dot_bonsai() self._config_parser.read(config_files) for path in config_files: if os.path.exists(path): self.file_paths.add(path) def _set_profile(self, section): # Create section if it does not exist if not self._config_parser.has_section(section) and section != _DEFAULT: self._config_parser.add_section(section) # Set profile in class and config self.profile = section if section == _DEFAULT: self._config_parser.set(_DEFAULT, _PROFILE, 'DEFAULT') else: self._config_parser.set(_DEFAULT, _PROFILE, str(section)) def _write_dot_bonsai(self): """ Writes to .bonsai in users home directory """ config_path = join(expanduser('~'), _DOT_BONSAI) with open(config_path, 'w') as f: self._config_parser.write(f) def _websocket_url(self): """ Converts api url to websocket url """ api_url = self.url parsed_api_url = urlparse(api_url) if parsed_api_url.scheme == 'http': parsed_ws_url = parsed_api_url._replace(scheme='ws') elif parsed_api_url.scheme == 'https': parsed_ws_url = parsed_api_url._replace(scheme='wss') else: return None ws_url = urlunparse(parsed_ws_url) return ws_url def _has_section(self, section): """Checks the configuration to see if section exists.""" if section == _DEFAULT: return True return self._config_parser.has_section(section) def _section_list(self): """ Returns a list of sections in config """ return self._config_parser.sections() def _section_items(self, section): """ Returns a dictionary of items in a section """ return self._config_parser.items(section) def _defaults(self): """ Returns an ordered dict of items in the DEFAULT section """ return self._config_parser.defaults() def _update(self, **kwargs): """ Updates the configuration with the Key/value pairs in kwargs and writes to the .bonsai file in the users home directory. """ if not kwargs: return for key, value in kwargs.items(): if key.lower() == _PROFILE.lower(): self._set_profile(value) else: try: self._config_parser.set(self.profile, key, str(value)) except NoSectionError as e: # Create and set default profile if it does not exist in .bonsai self._set_profile(self.profile) self._config_parser.set(self.profile, key, str(value)) self._write_dot_bonsai() self._parse_config(self.profile)
def read_yarrharr_conf(files, namespace): """ Read the given configuration files, mutating the given dictionary to contain Django settings. :raises UnreadableConfError: if any of the given files are not read """ conf = RawConfigParser() conf.read_file(StringIO(DEFAULT_CONF), "<defaults>") files_read = conf.read(files) files_unread = set(files) - set(files_read) if files_unread: raise UnreadableConfError(files_unread) namespace["DEBUG"] = conf.getboolean("yarrharr", "debug") namespace["DATABASES"] = { "default": { "ENGINE": conf.get("db", "engine"), "NAME": conf.get("db", "name"), "USER": conf.get("db", "user"), "PASSWORD": conf.get("db", "password"), "HOST": conf.get("db", "host"), "PORT": conf.get("db", "port"), }, } namespace["ATOMIC_REQUESTS"] = True namespace["DEFAULT_AUTO_FIELD"] = "django.db.models.AutoField" external_url = urlparse(conf.get("yarrharr", "external_url")) if external_url.path != "": # Ensure that the URL doesn't contain a path, as some day we will # probably want to add the ability to add a prefix to the path. msg = "external_url must not include path: remove {!r}".format( external_url.path) raise ValueError(msg) namespace["ALLOWED_HOSTS"] = [external_url.hostname] # The proxied config is an enumeration to ensure it can be extended to # support the Forwarded header (RFC 7239) in the future. We require expicit # configuration rather than auto-detecting these headers because the # frontend proxy *must* be configured to strip whatever header is in use, # lest clients be able to forge it. proxied = conf.get("yarrharr", "proxied") if proxied not in {"no", "x-forwarded"}: msg = "proxied must be 'no' or 'x-forwarded', not {!r}".format(proxied) raise ValueError(msg) namespace["USE_X_FORWARDED_HOST"] = proxied == "x-forwarded" # Config for the Twisted production server. namespace["SERVER_ENDPOINT"] = conf.get("yarrharr", "server_endpoint") namespace["ROOT_URLCONF"] = "yarrharr.urls" namespace["LOGIN_URL"] = "login" namespace["LOGIN_REDIRECT_URL"] = "home" namespace["LOGOUT_URL"] = "logout" namespace["LANGUAGE_CODE"] = "en-us" namespace["USE_I18N"] = True namespace["USE_TZ"] = True namespace["TIME_ZONE"] = "UTC" namespace["STATIC_ROOT"] = conf.get("yarrharr", "static_root") namespace["STATIC_URL"] = conf.get("yarrharr", "static_url") namespace["STATICFILES_FINDERS"] = ( "django.contrib.staticfiles.finders.AppDirectoriesFinder", ) # Template context processors. This list is missing most of the processors # in the default list as Yarrharr's templates don't use them. context_processors = [ "django.contrib.auth.context_processors.auth", "yarrharr.context_processors.csp", ] if namespace["DEBUG"]: # When in debug mode, display SQL queries for requests coming from the # loopback interface. context_processors.append("django.template.context_processors.debug") namespace["INTERNAL_IPS"] = ["127.0.0.1"] namespace["TEMPLATES"] = [{ "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [], "APP_DIRS": True, "OPTIONS": { "context_processors": context_processors }, }] namespace["SECRET_KEY"] = conf.get("secrets", "secret_key") namespace["X_FRAME_OPTIONS"] = "DENY" namespace["MIDDLEWARE"] = ( "django.middleware.common.CommonMiddleware", "django.contrib.sessions.middleware.SessionMiddleware", "django.middleware.csrf.CsrfViewMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.middleware.clickjacking.XFrameOptionsMiddleware", ) namespace[ "SESSION_ENGINE"] = "django.contrib.sessions.backends.signed_cookies" namespace["SESSION_COOKIE_HTTPONLY"] = True namespace["SESSION_COOKIE_SECURE"] = external_url.scheme == "https" namespace["CSRF_COOKIE_SECURE"] = external_url.scheme == "https" namespace["CSRF_TRUSTED_ORIGINS"] = [ urlunparse(external_url[0:2] + ("", "", "", "")) ] namespace["WSGI_APPLICATION"] = "yarrharr.wsgi.application" namespace["INSTALLED_APPS"] = ( "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.staticfiles", "yarrharr", ) if "runserver" not in sys.argv: # Disable Django's logging configuration stuff (except when running under # the dev server). namespace["LOGGING_CONFIG"] = None namespace["YARRHARR_SCRIPT_NONCE"] = True else: # Under the dev server send the same headers as the real Twisted server. # See yarrharr.application.Root. namespace["SECURE_REFERRER_POLICY"] = "same-origin" namespace["SECURE_CROSS_ORIGIN_OPENER_POLICY"] = "same-origin" namespace["YARRHARR_SCRIPT_NONCE"] = False return conf
def upload(self, subdir, filepath): if self.use_package_upload == 'http': import requests try: from configparser import RawConfigParser except: from ConfigParser import RawConfigParser config = RawConfigParser() config.read(os.path.expanduser("~/.passwd")) data = { "password": config.get('cgdo.ru', 'upload_password'), "subdir": subdir, } files = { "file": open(filepath, "rb"), } proxies = {} if self.use_proxy: proxies = { "http": self.use_proxy, "https": self.use_proxy, } sys.stdout.write("Uploading package '%s' to '%s'...\n" % (filepath, subdir)) requests.post("http://cgdo.ru/upload", files=files, data=data, proxies=proxies) elif self.use_package_upload == 'ftp': try: from configparser import ConfigParser except: from ConfigParser import ConfigParser config = ConfigParser() config.read(os.path.expanduser("~/.passwd")) now = datetime.datetime.now() subdir = now.strftime("%Y%m%d") cmd = None if sys.platform == 'win32': ftpScriptFilepath = os.path.join( tempfile.gettempdir(), "blender_for_vray_upload.txt") with open(ftpScriptFilepath, 'w') as f: f.write('option batch abort\n') f.write('option confirm off\n') f.write( 'open ftp://%s:%s@%s -rawsettings ProxyMethod=%s ProxyHost=%s ProxyPort=%s\n' % ( config.get('nightlies.ftp', 'user'), config.get('nightlies.ftp', 'pass'), config.get('nightlies.ftp', 'host'), config.get('nightlies.ftp', 'proxy_type'), config.get('nightlies.ftp', 'proxy_host'), config.get('nightlies.ftp', 'proxy_port'), )) f.write('option transfer binary\n') f.write('put %s /%s/\n' % (filepath, subdir)) f.write('exit\n') f.write('\n') cmd = ['winscp'] cmd.append('/passive') cmd.append('/script="%s"' % ftpScriptFilepath) if not self.mode_test: os.system(' '.join(cmd)) else: cmd = ['curl'] cmd.append('--no-epsv') if self.use_proxy: cmd.append('--proxy') cmd.append(self.use_proxy) cmd.append('--user') cmd.append('%s:%s' % ( config.get('nightlies.ftp', 'user'), config.get('nightlies.ftp', 'pass'), )) cmd.append('--upload-file') cmd.append(filepath) cmd.append('ftp://%s/%s/' % ( config.get('nightlies.ftp', 'host'), subdir, )) if not self.mode_test: subprocess.call(cmd) if self.mode_test: print(' '.join(cmd))
def __init__(self, simulation=True, hardware=False, server='', diminution=1, factor_sim=40, config='', interactive=True, webserver='', joystick=''): if config == '' or joystick == '': cfg_path = path.join(path.dirname(__file__), '..', 'config', 'default.cfg') cfg_parser = RawConfigParser() cfg_parser.read(cfg_path) if config == '': config = cfg_parser.get('DEFAULT', 'config') if joystick == '': joystick = cfg_parser.get('DEFAULT', 'joystick') if not path.isfile(config): config = path.join(path.dirname(__file__), '..', 'config', config) if not path.isfile(config): raise IOError("Config file '{}' not found".format(config)) if not path.isfile(joystick): joystick = path.join(path.dirname(__file__), '..', 'config', joystick) if not path.isfile(joystick): raise IOError( "Joystick mapping file '{}' not found".format(joystick)) try: with open(config, 'r') as f: self.config = load(f) except ValueError as e: raise ValueError( "Your configuration file {} has an incorrect format, make sure it is a valid JSON. {}" .format(config, str(e))) except IOError as e: raise IOError("Configuration file {} can't be read. {}".format( config, str(e))) try: with open(joystick, 'r') as f: self.joystick = load(f) except ValueError as e: raise ValueError( "Your joystick mapping file {} has an incorrect format, make sure it is a valid JSON. {}" .format(joystick, str(e))) except IOError as e: raise IOError("Joystick mapping file {} can't be read. {}".format( joystick, str(e))) self._simulation = simulation self._hardware = hardware self._server = server self.diminution = diminution self.height = len(self.config['mapping']) self.width = len(self.config['mapping'][0]) if self.height > 0 else 0 if ('automapping' in self.config): (w, h, opt) = self.config['automapping'] self.config['mapping'] = [[x + w * y for x in range(w)] for y in range(h)] self.height = h self.width = w if (opt == 'ZIGZAG' ): #When leds are chained in zigzag, reverse odd lines for x in [k for k in range(h) if k % 2]: self.config['mapping'][x] = self.config['mapping'][x][::-1] if (opt == 'ZAGZIG' ): #When leds are chained in zigzag, reverse Even lines for x in [k for k in range(h) if not k % 2]: self.config['mapping'][x] = self.config['mapping'][x][::-1] if ('webserver' in self.config): self._webserver = self.config["webserver"] self.user_model = Model(self.height, self.width, 'black') self.touch = CapacitiveTouch(config, self.height, self.width) self.sdl_lock = RLock( ) # Temporary hack to lock pygame calls using SDL before we create a centralized event manager for joystick and so on self.events = Events(self, True) self._models = {'user': self.user_model, 'touch': self.touch.model} # Start connection to real, simulated, or network LED table self.arbasim = None self.arbalink = None self.arbaclient = None if self._simulation: print("Launching simulation for %d x %d with a factor of %d" % (self.height, self.width, factor_sim)) self.arbasim = Simulator(self, self.height * factor_sim, self.width * factor_sim) if self._hardware: self.arbalink = Arbalink.factory(self) if len(self._server) > 0: server = self._server.split(':') if len(server) == 2: self.arbaclient = Arbaclient(self, server[0], int(server[1])) elif len(server) == 1: self.arbaclient = Arbaclient(self, server[0]) else: raise ValueError('Incorrect server address, use ip:port or ip') if ('webserver' in self.config): webserver = self.config["webserver"].split(':') if len(webserver) == 2: self.webserver = Arbaweb(self, webserver[0], int(webserver[1])) elif len(webserver) == 1: self.webserver = Arbaweb(self, webserver[0]) else: raise ValueError( 'Incorrect webserver address, use ip:port or ip')
def readConfigData(section, key): config = RawConfigParser() config.read("./ConfigurationFiles/Config.cfg") return config.get(section, key)
def fetchElementLocators(section, key): config = RawConfigParser() config.read("./ConfigurationFiles/Elements.cfg") return config.get(section, key)