def remove_section(self, name): section_name = self._get_section_name(name) return SafeConfigParser.remove_section(self, section_name)
class PackageConfigHandler(object): """ Manager class for packages files for tracking installation of modules """ def __init__(self): # noinspection PyUnresolvedReferences from six.moves.configparser import SafeConfigParser self.package_cfg = os.path.expanduser('~/Documents/site-packages/.pypi_packages') if not os.path.isfile(self.package_cfg): print('Creating package file') with open(self.package_cfg, 'w') as outs: outs.close() self.parser = SafeConfigParser() self.parser.read(self.package_cfg) def save(self): with open(self.package_cfg, 'w') as outs: self.parser.write(outs) def add_module(self, pkg_info): """ :param pkg_info: A dict that has name, url, version, summary :return: """ if not self.parser.has_section(pkg_info['name']): self.parser.add_section(pkg_info['name']) self.parser.set(pkg_info['name'], 'url', pkg_info['url']) self.parser.set(pkg_info['name'], 'version', pkg_info['version']) self.parser.set(pkg_info['name'], 'summary', pkg_info['summary']) self.parser.set(pkg_info['name'], 'files', pkg_info['files']) self.parser.set(pkg_info['name'], 'dependency', pkg_info['dependency']) self.save() def list_modules(self): return [module for module in self.parser.sections()] def module_exists(self, name): return self.parser.has_section(name) def get_info(self, name): if self.parser.has_section(name): tbl = {} for opt, value in self.parser.items(name): tbl[opt] = value return tbl def remove_module(self, name): self.parser.remove_section(name) self.save() def get_files_installed(self, section_name): if self.parser.has_option(section_name, 'files'): files = self.parser.get(section_name, 'files').strip() return files.split(',') else: return None def get_dependencies(self, section_name): if self.parser.has_option(section_name, 'dependency'): dependencies = self.parser.get(section_name, 'dependency').strip() return set(dependencies.split(',')) if dependencies != '' else set() else: return None def get_all_dependencies(self, exclude_module=()): all_dependencies = set() for section_name in self.parser.sections(): if section_name not in exclude_module and self.parser.has_option(section_name, 'dependency'): dependencies = self.parser.get(section_name, 'dependency').strip() if dependencies != '': for dep in dependencies.split(','): all_dependencies.add(dep) return all_dependencies
class Config(MutableMapping): """Read and write to config file. A config object is essentially a string key-value store that can be treated like a dictionary:: c = Config() c['foo'] = 'bar' print c['foo'] The file location may be specified:: c = Config('~/matt/anotherconfig.cfg') c['where'] = 'in a different file' If no location is specified, the environment variable CHEMDATAEXTRACTOR_CONFIG is checked and used if available. Otherwise, a standard config location is used, which varies depending on the operating system. You can check the location using the ``path`` property. For more information see https://github.com/ActiveState/appdirs It is possible to edit the file by hand with a text editor. Warning: multiple instances of Config() pointing to the same file will not see each others' changes, and will overwrite the entire file when any key is changed. """ #: These values will be present in a config object unless they are explicitly defined otherwise in the config file default_values = {} def __init__(self, path=None): """ :param string path: (Optional) Path to config file location. """ self._path = path # Use CHEMDATAEXTRACTOR_CONFIG environment variable if set if not self._path: self._path = os.environ.get('CHEMDATAEXTRACTOR_CONFIG') # Use OS-dependent config directory given by appdirs if not self._path: self._path = os.path.join( appdirs.user_config_dir('ChemDataExtractor'), 'config.cfg') self._parser = SafeConfigParser() if os.path.isfile(self.path): with open(self.path) as f: self._parser.readfp(f) if not self._parser.has_section('cde'): self._parser.add_section('cde') for k, v in six.iteritems(self.default_values): if not self._parser.has_option('cde', k.encode('utf-8')): self._parser.set('cde', k.encode('utf-8'), v.encode('utf-8')) @property def path(self): """The path to the config file.""" return self._path def _flush(self): """Save the contents of data to the file on disk. You should not need to call this manually.""" d = os.path.dirname(self.path) if not os.path.isdir(d): os.makedirs(d) with open(self.path, 'w') as f: self._parser.write(f) def __contains__(self, k): return self._parser.has_option('cde', k.encode('utf-8')) def __getitem__(self, k): try: return self._parser.get('cde', k.encode('utf-8')) except NoOptionError: raise KeyError(k) def __setitem__(self, k, v): self._parser.set('cde', k.encode('utf-8'), v.encode('utf-8')) self._flush() def __delitem__(self, k): try: self._parser.remove_option('cde', k.encode('utf-8')) self._flush() except NoOptionError: raise KeyError(k) def __iter__(self): return (k for k, v in self._parser.items('cde')) def __len__(self): return len(self._parser.items('cde')) def __repr__(self): return '<Config: %s>' % self.path def clear(self): """Clear all values from config.""" self._parser.remove_section('cde') self._parser.add_section('cde') self._flush()