def __init__(self,
fn,
owner=None,
alt=(),
extra=(),
help_names=('help', 'h'),
helper_class=None,
hide_help=False):
"""
:param sequence alt: Alternate actions the CLI will handle.
:param help_names: Names to use to trigger the help.
:type help_names: sequence of strings
:param helper_class: A callable to produce a helper object to be
used when the help is triggered. If unset, uses `.ClizeHelp`.
:type helper_class: a type like `.ClizeHelp`
:param bool hide_help: Mark the parameters used to trigger the help
as undocumented.
"""
update_wrapper(self, fn)
self.func = fn
self.owner = owner
self.alt = util.maybe_iter(alt)
self.extra = extra
self.help_names = help_names
self.help_aliases = [util.name_py2cli(s, kw=True) for s in help_names]
self.helper_class = helper_class
self.hide_help = hide_help
def _clize(fn, alias={}, force_positional=(), coerce={},
require_excess=False, extra=(),
use_kwoargs=None):
sig = util.funcsigs.signature(fn)
has_kwoargs = False
annotations = defaultdict(list)
ann_positional = []
for param in sig.parameters.values():
if param.kind == param.KEYWORD_ONLY:
has_kwoargs = True
elif require_excess and param.kind == param.VAR_POSITIONAL:
annotations[param.name].append(parser.Parameter.REQUIRED)
if param.annotation != param.empty:
ann = util.maybe_iter(param.annotation)
annotations[param.name].extend(ann)
if clize.POSITIONAL in ann:
ann_positional.append(param.name)
annotations[param.name].remove(clize.POSITIONAL)
for name, aliases in alias.items():
annotations[name].extend(aliases)
for name, func in coerce.items():
annotations[name].append(func)
annotate(**annotations)(fn)
use_kwoargs = has_kwoargs if use_kwoargs is None else use_kwoargs
if not use_kwoargs:
fn = autokwoargs(
exceptions=chain(ann_positional, force_positional))(fn)
return runner.Clize(fn, extra=extra)
def cli_commands(obj, namef, clizer):
cmds = util.OrderedDict()
cmd_by_name = {}
for key, val in util.dict_from_names(obj).items():
if not key:
continue
names = tuple(namef(name) for name in util.maybe_iter(key))
cli = clizer.get_cli(val)
cmds[names] = cli
for name in names:
cmd_by_name[name] = cli
return cmds, cmd_by_name
def from_parameter(self, param):
""""""
if param.annotation != param.empty:
annotations = util.maybe_iter(param.annotation)
else:
annotations = []
for i, annotation in enumerate(annotations):
if getattr(annotation, '_clize__parameter_converter', False):
conv = annotation
annotations = annotations[:i] + annotations[i+1:]
break
else:
conv = default_converter
return conv(param, annotations)
def cli_commands(obj, namef, clizer):
cmds = util.OrderedDict()
cmd_by_name = {}
try:
names = util.dict_from_names(obj).items()
except AttributeError:
raise ValueError("Cannot guess name for anonymous objects "
"(lists, dicts, etc)")
for key, val in names:
if not key:
continue
names = tuple(namef(name) for name in util.maybe_iter(key))
cli = clizer.get_cli(val)
cmds[names] = cli
for name in names:
cmd_by_name[name] = cli
return cmds, cmd_by_name
def cli_commands(obj, namef, clizer):
cmds = util.OrderedDict()
cmd_by_name = {}
try:
names = util.dict_from_names(obj).items()
except AttributeError:
raise ValueError("Cannot guess name for anonymous objects "
"(lists, dicts, etc)")
for key, val in names:
if not key:
continue
names = tuple(namef(name) for name in util.maybe_iter(key))
cli = clizer.get_cli(val)
cmds[names] = cli
for name in names:
cmd_by_name[name] = cli
return cmds, cmd_by_name
def _clize(fn,
alias={},
force_positional=(),
coerce={},
require_excess=False,
extra=(),
use_kwoargs=None):
sig = specifiers.signature(fn)
has_kwoargs = False
annotations = defaultdict(list)
ann_positional = []
for param in sig.parameters.values():
coerce_set = False
if param.kind == param.KEYWORD_ONLY:
has_kwoargs = True
elif param.kind == param.VAR_KEYWORD:
annotations[param.name].append(parser.Parameter.IGNORE)
elif require_excess and param.kind == param.VAR_POSITIONAL:
annotations[param.name].append(parser.Parameter.REQUIRED)
if param.annotation != param.empty:
for thing in util.maybe_iter(param.annotation):
if thing == clize.POSITIONAL:
ann_positional.append(param.name)
continue
elif callable(thing):
coerce_set = True
thing = _convert_coerce(thing)
annotations[param.name].append(thing)
try:
func = coerce[param.name]
except KeyError:
pass
else:
annotations[param.name].append(_convert_coerce(func))
coerce_set = True
annotations[param.name].extend(alias.get(param.name, ()))
if not coerce_set and param.default != param.empty:
annotations[param.name].append(_convert_coerce(type(
param.default)))
fn = modifiers.annotate(**annotations)(fn)
use_kwoargs = has_kwoargs if use_kwoargs is None else use_kwoargs
if not use_kwoargs:
fn = modifiers.autokwoargs(
exceptions=chain(ann_positional, force_positional))(fn)
return runner.Clize(fn, extra=extra)
def convert_parameter(cls, param):
"""Convert a Python parameter to a CLI parameter."""
if param.annotation != param.empty:
annotations = util.maybe_iter(param.annotation)
else:
annotations = []
if Parameter.IGNORE in annotations:
return Parameter.IGNORE
for i, annotation in enumerate(annotations):
if getattr(annotation, '_clize__parameter_converter', False):
conv = annotation
annotations = annotations[:i] + annotations[i + 1:]
break
else:
conv = cls.converter
return conv(param, annotations)
def convert_parameter(cls, param):
"""Convert a Python parameter to a CLI parameter."""
if param.annotation != param.empty:
annotations = util.maybe_iter(param.annotation)
else:
annotations = []
if Parameter.IGNORE in annotations:
return Parameter.IGNORE
for i, annotation in enumerate(annotations):
if getattr(annotation, '_clize__parameter_converter', False):
conv = annotation
annotations = annotations[:i] + annotations[i+1:]
break
else:
conv = cls.converter
return conv(param, annotations)
def _clize(fn, alias={}, force_positional=(), coerce={},
require_excess=False, extra=(),
use_kwoargs=None):
sig = specifiers.signature(fn)
has_kwoargs = False
annotations = defaultdict(list)
ann_positional = []
for param in sig.parameters.values():
coerce_set = False
if param.kind == param.KEYWORD_ONLY:
has_kwoargs = True
elif param.kind == param.VAR_KEYWORD:
annotations[param.name].append(parser.Parameter.IGNORE)
elif require_excess and param.kind == param.VAR_POSITIONAL:
annotations[param.name].append(parser.Parameter.REQUIRED)
if param.annotation != param.empty:
for thing in util.maybe_iter(param.annotation):
if thing == clize.POSITIONAL:
ann_positional.append(param.name)
continue
elif callable(thing):
coerce_set = True
thing = _convert_coerce(thing)
annotations[param.name].append(thing)
try:
func = coerce[param.name]
except KeyError:
pass
else:
annotations[param.name].append(_convert_coerce(func))
coerce_set = True
annotations[param.name].extend(alias.get(param.name, ()))
if not coerce_set and param.default != param.empty:
annotations[param.name].append(
_convert_coerce(type(param.default)))
fn = modifiers.annotate(**annotations)(fn)
use_kwoargs = has_kwoargs if use_kwoargs is None else use_kwoargs
if not use_kwoargs:
fn = modifiers.autokwoargs(
exceptions=chain(ann_positional, force_positional))(fn)
return runner.Clize(fn, extra=extra)
def __init__(self, fn, owner=None, alt=(), extra=(),
help_names=('help', 'h'), helper_class=None, hide_help=False):
"""
:param sequence alt: Alternate actions the CLI will handle.
:param help_names: Names to use to trigger the help.
:type help_names: sequence of strings
:param helper_class: A callable to produce a helper object to be
used when the help is triggered. If unset, uses `.ClizeHelp`.
:type helper_class: a type like `.ClizeHelp`
:param bool hide_help: Mark the parameters used to trigger the help
as undocumented.
"""
update_wrapper(self, fn)
self.func = fn
self.owner = owner
self.alt = util.maybe_iter(alt)
self.extra = extra
self.help_names = help_names
self.help_aliases = [util.name_py2cli(s, kw=True) for s in help_names]
self.helper_class = helper_class
self.hide_help = hide_help
