--- /dev/null
+# Copyright 2002 by Andrew Dalke.
+# All rights reserved.
+# This code is part of the Biopython distribution and governed by its
+# license. Please see the LICENSE file that should have been included
+# as part of this package.
+"""Decode elements from a Std/Martel parsed XML stream (OBSOLETE).
+
+Andrew Dalke is no longer maintaining Martel or Bio.Mindy, and these modules
+(and therefore Bio.Decode) have been deprecated. They are no longer used in
+any of the current Biopython parsers, and are likely to be removed in a
+future release."""
+
+import warnings
+warnings.warn("Martel and those parts of Biopython depending on it" \
+ +" directly (such as Bio.Mindy and Bio.Decode) are now" \
+ +" deprecated, and will be removed in a future release of"\
+ +" Biopython. If you want to continue to use this code,"\
+ +" please get in contact with the Biopython developers via"\
+ +" the mailing lists to avoid its permanent removal from"\
+ +" Biopython.", \
+ DeprecationWarning)
+
+import string
+from Bio.Parsers.spark import GenericScanner, GenericParser
+
+def unescape_C(s):
+ result = []
+ for i in range(len(s)):
+ if s[i] != "\\":
+ result.append(s[i])
+ continue
+ c = s[i+1:i+2]
+ if c == "x":
+ x = s[i+2:i+4]
+ if len(x) != 2:
+ raise ValueError("invalid \\x escape")
+ i = int(x, 16)
+ result.append(chr(i))
+ continue
+ if c in "01234567":
+ x = s[i+1:i+4]
+ # \octals don't do a length assertion check
+ i = int(x, 8)
+ result.append(chr(i))
+ continue
+ result.append(c)
+ return "".join(result)
+
+def join_english(fields):
+ if not fields:
+ return ""
+ s = fields[0]
+ for field in fields[1:]:
+ if s[-1:] == "-" and s[-3:-2] == "-":
+ s = s + field
+ continue
+ if s.find(" ") == -1 and field.find(" ") == -1:
+ s = s + field
+ continue
+ s = s + " " + field
+ return (" ".join(s.split())).strip()
+
+
+
+def chomp(s, c):
+ if s[-1:] == c:
+ return s[:-1]
+ return s
+
+def lchomp(s, c):
+ if s[:1] == c:
+ return s[1:]
+ return s
+
+def chompchomp(s, c):
+ if s[:1] == c and s[-1:] == c:
+ return s[1:-1]
+ return s
+
+def fixspaces(s):
+ # s.split breaks down to a list of words
+ # " ".join puts them together
+ # strip removes leading and trailing spaces
+ return " ".join(s.split()).strip()
+
+def join_fixspaces(lines):
+ return " ".join((" ".join(lines)).split()).strip()
+
+def tr(s, frm, to):
+ table = string.maketrans(frm, to)
+ return s.translate(table)
+
+def safe_int(s):
+ """converts to int if the number is small, long if it's large"""
+ try:
+ return int(s)
+ except ValueError:
+ return long(s)
+
+decode_functions = {
+ "chomp": (chomp, str, str),
+ "chompchomp": (chompchomp, str, str),
+ "chop": (lambda s: s[:-1], str, str),
+ "chopchop": (lambda s: s[1:-1], str, str),
+ "fixspaces": (fixspaces, str, str),
+ "lchomp": (lchomp, str, str),
+ "lchop": (lambda s: s[1:], str, str),
+ "lower": (lambda s: s.lower(), str, str),
+ "lstrip": (lambda s: s.lstrip(), str, str),
+ "replace": (lambda s, old, new: s.replace(old, new), str, str),
+ "rstrip": (lambda s: s.rstrip(), str, str),
+ "str": (str, str, str),
+ "strip": (lambda s: s.strip(), str, str),
+ "tr": (tr, str, str),
+ "unescape.c": (unescape_C, str, str),
+ "unescape.doublequote": (lambda s: s.replace('""', '"'), str, str),
+ "unescape.singlequote": (lambda s: s.replace("''", "'"), str, str),
+ "upper": (lambda s: s.upper(), str, str),
+
+ # List operations
+ "join": (lambda lst, s = " ": s.join(lst), list, str),
+ "join.english": (join_english, list, str),
+
+ # Integer operations
+ "int": (safe_int, [float, str, int], int),
+ "int.comma": (lambda s: safe_int(s.replace(",", "")),
+ [float, str, int], int),
+ "hex": (hex, str, int),
+ "oct": (oct, str, int),
+ "add": ((lambda i, j: i+j), int, int),
+
+ # Float operations
+ "float": (float, (float, str, int), float),
+
+ }
+
+def _fixup_defs():
+ # Normalize so the 2nd and 3rd terms are tuples
+ for k, v in decode_functions.items():
+ f, in_types, out_types = v
+ if isinstance(in_types, type([])):
+ in_types = tuple(in_types)
+ elif not isinstance(in_types, type( () )):
+ in_types = (in_types,)
+
+ if isinstance(out_types, type([])):
+ out_types = tuple(out_types)
+ elif not isinstance(out_types, type( () )):
+ out_types = (out_types,)
+
+ decode_functions[k] = (f, in_types, out_types)
+_fixup_defs()
+
+class Token:
+ def __init__(self, type):
+ self.type = type
+ def __cmp__(self, other):
+ return cmp(self.type, other)
+ def __repr__(self):
+ return "Token(%r)" % (self.type,)
+
+class ValueToken(Token):
+ def __init__(self, type, val):
+ Token.__init__(self, type)
+ self.val = val
+ def __cmp__(self, other):
+ return cmp(self.type, other)
+ def __repr__(self):
+ return "%s(%r)" % (self.__class__.__name__, self.val)
+ def __str__(self):
+ return str(self.val)
+
+class Integer(ValueToken):
+ def __init__(self, val):
+ ValueToken.__init__(self, "integer", val)
+
+class Float(ValueToken):
+ def __init__(self, val):
+ ValueToken.__init__(self, "float", val)
+
+class String(ValueToken):
+ def __init__(self, val):
+ ValueToken.__init__(self, "string", val)
+
+class FunctionName(ValueToken):
+ def __init__(self, val):
+ ValueToken.__init__(self, "functionname", val)
+
+class DecodeScanner(GenericScanner):
+ def __init__(self):
+ GenericScanner.__init__(self)
+
+ def tokenize(self, input):
+ self.rv = []
+ GenericScanner.tokenize(self, input)
+ return self.rv
+
+ def t_functionname(self, input):
+ r" \w+(\.\w+)*"
+ self.rv.append(FunctionName(input))
+
+ def t_pipe(self, input):
+ r" \| "
+ self.rv.append(Token("pipe"))
+
+ def t_open_paren(self, input):
+ r" \( "
+ self.rv.append(Token("open_paren"))
+
+ def t_close_paren(self, input):
+ r" \) "
+ self.rv.append(Token("close_paren"))
+
+ def t_comma(self, input):
+ r" , "
+ self.rv.append(Token("comma"))
+
+ def t_whitespace(self, input):
+ r" \s+ "
+ pass
+
+ def t_string(self, input):
+ r""" "([^"\\]+|\\.)*"|'([^'\\]+|\\.)*' """
+ # "' # emacs cruft
+ s = input[1:-1]
+ s = unescape_C(s)
+
+ self.rv.append(String(s))
+
+ def t_float(self, input):
+ r""" [+-]?((\d+(\.\d*)?)|\.\d+)([eE][+-]?[0-9]+)? """
+ # See if this is an integer
+ try:
+ self.rv.append(Integer(safe_int(input)))
+ except ValueError:
+ self.rv.append(Float(float(input)))
+
+class Function:
+ def __init__(self, name, args = ()):
+ self.name = name
+ self.args = args
+ def __str__(self):
+ args = self.args
+ if not args:
+ s = ""
+ else:
+ s = str(args)[1:-1]
+ return "%s(x, %s)" % (self.name, s)
+ __repr__ = __str__
+
+class DecodeParser(GenericParser):
+ def __init__(self, start = "expression"):
+ GenericParser.__init__(self, start)
+ self.begin_pos = 0
+
+ def p_expression(self, args):
+ """
+ expression ::= term
+ expression ::= term pipe expression
+ """
+ if len(args) == 1:
+ return [args[0]]
+ return [args[0]] + args[2]
+
+ def p_term(self, args):
+ """
+ term ::= functionname
+ term ::= functionname open_paren args close_paren
+ """
+ if len(args) == 1:
+ return Function(args[0].val)
+ return Function(args[0].val, tuple([x.val for x in args[2]]))
+
+ def p_args(self, args):
+ """
+ args ::= arg
+ args ::= arg comma args
+ """
+ if len(args) == 1:
+ return [args[0]]
+ return [args[0]] + args[2]
+
+ def p_arg(self, args):
+ """
+ arg ::= string
+ arg ::= integer
+ arg ::= float
+ """
+ return args[0]
+
+def scan(input):
+ scanner = DecodeScanner()
+ return scanner.tokenize(input)
+
+def parse(tokens):
+ parser = DecodeParser()
+ return parser.parse(tokens)
+
+_decoder_cache = {}
+
+class FunctionCall:
+ def __init__(self, f, args):
+ self.f = f
+ self.args = args
+ def __call__(self, x):
+ return self.f(x, *self.args)
+
+class FunctionCallChain:
+ def __init__(self, inner_f, f, args):
+ self.inner_f = inner_f
+ self.f = f
+ self.args = args
+ def __call__(self, x):
+ return self.f(self.inner_f(x), *self.args)
+
+#### I don't think this is the right way to do things
+##class CheckTypes:
+## def __init__(self, f, call_types, return_types):
+## self.f = f
+## self.call_types = call_types
+## self.return_types = return_types
+## def __call__(self, x):
+## if self.call_types is not None:
+## for T in self.call_types:
+## if isinstance(x, T):
+## break
+## else:
+## raise TypeError(
+## "Call value %s of type %s, expecting one of %s" %
+## (x, type(x).__name__,
+## [T.name for T in self.call_types]))
+## y = self.f(x)
+
+## if not self.return_types:
+## return y
+
+## for T in self.return_types:
+## if isinstance(y, T):
+## return y
+## raise TypeError("Return value %s of type %s, expecting one of %s" %
+## (y, type(y).__name__,
+## [T.name for T in self.return_types]))
+
+def make_decoder(s):
+ try:
+ return _decoder_cache[s]
+ except KeyError:
+ pass
+
+ functions = parse(scan(s))
+
+ f = functions[0]
+ fc = decode_functions[f.name][0]
+ args = f.args
+ if args:
+ fc = FunctionCall(fc, args)
+ for f in functions[1:]:
+ fc = FunctionCallChain(fc, decode_functions[f.name][0], f.args)
+ _decoder_cache[s] = fc
+ return fc
+
+def _verify_subtypes(subset, total, old_name, new_name):
+ for x in subset:
+ if x not in total:
+ raise TypeError("%s can produce a %r value not accepted by %s" %
+ (old_name, x.__name__, new_name))
+
+_typechecked_decoder_cache = {}
+def make_typechecked_decoder(s, input_types = None, output_types = None):
+ cache_lookup = (s, input_types, output_types)
+ try:
+ return _typechecked_decoder_cache[cache_lookup]
+ except KeyError:
+ pass
+ if input_types is not None and not isinstance(input_types, type( () )):
+ input_types = (input_types,)
+ if output_types is not None and not isinstance(output_types, type( () )):
+ output_types = (output_types,)
+
+ functions = parse(scan(s))
+
+ # Make sure the input type(s) are allowed
+ f = functions[0]
+ fc, in_types, out_types = decode_functions[f.name]
+ if input_types is not None:
+ for x in input_types:
+ if x not in in_types:
+ raise TypeError(
+ "the input type includes %r which isn't supported by %s" %
+ (x.__name__, f.name))
+
+ # Do the composition
+ old_name = f.name
+ input_types = out_types
+ args = functions[0].args
+ if args:
+ fc = FunctionCall(fc, args)
+
+ for f in functions[1:]:
+ transform_func, in_types, out_types = decode_functions[f.name]
+ _verify_subtypes(input_types, in_types, old_name, f.name)
+ old_name = f.name
+ input_types = out_types
+ fc = FunctionCallChain(fc, transform_func, f.args)
+
+ if output_types is not None:
+ _verify_subtypes(input_types, output_types, old_name, "the output")
+ _typechecked_decoder_cache[cache_lookup] = fc
+ return fc
+
+
+def test():
+ assert make_decoder("chop")("Andrew") == "Andre"
+ assert make_decoder("int")("9") == 9
+ assert make_decoder('join(" ")')(["Andrew", "Dalke"]) == \
+ "Andrew Dalke"
+ assert make_decoder('chomp("|")')("|test|") == "|test"
+ assert make_decoder('chomp("|")')("|test") == "|test"
+ assert make_decoder('chomp("A")|chop')("BA") == ""
+ assert make_decoder('chomp("A")|chop')("AB") == "A"
+ assert make_decoder('chop|chomp("A")')("AB") == ""
+ assert make_decoder('chop|chomp("A")')("BA") == "B"
+ assert make_decoder('add(5)')(2) == 7
+ assert make_decoder('add(-2)')(5) == 3
+
+if __name__ == "__main__":
+ test()
git://source.jalview.org / jabaws.git / blobdiff