robofab.plistlib
index
/code/projects/robofab/Lib/robofab/plistlib.py

plistlib.py -- a tool to generate and parse MacOSX .plist files.
 
The PropertList (.plist) file format is a simple XML pickle supporting
basic object types, like dictionaries, lists, numbers and strings.
Usually the top level object is a dictionary.
 
To write out a plist file, use the writePlist(rootObject, pathOrFile)
function. 'rootObject' is the top level object, 'pathOrFile' is a
filename or a (writable) file object.
 
To parse a plist from a file, use the readPlist(pathOrFile) function,
with a file name or a (readable) file object as the only argument. It
returns the top level object (again, usually a dictionary).
 
To work with plist data in strings, you can use readPlistFromString()
and writePlistToString().
 
Values can be strings, integers, floats, booleans, tuples, lists,
dictionaries, Data or datetime.datetime objects. String values (including
dictionary keys) may be unicode strings -- they will be written out as
UTF-8.
 
The <data> plist type is supported through the Data class. This is a
thin wrapper around a Python string.
 
Generate Plist example:
 
    pl = dict(
        aString="Doodah",
        aList=["A", "B", 12, 32.1, [1, 2, 3]],
        aFloat = 0.1,
        anInt = 728,
        aDict=dict(
            anotherString="<hello & hi there!>",
            aUnicodeValue=u'Mässig, Maß',
            aTrueValue=True,
            aFalseValue=False,
        ),
        someData = Data("<binary gunk>"),
        someMoreData = Data("<lots of binary gunk>" * 10),
        aDate = datetime.fromtimestamp(time.mktime(time.gmtime())),
    )
    # unicode keys are possible, but a little awkward to use:
    pl[u'Åbenraa'] = "That was a unicode key."
    writePlist(pl, fileName)
 
Parse Plist example:
 
    pl = readPlist(pathOrFile)
    print pl["aKey"]

 
Modules
       
binascii
re
sys

 
Classes
       
Data
DumbXMLWriter
PlistWriter
PlistParser
_InternalDict(__builtin__.dict)
Dict
Plist

 
class Data
    Wrapper for binary data.
 
  Methods defined here:
__cmp__(self, other)
__init__(self, data)
__repr__(self)
asBase64(self, maxlinelength=76)

Class methods defined here:
fromBase64(cls, data) from __builtin__.classobj

 
class Dict(_InternalDict)
    
Method resolution order:
Dict
_InternalDict
__builtin__.dict
__builtin__.object

Methods defined here:
__init__(self, **kwargs)

Methods inherited from _InternalDict:
__delattr__(self, attr)
__getattr__(self, attr)
__setattr__(self, attr, value)

Data and other attributes inherited from _InternalDict:
__dict__ = <dictproxy object at 0x13ec2d0>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of '_InternalDict' objects>
list of weak references to the object (if defined)

Methods inherited from __builtin__.dict:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
clear(...)
D.clear() -> None.  Remove all items from D.
copy(...)
D.copy() -> a shallow copy of D
get(...)
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
has_key(...)
D.has_key(k) -> True if D has a key k, else False
items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples
iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D
iterkeys(...)
D.iterkeys() -> an iterator over the keys of D
itervalues(...)
D.itervalues() -> an iterator over the values of D
keys(...)
D.keys() -> list of D's keys
pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value
If key is not found, d is returned if given, otherwise KeyError is raised
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty
setdefault(...)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
update(...)
D.update(E) -> None.  Update D from E: for k in E.keys(): D[k] = E[k]
values(...)
D.values() -> list of D's values

Data and other attributes inherited from __builtin__.dict:
__new__ = <built-in method __new__ of type object at 0xa866d054>
T.__new__(S, ...) -> a new object with type S, a subtype of T
fromkeys = <built-in method fromkeys of type object at 0x115e340>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.

 
class DumbXMLWriter
     Methods defined here:
