Changeset 4113:90434cb52f2b in livinglogic.python.xist

Show
Ignore:
Timestamp:
09/23/10 15:34:22 (9 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Use argparse instead of optparse.

Files:
24 modified

Legend:

Unmodified
Added
Removed
  • MIGRATION.rst

    r4111 r4113  
     1Migrating to version 3.10 
     2========================= 
     3 
     4Changes to the required Python version 
     5-------------------------------------- 
     6 
     7Python 2.7 is required now. 
     8 
     9Changes to :mod:`ll.make` 
     10------------------------- 
     11 
     12*   :mod:`ll.make` uses :mod:`argparse` now. 
     13 
     14*   :meth:`ll.make.Project.optionparser` has been renamed to :meth:`argparser` 
     15    and returns a :class:`argparse.ArgumentParser` object now. 
     16 
     17*   :meth:`ll.make.Project.parseoptions` has been renamed to :meth:`parseargs` 
     18    and returns a :class:`argparse.Namespace` object now. 
     19 
     20Changes to :mod:`ll.daemon` 
     21--------------------------- 
     22 
     23*   :mod:`ll.daemon` uses :mod:`argparse` now. :meth:`ll.daemon.Daemon.optionparser` 
     24    has been renamed to :meth:`argparser. 
     25 
     26 
    127Migrating to version 3.9 
    228======================== 
     
    834    ``xml:lang`` attributes. This functionality has been moved to the new element 
    935    :class:`ll.xist.ns.htmlspecials.html`. Furthermore this new element will not 
    10     change any attribute if it has already been set. 
     36    change an attribute if this attribute has already been set. 
    1137 
    1238    So if you need the functionality replace any use of 
  • NEWS.rst

    r4111 r4113  
    1 Changes in 3.10 (released ??/??/2010) 
     1Changes in 3.10 (released 09/23/2010) 
    22------------------------------------- 
     3 
     4*   Python 2.7 is required now as XIST now uses ``"{}".format(foo)`` and 
     5    :mod:`argparse`. 
     6 
     7*   All scripts and :mod:`ll.make` have been ported to use :mod:`argparse`. 
    38 
    49*   Fixed a bug in :mod:`ll.nightshade`. If the function/procedure didn't set an 
     
    26312636 
    26322637*   Image size calculation is now done in :meth:`asString` and not in 
    2633     :meth:`asHTML`. This allows to write faster code. Old method:: 
     2638    :meth:`asHTML`. This allows to write faster code. Old method:: 
    26342639 
    26352640        e = html.div(html.img(...),gurk.hurz()).asHTML().asString() 
  • demos/cherrypy-images/images.py

    r4052 r4113  
    2525    @cherrypy.expose 
    2626    def images(self, filename): 
    27         return cptools.serveFile("{0}/{1}".format(self.directory, filename)) 
     27        return cptools.serveFile("{}/{}".format(self.directory, filename)) 
    2828 
    2929    @cherrypy.expose 
  • docs/XIST_Advanced.xml

    r4052 r4113  
    153153            node = converter.target.inline(self.content, font_weight="bold") 
    154154        else: 
    155             raise TypeError("unsupported conversion target {0!r}".format(converter.target)) 
     155            raise TypeError("unsupported conversion target {!r}".format(converter.target)) 
    156156        return node.convert(converter) 
    157157</prog> 
  • docs/XIST_Examples.xml

    r4063 r4113  
    286286    def convert(self, converter): 
    287287        context = converter[self] 
    288         elementname = "h{0}".format(min(context.level, 6)) 
     288        elementname = "h{}".format(min(context.level, 6)) 
    289289        node = xsc.Frag( 
    290290            getattr(converter.target, elementname)(self.attrs.title), 
  • setup.py

    r4097 r4113  
    228228args = dict( 
    229229    name="ll-xist", 
    230     version="3.9", 
     230    version="3.10", 
    231231    description="Extensible HTML/XML generator, cross-platform templating language, Oracle utilities and various other tools", 
    232232    long_description=descr, 
  • src/ll/daemon.py

    r4042 r4113  
    4242 
    4343 
    44 import sys, os, signal, pwd, grp, optparse 
     44import sys, os, signal, pwd, grp, argparse 
    4545 
    4646 
    4747__docformat__ = "reStructuredText" 
     48 
     49 
     50class Options(object): 
     51    def __init__(self, **values): 
     52        self.__dict__.update(values) 
    4853 
    4954 
     
    7378        :meth:`start` will switch to this group. 
    7479        """ 
    75         options = dict( 
     80        self.options = Options( 
    7681            stdin=stdin, 
    7782            stdout=stdout, 
     
    8186            group=group, 
    8287        ) 
    83  
    84         self.options = optparse.Values(options) 
    8588 
    8689    def openstreams(self): 
     
    197200        os.kill(pid, signal.SIGTERM) 
    198201 
    199     def optionparser(self): 
    200         """ 
    201         Return an :mod:`optparse` parser for parsing the command line options. 
    202         This can be overwritten in subclasses to add more options. 
    203         """ 
    204         p = optparse.OptionParser(usage="usage: %prog [options] (start|stop|restart|run)") 
    205         p.add_option("--pidfile", dest="pidfile", help="PID filename (default %default)", default=self.options.pidfile) 
    206         p.add_option("--stdin", dest="stdin", help="stdin filename (default %default)", default=self.options.stdin) 
    207         p.add_option("--stdout", dest="stdout", help="stdout filename (default %default)", default=self.options.stdout) 
    208         p.add_option("--stderr", dest="stderr", help="stderr filename (default %default)", default=self.options.stderr) 
    209         p.add_option("--user", dest="user", help="user name or id (default %default)", default=self.options.user) 
    210         p.add_option("--group", dest="group", help="group name or id (default %default)", default=self.options.group) 
     202    def argparser(self): 
     203        """ 
     204        Return an :mod:`argparse` parser for parsing the command line arguments. 
     205        This can be overwritten in subclasses to add more arguments. 
     206        """ 
     207        p = argparse.ArgumentParser(description="Start, stop or restart a daemon process") 
     208        p.add_argument("action", help="Action to execute", choices=("start", "stop", "restart", "run")) 
     209        p.add_argument("--pidfile", dest="pidfile", help="PID filename (default %(default)s)", default=self.options.pidfile) 
     210        p.add_argument("--stdin", dest="stdin", help="stdin filename (default %(default)s)", default=self.options.stdin) 
     211        p.add_argument("--stdout", dest="stdout", help="stdout filename (default %(default)s)", default=self.options.stdout) 
     212        p.add_argument("--stderr", dest="stderr", help="stderr filename (default %(default)s)", default=self.options.stderr) 
     213        p.add_argument("--user", dest="user", help="user name or id (default %(default)s)", default=self.options.user) 
     214        p.add_argument("--group", dest="group", help="group name or id (default %(default)s)", default=self.options.group) 
    211215        return p 
    212216 
     
    222226        command line argument, i.e. if the daemon should be started. 
    223227 
    224         The :mod:`optparse` options and arguments are available 
    225         afterwards as ``self.options`` and ``self.args``. 
    226         """ 
    227         p = self.optionparser() 
    228         if args is None: 
    229             args = sys.argv 
    230         (self.options, self.args) = p.parse_args(args) 
    231         if len(self.args) != 2: 
    232             p.error("incorrect number of arguments") 
    233             sys.exit(1) 
    234         if self.args[1] == "run": 
     228        The :mod:`argparse` arguments are available afterwards as ``self.args``. 
     229        """ 
     230        p = self.argparser() 
     231        self.args = p.parse_args(args) 
     232        if self.args.action == "run": 
    235233            return True 
    236         elif self.args[1] == "restart": 
     234        elif self.args.action == "restart": 
    237235            self.stop() 
    238236            self.start() 
    239237            return True 
    240         elif self.args[1] == "start": 
     238        elif self.args.action == "start": 
    241239            self.start() 
    242240            return True 
    243         elif self.args[1] == "stop": 
     241        elif self.args.action == "stop": 
    244242            self.stop() 
    245243            return False 
    246         else: 
    247             p.error("incorrect argument {0}".format(self.args[1])) 
    248             sys.exit(1) 
  • src/ll/make.py

    r4059 r4113  
    4848 
    4949 
    50 import sys, os, os.path, optparse, warnings, re, datetime, cStringIO, errno, tempfile, operator, types, cPickle, gc, contextlib, locale, gzip 
     50import sys, os, os.path, argparse, warnings, re, datetime, cStringIO, errno, tempfile, operator, types, cPickle, gc, contextlib, locale, gzip 
    5151 
    5252from ll import misc, url 
     
    14971497        self.create() 
    14981498 
    1499     def optionparser(self): 
    1500         """ 
    1501         Return an :mod:`optparse` parser for parsing the command line options. 
    1502         This can be overwritten in subclasses to add more options. 
     1499    def argparser(self): 
     1500        """ 
     1501        Return an :mod:`argparse` parser for parsing the command line arguments. 
     1502        This can be overwritten in subclasses to add more arguments. 
    15031503        """ 
    15041504 
     
    15171517                return "all" 
    15181518 
    1519         actions = ["all", "file", "phony", "filephony", "none"] 
    1520         p = optparse.OptionParser(usage="usage: %prog [options] [targets]") 
    1521         p.add_option("-x", "--ignore", dest="ignoreerrors", help="Ignore errors", action="store_true", default=None) 
    1522         p.add_option("-X", "--noignore", dest="ignoreerrors", help="Don't ignore errors", action="store_false", default=None) 
    1523         p.add_option("-c", "--color", dest="color", help="Use colored output", action="store_true", default=None) 
    1524         p.add_option("-C", "--nocolor", dest="color", help="No colored output", action="store_false", default=None) 
    1525         p.add_option("-g", "--growl", dest="growl", help="Issue growl notification after the build?", action="store_true", default=None) 
    1526         p.add_option("-a", "--showaction", dest="showaction", help="Show actions ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showaction)) 
    1527         p.add_option("-s", "--showstep", dest="showstep", help="Show steps ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showstep)) 
    1528         p.add_option("-n", "--shownote", dest="shownote", help="Show notes ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.shownote)) 
    1529         p.add_option("-r", "--showregistration", dest="showregistration", help="Show registration ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showregistration)) 
    1530         p.add_option("-i", "--showidle", dest="showidle", help="Show actions that didn't produce data?", action="store_true", default=self.showidle) 
    1531         p.add_option("-d", "--showdata", dest="showdata", help="Show data?", action="store_true", default=self.showdata) 
     1519        actions = ("all", "file", "phony", "filephony", "none") 
     1520        p = argparse.ArgumentParser(description="build one or more targets") 
     1521        p.add_argument("targets", metavar="target", help="Target to be built", nargs="*") 
     1522        p.add_argument("-x", "--ignore", dest="ignoreerrors", help="Ignore errors", action="store_true", default=None) 
     1523        p.add_argument("-X", "--noignore", dest="ignoreerrors", help="Don't ignore errors", action="store_false", default=None) 
     1524        p.add_argument("-c", "--color", dest="color", help="Use colored output", action="store_true", default=None) 
     1525        p.add_argument("-C", "--nocolor", dest="color", help="No colored output", action="store_false", default=None) 
     1526        p.add_argument("-g", "--growl", dest="growl", help="Issue growl notification after the build?", action="store_true", default=None) 
     1527        p.add_argument("-a", "--showaction", dest="showaction", help="Show actions?", choices=actions, default=action2name(self.showaction)) 
     1528        p.add_argument("-s", "--showstep", dest="showstep", help="Show steps?", choices=actions, default=action2name(self.showstep)) 
     1529        p.add_argument("-n", "--shownote", dest="shownote", help="Show notes?", choices=actions, default=action2name(self.shownote)) 
     1530        p.add_argument("-r", "--showregistration", dest="showregistration", help="Show registration?", choices=actions, default=action2name(self.showregistration)) 
     1531        p.add_argument("-i", "--showidle", dest="showidle", help="Show actions that didn't produce data?", action="store_true", default=self.showidle) 
     1532        p.add_argument("-d", "--showdata", dest="showdata", help="Show data?", action="store_true", default=self.showdata) 
    15321533        return p 
    15331534 
    1534     def parseoptions(self, commandline=None): 
    1535         """ 
    1536         Use the parser returned by :meth:`optionparser` to parse the option 
    1537         sequence :var:`commandline`, modify :var:`self` accordingly and return 
     1535    def parseargs(self, args=None): 
     1536        """ 
     1537        Use the parser returned by :meth:`argparser` to parse the argument 
     1538        sequence :var:`args`, modify :var:`self` accordingly and return 
    15381539        the result of the parsers :meth:`parse_args` call. 
    15391540        """ 
    1540         p = self.optionparser() 
    1541         (options, args) = p.parse_args(commandline) 
    1542         if options.ignoreerrors is not None: 
    1543             self.ignoreerrors = options.ignoreerrors 
    1544         if options.color is not None: 
    1545             self.color = options.color 
     1541        p = self.argparser() 
     1542        args = p.parse_args(args) 
     1543        if args.ignoreerrors is not None: 
     1544            self.ignoreerrors = args.ignoreerrors 
     1545        if args.color is not None: 
     1546            self.color = args.color 
    15461547        if self.growl is not None: 
    1547             self.growl = options.growl 
    1548         self.showaction = options.showaction 
    1549         self.showstep = options.showstep 
    1550         self.shownote = options.shownote 
    1551         self.showregistration = options.showregistration 
    1552         self.showidle = options.showidle 
    1553         self.showdata = options.showdata 
    1554         return (options, args) 
     1548            self.growl = args.growl 
     1549        self.showaction = args.showaction 
     1550        self.showstep = args.showstep 
     1551        self.shownote = args.shownote 
     1552        self.showregistration = args.showregistration 
     1553        self.showidle = args.showidle 
     1554        self.showdata = args.showdata 
     1555        return args 
    15551556 
    15561557    def _get(self, target, since): 
     
    16561657                pipe.close() 
    16571658 
    1658     def buildwithargs(self, commandline=None): 
    1659         """ 
    1660         For calling make scripts from the command line. :var:`commandline` 
    1661         defaults to ``sys.argv[1:]``. Any positional arguments in the command 
    1662         line will be treated as target ids. If there are no positional arguments, 
    1663         a list of all registered :class:`PhonyAction` objects will be output. 
    1664         """ 
    1665         if not commandline: 
    1666             commandline = sys.argv[1:] 
    1667         (options, args) = self.parseoptions(commandline) 
    1668  
    1669         if args: 
    1670             self.build(*args) 
     1659    def buildwithargs(self, args=None): 
     1660        """ 
     1661        For calling make scripts from the command line. :var:`args` defaults to 
     1662        ``sys.argv``. Any positional arguments in the command line will be treated 
     1663        as target ids. If there are no positional arguments, a list of all 
     1664        registered :class:`PhonyAction` objects will be output. 
     1665        """ 
     1666        args = self.parseargs(args) 
     1667 
     1668        if args.targets: 
     1669            self.build(*args.targets) 
    16711670        else: 
    16721671            self.writeln("Available phony targets are:") 
  • src/ll/orasql/scripts/oracreate.py

    r4082 r4113  
    1010 
    1111 
    12 import sys, os, optparse 
     12import sys, os, argparse 
    1313 
    1414from ll import astyle, orasql 
     
    2222 
    2323def main(args=None): 
    24     colors = ("yes", "no", "auto") 
    25     p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    26     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    27     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    28     p.add_option("-s", "--seqcopy", dest="seqcopy", help="copy sequence values?", default=False, action="store_true") 
    29     p.add_option("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database", type="str") 
    30     p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
    31     p.add_option("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
    32     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     24    p = argparse.ArgumentParser(description="Print (or execute) the DDL of all objects in an Oracle database schema") 
     25    p.add_argument("connectstring", help="Oracle connect string") 
     26    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     27    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     28    p.add_argument("-s", "--seqcopy", dest="seqcopy", help="copy sequence values?", default=False, action="store_true") 
     29    p.add_argument("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database") 
     30    p.add_argument("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
     31    p.add_argument("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
     32    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    3333 
    34     (options, args) = p.parse_args(args) 
    35     if len(args) != 1: 
    36         p.error("incorrect number of arguments") 
    37         return 1 
     34    args = p.parse_args(args) 
    3835 
    39     if options.color == "yes": 
     36    if args.color == "yes": 
    4037        color = True 
    41     elif options.color == "no": 
     38    elif args.color == "no": 
    4239        color = False 
    4340    else: 
     
    4643    stderr = astyle.Stream(sys.stderr, color) 
    4744 
    48     connection = orasql.connect(args[0]) 
     45    connection = orasql.connect(args.connectstring) 
    4946 
    50     if options.execute: 
    51         connection2 = orasql.connect(options.execute) 
     47    if args.execute: 
     48        connection2 = orasql.connect(args.execute) 
    5249        cursor2 = connection2.cursor() 
    5350        term = False 
     
    5653 
    5754    cs1 = s4connectstring(connection.connectstring()) 
    58     if options.execute: 
     55    if args.execute: 
    5956        cs2 = s4connectstring(connection2.connectstring()) 
    6057 
     
    6259        if obj.owner is not None: 
    6360            return False 
    64         if options.keepjunk: 
     61        if args.keepjunk: 
    6562            return True 
    6663        # output pk, fks etc. only when they belong to a table we do output 
     
    7370    for (i, obj) in enumerate(connection.iterobjects(mode="create", schema="user")): 
    7471        keepobj = keep(obj) 
    75         if options.verbose: 
    76             if options.execute: 
     72        if args.verbose: 
     73            if args.execute: 
    7774                msg = astyle.style_default("oracreate.py: ", cs1, " -> ", cs2, ": fetching/creating #{0}".format(i+1)) 
    7875            else: 
     
    8481 
    8582        if keepobj: 
    86             if isinstance(obj, orasql.Sequence) and options.seqcopy: 
     83            if isinstance(obj, orasql.Sequence) and args.seqcopy: 
    8784                ddl = obj.createddlcopy(connection, term) 
    8885            else: 
    8986                ddl = obj.createddl(connection, term) 
    9087            if ddl: 
    91                 if options.execute: 
     88                if args.execute: 
    9289                    try: 
    9390                        cursor2.execute(ddl) 
    9491                    except orasql.DatabaseError, exc: 
    95                         if not options.ignore or "ORA-01013" in str(exc): 
     92                        if not args.ignore or "ORA-01013" in str(exc): 
    9693                            raise 
    9794                        stderr.writeln("oracreate.py: ", s4error("{0}: {1}".format(exc.__class__.__name__, str(exc).strip()))) 
    9895                else: 
    99                     stdout.writeln(ddl.encode(options.encoding)) 
     96                    stdout.writeln(ddl.encode(args.encoding)) 
    10097                    stdout.writeln() 
    10198 
  • src/ll/orasql/scripts/oradelete.py

    r3933 r4113  
    1010 
    1111 
    12 import sys, os, optparse 
     12import sys, os, argparse 
    1313 
    1414from ll import astyle, orasql 
     
    2222 
    2323def main(args=None): 
    24     colors = ("yes", "no", "auto") 
    25     fks = ("keep", "disable", "drop") 
    26     p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    27     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    28     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    29     p.add_option("-s", "--sequences", dest="sequences", help="Should sequences be reset?", default=False, action="store_true") 
    30     p.add_option("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
    31     p.add_option("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
    32     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    33     p.add_option("-t", "--truncate", dest="truncate", help="Truncate tables instead of deleting", default=False, action="store_true") 
     24    p = argparse.ArgumentParser(description="Print (or execute) SQL for deleting all records from all tables in an Oracle database schema") 
     25    p.add_argument("connectstring", help="Oracle connect string") 
     26    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     27    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     28    p.add_argument("-s", "--sequences", dest="sequences", help="Reset sequences?", default=False, action="store_true") 
     29    p.add_argument("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
     30    p.add_argument("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
     31    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     32    p.add_argument("-t", "--truncate", dest="truncate", help="Truncate tables instead of deleting", default=False, action="store_true") 
    3433 
    35     (options, args) = p.parse_args(args) 
    36     if len(args) != 1: 
    37         p.error("incorrect number of arguments") 
    38         return 1 
     34    args = p.parse_args(args) 
    3935 
    40     if options.color == "yes": 
     36    if args.color == "yes": 
    4137        color = True 
    42     elif options.color == "no": 
     38    elif args.color == "no": 
    4339        color = False 
    4440    else: 
     
    4844    stderr = astyle.Stream(sys.stderr, color) 
    4945 
    50     connection = orasql.connect(args[0]) 
     46    connection = orasql.connect(args.connectstring) 
    5147    cursor = connection.cursor() 
    5248 
     
    5551    for (i, obj) in enumerate(connection.itertables(schema="user", mode="drop")): 
    5652        # Progress report 
    57         if options.verbose: 
    58             msg = "truncating" if options.truncate else "deleting from" 
     53        if args.verbose: 
     54            msg = "truncating" if args.truncate else "deleting from" 
    5955            msg = astyle.style_default("oradelete.py: ", cs, ": {0} #{1} ".format(msg, i+1), s4object(str(obj))) 
    6056            stderr.writeln(msg) 
    6157 
    6258        # Print or execute SQL 
    63         if options.execute: 
     59        if args.execute: 
    6460            try: 
    65                 if options.truncate: 
     61                if args.truncate: 
    6662                    cursor.execute(u"truncate table {0}".format(obj.name)) 
    6763                else: 
    6864                    cursor.execute(u"delete from {0}".format(obj.name)) 
    6965            except orasql.DatabaseError, exc: 
    70                 if not options.ignore or "ORA-01013" in str(exc): 
     66                if not args.ignore or "ORA-01013" in str(exc): 
    7167                    raise 
    7268                stderr.writeln("oradelete.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
    7369        else: 
    74             if options.truncate: 
     70            if args.truncate: 
    7571                sql = u"truncate table {0};\n".format(obj.name) 
    7672            else: 
    7773                sql = u"delete from {1};\n".format(obj.name) 
    78             stdout.write(sql.encode(options.encoding)) 
    79     if not options.truncate: 
     74            stdout.write(sql.encode(args.encoding)) 
     75    if not args.truncate: 
    8076        connection.commit() 
    8177 
    82     if options.sequences: 
     78    if args.sequences: 
    8379        for (i, obj) in enumerate(connection.itersequences(schema="user")): 
    8480            # Progress report 
    85             if options.verbose: 
     81            if args.verbose: 
    8682                msg = astyle.style_default("oradelete.py: ", cs, ": recreating #{0} ".format(i+1), s4object(str(obj))) 
    8783                stderr.writeln(msg) 
    8884 
    8985            # Print or execute SQL 
    90             if options.execute: 
     86            if args.execute: 
    9187                try: 
    9288                    sql = obj.createddl(term=False) 
     
    9490                    cursor.execute(sql) 
    9591                except orasql.DatabaseError, exc: 
    96                     if not options.ignore or "ORA-01013" in str(exc): 
     92                    if not args.ignore or "ORA-01013" in str(exc): 
    9793                        raise 
    9894                    stderr.writeln("oradelete.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
    9995            else: 
    10096                sql = obj.dropddl(term=True) + obj.createddl(term=True) 
    101                 stdout.write(sql.encode(options.encoding)) 
     97                stdout.write(sql.encode(args.encoding)) 
    10298 
    10399if __name__ == "__main__": 
  • src/ll/orasql/scripts/oradiff.py

    r4042 r4113  
    1010 
    1111 
    12 import sys, os, difflib, optparse 
     12import sys, os, difflib, argparse 
    1313 
    1414from ll import orasql, astyle 
     
    111111 
    112112def main(args=None): 
    113     colors = ("yes", "no", "auto") 
    114     modes = ("brief", "udiff", "full") 
    115     blanks = ("literal", "trail", "lead", "both", "collapse") 
    116     p = optparse.OptionParser(usage="usage: %prog [options] connectstring1 connectstring2") 
    117     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    118     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    119     p.add_option("-m", "--mode", dest="mode", help="Output mode ({0})".format(", ".join(modes)), default="udiff", choices=modes) 
    120     p.add_option("-n", "--context", dest="context", help="Number of context lines", type="int", default=2) 
    121     p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
    122     p.add_option("-b", "--blank", dest="blank", help="How to treat whitespace ({0})".format(", ".join(blanks)), default="literal", choices=blanks) 
    123     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    124  
    125     (options, args) = p.parse_args(args) 
    126     if len(args) != 2: 
    127         p.error("incorrect number of arguments") 
    128         return 1 
    129  
    130     if options.color == "yes": 
     113    p = argparse.ArgumentParser(description="compare two Oracle database schemas") 
     114    p.add_argument("connectionstring1", help="First schema") 
     115    p.add_argument("connectionstring2", help="Second schema") 
     116    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     117    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     118    p.add_argument("-m", "--mode", dest="mode", help="Output mode", default="udiff", choices=("brief", "udiff", "full")) 
     119    p.add_argument("-n", "--context", dest="context", help="Number of context lines", type=int, default=2) 
     120    p.add_argument("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
     121    p.add_argument("-b", "--blank", dest="blank", help="How to treat whitespace ({0})".format(", ".join(blanks)), default="literal", choices=("literal", "trail", "lead", "both", "collapse")) 
     122    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     123 
     124    args = p.parse_args(args) 
     125 
     126    if args.color == "yes": 
    131127        color = True 
    132     elif options.color == "no": 
     128    elif args.color == "no": 
    133129        color = False 
    134130    else: 
     
    137133    stderr = astyle.Stream(sys.stderr, color) 
    138134 
    139     connection1 = orasql.connect(args[0]) 
    140     connection2 = orasql.connect(args[1]) 
    141  
    142     print connection1, connection2 
     135    connection1 = orasql.connect(args.connectionstring1) 
     136    connection2 = orasql.connect(args.connectionstring2) 
     137 
    143138    def fetch(connection): 
    144139        objects = set() 
     
    147142            if obj.owner is not None: 
    148143                return False 
    149             if options.keepjunk: 
     144            if args.keepjunk: 
    150145                return True 
    151146            if "$" in obj.name or obj.name.startswith("SYS_EXPORT_SCHEMA_"): 
     
    155150        for (i, obj) in enumerate(connection.iterobjects(mode="flat", schema="user")): 
    156151            keepdef = keep(obj) 
    157             if options.verbose: 
     152            if args.verbose: 
    158153                msg = astyle.style_default("oradiff.py: ", cs(connection), ": fetching #{0} ".format(i+1), df(obj)) 
    159154                if not keepdef: 
     
    169164    onlyin1 = objects1 - objects2 
    170165    for (i, obj) in enumerate(onlyin1): 
    171         if options.verbose: 
     166        if args.verbose: 
    172167            stderr.writeln("oradiff.py: only in ", cs(connection1), " #{0}/{1} ".format(i+1, len(onlyin1)), df(obj)) 
    173         if options.mode == "brief": 
     168        if args.mode == "brief": 
    174169            stdout.writeln(df(obj), ": only in ", cs(connection1)) 
    175         elif options.mode == "full": 
     170        elif args.mode == "full": 
    176171            stdout.writeln(comment(df(obj), ": only in ", cs(connection1))) 
    177172            ddl = obj.dropddl(connection1, term=True) 
    178173            if ddl: 
    179174                stdout.write(ddl) 
    180         elif options.mode == "udiff": 
    181             ddl = getcanonicalddl(obj.createddl(connection1), options.blank) 
    182             showudiff(stdout, obj, ddl, [], connection1, connection2, options.encoding, options.context) 
     175        elif args.mode == "udiff": 
     176            ddl = getcanonicalddl(obj.createddl(connection1), args.blank) 
     177            showudiff(stdout, obj, ddl, [], connection1, connection2, args.encoding, args.context) 
    183178 
    184179    onlyin2 = objects2 - objects1 
    185180    for (i, obj) in enumerate(onlyin2): 
    186         if options.verbose: 
     181        if args.verbose: 
    187182            stderr.writeln("oradiff.py: only in ", cs(connection2), " #{0}/{1} ".format(i+1, len(onlyin2)), df(obj)) 
    188         if options.mode == "brief": 
     183        if args.mode == "brief": 
    189184            stdout.writeln(df(obj), ": only in ", cs(connection2)) 
    190         elif options.mode == "full": 
     185        elif args.mode == "full": 
    191186            stdout.writeln(comment(df(obj), ": only in ", cs(connection2))) 
    192187            ddl = obj.createddl(connection2, term=True) 
    193188            if ddl: 
    194189                stdout.write(ddl) 
    195         elif options.mode == "udiff": 
    196             ddl = getcanonicalddl(obj.createddl(connection2), options.blank) 
    197             showudiff(stdout, obj, [], ddl, connection1, connection2, options.encoding, options.context) 
     190        elif args.mode == "udiff": 
     191            ddl = getcanonicalddl(obj.createddl(connection2), args.blank) 
     192            showudiff(stdout, obj, [], ddl, connection1, connection2, args.encoding, args.context) 
    198193 
    199194    common = objects1 & objects2 
    200195    for (i, obj) in enumerate(common): 
    201         if options.verbose: 
     196        if args.verbose: 
    202197            stderr.writeln("oradiff.py: diffing #{0}/{1} ".format(i+1, len(common)), df(obj)) 
    203198        ddl1 = obj.createddl(connection1) 
    204199        ddl2 = obj.createddl(connection2) 
    205         ddl1c = getcanonicalddl(ddl1, options.blank) 
    206         ddl2c = getcanonicalddl(ddl2, options.blank) 
     200        ddl1c = getcanonicalddl(ddl1, args.blank) 
     201        ddl2c = getcanonicalddl(ddl2, args.blank) 
    207202        if ddl1c != ddl2c: 
    208             if options.mode == "brief": 
     203            if args.mode == "brief": 
    209204                stdout.writeln(df(obj), ": different") 
    210             elif options.mode == "full": 
     205            elif args.mode == "full": 
    211206                stdout.writeln(comment(df(obj), ": different")) 
    212207                stdout.write(obj.createddl(connection2)) 
    213             elif options.mode == "udiff": 
    214                 showudiff(stdout, obj, ddl1c, ddl2c, connection1, connection2, options.encoding, options.context) 
     208            elif args.mode == "udiff": 
     209                showudiff(stdout, obj, ddl1c, ddl2c, connection1, connection2, args.encoding, args.context) 
    215210 
    216211 
  • src/ll/orasql/scripts/oradrop.py

    r4042 r4113  
    1010 
    1111 
    12 import sys, os, optparse 
     12import sys, os, argparse 
    1313 
    1414from ll import astyle, orasql 
     
    2222 
    2323def main(args=None): 
    24     colors = ("yes", "no", "auto") 
    25     fks = ("keep", "disable", "drop") 
    26     p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    27     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    28     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    29     p.add_option("-f", "--fks", dest="fks", help="How should foreign keys from other schemas be treated ({0})?".format(", ".join(fks)), default="disable", choices=fks) 
    30     p.add_option("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
    31     p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
    32     p.add_option("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
    33     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     24    p = argparse.ArgumentParser(description="Print (or execute) drop statements for all objects in an Oracle database schema") 
     25    p.add_argument("connectstring", help="Oracle connect string") 
     26    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     27    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     28    p.add_argument("-f", "--fks", dest="fks", help="How should foreign keys from other schemas be treated?", default="disable", choices=("keep", "disable", "drop")) 
     29    p.add_argument("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
     30    p.add_argument("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
     31    p.add_argument("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
     32    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    3433 
    35     (options, args) = p.parse_args(args) 
    36     if len(args) != 1: 
    37         p.error("incorrect number of arguments") 
    38         return 1 
     34    args = p.parse_args(args) 
    3935 
    40     if options.color == "yes": 
     36    if args.color == "yes": 
    4137        color = True 
    42     elif options.color == "no": 
     38    elif args.color == "no": 
    4339        color = False 
    4440    else: 
     
    4844    stderr = astyle.Stream(sys.stderr, color) 
    4945 
    50     connection = orasql.connect(args[0]) 
     46    connection = orasql.connect(args.connectstring) 
    5147 
    52     term = not options.execute 
     48    term = not args.execute 
    5349 
    5450    cs = s4connectstring(connection.connectstring()) 
     
    5753        if obj.owner is not None and not isinstance(obj, orasql.ForeignKey): 
    5854            return False 
    59         if options.keepjunk: 
     55        if args.keepjunk: 
    6056            return True 
    6157        if "$" in obj.name: 
     
    7167        if obj.owner is not None: 
    7268            if isinstance(obj, orasql.ForeignKey): 
    73                 if options.fks == "disable": 
     69                if args.fks == "disable": 
    7470                    ddl = obj.disableddl(cursor, term) 
    7571                    action = "disabled" 
    76                 elif options.fks == "drop": 
     72                elif args.fks == "drop": 
    7773                    ddl = obj.dropddl(cursor, term) 
    7874                    action = None 
     
    8278 
    8379        # Progress report 
    84         if options.verbose: 
     80        if args.verbose: 
    8581            msg = astyle.style_default("oradrop.py: ", cs, ": fetching #{0} ".format(i+1), s4object(str(obj))) 
    8682            if action is not None: 
     
    9086        if ddl: 
    9187            # Print or execute DDL 
    92             if options.execute: 
     88            if args.execute: 
    9389                ddls.append((obj, ddl)) 
    9490            else: 
    95                 stdout.write(ddl.encode(options.encoding)) 
     91                stdout.write(ddl.encode(args.encoding)) 
    9692 
    9793    # Execute DDL 
    98     if options.execute: 
     94    if args.execute: 
    9995        cursor = connection.cursor() 
    10096        for (i, (obj, ddl)) in enumerate(ddls): 
    101             if options.verbose: 
     97            if args.verbose: 
    10298                stderr.writeln("oradrop.py: ", cs, ": dropping #{0}/{1} ".format(i+1, len(ddls)), s4object(str(obj))) 
    10399            try: 
    104100                cursor.execute(ddl) 
    105101            except orasql.DatabaseError, exc: 
    106                 if not options.ignore or "ORA-01013" in str(exc): 
     102                if not args.ignore or "ORA-01013" in str(exc): 
    107103                    raise 
    108104                stderr.writeln("oradrop.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
  • src/ll/orasql/scripts/orafind.py

    r3933 r4113  
    1010 
    1111 
    12 import sys, os, optparse 
     12import sys, os, argparse 
    1313 
    1414from ll import orasql, astyle 
     
    8989 
    9090def main(args=None): 
    91     colors = ("yes", "no", "auto") 
    92     p = optparse.OptionParser(usage="usage: %prog [options] connectstring searchstring [table] [table] ...") 
    93     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    94     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    95     p.add_option("-i", "--ignore-case", dest="ignorecase", help="Ignore case distinctions?", default=False, action="store_true") 
    96     p.add_option("-r", "--read-lobs", dest="readlobs", help="Read LOBs when printing records?", default=False, action="store_true") 
    97     p.add_option("-e", "--encoding", dest="encoding", help="Encoding of the command line arguments", default="utf-8") 
     91    p = argparse.ArgumentParser(description="Search for a string in all fields of all tables in an Oracle database schema") 
     92    p.add_argument("connectstring", help="Oracle connect string") 
     93    p.add_argument("searchstring", help="String to search for") 
     94    p.add_argument("tables", metavar="table", nargs="*", help="Limit search to those tables") 
     95    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     96    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     97    p.add_argument("-i", "--ignore-case", dest="ignorecase", help="Ignore case distinctions?", default=False, action="store_true") 
     98    p.add_argument("-r", "--read-lobs", dest="readlobs", help="Read LOBs when printing records?", default=False, action="store_true") 
     99    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding of the command line arguments", default="utf-8") 
    98100 
    99     (options, args) = p.parse_args(args) 
    100     if len(args) < 2: 
    101         p.error("incorrect number of arguments") 
    102         return 1 
     101    args = p.parse_args(args) 
    103102 
    104     if options.color == "yes": 
     103    if args.color == "yes": 
    105104        color = True 
    106     elif options.color == "no": 
     105    elif args.color == "no": 
    107106        color = False 
    108107    else: 
     
    111110    stderr = astyle.Stream(sys.stderr, color) 
    112111 
    113     connectstring = args[0].decode(options.encoding) 
    114     searchstring = args[1].decode(options.encoding) 
    115     if options.ignorecase: 
     112    connectstring = args.connectstring.decode(args.encoding) 
     113    searchstring = args.searchstring.decode(args.encoding) 
     114    if args.ignorecase: 
    116115        searchstring = searchstring.lower() 
    117116    searchstring = "%{0}%".format(searchstring.replace("%", "%%")) 
    118     tablenames = [name.decode(options.encoding).lower() for name in args[2:]] 
     117    tablenames = [name.decode(args.encoding).lower() for name in args.tables] 
    119118 
    120     connection = orasql.connect(connectstring, readlobs=options.readlobs) 
     119    connection = orasql.connect(connectstring, readlobs=args.readlobs) 
    121120    c = connection.cursor() 
    122121 
     
    124123    for (i, table) in enumerate(tables): 
    125124        skip = tablenames and table.name.lower() not in tablenames 
    126         if options.verbose: 
     125        if args.verbose: 
    127126            msg = "skipped" if skip else "searching" 
    128127            stderr.writeln("orafind.py: ", df(table), " #", str(i+1), "/", str(len(tables)), ": ", msg) 
     
    132131                datatype = col.datatype() 
    133132                if datatype == "clob" or datatype.startswith("varchar2"): 
    134                     if options.ignorecase: 
     133                    if args.ignorecase: 
    135134                        where.append("lower({0}) like :searchstring".format(col.name)) 
    136135                    else: 
  • src/ll/orasql/scripts/oragrant.py

    r3933 r4113  
    1010 
    1111 
    12 import sys, os, optparse 
     12import sys, os, argparse 
    1313 
    1414from ll import astyle, orasql 
     
    2222 
    2323def main(args=None): 
    24     colors = ("yes", "no", "auto") 
    25     p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    26     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    27     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    28     p.add_option("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database", type="str") 
    29     p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
    30     p.add_option("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
    31     p.add_option("-m", "--mapgrantee", dest="mapgrantee", help="Map grantees (Python expression: list or dict)", default="True", type="str") 
    32     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     24    p = argparse.ArgumentParser(description="Print (and execute) grants statements from an Oracle database schema") 
     25    p.add_argument("connectstring", help="Oracle connect string") 
     26    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     27    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     28    p.add_argument("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database") 
     29    p.add_argument("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
     30    p.add_argument("-i", "--ignore", dest="ignore", help="Ignore errors?", default=False, action="store_true") 
     31    p.add_argument("-m", "--mapgrantee", dest="mapgrantee", help="Map grantees (Python expression: list or dict)", default="True") 
     32    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    3333 
    3434    (options, args) = p.parse_args(args) 
    35     if len(args) != 1: 
    36         p.error("incorrect number of arguments") 
    37         return 1 
    3835 
    39     if options.color == "yes": 
     36    if args.color == "yes": 
    4037        color = True 
    41     elif options.color == "no": 
     38    elif args.color == "no": 
    4239        color = False 
    4340    else: 
     
    4643    stderr = astyle.Stream(sys.stderr, color) 
    4744 
    48     connection = orasql.connect(args[0]) 
     45    connection = orasql.connect(args.connectstring) 
    4946 
    50     if options.execute: 
    51         connection2 = orasql.connect(options.execute) 
     47    if args.execute: 
     48        connection2 = orasql.connect(args.execute) 
    5249        cursor2 = connection2.cursor() 
    5350        term = False 
     
    5653 
    5754    cs1 = s4connectstring(connection.connectstring()) 
    58     if options.execute: 
     55    if args.execute: 
    5956        cs2 = s4connectstring(connection2.connectstring()) 
    6057 
    61     mapgrantee = eval(options.mapgrantee) 
     58    mapgrantee = eval(args.mapgrantee) 
    6259 
    6360    def keep(obj): 
    64         if options.keepjunk: 
     61        if args.keepjunk: 
    6562            return True 
    6663        if "$" in obj.name or "/" in obj.name or obj.name.startswith("SYS_EXPORT_SCHEMA_"): 
     
    7067    for (i, obj) in enumerate(connection.iterprivileges(schema="user")): 
    7168        keepobj = keep(obj) 
    72         if options.verbose: 
    73             if options.execute: 
     69        if args.verbose: 
     70            if args.execute: 
    7471                msg = astyle.style_default("oragrant.py: ", cs1, " -> ", cs2, ": fetching/granting #{0}".format(i+1)) 
    7572            else: 
     
    8380            ddl = obj.grantddl(connection, term, mapgrantee=mapgrantee) 
    8481            if ddl: 
    85                 if options.execute: 
     82                if args.execute: 
    8683                    try: 
    8784                        cursor2.execute(ddl) 
    8885                    except orasql.DatabaseError, exc: 
    89                         if not options.ignore or "ORA-01013" in str(exc): 
     86                        if not args.ignore or "ORA-01013" in str(exc): 
    9087                            raise 
    9188                        stderr.writeln("oragrant.py: ", s4error("{0}: {1}".format(exc.__class__.__name__, str(exc).strip()))) 
    9289                else: 
    93                     stdout.writeln(ddl.encode(options.encoding)) 
     90                    stdout.writeln(ddl.encode(args.encoding)) 
    9491                    stdout.writeln() 
    9592 
  • src/ll/orasql/scripts/oramerge.py

    r3933 r4113  
    1010 
    1111 
    12 import sys, os, difflib, optparse, tempfile, subprocess 
     12import sys, os, difflib, argparse, tempfile, subprocess 
    1313 
    1414from ll import orasql, astyle 
     
    8989 
    9090def main(args=None): 
    91     colors = ("yes", "no", "auto") 
    92     blanks = ("literal", "trail", "lead", "both", "collapse") 
    9391    # Merge changes between oldsource and newsource into destination 
    94     p = optparse.OptionParser(usage="usage: %prog [options] oldsourceconnectstring newsourceconnectstring destinationconnectstring") 
    95     p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    96     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    97     p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
    98     p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    99  
    100     (options, args) = p.parse_args(args) 
    101     if len(args) != 3: 
    102         p.error("incorrect number of arguments") 
    103         return 1 
    104  
    105     if options.color == "yes": 
     92    p = argparse.ArgumentParser(description="output info for merging the changes between two Oracle database schemas into a third") 
     93    p.add_argument("connectstring1", help="Old version of database schema") 
     94    p.add_argument("connectstring2", help="New version of database schema") 
     95    p.add_argument("connectstring3", help="Schema into which changes should be merged") 
     96    p.add_argument("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
     97    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     98    p.add_argument("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
     99    p.add_argument("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     100 
     101    args = p.parse_args(args) 
     102 
     103    if args.color == "yes": 
    106104        color = True 
    107     elif options.color == "no": 
     105    elif args.color == "no": 
    108106        color = False 
    109107    else: 
     
    112110    stderr = astyle.Stream(sys.stderr, color) 
    113111 
    114     connection1 = orasql.connect(args[0]) 
    115     connection2 = orasql.connect(args[1]) 
    116     connection3 = orasql.connect(args[2]) 
     112    connection1 = orasql.connect(args.connectstring1) 
     113    connection2 = orasql.connect(args.connectstring2) 
     114    connection3 = orasql.connect(args.connectstring3) 
    117115 
    118116    def fetch(connection, name): 
     
    120118 
    121119        for (i, obj) in enumerate(connection.iterobjects(mode="flat", schema="user")): 
    122             keep = ("$" not in obj.name and not obj.name.startswith("SYS_EXPORT_SCHEMA_")) or options.keepjunk 
    123             if options.verbose: 
     120            keep = ("$" not in obj.name and not obj.name.startswith("SYS_EXPORT_SCHEMA_")) or args.keepjunk 
     121            if args.verbose: 
    124122                msg = astyle.style_default("oramerge.py: ", cs(connection), connid(name), " fetching #{0} ".format(i+1), df(obj)) 
    125123                if not keep: 
     
    160158        in2 = obj in objects2 
    161159        in3 = obj in objects3 
    162         if options.verbose: 
     160        if args.verbose: 
    163161            stderr.write("oramerge.py: ", df(obj), " #", str(i+1), "/", str(len(allobjects)), ": ") 
    164162            first = True 
     
    174172        if in1 != in2: # ignore changes from in2 to in3, because only if something changed in the sources we have to do something 
    175173            if not in1 and in2 and not in3: # added in in2 => copy it to db3 
    176                 if options.verbose: 
     174                if args.verbose: 
    177175                    stderr.writeln(" => ", s4action("new (create it)")) 
    178176                countcreate += 1 
     
    180178            elif not in1 and in2 and in3: # added in both in2 and in3 => collision? 
    181179                if obj.createddl(connection2) != obj.createddl(connection3): 
    182                     if options.verbose: 
     180                    if args.verbose: 
    183181                        stderr.writeln(" => ", s4error("collision")) 
    184182                    countcollision += 1 
     
    186184                    retcode = 2 
    187185                else: 
    188                     if options.verbose: 
     186                    if args.verbose: 
    189187                        stderr.writeln(" => already created (keep it)") 
    190188            elif in1 and not in2 and not in3: # removed in in2 and in3 => not needed 
    191                 if options.verbose: 
     189                if args.verbose: 
    192190                    stderr.writeln(" => removed (not needed)") 
    193191            elif in1 and not in2 and in3: # removed in in2 => remove in db3 
    194                 if options.verbose: 
     192                if args.verbose: 
    195193                    stderr.writeln(" => ", s4action("drop it")) 
    196194                countdrop += 1 
     
    203201            ddl3 = obj.createddl(connection3) 
    204202 
    205             if options.verbose: 
     203            if args.verbose: 
    206204                stderr.write(" => diffing") 
    207205 
     
    256254                                    showcomment(stdout, "merged ", df(field)) 
    257255                                    stdout.writeln(ddl) 
    258                     if options.verbose: 
     256                    if args.verbose: 
    259257                        showreport(stderr, "field", fieldcountcreate, fieldcountdrop, fieldcountcollision, fieldcountmerge, fieldcountmergeconflict) 
    260258                else: 
    261                     if options.verbose: 
     259                    if args.verbose: 
    262260                        stderr.write(" => merge them") 
    263261                    action = "merge" 
    264262            else: 
    265                 if options.verbose: 
     263                if args.verbose: 
    266264                    stderr.writeln(" => identical") 
    267265        elif in3: 
    268             if options.verbose: 
     266            if args.verbose: 
    269267                stderr.writeln(" => keep it") 
    270268        else: 
    271             if options.verbose: 
     269            if args.verbose: 
    272270                stderr.writeln(" => not needed") 
    273271 
     
    290288                file1 = open(filename1, "wb") 
    291289                try: 
    292                     write(file1, ddl1.encode(options.encoding)) 
     290                    write(file1, ddl1.encode(args.encoding)) 
    293291 
    294292                    file2 = open(filename2, "wb") 
    295293                    try: 
    296                         write(file2, ddl2.encode(options.encoding)) 
     294                        write(file2, ddl2.encode(args.encoding)) 
    297295 
    298296                        file3 = open(filename3, "wb") 
    299297                        try: 
    300                             write(file3, ddl3.encode(options.encoding)) 
     298                            write(file3, ddl3.encode(args.encoding)) 
    301299 
    302300                            # do the diffing 
     
    325323                                # diff3 seems to append a "\n" 
    326324                                if finalddl != ddl3 and (not finalddl.endswith("\n") or finalddl[:-1] != ddl3): 
    327                                     if options.verbose: 
     325                                    if args.verbose: 
    328326                                        stderr.writeln(" => ", s4action("merged")) 
    329327                                    stdout.write(finalddl) 
    330328                            elif diffretcode == 1: # conflict 
    331329                                showcomment(stdout, "merge conflict ", df(obj)) 
    332                                 if options.verbose: 
     330                                if args.verbose: 
    333331                                    stderr.writeln(" => ", s4error("merge conflict")) 
    334332                                retcode = 2 
     
    355353                finally: 
    356354                    os.remove(filename1) 
    357     if options.verbose: 
     355    if args.verbose: 
    358356        stderr.write("oramerge.py: ", cs(connection3)) 
    359357        showreport(stderr, "object", countcreate, countdrop, countcollision, countmerge, countmergeconflict) 
  • src/ll/scripts/db2ul4.py

    r4067 r4113  
    22# -*- coding: utf-8 -*- 
    33 
    4 import sys, os, optparse, codecs 
     4import sys, os, argparse, codecs 
    55 
    66from ll import ul4c 
     
    8585 
    8686def main(args=None): 
    87     p = optparse.OptionParser(usage="usage: %prog [options] maintemplate [subtemplate1 subtemplate2 ...]") 
    88     p.add_option("-i", "--inputencoding", dest="inputencoding", help="Encoding for template sources", default="utf-8", metavar="ENCODING") 
    89     p.add_option("-o", "--outputencoding", dest="outputencoding", help="Encoding for output", default="utf-8", metavar="ENCODING") 
     87    p = argparse.ArgumentParser(description="render UL4 templates containing SQL statements") 
     88    p.add_argument("templates", metavar="template", help="templates to be used", nargs="+") 
     89    p.add_argument("-i", "--inputencoding", dest="inputencoding", help="Encoding for template sources", default="utf-8", metavar="ENCODING") 
     90    p.add_argument("-o", "--outputencoding", dest="outputencoding", help="Encoding for output", default="utf-8", metavar="ENCODING") 
    9091 
    91     (options, args) = p.parse_args(args) 
    92     if len(args) < 1: 
    93         p.error("incorrect number of arguments") 
    94         return 1 
     92    args = p.parse_args(args) 
    9593 
    9694    templates = {} 
    9795    maintemplate = None 
    98     for templatename in args: 
     96    for templatename in args.templates: 
    9997        if templatename == "-": 
    10098            templatestream = sys.stdin 
     
    105103            if os.path.extsep in templatename: 
    106104                templatename = templatename.rpartition(os.extsep)[0] 
    107         template = ul4c.compile(templatestream.read().decode(options.inputencoding)) 
     105        template = ul4c.compile(templatestream.read().decode(args.inputencoding)) 
    108106        # The first template is the main template 
    109107        if maintemplate is None: 
     
    111109        templates[templatename] = template 
    112110 
    113     vars = dict(connect=Connect(), system=System(), encoding=options.outputencoding, templates=templates) 
    114     for part in codecs.iterencode(maintemplate.render(**vars), options.outputencoding): 
     111    vars = dict(connect=Connect(), system=System(), encoding=args.outputencoding, templates=templates) 
     112    for part in codecs.iterencode(maintemplate.render(**vars), args.outputencoding): 
    115113        sys.stdout.write(part) 
    116114 
  • src/ll/scripts/ucat.py

    r4042 r4113  
    1111 
    1212 
    13 import sys, optparse, contextlib, errno 
     13import sys, argparse, contextlib, errno 
    1414 
    1515from ll import url 
     
    2929    def catone(urlread): 
    3030        if urlread.isdir(): 
    31             if options.recursive: 
     31            if args.recursive: 
    3232                for u in urlread.listdir(): 
    3333                    catone(urlread/u) 
     
    4545                            break 
    4646            except Exception: 
    47                 if not options.ignoreerrors: 
     47                if not args.ignoreerrors: 
    4848                    raise 
    4949 
    50     colors = ("yes", "no", "auto") 
    51     p = optparse.OptionParser(usage="usage: %prog [options] source-file-url target-file-url\n   or: %prog [options] source-file-url(s) target-dir-url") 
    52     p.add_option("-v", "--verbose", dest="verbose", help="Be verbose?", action="store_true", default=False) 
    53     p.add_option("-r", "--recursive", dest="recursive", help="Copy stuff recursively?", action="store_true", default=False) 
    54     p.add_option("-x", "--ignoreerrors", dest="ignoreerrors", help="Ignore errors?", action="store_true", default=False) 
     50    p = argparse.ArgumentParser(description="print URL content on the screen") 
     51    p.add_argument("urls", metavar="url", help="URLs to be printed", nargs="+", type=url.URL) 
     52    p.add_argument("-v", "--verbose", dest="verbose", help="Be verbose?", action="store_true", default=False) 
     53    p.add_argument("-r", "--recursive", dest="recursive", help="Copy stuff recursively?", action="store_true", default=False) 
     54    p.add_argument("-x", "--ignoreerrors", dest="ignoreerrors", help="Ignore errors?", action="store_true", default=False) 
    5555 
    56     (options, args) = p.parse_args(args) 
    57     if len(args) < 1: 
    58         p.error("need at least one url") 
    59         return 1 
    60  
     56    args = p.parse_args(args) 
    6157    with url.Context(): 
    62         for arg in args: 
    63             catone(url.URL(arg)) 
     58        for u in args.urls: 
     59            catone(u) 
    6460 
    6561 
  • src/ll/scripts/ucp.py

    r4042 r4113  
    1111 
    1212 
    13 import sys, optparse, contextlib 
     13import sys, argparse, contextlib 
    1414 
    1515from ll import url 
     
    2929    def copyone(urlread, urlwrite): 
    3030        if urlread.isdir(): 
    31             if options.recursive: 
     31            if args.recursive: 
    3232                for u in urlread.listdir(): 
    3333                    copyone(urlread/u, urlwrite/u) 
    3434            else: 
    35                 if options.verbose: 
     35                if args.verbose: 
    3636                    msg = astyle.style_default("ucp: ", astyle.style_url(str(urlread)), " (directory skipped)") 
    3737                    stderr.writeln(msg) 
    3838        else: 
    39             if options.verbose: 
     39            if args.verbose: 
    4040                msg = astyle.style_default("ucp: ", astyle.style_url(str(urlread)), " -> ") 
    4141                stderr.write(msg) 
     
    5454                    urlwrite.chown(user, group) 
    5555            except Exception: 
    56                 if options.ignoreerrors: 
    57                     if options.verbose: 
     56                if args.ignoreerrors: 
     57                    if args.verbose: 
    5858                        msg = astyle.style_error(" (failed)") 
    5959                        stderr.writeln(msg) 
     
    6161                    raise 
    6262            else: 
    63                 if options.verbose: 
     63                if args.verbose: 
    6464                    msg = astyle.style_default(astyle.style_url(str(urlwrite)), " (", str(size), " bytes)") 
    6565                    stderr.writeln(msg) 
     
    6767 
    6868 
    69     colors = ("yes", "no", "auto") 
    70     p = optparse.OptionParser(usage="usage: %prog [options] source-file-url target-file-url\n   or: %prog [options] source-file-url(s) target-dir-url") 
    71     p.add_option("-v", "--verbose", dest="verbose", help="Be verbose?", action="store_true", default=False) 
    72     p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    73     p.add_option("-u", "--user", dest="user", help="user id or name for target files") 
    74     p.add_option("-g", "--group", dest="group", help="group id or name for target files") 
    75     p.add_option("-r", "--recursive", dest="recursive", help="Copy stuff recursively?", action="store_true", default=False) 
    76     p.add_option("-x", "--ignoreerrors", dest="ignoreerrors", help="Ignore errors?", action="store_true", default=False) 
     69    p = argparse.ArgumentParser(description="Copies URLs") 
     70    p.add_argument("urls", metavar="url", help="either one source and one target file, or multiple source files and one target dir", nargs="*", type=url.URL) 
     71    p.add_argument("-v", "--verbose", dest="verbose", help="Be verbose?", action="store_true", default=False) 
     72    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     73    p.add_argument("-u", "--user", dest="user", help="user id or name for target files") 
     74    p.add_argument("-g", "--group", dest="group", help="group id or name for target files") 
     75    p.add_argument("-r", "--recursive", dest="recursive", help="Copy stuff recursively?", action="store_true", default=False) 
     76    p.add_argument("-x", "--ignoreerrors", dest="ignoreerrors", help="Ignore errors?", action="store_true", default=False) 
    7777 
    78     (options, args) = p.parse_args(args) 
    79     if len(args) < 2: 
     78    args = p.parse_args(args) 
     79    if len(args.urls) < 2: 
    8080        p.error("need at least one source url and one target url") 
    8181        return 1 
    8282 
    83     if options.color == "yes": 
     83    if args.color == "yes": 
    8484        color = True 
    85     elif options.color == "no": 
     85    elif args.color == "no": 
    8686        color = False 
    8787    else: 
     
    9090    stderr = astyle.Stream(sys.stderr, color) 
    9191 
    92     user = options.user 
     92    user = args.user 
    9393    try: 
    9494        user = int(user) 
     
    9696        pass 
    9797 
    98     group = options.group 
     98    group = args.group 
    9999    try: 
    100100        group = int(group) 
     
    103103 
    104104    with url.Context(): 
    105         args = [url.URL(arg) for arg in args] 
    106         if len(args) > 2 or args[-1].isdir(): # treat target as directory 
    107             for arg in args[:-1]: 
    108                 copyone(arg, args[-1]/arg.file) 
     105        urls = args.urls 
     106        if len(urls) > 2 or urls[-1].isdir(): # treat target as directory 
     107            for u in urls[:-1]: 
     108                copyone(u, urls[-1]/u.file) 
    109109        else: 
    110             copyone(args[0], args[-1]) 
     110            copyone(urls[0], urls[-1]) 
    111111 
    112112 
  • src/ll/scripts/uls.py

    r4042 r4113  
    1111 
    1212 
    13 import sys, optparse, contextlib, datetime, pwd, grp, stat, curses 
     13import sys, argparse, contextlib, datetime, pwd, grp, stat, curses 
    1414 
    1515from ll import url 
     
    156156            printone(url, long, human) 
    157157 
    158     colors = ("yes", "no", "auto") 
    159     p = optparse.OptionParser(usage="usage: %prog [options] [url] [url] ...") 
    160     p.add_option("-c", "--color", dest="color", help="Color output ([{0}])".format(", ".join(colors)), default="auto", choices=colors) 
    161     p.add_option("-1", "--one", dest="one", help="One entry per line?", action="store_true") 
    162     p.add_option("-l", "--long", dest="long", help="Long format?", action="store_true") 
    163     p.add_option("-s", "--human-readable-sizes", dest="human", help="Output human readable sizes?", action="store_true") 
    164     p.add_option("-r", "--recursive", dest="recursive", help="Recursive listing?", action="store_true") 
    165     p.add_option("-w", "--spacing", dest="spacing", help="Spacing between columns", type="int", default=3) 
     158    p = argparse.ArgumentParser(description="List the content of one or more URLs") 
     159    p.add_argument("urls", metavar="url", help="URLs to be listed (default: current dir)", nargs="*", default=url.here(), type=url.URL) 
     160    p.add_argument("-c", "--color", dest="color", help="Color output", default="auto", choices=("yes", "no", "auto")) 
     161    p.add_argument("-1", "--one", dest="one", help="One entry per line?", action="store_true") 
     162    p.add_argument("-l", "--long", dest="long", help="Long format?", action="store_true") 
     163    p.add_argument("-s", "--human-readable-sizes", dest="human", help="Human readable file sizes?", action="store_true") 
     164    p.add_argument("-r", "--recursive", dest="recursive", help="Recursive listing?", action="store_true") 
     165    p.add_argument("-w", "--spacing", dest="spacing", metavar="N", help="Number of spaces between columns", type=int, default=3) 
    166166 
    167     (options, args) = p.parse_args(args) 
     167    args = p.parse_args(args) 
    168168 
    169     if options.color == "yes": 
     169    if args.color == "yes": 
    170170        color = True 
    171     elif options.color == "no": 
     171    elif args.color == "no": 
    172172        color = False 
    173173    else: 
     
    176176    stderr = astyle.Stream(sys.stderr, color) 
    177177 
    178     if not args: 
    179         args = [url.here(scheme=None)] 
    180  
    181178    with url.Context(): 
    182         for u in args: 
    183             u = url.URL(u) 
    184             printall(u, u, options.one, options.long, options.recursive, options.human, options.spacing) 
     179        for u in args.urls: 
     180            printall(u, u, args.one, args.long, args.recursive, args.human, args.spacing) 
    185181 
    186182 
  • src/ll/xist/ns/rest.py

    r3933 r4113  
    1111__docformat__ = "reStructuredText" 
    1212 
    13 import os, optparse, collections, contextlib 
     13import os, collections, contextlib 
    1414 
    1515from ll import url 
  • src/ll/xist/scripts/dtd2xsc.py

    r4055 r4113  
    2525 
    2626 
    27 import sys, os.path, optparse 
     27import sys, os.path, argparse 
    2828 
    2929try: 
     
    169169 
    170170def main(args=None): 
    171     p = optparse.OptionParser(usage="usage: %prog [options] <input.dtd >output_xmlns.py") 
    172     p.add_option("-x", "--xmlns", dest="xmlns", help="the namespace name for this module") 
    173     p.add_option("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
    174     p.add_option("-m", "--model", dest="model", default="once", help="Add sims information to the namespace", choices=("no", "all", "once")) 
    175     p.add_option("-d", "--defaults", action="store_true", dest="defaults", help="Output default values for attributes") 
     171    p = argparse.ArgumentParser(description="Convert DTD (on stdin) to XIST namespace (on stdout)") 
     172    p.add_argument("-x", "--xmlns", dest="xmlns", help="the namespace name for this module") 
     173    p.add_argument("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
     174    p.add_argument("-m", "--model", dest="model", default="once", help="Add sims information to the namespace", choices=("no", "all", "once")) 
     175    p.add_argument("-d", "--defaults", action="store_true", dest="defaults", help="Output default values for attributes?") 
    176176 
    177     (options, args) = p.parse_args(args) 
    178     if len(args) != 0: 
    179         p.error("incorrect number of arguments") 
    180         return 1 
    181     print stream2xnd(sys.stdin, options.xmlns, options.shareattrs).aspy(model=options.model, defaults=options.defaults) 
     177    args = p.parse_args(args) 
     178    print stream2xnd(sys.stdin, options.xmlns, args.shareattrs).aspy(model=args.model, defaults=args.defaults) 
    182179 
    183180 
  • src/ll/xist/scripts/tld2xsc.py

    r4063 r4113  
    2222 
    2323 
    24 import sys, optparse 
     24import sys, argparse 
    2525 
    2626from ll import url 
     
    4646 
    4747def main(args=None): 
    48     p = optparse.OptionParser(usage="usage: %prog [options] <input.tld >output_xmlns.py") 
    49     p.add_option("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
    50     p.add_option("-m", "--model", dest="model", default="once", help="Add sims information to the namespace", choices=("no", "all", "once")) 
    51     p.add_option("-d", "--defaults", action="store_true", dest="defaults", help="Output default values for attributes") 
     48    p = argparse.ArgumentParser(description="Convert JSP Tag Library Descriptor XML file (on stdin) to XIST namespace (on stdout)") 
     49    p.add_argument("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
     50    p.add_argument("-m", "--model", dest="model", help="Add sims information to the namespace", choices=("no", "all", "once"), default="once") 
     51    p.add_argument("-d", "--defaults", dest="defaults", action="store_true", help="Output default values for attributes?") 
    5252 
    53     (options, args) = p.parse_args(args) 
    54     if len(args) != 0: 
    55         p.error("incorrect number of arguments") 
    56         return 1 
    57     print tld2xnd(sys.stdin, options.shareattrs).aspy(model=options.model, defaults=options.defaults) 
     53    args = p.parse_args(args) 
     54    print tld2xnd(sys.stdin, args.shareattrs).aspy(model=args.model, defaults=args.defaults) 
    5855 
    5956 
  • src/ll/xist/scripts/xml2xsc.py

    r4042 r4113  
    1010 
    1111 
    12 import sys, optparse 
     12import sys, argparse 
    1313 
    1414from ll.xist import xsc, xnd, sims 
     
    3838 
    3939 
    40 def etree2xnd(sims, node): 
     40def etree2xnd(model, node): 
    4141    ns = xnd.Module() 
    4242    elements = {} # maps (name, xmlns) to (xnd.Element, content set, attrname->xnd.Attr map) 
    4343    procinsts = {} # maps name to xnd.ProcInst 
    4444 
     45    # Iterate through the tree a collect: which elements are encountered and how they are nested 
    4546    for path in iterpath(node): 
    4647        node = path[-1] 
     
    8384 
    8485    # Put sims info into the element definitions 
    85     if sims == "none": 
     86    if model == "none": 
    8687        pass 
    87     elif sims == "simple": 
     88    elif model == "simple": 
    8889        for entry in elements.itervalues(): 
    8990            entry[0].modeltype = bool(entry[1]) 
    90     elif sims == "full": 
     91    elif model == "full": 
    9192        for entry in elements.itervalues(): 
    9293            if not entry[1]: 
     
    106107                    entry[0].modelargs = elements 
    107108    else: 
    108         raise ValueError("unknown sims mode {0!r}".format(sims)) 
     109        raise ValueError("unknown sims mode {0!r}".format(model)) 
    109110    return ns 
    110111 
    111112 
    112 def stream2xnd(stream, sims="simple", parser="etree"): 
     113def stream2xnd(stream, model="simple", parser="etree"): 
    113114    if parser == "etree": 
    114115        from xml.etree import cElementTree 
     
    120121        raise ValueError("unknown parser {0!r}".format(parser)) 
    121122 
    122     return etree2xnd(sims, node) 
     123    return etree2xnd(model, node) 
    123124 
    124125 
    125126def main(args=None): 
    126     p = optparse.OptionParser(usage="usage: %prog [options] <input.xml >output.py") 
    127     p.add_option("-p", "--parser", dest="parser", help="parser module to use for XML parsing (etree or lxml)", choices=("etree", "lxml"), default="etree") 
    128     choices = ["none", "simple", "full"] 
    129     p.add_option("-s", "--sims", dest="sims", help="Create sims info? ({0})".format(", ".join(choices)), metavar="MODE", default="simple") 
     127    p = argparse.ArgumentParser(description="Convert XML (on stdin) to XIST namespace (on stdout)") 
     128    p.add_argument("-p", "--parser", dest="parser", help="parser module to use for XML parsing (etree or lxml)", choices=("etree", "lxml"), default="etree") 
     129    p.add_argument("-m", "--model", dest="model", help="Create sims info?", choices=("none", "simple", "full"), default="simple") 
    130130 
    131     (options, args) = p.parse_args(args) 
    132     if len(args) != 0: 
    133         p.error("incorrect number of arguments") 
    134         return 1 
    135     print stream2xnd(sys.stdin, sims=options.sims, parser=options.parser).aspy() 
     131    args = p.parse_args(args) 
     132    print stream2xnd(sys.stdin, model=args.model, parser=args.parser).aspy() 
    136133 
    137134 
  • test/test_xist_xml2xsc.py

    r3930 r4113  
    2323 
    2424 
    25 def xml2mod(s, parser="etree", sims="simple"): 
     25def xml2mod(s, parser="etree", model="simple"): 
    2626    with xsc.Pool(): 
    27         xnd = xml2xsc.stream2xnd(cStringIO.StringIO(s), parser=parser, sims=sims) 
     27        xnd = xml2xsc.stream2xnd(cStringIO.StringIO(s), parser=parser, model=model) 
    2828 
    2929        code = xnd.aspy().encode() 
     
    5757def test_model1(): 
    5858    xml = "<foo><foo/><bar><foo/></bar></foo>" 
    59     mod = xml2mod(xml, parser=parser, sims="full") 
     59    mod = xml2mod(xml, parser=parser, model="full") 
    6060 
    6161    assert mod.foo in mod.foo.model.elements 
     
    6767def test_model2(): 
    6868    xml = "<foo><bar>gurk<bar/></bar><baz><!--nix--><baz/></baz></foo>" 
    69     mod = xml2mod(xml, parser=parser, sims="full") 
     69    mod = xml2mod(xml, parser=parser, model="full") 
    7070 
    7171    assert isinstance(mod.foo.model, sims.Elements)