minjson.py :  » Ajax » json-py » src » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Ajax » json py 
json py » src » minjson.py
##############################################################################
##
##    minjson.py implements JSON reading and writing in python.
##    Copyright (c) 2005 Jim Washington and Contributors.
##
##    This library is free software; you can redistribute it and/or
##    modify it under the terms of the GNU Lesser General Public
##    License as published by the Free Software Foundation; either
##    version 2.1 of the License, or (at your option) any later version.
##
##    This library is distributed in the hope that it will be useful,
##    but WITHOUT ANY WARRANTY; without even the implied warranty of
##    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
##    Lesser General Public License for more details.=
##
##    You should have received a copy of the GNU Lesser General Public
##    License along with this library; if not, write to the Free Software
##    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
##
##############################################################################


# minjson.py
# use python's parser to read minimal javascript objects.
# str's objects and fixes the text to write javascript.

# Thanks to Patrick Logan for starting the json-py project and making so many
# good test cases.

# Jim Washington 7 Aug 2005.

from re import compile,sub,search,DOTALL

# set to true if transmission size is much more important than speed
# only affects writing, and makes a minimal difference in output size.
alwaysStripWhiteSpace = False

# add to this string if you wish to exclude additional math operators
# from reading.
badOperators = '*'

#################################
#      read JSON object         #
#################################

slashstarcomment = compile(r'/\*.*?\*/',DOTALL)
doubleslashcomment = compile(r'//.*\n')

def _Read(aString):
        """Use eval in a 'safe' way to turn javascript expression into
           a python expression.  Allow only True, False, and None in global
           __builtins__, and since those map as true, false, null in
           javascript, pass those as locals
        """
        try:
            result = eval(aString,
            {"__builtins__":{'True':True,'False':False,'None':None}},
            {'null':None,'true':True,'false':False})
        except NameError:
            raise ReadException, \
            "Strings must be quoted. Could not read '%s'." % aString
        except SyntaxError:
            raise ReadException, \
            "Syntax error.  Could not read '%s'." % aString
        return result

# badOperators is defined at the top of the module

# generate the regexes for math detection
regexes = {}
for operator in badOperators:
    if operator in '+*':
        # '+' and '*' need to be escaped with \ in re
        regexes[operator,'numeric operation'] \
        = compile(r"\d*\s*\%s|\%s\s*\d*" % (operator, operator))
    else:
        regexes[operator,'numeric operation'] \
        = compile(r"\d*\s*%s|%s\s*\d*" % (operator, operator))

def _getStringState(aSequence):
    """return the list of required quote closures if the end of aString needs them
    to close quotes.
    """
    state = []
    for k in aSequence:
        if k in ['"',"'"]:
            if state and k == state[-1]:
                state.pop()
            else:
                state.append(k)
    return state

def _sanityCheckMath(aString):
    """just need to check that, if there is a math operator in the
       client's JSON, it is inside a quoted string. This is mainly to
       keep client from successfully sending 'D0S'*9**9**9**9...
       Return True if OK, False otherwise
    """
    for operator in badOperators:
        #first check, is it a possible math operation?
        if regexes[(operator,'numeric operation')].search(aString) is not None:
            # OK.  possible math operation. get the operator's locations
            getlocs = regexes[(operator,'numeric operation')].finditer(aString)
            locs = [item.span() for item in getlocs]
            halfStrLen = len(aString) / 2
            #fortunately, this should be rare
            for loc in locs:
                exprStart = loc[0]
                exprEnd = loc[1]
                # We only need to know the char is within open quote
                # status.
                if exprStart <= halfStrLen:
                    teststr = aString[:exprStart]
                else:
                    teststr = list(aString[exprEnd+1:])
                    teststr.reverse()
                if not _getStringState(teststr):
                    return False
    return True

def safeRead(aString):
    """turn the js into happier python and check for bad operations
       before sending it to the interpreter
    """
    # get rid of trailing null. Konqueror appends this, and the python
    # interpreter balks when it is there.
    CHR0 = chr(0)
    while aString.endswith(CHR0):
        aString = aString[:-1]
    # strip leading and trailing whitespace
    aString = aString.strip()
    # zap /* ... */ comments
    aString = slashstarcomment.sub('',aString)
    # zap // comments
    aString = doubleslashcomment.sub('',aString)
    # here, we only check for the * operator as a DOS problem by default;
    # additional operators may be excluded by editing badOperators
    # at the top of the module
    if _sanityCheckMath(aString):
        return _Read(aString)
    else:
        raise ReadException, 'Unacceptable JSON expression: %s' % aString

read = safeRead

#################################
#   write object as JSON        #
#################################