__init__(self, file, indentLevel=0, indent='\t')
beginElement(self, element)
endElement(self, element)
simpleElement(self, element, value=None)
writeln(self, line)

 
class Plist(_InternalDict)
    This class has been deprecated. Use readPlist() and writePlist()
functions instead, together with regular dict objects.
 
 
Method resolution order:
Plist
_InternalDict
__builtin__.dict
__builtin__.object

Methods defined here:
__init__(self, **kwargs)
write(self, pathOrFile)
Deprecated. Use the writePlist() function instead.

Class methods defined here:
fromFile(cls, pathOrFile) from __builtin__.type
Deprecated. Use the readPlist() function instead.

Methods inherited from _InternalDict:
__delattr__(self, attr)
__getattr__(self, attr)
__setattr__(self, attr, value)

Data and other attributes inherited from _InternalDict:
__dict__ = <dictproxy object at 0x13ec590>
dictionary for instance variables (if defined)
__weakref__ = <attribute '__weakref__' of '_InternalDict' objects>
list of weak references to the object (if defined)

Methods inherited from __builtin__.dict:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
clear(...)
D.clear() -> None.  Remove all items from D.
copy(...)
D.copy() -> a shallow copy of D
get(...)
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
has_key(...)
D.has_key(k) -> True if D has a key k, else False
items(...)
D.items() -> list of D's (key, value) pairs, as 2-tuples
iteritems(...)
D.iteritems() -> an iterator over the (key, value) items of D
iterkeys(...)
D.iterkeys() -> an iterator over the keys of D
itervalues(...)
D.itervalues() -> an iterator over the values of D
keys(...)
D.keys() -> list of D's keys
pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value
If key is not found, d is returned if given, otherwise KeyError is raised
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty
setdefault(...)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
update(...)
D.update(E) -> None.  Update D from E: for k in E.keys(): D[k] = E[k]
values(...)
D.values() -> list of D's values

Data and other attributes inherited from __builtin__.dict:
__new__ = <built-in method __new__ of type object at 0xa866d054>
T.__new__(S, ...) -> a new object with type S, a subtype of T
fromkeys = <built-in method fromkeys of type object at 0x115e510>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.

 
class PlistParser
     Methods defined here:
__init__(self)
addObject(self, value)
begin_array(self, attrs)
begin_dict(self, attrs)
end_array(self)
end_data(self)
end_date(self)
end_dict(self)
end_false(self)
end_integer(self)
end_key(self)
end_real(self)
end_string(self)
end_true(self)
getData(self)
handleBeginElement(self, element, attrs)
handleData(self, data)
handleEndElement(self, element)
parse(self, fileobj)

 
class PlistWriter(DumbXMLWriter)
     Methods defined here:
__init__(self, file, indentLevel=0, indent='\t', writeHeader=1)
writeArray(self, array)
writeData(self, data)
writeDict(self, d)
writeValue(self, value)

Methods inherited from DumbXMLWriter:
beginElement(self, element)
endElement(self, element)
simpleElement(self, element, value=None)
writeln(self, line)

 
Functions
       
StringIO(...)
StringIO([s]) -- Return a StringIO-like stream for reading or writing
readPlist(pathOrFile)
Read a .plist file. 'pathOrFile' may either be a file name or a
(readable) file object. Return the unpacked root object (which
usually is a dictionary).
readPlistFromResource(path, restype='plst', resid=0)
Read plst resource from the resource fork of path.
readPlistFromString(data)
Read a plist data from a string. Return the root object.
writePlist(rootObject, pathOrFile)
Write 'rootObject' to a .plist file. 'pathOrFile' may either be a
file name or a (writable) file object.
writePlistToResource(rootObject, path, restype='plst', resid=0)
Write 'rootObject' as a plst resource to the resource fork of path.
writePlistToString(rootObject)
Return 'rootObject' as a plist-formatted string.

 
Data
        PLISTHEADER = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE...http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
__all__ = ['readPlist', 'writePlist', 'readPlistFromString', 'writePlistToString', 'readPlistFromResource', 'writePlistToResource', 'Plist', 'Data', 'Dict']