def getchangelog():
'''
Opens up EDITOR, and allows user to enter changelog.
Splits by the boilerplate text and returns user input
'''
branch = git.branch() or '<unavailable>'
user = git.username() or '<unavailable>'
data = click.edit(
text=RELEASE_LOG_TEXT.format(branch, user),
require_save=True
)
try:
serialized = data.split(RELEASE_LOG_TEXT.format(branch, user))
return serialized[0]
except Exception: # pylint: disable=broad-except
return ''
python类edit()的实例源码
def run_open(module, three=None, python=None):
# Ensure that virtualenv is available.
ensure_project(three=three, python=python, validate=False)
c = delegator.run('{0} -c "import {1}; print({1}.__file__);"'.format(which('python'), module))
try:
assert c.return_code == 0
except AssertionError:
click.echo(crayons.red('Module not found!'))
sys.exit(1)
if '__init__.py' in c.out:
p = os.path.dirname(c.out.strip().rstrip('cdo'))
else:
p = c.out.strip().rstrip('cdo')
click.echo(crayons.normal('Opening {0!r} in your EDITOR.'.format(p), bold=True))
click.edit(filename=p)
sys.exit(0)
def configure():
from config import config, config_filename, generate_config
if not config:
logger.info('generating new config {}'.format(config_filename))
generate_config(config_filename)
click.edit(filename=config_filename)
def edit_config_file(self):
click.edit(filename=self.config_file)
def edit(ctx):
"""
Edit your Farmer configuration file.
"""
config = ctx.obj['config']
click.edit(filename=config._sources[1].yaml_filename)
def commit(repo, files, message):
"""Commits outstanding changes.
Commit changes to the given files into the repository. You will need to
"repo push" to push up your changes to other repositories.
If a list of files is omitted, all changes reported by "repo status"
will be committed.
"""
if not message:
marker = '# Files to be committed:'
hint = ['', '', marker, '#']
for file in files:
hint.append('# U %s' % file)
message = click.edit('\n'.join(hint))
if message is None:
click.echo('Aborted!')
return
msg = message.split(marker)[0].rstrip()
if not msg:
click.echo('Aborted! Empty commit message')
return
else:
msg = '\n'.join(message)
click.echo('Files to be committed: %s' % (files,))
click.echo('Commit message:\n' + msg)
def read(ctx, item_id, with_note):
""" Read an item attachment. """
try:
item_id = pick_item(ctx.obj, item_id)
except ValueError as e:
ctx.fail(e.args[0])
read_att = None
attachments = ctx.obj.attachments(item_id)
if not attachments:
ctx.fail("Could not find an attachment for reading.")
elif len(attachments) > 1:
click.echo("Multiple attachments available.")
read_att = select([(att, att['data']['title'])
for att in attachments])
else:
read_att = attachments[0]
att_path = ctx.obj.get_attachment_path(read_att)
click.echo("Opening '{}'.".format(att_path))
click.launch(str(att_path), wait=False)
if with_note:
existing_notes = list(ctx.obj.notes(item_id))
if existing_notes:
edit_existing = click.confirm("Edit existing note?")
if edit_existing:
note = pick_note(ctx, ctx.obj, item_id)
else:
note = None
else:
note = None
note_body = click.edit(
text=note['data']['note']['text'] if note else None,
extension=get_extension(ctx.obj.note_format))
if note_body and note is None:
ctx.obj.create_note(item_id, note_body)
elif note_body:
note['data']['note']['text'] = note_body
ctx.obj.save_note(note)
def add_note(ctx, item_id, note_format):
""" Add a new note to an existing item. """
if note_format:
ctx.obj.note_format = note_format
try:
item_id = pick_item(ctx.obj, item_id)
except ValueError as e:
ctx.fail(e.args[0])
note_body = click.edit(extension=get_extension(ctx.obj.note_format))
if note_body:
ctx.obj.create_note(item_id, note_body)
def edit_note(ctx, item_id, note_num):
""" Edit a note. """
try:
item_id = pick_item(ctx.obj, item_id)
except ValueError as e:
ctx.fail(e.args[0])
note = pick_note(ctx, ctx.obj, item_id, note_num)
updated_text = click.edit(note['data']['note']['text'],
extension=get_extension(ctx.obj.note_format))
if updated_text:
note['data']['note']['text'] = updated_text
ctx.obj.save_note(note)
def edit(ctx, pass_name):
"""Insert a new password or edit an existing one using the editor
specified by either EDITOR or VISUAL or falling back on the
platform default if both are not set.
"""
try:
data = ctx.obj.get_key(pass_name)
except FileNotFoundError:
data = ''
except StoreNotInitialisedError:
click.echo(MSG_STORE_NOT_INITIALISED_ERROR)
return 1
except PermissionError:
click.echo(MSG_PERMISSION_ERROR)
return 1
if 'EDITOR' in os.environ:
data = click.edit(text=data, editor=os.environ['EDITOR'])
else:
data = click.edit(text=data)
if data is None:
click.echo('Password unchanged.')
return 1
ctx.obj.set_key(pass_name, data, force=True)
def config(ctx, key, value, remove, edit):
"""Get or set config item."""
conf = ctx.obj["conf"]
if not edit and not key:
raise click.BadArgumentUsage("You have to specify either a key or use --edit.")
if edit:
return click.edit(filename=conf.config_file)
if remove:
try:
conf.cfg.remove_option(key[0], key[1])
except Exception as e:
logger.debug(e)
else:
conf.write_config()
return
if not value:
try:
click.echo(conf.cfg.get(key[0], key[1]))
except Exception as e:
logger.debug(e)
return
if not conf.cfg.has_section(key[0]):
conf.cfg.add_section(key[0])
conf.cfg.set(key[0], key[1], value)
conf.write_config()
def clip(save, edit, view, overwrite):
"""convert html in the clipboard to markdown"""
path = save
html = get_clipboard_html()
if html is None:
click.echo('No html in the clipboard')
return
if path is None:
content = html2md.html_to_markdown(html).strip()
click.echo(content)
return
if not path.endswith('.md'):
click.echo('Note must have extension ".md"')
return
note = util.abs_path(path)
if os.path.exists(note) and not overwrite:
click.echo('Note already exists at "{}" (specify `--overwrite` to overwrite)'.format(note))
return
html = parsers.rewrite_external_images(html, note)
content = html2md.html_to_markdown(html).strip()
with open(note, 'w') as f:
f.write(content)
if edit:
click.edit(filename=note)
if view:
compile_note(note, '/tmp', view=True)
def editor(content='', marker='# Enter a description, markdown is allowed!\n'):
message = click.edit(content + '\n\n' + marker)
if message is not None:
return message.split(marker, 1)[0].rstrip('\n')
def editor(content='', marker='# Before we start this run, enter a brief description. (to skip, direct stdin to dev/null: `python train.py < /dev/null`)\n'):
message = click.edit(content + '\n\n' + marker)
if message is None:
return None
return message.split(marker, 1)[0].rstrip('\n')
def edittoot():
edited_message = click.edit()
if edited_message:
return edited_message
return ''
#####################################
######## DECORATORS ########
#####################################
def edit_unsync_issues(cls, issues):
"""
Allows a user to manage all new tasks. They can have three statuses: migrate, skip and hide.
"""
MARKER = """
# Commands:
# m = migrate issue.
# s = skip issue for this time (also you can just remove the line).
# h = hide issue (skip and never migrate).
"""
max_len = max([len(issue.fields.summary) for issue in issues])
max_len = max_len if max_len < 200 else 200
def line_format(issue):
summary = cls.truncate_summary(issue.fields.summary, max_len).ljust(max_len + 2)
return 'm ' + issue.key + '\t' + summary + ' ' + issue.permalink()
items = [line_format(issue) for issue in issues]
while True:
message = click.edit("\n".join(items) + '\n\n' + MARKER)
if message is None:
raise Abort
lines = message.split(MARKER, 1)[0].rstrip('\n').split('\n')
if lines == ['']:
raise Abort
try:
return cls._read_unsync_issues(lines, issues)
except InputException as e:
cls.error(e.message, nl=True)
click.pause()
continue
def cli(issue, file):
"""
Comment on an issue/PR.
If a file is given on the command line, its contents will be used as the
comment body. Otherwise, an editor will be opened for you to type your
comment.
"""
if file is None:
body = click.edit()
if body is None:
click.echo('No text entered; exiting')
else:
body = file.read()
issue.comments.post(json={"body": body})
def cli(issue, file):
"""
Comment on an issue/PR.
If a file is given on the command line, its contents will be used as the
comment body. Otherwise, an editor will be opened for you to type your
comment.
"""
if file is None:
body = click.edit()
if body is None:
click.echo('No text entered; exiting')
else:
body = file.read()
issue.comments.post(json={"body": body})
def edit_as_mail(obj: dict, fields=None, bodyfield=None):
# Returns only the fields that changed
# Fields that the user deletes are considered unchanged
if fields is None:
fields = sorted(obj.keys())
if bodyfield is not None:
fields.remove(bodyfield)
elif isinstance(fields, str):
fields = fields.split()
parser = HeaderParser(body=False if bodyfield is None else None)
msg = ''
for f in fields:
dispname = f.replace('_', '-').title()
val = obj[f]
if val is None:
msg += '{}: \n'.format(dispname, val)
parser.add_field(dispname, dest=f)
elif isinstance(val, bool):
msg += '{}: {}\n'.format(dispname, 'yes' if val else 'no')
parser.add_field(dispname, type=BOOL, dest=f)
elif isinstance(val, str):
msg += '{}: {}\n'.format(dispname, val)
parser.add_field(dispname, dest=f)
elif isinstance(val, (list, tuple)):
msg += '{}: {}\n'.format(dispname, ', '.join(map(str, val)))
parser.add_field(dispname, type=LIST, dest=f)
else:
raise TypeError('only string, boolean, and list fields supported')
if bodyfield is not None:
msg += '\n' + (obj[bodyfield] or '')
msg = click.edit(msg, require_save=True)
if msg is None:
return None
data = parser.parse_string(msg)
newobj = dict(data)
if data.body is not None:
newobj[bodyfield] = data.body
for k,v in list(newobj.items()):
if (list(obj[k]) if isinstance(obj[k], tuple) else obj[k]) == v or \
obj[k] is None and v == '':
del newobj[k]
return newobj
