You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

387 lines
14 KiB

#-*- coding: utf-8 -*-
# Copyright 2010 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
import re
import textwrap
import optparse
from cl_utils import _toUNICODE
from cl_lang import lang
tr = lang()
tr.setLocalDomain('cl_lib')
tr.setLanguage(sys.modules[__name__])
tr.setLanguage(optparse)
def check_choice_regignore(option, opt, value):
"""Check choice with registry independence"""
if value.lower() in map(lambda x:x.lower(),option.choices):
return value
else:
return optparse.check_choice(option,opt,value)
def make_option(shortOption=None, longOption=None,
optVal=None, help=None, default=None,
action=None, type=None, choices=None,
choices_regignore=None):
"""Make option. Used for processing options parameter in opt __init__.
shortOption short option
longOption long option
optVal argument name, if specified then
option is store, else bool value
help help string
default default value of this option
action another action (at example append, for creating list)
type type of value
choices choice values for type 'choice'
choices_regignore alsa as choice only registry ignored
Examples:
Simple bool option:
make_option(shortOption="q",help=_("quiet work mode"))
Simple value option:
make_option(longOption="file",help=_("log file"),optVal="LOGFILE",
default="/var/log/test.log")
Choice option:
make_option(shortOption="color",help=_("color mode"), type="choice",
choices=["auto","always","never"])
Many option:
make_option(longOption="set",help=_("set variable"),action="append",
optVal="VAR")
"""
# create option by arguments
args = []
dest = None
choices = choices or choices_regignore
if not shortOption is None:
args.append("-%s"%shortOption)
dest = shortOption
if not longOption is None:
args.append("--%s"%longOption)
if type == "choice":
action = "store"
else:
if not optVal is None:
if not action:
action = "store"
type = "string"
else:
if not action:
action = "store_true"
default = False
type = None
opt = optparse.make_option(*args, action=action, type=type,
dest=dest, metavar=optVal,
help=help, default=default,
choices=choices)
if choices_regignore:
opt.TYPE_CHECKER["choice"] = check_choice_regignore
return opt
class ShareHelpFormatter:
"""Общие методы форматирования help-а"""
def format_option(self, option):
# The help for each option consists of two parts:
# * the opt strings and metavars
# eg. ("-x", or "-fFILENAME, --file=FILENAME")
# * the user-supplied help string
# eg. ("turn on expert mode", "read data from FILENAME")
#
# If possible, we write both of these on the same line:
# -x turn on expert mode
#
# But if the opt string list is too long, we put the help
# string on a second line, indented to the same column it would
# start in if it fit on the first line.
# -fFILENAME, --file=FILENAME
# read data from FILENAME
result = []
opts = self.option_strings[option]
opt_width = self.help_position - self.current_indent - 2
if len(opts) > opt_width:
opts = "%*s%s\n" % (self.current_indent, "", opts)
indent_first = self.help_position
else: # start help on same line as opts
opts = "%*s%-*s " % (self.current_indent, "", opt_width, opts)
indent_first = 0
result.append(opts)
if option.help:
help_text = self.expand_default(option)
help_lines = map(lambda x : x.encode('UTF-8'),
textwrap.wrap(_toUNICODE(help_text),
self.help_width))
result.append("%*s%s\n" % (indent_first, "", help_lines[0]))
result.extend(["%*s%s\n" % (self.help_position, "", line)
for line in help_lines[1:]])
elif opts[-1] != "\n":
result.append("\n")
return "".join(result)
def _format_text(self, text):
"""
Format a paragraph of free-form text for inclusion in the
help output at the current indentation level.
"""
text_width = self.width - self.current_indent
indent = " "*self.current_indent
return textwrap.fill(_toUNICODE(text),
text_width,
initial_indent=indent,
subsequent_indent=indent).encode('UTF-8')
def format_description(self, description):
if description:
lines = map(lambda x: self._format_text(x), description.split("\n"))
return "\n".join(lines)
else:
return ""
def get_example_header(self):
return _("Examples") + ":\n"
def format_examples(self, examples, comment=""):
if examples:
# "Examples:"
header = self.get_example_header()
if comment:
comment = "%s" % comment
backup_width = self.width
self.width = self.width - self.indent_increment - 2
lines = []
for line in comment.split("\n"):
lines.append(self._format_text(line))
self.width = backup_width
lines = ("\n".join(lines)).split("\n")
out_lines = []
for line in lines:
if line.strip():
out_lines.append(" "*self.indent_increment+"# "+line)
else:
out_lines.append(line)
comment = "\n".join(out_lines)
text_examples = "%s\n%s%s" \
%(comment," "*self.indent_increment, examples)
else:
text_examples = "%s%s" %(" "*self.indent_increment,examples)
return header + text_examples + "\n"
else:
return ""
class TitledHelpFormatter(ShareHelpFormatter, optparse.TitledHelpFormatter):
"""Форматирование вывода помощи с заголовками"""
def __init__(self,
indent_increment=2,
max_help_position=24,
width=None,
short_first=1):
optparse.TitledHelpFormatter.__init__(self, indent_increment,
max_help_position, width,
short_first)
def format_usage(self, usage):
if usage:
return "%s%s%s" % (self.format_heading(_("Usage")),
" "*self.indent_increment,
usage)
else:
return ""
def get_example_header(self):
return self.format_heading(_("Examples"))
def format_description(self, description):
description = ShareHelpFormatter.format_description(self, description)
if description:
return " "*self.indent_increment + description
else:
return ""
class IndentedHelpFormatter(ShareHelpFormatter, optparse.IndentedHelpFormatter):
"""Форматирование вывода стандартный класс"""
def __init__(self,
indent_increment=2,
max_help_position=24,
width=None,
short_first=1):
optparse.IndentedHelpFormatter.__init__(self, indent_increment,
max_help_position, width,
short_first)
def format_usage(self, usage):
if usage:
return _("Usage") + ": %s" % usage
else:
return ""
class opt(optparse.OptionParser):
"""Class of options for calculate utilities
Example:
class new_utility(opt):
def __init__(self):
opt.__init__(self,
package=__app__,
version=__version__,
description=_("Some description"),\
option_list= [\
#Simple bool option:
{
'shortOption':'q',
'help':_("quiet work mode")
},
#Simple value option:
{
'longOption':"file",
'help':_("log file"),
'optVal':"LOGFILE",
"default":"/var/log/test.log")
},
#Choice option:
{
'shortOption':"color",
'help':_("color mode"),
'type':"choice",
'choices'=["auto","always","never"]
},
#Summary option:
{
'longOption':"set",
'help':_("set variable"),
'action':"append",
'optVal'="VAR"
}
]
)
"""
variable_set = \
[{'longOption':"set",
'optVal':"VAR=VALUE",
'action':'append',
'help':_("set the variable value")
}]
variable_view = \
[{'shortOption':"v",
'longOption':"show-variables",
'action':'count',
'help':_("print variables, in verbose mode if the two options "
"applied (includes printing hidden variables)")
},
{'longOption':"filter",
'optVal':"FILTER",
'help':_("filter variables (as regexp, use *), to be used in"
" conjunction with options '-v --show-variables'")
},
{'longOption':"xml",
'help':_("output variables in XML format, to be used in"
" conjunction with options '-v --show-variables'")
}]
variable_control = variable_set + variable_view
color_control = \
[
{'longOption':"color",
'optVal':"WHEN",
'type':'choice',
'choices':['never','always','auto'],
'help':_("control whether color is used. WHEN may be") +\
" 'never', 'always', "+ _("or") + " 'auto'"
}]
def __init__(self, package=None, version=None,
usage=None, examples=None, description=None,
option_list=[],
epilog=None,
comment_examples=None,
formatter=IndentedHelpFormatter(),
check_values=None):
"""Установка опций командной строки"""
self.package = package
self.examples = examples
self.comment_examples = comment_examples
# Дополнительная функция проверки опций
if check_values:
self.check_values = check_values
optparse.OptionParser.__init__(self,
usage=usage,
option_list=[make_option(**i) for i in option_list],
option_class=optparse.Option,
version=version,
conflict_handler="error",
description=description,
formatter=formatter,
#formatter=TitledHelpFormatter(),
epilog=epilog)
self.formatter._long_opt_fmt = "%s %s"
def _get_encoding(self, file):
encoding = getattr(file, "encoding", None)
if not encoding:
encoding = "UTF-8"
return encoding
def get_usage(self):
"""Replace standard help header"""
if self.usage:
return "%s %s\n\n%s"%(self.package,self.version,
self.formatter.format_usage(self.expand_prog_name(self.usage)))
else:
return ""
def get_description(self):
"""Replace standard help header"""
if self.examples:
if self.comment_examples:
text_examples = self.formatter.format_examples(self.examples,
self.comment_examples)
else:
text_examples = self.formatter.format_examples(self.examples)
return self.description + "\n\n" +\
self.expand_prog_name(text_examples)
return self.description + "\n"
def format_help(self, formatter=None):
"""Decode format help from utf-8 to unicode"""
return \
optparse.OptionParser.format_help(self,formatter).decode('UTF-8')
def error(self, msg):
"""error(msg : string)
Print a usage message incorporating 'msg' to stderr and exit.
If you override this in a subclass, it should not return -- it
should either exit or raise an exception.
"""
self.print_usage(sys.stderr)
self.exit(2, "%s: %s: %s\n%s\n" % (self.get_prog_name(),
_("error"), msg,
_("Try `%s' for more information")%
("%s --help"%self.get_prog_name())))
def checkVarSyntax(self,values):
"""Check value of parameter set, was used for change vars"""
reCheckSet = re.compile("^[0-9a-z_]+=.*$")
if values.set:
for val in values.set:
if not reCheckSet.match(val):
self.error(_("wrong variable set %s")%val)