#alwaysStripWhiteSpace is defined at the top of the module

tfnTuple = (('True','true'),('False','false'),('None','null'),)

def _replaceTrueFalseNone(aString):
    """replace True, False, and None with javascript counterparts"""
    for k in tfnTuple:
        if k[0] in aString:
            aString = aString.replace(k[0],k[1])
    return aString

def _handleCode(subStr,stripWhiteSpace):
    """replace True, False, and None with javascript counterparts if
       appropriate, remove unicode u's, fix long L's, make tuples
       lists, and strip white space if requested
    """
    if 'e' in subStr:
        #True, False, and None have 'e' in them. :)
        subStr = (_replaceTrueFalseNone(subStr))
    if stripWhiteSpace:
        # re.sub might do a better job, but takes longer.
        # Spaces are the majority of the whitespace, anyway...
        subStr = subStr.replace(' ','')
    if subStr[-1] in "uU":
        #remove unicode u's
        subStr = subStr[:-1]
    if "L" in subStr:
        #remove Ls from long ints
        subStr = subStr.replace("L",'')
    #do tuples as lists
    if "(" in subStr:
        subStr = subStr.replace("(",'[')
    if ")" in subStr:
        subStr = subStr.replace(")",']')
    return subStr

# re for a double-quoted string that has a single-quote in it
# but no double-quotes and python punctuation after:
redoublequotedstring = compile(r'"[^"]*\'[^"]*"[,\]\}:\)]')
escapedSingleQuote = r"\'"
escapedDoubleQuote = r'\"'

def doQuotesSwapping(aString):
    """rewrite doublequoted strings with single quotes as singlequoted strings with
    escaped single quotes"""
    s = []
    foundlocs = redoublequotedstring.finditer(aString)
    prevend = 0
    for loc in foundlocs:
        start,end = loc.span()
        s.append(aString[prevend:start])
        tempstr = aString[start:end]
        endchar = tempstr[-1]
        ts1 = tempstr[1:-2]
        ts1 = ts1.replace("'",escapedSingleQuote)
        ts1 = "'%s'%s" % (ts1,endchar)
        s.append(ts1)
        prevend = end
    s.append(aString[prevend:])
    return ''.join(s)

def _pyexpr2jsexpr(aString, stripWhiteSpace):
    """Take advantage of python's formatting of string representations of
    objects.  Python always uses "'" to delimit strings.  Except it doesn't when
    there is ' in the string.  Fix that, then, if we split
    on that delimiter, we have a list that alternates non-string text with
    string text.  Since string text is already properly escaped, we
    only need to replace True, False, and None in non-string text and
    remove any unicode 'u's preceding string values.

    if stripWhiteSpace is True, remove spaces, etc from the non-string
    text.
    """
    inSingleQuote = False
    inDoubleQuote = False
    #python will quote with " when there is a ' in the string,
    #so fix that first
    if redoublequotedstring.search(aString):
        aString = doQuotesSwapping(aString)
    marker = None
    if escapedSingleQuote in aString:
        #replace escaped single quotes with a marker
        marker = markerBase = '|'
        markerCount = 1
        while marker in aString:
            #if the marker is already there, make it different
            markerCount += 1
            marker = markerBase * markerCount
        aString = aString.replace(escapedSingleQuote,marker)

    #escape double-quotes
    aString = aString.replace('"',escapedDoubleQuote)
    #split the string on the real single-quotes
    splitStr = aString.split("'")
    outList = []
    alt = True
    for subStr in splitStr:
        #if alt is True, non-string; do replacements
        if alt:
            subStr = _handleCode(subStr,stripWhiteSpace)
        outList.append(subStr)
        alt = not alt
    result = '"'.join(outList)
    if marker:
        #put the escaped single-quotes back as "'"
        result = result.replace(marker,"'")
    return result

def write(obj, encoding="utf-8",stripWhiteSpace=alwaysStripWhiteSpace):
    """Represent the object as a string.  Do any necessary fix-ups
    with pyexpr2jsexpr"""
    try:
        #not really sure encode does anything here
        aString = str(obj).encode(encoding)
    except UnicodeEncodeError:
        aString = obj.encode(encoding)
    if isinstance(obj,basestring):
        if '"' in aString:
            aString = aString.replace(escapedDoubleQuote,'"')
            result = '"%s"' % aString.replace('"',escapedDoubleQuote)
        else:
            result = '"%s"' % aString
    else:
        result = _pyexpr2jsexpr(aString,stripWhiteSpace).encode(encoding)
    return result

class ReadException(Exception):
    pass

class WriteException(Exception):
    pass
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.