def save(self):
"""Save the modules to @_path. If @modules is an empty
dict, then @_path should be removed.
"""
root_logger.debug("Saving StateFile to '%s'", self._path)
for module in list(self.modules.keys()):
if len(self.modules[module]) == 0:
del self.modules[module]
if len(self.modules) == 0:
root_logger.debug(" -> no modules, removing file")
if os.path.exists(self._path):
os.remove(self._path)
return
p = SafeConfigParser()
p.optionxform = str
for module in self.modules.keys():
p.add_section(module)
for (key, value) in self.modules[module].items():
p.set(module, key, str(value))
with open(self._path, "w") as f:
p.write(f)
def save(self):
"""Save the modules to @_path. If @modules is an empty
dict, then @_path should be removed.
"""
root_logger.debug("Saving StateFile to '%s'", self._path)
for module in list(self.modules):
if len(self.modules[module]) == 0:
del self.modules[module]
if len(self.modules) == 0:
root_logger.debug(" -> no modules, removing file")
if os.path.exists(self._path):
os.remove(self._path)
return
p = SafeConfigParser()
p.optionxform = str
for module in self.modules:
p.add_section(module)
for (key, value) in self.modules[module].items():
p.set(module, key, str(value))
with open(self._path, "w") as f:
p.write(f)
def load_config(config_files=(), overrides=()):
cp = SafeConfigParser()
cp.optionxform = str # make parsing case-sensitive
cp.read(FILENAMES + config_files)
for section, option, value in overrides:
if value is not None:
if isinstance(value, bool):
value = int(value)
cp.set(section, option, str(value))
return {section: dict(cp.items(section)) for section in cp.sections()}
def init_ini_file(file=args.ini_file):
cp = SafeConfigParser()
fp = open(file)
cp.optionxform = str
cp.readfp(fp)
fp.close()
cp.set('condor', 'lalsuite-install', lalinf_prefix)
cp.set('analysis', 'engine', args.engine)
cp.remove_option('analysis', 'nparallel')
return cp
def init_ini_file(file=args.ini_file):
cp=SafeConfigParser()
fp=open(file)
cp.optionxform = str
cp.readfp(fp)
fp.close()
cp.set('condor','lalsuite-install',lalinf_prefix)
cp.set('analysis','engine',args.engine)
cp.remove_option('analysis','nparallel')
return cp
def read_config_file():
if not os.path.isfile(config_file_path):
download_config_file()
config = SafeConfigParser()
config.optionxform = str
list_of_successfully_parsed_files = config.read(config_file_path)
if config_file_path not in list_of_successfully_parsed_files:
raise Exception(
'Could not read {0} succesfully.'.format(config_file_path)
)
return config
def read_ini(cls, path, section=None):
"""read preferences from an .ini file"""
parser = ConfigParser()
parser.optionxform = str
parser.readfp(mozfile.load(path))
if section:
if section not in parser.sections():
raise PreferencesReadError("No section '%s' in %s" % (section, path))
retval = parser.items(section, raw=True)
else:
retval = parser.defaults().items()
# cast the preferences since .ini is just strings
return [(i, cls.cast(j)) for i, j in retval]
def read_ini(cls, path, section=None):
"""read preferences from an .ini file"""
parser = ConfigParser()
parser.optionxform = str
parser.readfp(mozfile.load(path))
if section:
if section not in parser.sections():
raise PreferencesReadError("No section '%s' in %s" % (section, path))
retval = parser.items(section, raw=True)
else:
retval = parser.defaults().items()
# cast the preferences since .ini is just strings
return [(i, cls.cast(j)) for i, j in retval]
def _load(self):
"""Load the file list from the index file. @files will
be an empty dictionary if the file doesn't exist.
"""
root_logger.debug("Loading Index file from '%s'", self._index)
self.files = {}
p = SafeConfigParser()
p.optionxform = str
p.read(self._index)
for section in p.sections():
if section == "files":
for (key, value) in p.items(section):
self.files[key] = value
def _load(self):
"""Load the file list from the index file. @files will
be an empty dictionary if the file doesn't exist.
"""
root_logger.debug("Loading Index file from '%s'", self._index)
self.files = {}
p = SafeConfigParser()
p.optionxform = str
p.read(self._index)
for section in p.sections():
if section == "files":
for (key, value) in p.items(section):
self.files[key] = value
def _load(self):
"""Load the modules from the file @_path. @modules will
be an empty dictionary if the file doesn't exist.
"""
root_logger.debug("Loading StateFile from '%s'", self._path)
self.modules = {}
p = SafeConfigParser()
p.optionxform = str
p.read(self._path)
for module in p.sections():
self.modules[module] = {}
for (key, value) in p.items(module):
if value == str(True):
value = True
elif value == str(False):
value = False
self.modules[module][key] = value
def _load(self):
"""Load the modules from the file @_path. @modules will
be an empty dictionary if the file doesn't exist.
"""
root_logger.debug("Loading StateFile from '%s'", self._path)
self.modules = {}
p = SafeConfigParser()
p.optionxform = str
p.read(self._path)
for module in p.sections():
self.modules[module] = {}
for (key, value) in p.items(module):
if value == str(True):
value = True
elif value == str(False):
value = False
self.modules[module][key] = value
def save(self):
"""Save the file list to @_index. If @files is an empty
dict, then @_index should be removed.
"""
root_logger.debug("Saving Index File to '%s'", self._index)
if len(self.files) == 0:
root_logger.debug(" -> no files, removing file")
if os.path.exists(self._index):
os.remove(self._index)
return
p = SafeConfigParser()
p.optionxform = str
p.add_section('files')
for (key, value) in self.files.items():
p.set('files', key, str(value))
with open(self._index, "w") as f:
p.write(f)
def save(self):
"""Save the file list to @_index. If @files is an empty
dict, then @_index should be removed.
"""
root_logger.debug("Saving Index File to '%s'", self._index)
if len(self.files) == 0:
root_logger.debug(" -> no files, removing file")
if os.path.exists(self._index):
os.remove(self._index)
return
p = SafeConfigParser()
p.optionxform = str
p.add_section('files')
for (key, value) in self.files.items():
p.set('files', key, str(value))
with open(self._index, "w") as f:
p.write(f)
def newScheme(): parser = SafeConfigParser() parser.optionxform = str return parser
def parseOptions(self):
"""Parse the command line options."""
log = LOGGER.getChild("Options")
conf_parser = argparse.ArgumentParser(
"Dirac Release Notes",
formatter_class=argparse.RawTextHelpFormatter,
add_help=False,
)
conf_parser.add_argument("-c", "--configFile", help="Specify config file", metavar="FILE", dest="configFile")
conf_parser.add_argument("-t", "--token", help="API token to use", default="")
conf_parser.add_argument("-d", "--debug", action="count", dest="debug", help="d, dd, ddd", default=0)
args, _remaining_argv = conf_parser.parse_known_args()
self.token = args.token
self.printLevel = _parsePrintLevel(args.debug)
LOGGER.setLevel(self.printLevel)
log.debug("Parsing options")
defaults = {}
if args.configFile:
log.debug("Parsing configFile: %r", args.configFile)
config = ConfigParser()
config.optionxform = str
config.read([args.configFile])
defaults.update(dict(config.items("ReleaseNotes")))
log.info("Settings from config file: %r", defaults)
if config.has_section("ReleaseNotes.Categories"):
items = config.items("ReleaseNotes.Categories")
log.info("Found Categories: %r", items)
for short, system in items:
self.names[short] = system
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter,
# Inherit options from config_parser
parents=[conf_parser],
)
parser.add_argument(
"--branches",
action="store",
default=self.branches,
dest="branches",
nargs="+",
help="branches to get release notes for",
)
parser.add_argument(
"--date",
action="store",
default=self.startDate,
dest="date",
help="date and optionally time after which PRs are checked (ISO 8601),\
accepting 2020-01-08 or 2018-05-20T15:23:45Z,\
default (two weeks ago): %s"
% self.startDate,
)
parser.add_argument(
"--sinceLatestTag",
action="store_true",
dest="sinceLatestTag",
default=self.sinceLatestTag,
help="get release notes since latest tag (incompatible with --date)",
)
parser.add_argument(
"--headerMessage",
action="store",
default=self.headerMessage,
dest="headerMessage",
help="Header message to add between the release name and the list of PR. If it is a path,\
read the content of the file",
)
parser.add_argument(
"--footerMessage",
action="store",
default=self.footerMessage,
dest="footerMessage",
help="Footer message to add after the list of PR. If it is a path,\
read the content of the file",
)
parser.add_argument(
"--openPRs",
action="store_true",
dest="openPRs",
default=self.openPRs,
help="get release notes for open (unmerged) PRs, for testing purposes",
)
parser.add_argument(
"-r",
"--repo",
action="store",
dest="repo",
help="Github repository to check: [Group/]Repo",
default="DiracGrid/Dirac",
)
parser.add_argument(
"-g", "--gitlab", action="store_true", dest="gitlab", help="Using gitlab instance", default=False
)
parser.add_argument(
"-u",
"--gitlabUrl",
action="store",
dest="gitlabUrl",
help="URL of the gitlab instance",
default="https://gitlab.cern.ch",
)
parser.add_argument(
"-i",
"--gitlabProjectID",
action="store",
dest="gitlabProjectID",
help="ID of the project in Gitlab",
default="0",
)
parser.add_argument(
"--deployRelease",
action="store_true",
dest="deployRelease",
help="Convert an existing tag into a github/gitlab release. Requires --releaseNotes and --tagName",
default=self.deployRelease,
)
parser.add_argument(
"--tagName",
action="store",
dest="tagName",
help="Name of the tag to release (with --deployRelease)",
default=self.tagName,
)
parser.add_argument(
"--releaseNotes",
action="store",
dest="releaseNotes",
help="Path to the file containing release notes for this version (with --deployRelease)",
default=self.releaseNotes,
)
parser.set_defaults(**defaults)
parsed = parser.parse_args()
for var, val in sorted(vars(parsed).items()):
log.info("Parsed options: %s = %s", var, pformat(val))
self.branches = listify(parsed.branches)
log.info("Getting PRs for: %s", self.branches)
# If the date parsed does not correspond to the default,
# and latestTag is asked, we throw an error
if (parsed.date != self.startDate) and parsed.sinceLatestTag:
raise RuntimeError("--sinceLatestTag incompatible with --date")
self.sinceLatestTag = parsed.sinceLatestTag
if self.sinceLatestTag:
log.info("Starting from the latest tag")
self.startDate = None
del parsed.date
else:
if not isinstance(parsed.date, datetime.date):
parsed.date = dateutil.parser.isoparse(parsed.date)
if parsed.date.tzinfo is None or parsed.date.tzinfo.utcoffset(parsed.date) is None:
self.startDate = pytz.utc.localize(parsed.date)
else:
self.startDate = parsed.date
log.info("Starting from: %s", self.startDate)
self.openPRs = parsed.openPRs
log.info("Also including openPRs?: %s", self.openPRs)
self.headerMessage = parsed.headerMessage
if self.headerMessage:
log.info("Using header message: %s", self.headerMessage)
self.footerMessage = parsed.footerMessage
if self.footerMessage:
log.info("Using footer message: %s", self.footerMessage)
self.useGitlab = parsed.gitlab if isinstance(parsed.gitlab, bool) else parsed.gitlab.lower() == "true"
self.useGithub = not self.useGitlab
self.gitlabUrl = parsed.gitlabUrl
self.glProjectID = int(parsed.gitlabProjectID)
self.deployRelease = parsed.deployRelease
self.releaseNotes = parsed.releaseNotes
self.tagName = parsed.tagName
if self.deployRelease:
if not (self.releaseNotes and self.tagName):
raise RuntimeError("--deployRelease requires --releaseNotes and --tagName")
if not os.path.isfile(self.releaseNotes):
raise RuntimeError("--releaseNotes should point to an existing file")
repo = parsed.repo
repos = repo.split("/")
if len(repos) == 1:
self.repo = repo
elif len(repos) == 2:
self.owner = repos[0]
self.repo = repos[1]
else:
raise RuntimeError("Cannot parse repo option: %s" % repo)
for var, val in sorted(vars(parsed).items()):
log.info("Using options: %s = %s", var, pformat(val))