Changeset 2522:05f2f122ce1e in livinglogic.python.xist

Show
Ignore:
Timestamp:
05/23/06 17:46:44 (13 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Turn scripts into modules and add setuptools entrypoints for them.

Add installation dependencies.

Files:
4 added
5 modified

Legend:

Unmodified
Added
Removed
  • scripts/doc2txt.py

    r2273 r2522  
    22# -*- coding: iso-8859-1 -*- 
    33 
    4 ## Copyright 1999-2005 by LivingLogic AG, Bayreuth/Germany. 
    5 ## Copyright 1999-2005 by Walter Dörwald 
    6 ## 
    7 ## All Rights Reserved 
    8 ## 
    9 ## See xist/__init__.py for the license 
    104 
    11 """ 
    12 Module that uses the w3m browser to generate a text version 
    13 of a docbook fragment. 
    14 Usage: python docbooklite2text.py spam.xml spam.txt 
    15        to generate spam.txt from spam.xml 
    16 """ 
    17  
    18 __version__ = tuple(map(int, "$Revision$"[11:-2].split("."))) 
    19 # $Source$ 
    20  
    21  
    22 import sys, getopt 
    23  
    24 from ll.xist import xsc, parsers, converters 
    25 from ll.xist.ns import html, doc, text 
    26  
    27  
    28 def xsc2txt(infilename, outfilename, title, width): 
    29     e = parsers.parseFile(infilename, prefixes=xsc.DocPrefixes()) 
    30  
    31     if title is None: 
    32         title = xsc.Null 
    33     else: 
    34         title = doc.title(title) 
    35     e = html.html( 
    36         html.body( 
    37             doc.section(title, e) 
    38         ) 
    39     ) 
    40  
    41     e = e.conv(target=text) 
    42  
    43     file = open(outfilename, "wb") 
    44     file.write(e.asText(width=width)) 
    45     file.close() 
     5import sys 
    466 
    477 
    488if __name__ == "__main__": 
    49     title = None 
    50     width = 72 
    51     (options, args) = getopt.getopt(sys.argv[1:], "t:i:w:", ["title=", "import=", "width="]) 
    52  
    53     for (option, value) in options: 
    54         if option=="-t" or option=="--title": 
    55             title = value 
    56         elif option=="-i" or option=="--import": 
    57             __import__(value) 
    58         if option=="-w" or option=="--width": 
    59             width = int(value) 
    60  
    61     xsc2txt(args[0], args[1], title, width) 
     9    from ll.xist.scripts import doc2txt 
     10    sys.exit(doc2txt.main()) 
  • scripts/dtd2xsc.py

    r2273 r2522  
    22# -*- coding: iso-8859-1 -*- 
    33 
    4 ## Copyright 1999-2005 by LivingLogic AG, Bayreuth/Germany. 
    5 ## Copyright 1999-2005 by Walter Dörwald 
    6 ## 
    7 ## All Rights Reserved 
    8 ## 
    9 ## See xist/__init__.py for the license 
    104 
    11 """ 
    12 <par>Module that helps to create &xist; namespace modules from &dtd;s. 
    13 Needs <app>xmlproc</app> from the <app>PyXML</app> package. 
    14 For usage information type:</par> 
    15 <prog> 
    16 dtd2xsc --help 
    17 </prog> 
    18 """ 
    19  
    20  
    21 __version__ = "$Revision$"[11:-2] 
    22 # $Source$ 
    23  
    24  
    25 import sys, os.path, optparse 
    26  
    27 from xml.parsers.xmlproc import dtdparser 
    28  
    29 from ll import url 
    30 from ll.xist import xsc, parsers, xnd 
    31  
    32  
    33 def dtd2xsc(dtdurl, outurl, verbose, xmlname, xmlurl, shareattrs, asmod, defaults): 
    34     if verbose: 
    35         print "Parsing DTD %s ..." % dtdurl 
    36     d = dtdparser.load_dtd(dtdurl.url) 
    37  
    38     if verbose: 
    39         print "Converting ..." 
    40     data = xnd.fromdtd(d, xmlname, xmlurl) 
    41  
    42     if shareattrs=="dupes": 
    43         data.shareattrs(False) 
    44     elif shareattrs=="all": 
    45         data.shareattrs(True) 
    46  
    47     if verbose: 
    48         print "Writing to %s ..." % outurl 
    49     file = outurl.openwrite() 
    50     file.write(data.aspy(asmod=asmod, defaults=defaults)) 
    51     file.close() 
     5import sys 
    526 
    537 
    548if __name__ == "__main__": 
    55     p = optparse.OptionParser(usage="usage: %prog [options] inputurl.dtd") 
    56     p.add_option("-o", "--output", dest="output", metavar="FILE", help="write output to FILE") 
    57     p.add_option("-v", "--verbose", action="store_true", dest="verbose") 
    58     p.add_option("-p", "--prefix", dest="xmlname", help="the XML prefix for this namespace", default="prefix", metavar="PREFIX") 
    59     p.add_option("-u", "--url", dest="xmlurl", help="the XML namespace name", metavar="URL") 
    60     p.add_option("-a", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
    61     p.add_option("-m", "--model", dest="model", default="once", help="Add sims information to the namespace", choices=("no", "all", "once")) 
    62     p.add_option("-d", "--defaults", action="store_true", dest="defaults", help="Output default values for attributes") 
    63  
    64     (options, args) = p.parse_args() 
    65     if len(args) != 1: 
    66         p.error("incorrect number of arguments") 
    67         sys.exit(1) 
    68     input = url.URL(args[0]) 
    69     if options.output is None: 
    70         output = url.File(input.withExt("py").file) 
    71     else: 
    72         output = url.URL(options.output) 
    73     dtd2xsc(input, output, options.verbose, options.xmlname, options.xmlurl, options.shareattrs, options.model, options.defaults) 
     9    from ll.xist.scripts import dtd2xsc 
     10    sys.exit(dtd2xsc.main()) 
  • scripts/tld2xsc.py

    r2273 r2522  
    22# -*- coding: iso-8859-1 -*- 
    33 
    4 ## Copyright 1999-2005 by LivingLogic AG, Bayreuth/Germany. 
    5 ## Copyright 1999-2005 by Walter Dörwald 
    6 ## 
    7 ## All Rights Reserved 
    8 ## 
    9 ## See xist/__init__.py for the license 
    104 
    11  
    12 """ 
    13 <par>Module that helps to create &xist; namespace modules from TLD files 
    14 (Java tag library descriptors). 
    15 For usage information type:</par> 
    16 <prog> 
    17 tld2xsc --help 
    18 </prog> 
    19 """ 
    20  
    21  
    22 __version__ = tuple(map(int, "$Revision$"[11:-2].split("."))) 
    23 # $Source$ 
    24  
    25  
    26 import sys, optparse 
    27  
    28 from ll import url 
    29 from ll.xist import xsc, xfind, parsers, converters 
    30 from ll.xist.ns import tld 
    31  
    32  
    33 def tld2xsc(inurl, outurl, verbose, xmlname, xmlurl, shareattrs): 
    34     if verbose: 
    35         print "Parsing TLD %s ..." % dtdurl 
    36     node = parsers.parseURL(inurl) 
    37  
    38     if verbose: 
    39         print "Converting ..." 
    40  
    41     # get and convert the taglib object 
    42     node = xfind.first(node/tld.taglib) 
    43     data = node.asxnd() 
    44  
    45     if shareattrs=="dupes": 
    46         data.shareattrs(False) 
    47     elif shareattrs=="all": 
    48         data.shareattrs(True) 
    49  
    50     if verbose: 
    51         print "Writing to %s ..." % outurl 
    52  
    53     file = outurl.openwrite() 
    54     file.write(data.aspy()) 
    55     file.close() 
     5import sys 
    566 
    577 
    588if __name__ == "__main__": 
    59     p = optparse.OptionParser(usage="usage: %prog [options] inputurl.tld") 
    60     p.add_option("-o", "--output", dest="output", metavar="FILE", help="write output to FILE") 
    61     p.add_option("-v", "--verbose", action="store_true", dest="verbose") 
    62     p.add_option("-p", "--prefix", dest="xmlname", help="the XML prefix for this namespace", default="prefix", metavar="PREFIX") 
    63     p.add_option("-u", "--url", dest="xmlurl", help="the XML namespace name", metavar="URL") 
    64     p.add_option("-s", "--shareattrs", dest="shareattrs", help="Should identical attributes be shared among elements?", choices=("none", "dupes", "all"), default="dupes") 
    65     p.add_option("-m", "--model", dest="model", default="once", help="Add sims information to the namespace", choices=("no", "all", "once")) 
    66     p.add_option("-d", "--defaults", action="store_true", dest="defaults", help="Output default values for attributes") 
    67  
    68     (options, args) = p.parse_args() 
    69     if len(args) != 1: 
    70         p.error("incorrect number of arguments") 
    71         sys.exit(1) 
    72     input = url.URL(args[0]) 
    73     if options.output is None: 
    74         output = url.File(input.withExt("py").file) 
    75     else: 
    76         output = url.URL(options.output) 
    77     tld2xsc(input, output, options.verbose, options.xmlname, options.xmlurl, options.shareattrs, options.model, options.defaults) 
     9    from ll.xist.scripts import tld2xsc 
     10    sys.exit(tld2xsc.main()) 
  • scripts/xml2xsc.py

    r2396 r2522  
    33 
    44 
    5 import sys, optparse 
    6  
    7 from xml.sax import sax2exts, handler, xmlreader 
    8  
    9 from ll.xist import xsc, xnd, sims 
    10  
    11  
    12 class Handler(handler.ErrorHandler, handler.ContentHandler, handler.DTDHandler, handler.EntityResolver): 
    13     def __init__(self, name, url, sims): 
    14         self.name = name 
    15         self.url = url 
    16         self.sims = sims 
    17         self.xnd = None # will be set by startDocument() 
    18         self.stack = None # will be set by startDocument() 
    19         self.elements = {} # maps name to (xnd.Element, content set, attrname->xnd.Attr map) 
    20         self.entities = {} # maps name to xnd.Entity 
    21         self.procinsts = {} # maps name to xnd.ProcInst 
    22  
    23     def error(self, exception): 
    24         print "error: %r" % exception 
    25         raise exception 
    26  
    27     def fatalError(self, exception): 
    28         print "fatalError: %r" % exception 
    29         raise exception 
    30  
    31     def warning(self, exception): 
    32         print "warning: %r" % exception 
    33  
    34     def startDocument(self): 
    35         self.xnd = xnd.Namespace(self.name, url=self.url) 
    36         self.stack = [] 
    37  
    38     def endDocument(self): 
    39         # Put sims info into the element definitions 
    40         if self.sims == "none": 
    41             pass 
    42         elif self.sims == "simple": 
    43             for entry in self.elements.itervalues(): 
    44                 entry[0].modeltype = bool(entry[1]) 
    45         elif self.sims == "full": 
    46             for entry in self.elements.itervalues(): 
    47                 if not entry[1]: 
    48                     entry[0].modeltype = "sims.Empty" 
    49                 else: 
    50                     elements = [el for el in entry[1] if not el.startswith("#")] 
    51                     if not elements: 
    52                         if "#text" in entry[1]: 
    53                             entry[0].modeltype = "sims.NoElements" 
    54                         else: 
    55                             entry[0].modeltype = "sims.NoElementsOrText" 
    56                     else: 
    57                         if "#text" in entry[1]: 
    58                             entry[0].modeltype = "sims.ElementsOrText" 
    59                         else: 
    60                             entry[0].modeltype = "sims.Elements" 
    61                         entry[0].modelargs = [self.xnd.element(el) for el in elements] 
    62         else: 
    63             raise ValueError("unknown sims mode %r" % self.sims) 
    64  
    65     def startElement(self, name, attrs): 
    66         if name not in self.elements: 
    67             element = xnd.Element(name) 
    68             entry = self.elements[name] = (element, set(), {}) 
    69             self.xnd(element) 
    70         else: 
    71             entry = self.elements[name] 
    72         for attrname in attrs.keys(): 
    73             if attrname != "xmlns" and not attrname.startswith("xmlns:") and attrname not in entry[2]: 
    74                 attr = xnd.Attr(attrname, type=xsc.TextAttr) 
    75                 entry[0](attr) 
    76                 entry[2][attrname] = attr 
    77         if self.stack: 
    78             self.stack[-1][1].add(name) 
    79         self.stack.append(entry) 
    80  
    81     def endElement(self, name): 
    82         self.stack.pop(-1) 
    83  
    84     #def startPrefixMapping(self, prefix, uri): 
    85  
    86     #def endPrefixMapping(self, prefix): 
    87  
    88     #def startElementNS(self, name, qname, attrs): 
    89  
    90     #def endElementNS(self, name, qname): 
    91  
    92     def characters(self, content): 
    93         if self.stack and content: 
    94             if content.isspace(): 
    95                 self.stack[-1][1].add("#whitespace") 
    96             else: 
    97                 self.stack[-1][1].add("#text") 
    98  
    99     def entity(self, name): 
    100         self.skippedEntity(name) 
    101  
    102     def ignorableWhitespace(self, whitespace): 
    103         if self.stack: 
    104             self.stack[-1][1].add("#whitespace") 
    105  
    106     def comment(self, content): 
    107         if self.stack: 
    108             self.stack[-1][1].add("#comment") 
    109  
    110     def processingInstruction(self, target, data): 
    111         if self.stack: 
    112             self.stack[-1][1].add("#procinst") 
    113         if target not in self.procinsts: 
    114             procinst = xnd.ProcInst(target) 
    115             self.procinsts[name] = procinst 
    116             self.xnd(procinst) 
    117  
    118     def skippedEntity(self, name): 
    119         if self.stack: 
    120             self.stack[-1][1].add("#entity") 
    121         if name not in self.entities: 
    122             entity = xnd.Entity(name) 
    123             self.entities[name] = entity 
    124             self.xnd(entity) 
    125  
    126  
    127 def stream2xnd(stream, name="foo", url="http://www.example.com/foons", sims="simple", parser=None): 
    128     if parser is None or parser==[]: 
    129         from ll.xist import parsers 
    130         parser = parsers.SGMLOPParser() 
    131     elif isinstance(parser, list): 
    132         parser = sax2exts.make_parser(parser) 
    133      
    134     app = Handler(name, url, sims) 
    135  
    136     parser.setErrorHandler(app) 
    137     parser.setContentHandler(app) 
    138     parser.setDTDHandler(app) 
    139     parser.setEntityResolver(app) 
    140  
    141     #parser.setFeature(handler.feature_namespaces, 1) 
    142     parser.setFeature(handler.feature_external_ges, False) # Don't process external entities, but pass them to skippedEntity 
    143      
    144     source = xmlreader.InputSource() 
    145     source.setByteStream(stream) 
    146  
    147     parser.parse(source) 
    148      
    149     return app.xnd 
     5import sys 
    1506 
    1517 
    1528if __name__ == "__main__": 
    153     p = optparse.OptionParser(usage="usage: %prog [options] <input.xml >output.py") 
    154     p.add_option("-n", "--name", dest="name", help="xmlname for the new namespace", default="foo") 
    155     p.add_option("-u", "--url", dest="url", help="xmlurl for the new namespace", default="http://www.example.com/foons") 
    156     p.add_option("-p", "--parser", dest="parser", help="parser module to use for XML parsing", action="append", default=[]) 
    157     choices = ["none", "simple", "full"] 
    158     p.add_option("-s", "--sims", dest="sims", help="Create sims info? (%s)" % ", ".join(choices), metavar="MODE", default="simple") 
    159  
    160     (options, args) = p.parse_args() 
    161     if len(args) != 0: 
    162         p.error("incorrect number of arguments") 
    163         sys.exit(1) 
    164     print stream2xnd(sys.stdin, name=options.name, url=options.url, sims=options.sims, parser=options.parser).aspy() 
     9    from ll.xist.scripts import xml2xsc 
     10    sys.exit(xml2xsc.main()) 
  • setup.py

    r2521 r2522  
    77# $Source$ 
    88 
     9 
    910try: 
    1011    import setuptools as tools 
     
    1314 
    1415import textwrap 
     16 
    1517 
    1618DESCRIPTION = """ 
     
    6567    keywords=",".join(KEYWORDS.strip().splitlines()), 
    6668    package_dir={"": "src"}, 
    67     packages=["ll", "ll.xist", "ll.xist.ns"], 
     69    packages=["ll", "ll.xist", "ll.xist.ns", "ll.xist.scripts"], 
    6870    ext_modules=[ 
    6971        tools.Extension("ll.xist.csstokenizer", ["src/ll/xist/csstokenizer.cxx"]), 
    7072        tools.Extension("ll.xist.helpers", ["src/ll/xist/helpers.c"]) 
    7173    ], 
     74    entry_points=dict( 
     75        console_scripts=[ 
     76            "dtd2xsc = ll.xist.scripts.dtd2xsc:main", 
     77            "tld2xsc = ll.xist.scripts.tld2xsc:main", 
     78            "doc2txt = ll.xist.scripts.doc2txt:main", 
     79            "xml2xsc = ll.xist.scripts.xml2xsc:main", 
     80        ] 
     81    ), 
    7282    scripts=[ 
    7383        "scripts/dtd2xsc.py", 
     
    7686        "scripts/xml2xsc.py", 
    7787    ], 
     88    install_requires=[ 
     89        "ll-core >= 1.3", 
     90        "PyXML >= 0.8.4", 
     91    ], 
    7892    namespace_packages=["ll"], 
    79     zip_safe=False 
     93    zip_safe=False, 
     94    dependency_links=[ 
     95        "http://sourceforge.net/project/showfiles.php?group_id=6473", # PyXML 
     96    ], 
    8097) 
    8198