Python ConfigParser.set方法代码示例

# 需要导入模块: from iniparse import ConfigParser [as 别名]
# 或者: from iniparse.ConfigParser import set [as 别名]
    def write(self,
              path=None,
              dependencies = None,
              src_uri = None,
              description = None,
              install_method = None,
              src_type = None,
              url = None,
              revision = None,
              category = None,
              src_opts = None,
              src_md5 = None,
              python = None,
              scm_branch = None,
             ):
        """Store/Update the minibuild config
        """
        to_write = OrderedDict(
            [('dependencies', dependencies),
            ('src_uri', src_uri),
            ('install_method', install_method),
            ('src_type', src_type),
            ('revision', revision),
            ('category', category),
            ('description', description),
            ('src_md5', src_md5),
            ('url', url),
            ('src_opts', src_opts),
            ('python', python),
            ('scm_branch', scm_branch),]
        )

        # open config
        if not path:
            path = self.path
        shutil.copy2(path, path+'.sav')
        wconfig = WritableConfigParser()
        wconfig.read(path)

        for metadata in to_write:
            value = to_write[metadata]
            if isinstance(value, list):
                if len(value) < 1:
                    value = None
                else:
                    value =  ' '.join(value)
            if value is not None:
                wconfig.set('minibuild' , metadata, value)

        # write back cofig
        fic = open(path, 'w')
        wconfig.write(fic)
        fic.flush()
        fic.close()
        newline(path)

        # reload minibuild
        self.load()

# 需要导入模块: from iniparse import ConfigParser [as 别名]
# 或者: from iniparse.ConfigParser import set [as 别名]
    def update(self, repo):
        # Need to clear out the old section to allow unsetting options:
        # don't use remove section though, as that will reorder sections,
        # and move whitespace around (resulting in more and more whitespace
        # as time progresses).
        for (k, v) in self.items(repo.id):
            self.remove_option(repo.id, k)

        for k, v in repo.items():
            ConfigParser.set(self, repo.id, k, v)

# 需要导入模块: from iniparse import ConfigParser [as 别名]
# 或者: from iniparse.ConfigParser import set [as 别名]
    def _apply():
        debug('Write ini settings to %s' % filename)
        debug(config)

        cfg = ConfigParser()
        cfg.read(filename)
        for section, values in config.items():
            if not cfg.has_section(section):
                if strict_sections:
                    raise Exception('No section %s in ini file %s' % (section, filename))
                else:
                    cfg.add_section(section)

            for key, val in values.items():
                cfg.set(section, key, val)

        with open(filename, 'w') as configfile:
            cfg.write(configfile)

        event(on_apply)

# 需要导入模块: from iniparse import ConfigParser [as 别名]
# 或者: from iniparse.ConfigParser import set [as 别名]
def archive_inv(gameDir, dummyPath, game='FO3', mode=True):
	'''Apply ArchiveInvalidationInvalidated.'''
	if mode:
		if game == 'NV':
			try:
				ini = ConfigParser()
				ini.read(os.environ['USERPROFILE'] + '\\My Games\\FalloutNV\\Fallout.ini')
				ini.set('Archive', 'bInvalidateOlderFiles', '1')
				ini.set('Archive', 'SArchiveList', 'Dummy.bsa,' + ini.get('Archive', 'SArchiveList'))
				
				iniFile = open(os.environ['USERPROFILE'] + '\\My Games\\FalloutNV\\Fallout.ini', 'w')
				ini.write(iniFile)
				
				bsa = open(dummyPath, 'rb').read()
				dummy = open(gameDir + '\\Data\\Dummy.bsa', 'wb')
				dummy.write(bsa)
				dummy.close()
				
				return True
			except IOError:
				return False

# 需要导入模块: from iniparse import ConfigParser [as 别名]
# 或者: from iniparse.ConfigParser import set [as 别名]

#.........这里部分代码省略.........

    # -- contents manipulation ------------------------------------------------------------

    def add_repo(self, repo):
        """
        Adds a new repo to this object, however the file is not saved.

        This is not saved as an object reference, so future changes to the passed in
        repo will not be captured in this RepoFile instance. If changes are made to
        the original Repo object, it must be passed into the RepoFile instance through
        update_repo in order for the changes to be captured.

        @param repo: repo to add; may not be None
        @type  repo: L{Repo}
        """
        self.parser.add_section(repo.id)
        self._repo_to_parser(repo)

    def remove_repo_by_name(self, repo_name):
        """
        Removes the repo with the given name. If the repo does not exist, this
        method does nothing.

        @param repo: identifies the repo to remove
        @type  repo: string
        """
        return self.parser.remove_section(repo_name)

    def update_repo(self, repo):
        """
        Updates the underlying store with the latest contents of a repo. The repo
        passed to this method must have been created prior to this call.

        The repo is not saved as an object reference. Instead, the values are captured
        to the underlying store at the point in time this is called.

        @param repo: repo instance containing updated values to store; cannot be None
        @type  repo: L{Repo}
        """
        self._repo_to_parser(repo)

    def get_repo(self, repo_id):
        """
        Loads a repo by repo ID. If the repo does not exist, returns None.

        @param repo_id: id of the repo to retrieve
        @type  repo_id: string

        @return: repo instance if one exists; None otherwise
        @rtype:  L{Repo}
        """
        if self.parser.has_section(repo_id):
            repo = self._parser_to_repo(repo_id)
            return repo
        else:
            return None

    def all_repos(self):
        """
        Returns a list of all repos in the store.

        @return: list of repo instances; empty list if there are none
        @rtype:  list of L{Repo}
        """
        repos = []
        for repo_name in self.parser.sections():
            repo = self._parser_to_repo(repo_name)
            repos.append(repo)

        return repos

    def _repo_to_parser(self, repo):
        """
        Adds the contents of the repo to the underlying store. This call assumes
        the parser section has already been created.

        @param repo: repo instance to update in the parser; cannot be None
        @type  repo: L{Repo}
        """
        for k, v in repo.items():
            if v:
                self.parser.set(repo.id, k, v)
            else:
                self.parser.remove_option(repo.id, k)

    def _parser_to_repo(self, repo_name):
        """
        Utility for converting the config parser section into a repo object.

        @param repo_name: name of the repo being retrieved from the store
        @type  repo_name: string

        @return: repo instance populated from the section data
        @rtype:  L{Repo}
        """
        repo = Repo(repo_name)
        for key, value in self.parser.items(repo_name):
            repo[key] = value

        return repo