home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1610 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  25.2 KB  |  661 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = []
  5. __docformat__ = 'restructuredtext'
  6. __version__ = '$Id: util.py 1939 2010-03-22 22:38:43Z cthedot $'
  7. from helper import normalize
  8. from itertools import ifilter
  9. import css
  10. import codec
  11. import codecs
  12. import errorhandler
  13. import tokenize2
  14. import types
  15. import xml.dom as xml
  16.  
  17. try:
  18.     from _fetchgae import _defaultFetcher
  19. except ImportError:
  20.     e = None
  21.     from _fetch import _defaultFetcher
  22.  
  23. log = errorhandler.ErrorHandler()
  24.  
  25. class _BaseClass(object):
  26.     _log = errorhandler.ErrorHandler()
  27.     _prods = tokenize2.CSSProductions
  28.     
  29.     def _checkReadonly(self):
  30.         if hasattr(self, '_readonly') and self._readonly:
  31.             raise xml.dom.NoModificationAllowedErr(u'%s is readonly.' % self.__class__)
  32.         return self._readonly
  33.         return False
  34.  
  35.     
  36.     def _valuestr(self, t):
  37.         if not t:
  38.             return u''
  39.         if isinstance(t, basestring):
  40.             return t
  41.         return []([ x[1] for x in t ])
  42.  
  43.  
  44.  
  45. class _NewBase(_BaseClass):
  46.     
  47.     def __init__(self):
  48.         self._seq = Seq()
  49.  
  50.     
  51.     def _setSeq(self, newseq):
  52.         newseq._readonly = True
  53.         self._seq = newseq
  54.  
  55.     
  56.     def _tempSeq(self, readonly = False):
  57.         return Seq(readonly = readonly)
  58.  
  59.     seq = property((lambda self: self._seq), doc = 'Internal readonly attribute, **DO NOT USE**!')
  60.  
  61.  
  62. class Base(_BaseClass):
  63.     __tokenizer2 = tokenize2.Tokenizer()
  64.     _SHORTHANDPROPERTIES = {
  65.         u'background': [],
  66.         u'background-position': [],
  67.         u'border': [],
  68.         u'border-left': [],
  69.         u'border-right': [],
  70.         u'border-top': [],
  71.         u'border-bottom': [],
  72.         u'cue': [],
  73.         u'font': [],
  74.         u'list-style': [],
  75.         u'outline': [],
  76.         u'pause': [] }
  77.     
  78.     def _normalize(x):
  79.         return normalize(x)
  80.  
  81.     _normalize = staticmethod(_normalize)
  82.     
  83.     def _splitNamespacesOff(self, text_namespaces_tuple):
  84.         if isinstance(text_namespaces_tuple, tuple):
  85.             return (text_namespaces_tuple[0], _SimpleNamespaces(self._log, text_namespaces_tuple[1]))
  86.         return (text_namespaces_tuple, _SimpleNamespaces(log = self._log))
  87.  
  88.     
  89.     def _tokenize2(self, textortokens):
  90.         if not textortokens:
  91.             return None
  92.         if isinstance(textortokens, basestring):
  93.             return self._Base__tokenizer2.tokenize(textortokens)
  94.         if types.GeneratorType == type(textortokens):
  95.             return textortokens
  96.         if isinstance(textortokens, tuple):
  97.             return [
  98.                 textortokens]
  99.         return (lambda .0: for x in .0:
  100. x)(textortokens)
  101.  
  102.     
  103.     def _nexttoken(self, tokenizer, default = None):
  104.         
  105.         try:
  106.             return tokenizer.next()
  107.         except (StopIteration, AttributeError):
  108.             return default
  109.  
  110.  
  111.     
  112.     def _type(self, token):
  113.         if token:
  114.             return token[0]
  115.         return None
  116.  
  117.     
  118.     def _tokenvalue(self, token, normalize = False):
  119.         if token and normalize:
  120.             return Base._normalize(token[1])
  121.         if token:
  122.             return token[1]
  123.         return None
  124.  
  125.     
  126.     def _stringtokenvalue(self, token):
  127.         if token:
  128.             value = token[1]
  129.             return value.replace('\\' + value[0], value[0])[1:-1]
  130.         return None
  131.  
  132.     
  133.     def _uritokenvalue(self, token):
  134.         if token:
  135.             value = token[1][4:-1].strip()
  136.             if value and value[0] in '\'"' and value[0] == value[-1]:
  137.                 value = value.replace('\\' + value[0], value[0])[1:-1]
  138.             
  139.             return value
  140.         return None
  141.  
  142.     
  143.     def _tokensupto2(self, tokenizer, starttoken = None, blockstartonly = False, blockendonly = False, mediaendonly = False, importmediaqueryendonly = False, mediaqueryendonly = False, semicolon = False, propertynameendonly = False, propertyvalueendonly = False, propertypriorityendonly = False, selectorattendonly = False, funcendonly = False, listseponly = False, separateEnd = False):
  144.         ends = u';}'
  145.         endtypes = ()
  146.         brace = bracket = parant = 0
  147.         if blockstartonly:
  148.             ends = u'{'
  149.             brace = -1
  150.         elif blockendonly:
  151.             ends = u'}'
  152.             brace = 1
  153.         elif mediaendonly:
  154.             ends = u'}'
  155.             brace = 1
  156.         elif importmediaqueryendonly:
  157.             ends = u';'
  158.             endtypes = ('STRING',)
  159.         elif mediaqueryendonly:
  160.             ends = u'{'
  161.             brace = -1
  162.             endtypes = ('STRING',)
  163.         elif semicolon:
  164.             ends = u';'
  165.         elif propertynameendonly:
  166.             ends = u':;'
  167.         elif propertyvalueendonly:
  168.             ends = u';!'
  169.         elif propertypriorityendonly:
  170.             ends = u';'
  171.         elif selectorattendonly:
  172.             ends = u']'
  173.             if starttoken and self._tokenvalue(starttoken) == u'[':
  174.                 bracket = 1
  175.             
  176.         elif funcendonly:
  177.             ends = u')'
  178.             parant = 1
  179.         elif listseponly:
  180.             ends = u','
  181.         
  182.         resulttokens = []
  183.         if starttoken:
  184.             resulttokens.append(starttoken)
  185.         
  186.         if tokenizer:
  187.             for token in tokenizer:
  188.                 (typ, val, line, col) = token
  189.                 if 'EOF' == typ:
  190.                     resulttokens.append(token)
  191.                     break
  192.                 
  193.                 if u'{' == val:
  194.                     brace += 1
  195.                 elif u'}' == val:
  196.                     brace -= 1
  197.                 elif u'[' == val:
  198.                     bracket += 1
  199.                 elif u']' == val:
  200.                     bracket -= 1
  201.                 elif u'(' == val or Base._prods.FUNCTION == typ:
  202.                     parant += 1
  203.                 elif u')' == val:
  204.                     parant -= 1
  205.                 
  206.                 resulttokens.append(token)
  207.                 if bracket == bracket and parant == parant:
  208.                     pass
  209.                 elif parant == 0:
  210.                     if val in ends or typ in endtypes:
  211.                         break
  212.                         continue
  213.                 if mediaqueryendonly and brace == -1:
  214.                     if parant == parant:
  215.                         pass
  216.                     elif parant == 0 and typ in endtypes:
  217.                         break
  218.                         continue
  219.             
  220.         
  221.         if separateEnd:
  222.             if resulttokens:
  223.                 return (resulttokens[:-1], resulttokens[-1])
  224.             return (resulttokens, None)
  225.         separateEnd
  226.         return resulttokens
  227.  
  228.     
  229.     def _adddefaultproductions(self, productions, new = None):
  230.         
  231.         def ATKEYWORD(expected, seq, token, tokenizer = (None, None)):
  232.             if expected != 'EOF':
  233.                 rule = css.CSSUnknownRule()
  234.                 rule.cssText = self._tokensupto2(tokenizer, token)
  235.                 if rule.wellformed:
  236.                     seq.append(rule)
  237.                 
  238.                 return expected
  239.             new['wellformed'] = False
  240.             self._log.error(u'Expected EOF.', token = token)
  241.             return expected
  242.  
  243.         
  244.         def COMMENT(expected, seq, token, tokenizer = None):
  245.             seq.append(css.CSSComment([
  246.                 token]))
  247.             return expected
  248.  
  249.         
  250.         def S(expected, seq, token, tokenizer = None):
  251.             return expected
  252.  
  253.         
  254.         def EOF(expected = None, seq = None, token = None, tokenizer = None):
  255.             return 'EOF'
  256.  
  257.         p = {
  258.             'ATKEYWORD': ATKEYWORD,
  259.             'COMMENT': COMMENT,
  260.             'S': S,
  261.             'EOF': EOF }
  262.         p.update(productions)
  263.         return p
  264.  
  265.     
  266.     def _parse(self, expected, seq, tokenizer, productions, default = None, new = None, initialtoken = None):
  267.         wellformed = True
  268.         if initialtoken:
  269.             
  270.             def tokens():
  271.                 yield initialtoken
  272.                 for item in tokenizer:
  273.                     yield item
  274.                 
  275.  
  276.             fulltokenizer = (lambda .0: for t in .0:
  277. t)(tokens())
  278.         else:
  279.             fulltokenizer = tokenizer
  280.         if fulltokenizer:
  281.             prods = self._adddefaultproductions(productions, new)
  282.             for token in fulltokenizer:
  283.                 p = prods.get(token[0], default)
  284.                 if p:
  285.                     expected = p(expected, seq, token, tokenizer)
  286.                     continue
  287.                 wellformed = False
  288.                 self._log.error(u'Unexpected token (%s, %s, %s, %s)' % token)
  289.             
  290.         
  291.         return (wellformed, expected)
  292.  
  293.  
  294.  
  295. class Base2(Base, _NewBase):
  296.     
  297.     def __init__(self):
  298.         self._seq = Seq()
  299.  
  300.     
  301.     def _adddefaultproductions(self, productions, new = None):
  302.         
  303.         def ATKEYWORD(expected, seq, token, tokenizer = (None, None)):
  304.             if expected != 'EOF':
  305.                 rule = css.CSSUnknownRule()
  306.                 rule.cssText = self._tokensupto2(tokenizer, token)
  307.                 if rule.wellformed:
  308.                     seq.append(rule, css.CSSRule.UNKNOWN_RULE, line = token[2], col = token[3])
  309.                 
  310.                 return expected
  311.             new['wellformed'] = False
  312.             self._log.error(u'Expected EOF.', token = token)
  313.             return expected
  314.  
  315.         
  316.         def COMMENT(expected, seq, token, tokenizer = (None, None)):
  317.             if expected == 'EOF':
  318.                 new['wellformed'] = False
  319.                 self._log.error(u'Expected EOF but found comment.', token = token)
  320.             
  321.             seq.append(css.CSSComment([
  322.                 token]), 'COMMENT')
  323.             return expected
  324.  
  325.         
  326.         def S(expected, seq, token, tokenizer = (None, None)):
  327.             if expected == 'EOF':
  328.                 new['wellformed'] = False
  329.                 self._log.error(u'Expected EOF but found whitespace.', token = token)
  330.             
  331.             return expected
  332.  
  333.         
  334.         def EOF(expected = None, seq = None, token = None, tokenizer = None):
  335.             return 'EOF'
  336.  
  337.         defaultproductions = {
  338.             'ATKEYWORD': ATKEYWORD,
  339.             'COMMENT': COMMENT,
  340.             'S': S,
  341.             'EOF': EOF }
  342.         defaultproductions.update(productions)
  343.         return defaultproductions
  344.  
  345.  
  346.  
  347. class Seq(object):
  348.     
  349.     def __init__(self, readonly = True):
  350.         self._seq = []
  351.         self._readonly = readonly
  352.  
  353.     
  354.     def __repr__(self):
  355.         return self.__class__.__name__ % (u',\n    '.join, [], []([ u'%r' % item for item in self._seq ]), self._readonly)
  356.  
  357.     
  358.     def __str__(self):
  359.         vals = []
  360.         for v in self:
  361.             if isinstance(v.value, basestring):
  362.                 vals.append(v.value)
  363.                 continue
  364.             if type(v) == tuple:
  365.                 vals.append(v.value[1])
  366.                 continue
  367.             vals.append(str(v))
  368.         
  369.         return '<cssutils.%s.%s object length=%r values=%r readonly=%r at 0x%x>' % (self.__module__, self.__class__.__name__, len(self), u', '.join(vals), self._readonly, id(self))
  370.  
  371.     
  372.     def __delitem__(self, i):
  373.         del self._seq[i]
  374.  
  375.     
  376.     def __getitem__(self, i):
  377.         return self._seq[i]
  378.  
  379.     
  380.     def __setitem__(self, i, .2):
  381.         (val, typ, line, col) = .2
  382.         self._seq[i] = Item(val, typ, line, col)
  383.  
  384.     
  385.     def __iter__(self):
  386.         return iter(self._seq)
  387.  
  388.     
  389.     def __len__(self):
  390.         return len(self._seq)
  391.  
  392.     
  393.     def absorb(self, other):
  394.         self._seq = other._seq
  395.  
  396.     
  397.     def append(self, val, typ, line = None, col = None):
  398.         if self._readonly:
  399.             raise AttributeError('Seq is readonly.')
  400.         self._readonly
  401.         self._seq.append(Item(val, typ, line, col))
  402.  
  403.     
  404.     def appendItem(self, item):
  405.         if self._readonly:
  406.             raise AttributeError('Seq is readonly.')
  407.         self._readonly
  408.         self._seq.append(item)
  409.  
  410.     
  411.     def replace(self, index = -1, val = None, typ = None, line = None, col = None):
  412.         if self._readonly:
  413.             raise AttributeError('Seq is readonly.')
  414.         self._readonly
  415.         self._seq[index] = Item(val, typ, line, col)
  416.  
  417.     
  418.     def rstrip(self):
  419.         while self._seq and self._seq[-1].type == tokenize2.CSSProductions.S:
  420.             del self._seq[-1]
  421.  
  422.     
  423.     def appendToVal(self, val = None, index = -1):
  424.         if self._readonly:
  425.             raise AttributeError('Seq is readonly.')
  426.         self._readonly
  427.         old = self._seq[index]
  428.         self._seq[index] = Item(old.value + val, old.type, old.line, old.col)
  429.  
  430.  
  431.  
  432. class Item(object):
  433.     
  434.     def __init__(self, value, type, line = None, col = None):
  435.         self._Item__value = value
  436.         self._Item__type = type
  437.         self._Item__line = line
  438.         self._Item__col = col
  439.  
  440.     type = property((lambda self: self._Item__type))
  441.     value = property((lambda self: self._Item__value))
  442.     line = property((lambda self: self._Item__line))
  443.     col = property((lambda self: self._Item__col))
  444.     
  445.     def __repr__(self):
  446.         return '%s.%s(value=%r, type=%r, line=%r, col=%r)' % (self.__module__, self.__class__.__name__, self._Item__value, self._Item__type, self._Item__line, self._Item__col)
  447.  
  448.  
  449.  
  450. class ListSeq(object):
  451.     
  452.     def __init__(self):
  453.         self.seq = []
  454.  
  455.     
  456.     def __contains__(self, item):
  457.         return item in self.seq
  458.  
  459.     
  460.     def __delitem__(self, index):
  461.         del self.seq[index]
  462.  
  463.     
  464.     def __getitem__(self, index):
  465.         return self.seq[index]
  466.  
  467.     
  468.     def __iter__(self):
  469.         
  470.         def gen():
  471.             for x in self.seq:
  472.                 yield x
  473.             
  474.  
  475.         return gen()
  476.  
  477.     
  478.     def __len__(self):
  479.         return len(self.seq)
  480.  
  481.     
  482.     def __setitem__(self, index, item):
  483.         raise NotImplementedError
  484.  
  485.     
  486.     def append(self, item):
  487.         raise NotImplementedError
  488.  
  489.  
  490.  
  491. class _Namespaces(object):
  492.     
  493.     def __init__(self, parentStyleSheet, log = None, *args):
  494.         self.parentStyleSheet = parentStyleSheet
  495.         self._log = log
  496.  
  497.     
  498.     def __repr__(self):
  499.         return '%r' % self.namespaces
  500.  
  501.     
  502.     def __contains__(self, prefix):
  503.         return prefix in self.namespaces
  504.  
  505.     
  506.     def __delitem__(self, prefix):
  507.         if not prefix:
  508.             prefix = u''
  509.         
  510.         delrule = self._Namespaces__findrule(prefix)
  511.         for i, rule in enumerate(ifilter((lambda r: r.type == r.NAMESPACE_RULE), self.parentStyleSheet.cssRules)):
  512.             if rule == delrule:
  513.                 self.parentStyleSheet.deleteRule(i)
  514.                 return None
  515.         
  516.         self._log.error('Prefix %r not found.' % prefix, error = xml.dom.NamespaceErr)
  517.  
  518.     
  519.     def __getitem__(self, prefix):
  520.         
  521.         try:
  522.             return self.namespaces[prefix]
  523.         except KeyError:
  524.             e = None
  525.             self._log.error('Prefix %r not found.' % prefix, error = xml.dom.NamespaceErr)
  526.  
  527.  
  528.     
  529.     def __iter__(self):
  530.         return self.namespaces.__iter__()
  531.  
  532.     
  533.     def __len__(self):
  534.         return len(self.namespaces)
  535.  
  536.     
  537.     def __setitem__(self, prefix, namespaceURI):
  538.         if not prefix:
  539.             prefix = u''
  540.         
  541.         rule = self._Namespaces__findrule(prefix)
  542.         if not rule:
  543.             self.parentStyleSheet.insertRule(css.CSSNamespaceRule(prefix = prefix, namespaceURI = namespaceURI), inOrder = True)
  544.         elif prefix in self.namespaces:
  545.             rule.namespaceURI = namespaceURI
  546.         
  547.         if namespaceURI in self.namespaces.values():
  548.             rule.prefix = prefix
  549.         
  550.  
  551.     
  552.     def _Namespaces__findrule(self, prefix):
  553.         for rule in ifilter((lambda r: r.type == r.NAMESPACE_RULE), reversed(self.parentStyleSheet.cssRules)):
  554.             if rule.prefix == prefix:
  555.                 return rule
  556.         
  557.  
  558.     
  559.     def namespaces(self):
  560.         namespaces = { }
  561.         for rule in ifilter((lambda r: r.type == r.NAMESPACE_RULE), reversed(self.parentStyleSheet.cssRules)):
  562.             if rule.namespaceURI not in namespaces.values():
  563.                 namespaces[rule.prefix] = rule.namespaceURI
  564.                 continue
  565.         
  566.         return namespaces
  567.  
  568.     namespaces = property(namespaces)
  569.     
  570.     def get(self, prefix, default):
  571.         return self.namespaces.get(prefix, default)
  572.  
  573.     
  574.     def items(self):
  575.         return self.namespaces.items()
  576.  
  577.     
  578.     def keys(self):
  579.         return self.namespaces.keys()
  580.  
  581.     
  582.     def values(self):
  583.         return self.namespaces.values()
  584.  
  585.     
  586.     def prefixForNamespaceURI(self, namespaceURI):
  587.         for prefix, uri in self.namespaces.items():
  588.             if uri == namespaceURI:
  589.                 return prefix
  590.         
  591.         raise IndexError(u'NamespaceURI %r not found.' % namespaceURI)
  592.  
  593.     
  594.     def __str__(self):
  595.         return u'<cssutils.util.%s object parentStyleSheet=%r at 0x%x>' % (self.__class__.__name__, str(self.parentStyleSheet), id(self))
  596.  
  597.  
  598.  
  599. class _SimpleNamespaces(_Namespaces):
  600.     
  601.     def __init__(self, log = None, *args):
  602.         super(_SimpleNamespaces, self).__init__(parentStyleSheet = None, log = log)
  603.         self._SimpleNamespaces__namespaces = dict(*args)
  604.  
  605.     
  606.     def __setitem__(self, prefix, namespaceURI):
  607.         self._SimpleNamespaces__namespaces[prefix] = namespaceURI
  608.  
  609.     namespaces = property((lambda self: self._SimpleNamespaces__namespaces), doc = u'Dict Wrapper for self.sheets @namespace rules.')
  610.     
  611.     def __str__(self):
  612.         return u'<cssutils.util.%s object namespaces=%r at 0x%x>' % (self.__class__.__name__, self.namespaces, id(self))
  613.  
  614.     
  615.     def __repr__(self):
  616.         return u'cssutils.util.%s(%r)' % (self.__class__.__name__, self.namespaces)
  617.  
  618.  
  619.  
  620. def _readUrl(url, fetcher = None, overrideEncoding = None, parentEncoding = None):
  621.     enctype = None
  622.     if not fetcher:
  623.         fetcher = _defaultFetcher
  624.     
  625.     r = fetcher(url)
  626.     if r and len(r) == 2 and r[1] is not None:
  627.         (httpEncoding, content) = r
  628.         if overrideEncoding:
  629.             enctype = 0
  630.             encoding = overrideEncoding
  631.         elif httpEncoding:
  632.             enctype = 1
  633.             encoding = httpEncoding
  634.         elif isinstance(content, unicode):
  635.             explicit = False
  636.         else:
  637.             (contentEncoding, explicit) = codec.detectencoding_str(content)
  638.         if explicit:
  639.             enctype = 2
  640.             encoding = contentEncoding
  641.         elif parentEncoding:
  642.             enctype = 4
  643.             encoding = parentEncoding
  644.         else:
  645.             enctype = 5
  646.             encoding = 'utf-8'
  647.         if isinstance(content, unicode):
  648.             decodedCssText = content
  649.         else:
  650.             
  651.             try:
  652.                 decodedCssText = codecs.lookup('css')[1](content, encoding = encoding)[0]
  653.             except UnicodeDecodeError:
  654.                 e = None
  655.                 log.warn(e, neverraise = True)
  656.                 decodedCssText = None
  657.  
  658.         return (encoding, enctype, decodedCssText)
  659.     return (None, None, None)
  660.  
  661.