pyamf.amf3
index
/usr/local/lib/python2.7/dist-packages/pyamf/amf3.py

AMF3 implementation.
 
C{AMF3} is the default serialization for
U{ActionScript<http://en.wikipedia.org/wiki/ActionScript>} 3.0 and provides
various advantages over L{AMF0<pyamf.amf0>}, which is used for ActionScript 1.0
and 2.0. It adds support for sending C{int} and C{uint} objects as integers and
supports data types that are available only in ActionScript 3.0, such as
L{ByteArray} and L{ArrayCollection}.
 
@see: U{Official AMF3 Specification in English
<http://opensource.adobe.com/wiki/download/attachments/1114283/amf3_spec_05_05_08.pdf>}
@see: U{Official AMF3 Specification in Japanese
<http://opensource.adobe.com/wiki/download/attachments/1114283/JP_amf3_spec_121207.pdf>}
@see: U{AMF3 documentation on OSFlash
<http://osflash.org/documentation/amf3>}
 
@since: 0.1

 
Modules
       
pyamf.codec
datetime
pyamf
pyamf.python
pyamf.util
pyamf.xml
zlib

 
Classes
       
cpyamf.util.BufferedByteStream(cpyamf.util.cBufferedByteStream)
ByteArray(cpyamf.util.BufferedByteStream, DataInput, DataOutput)
DataInput(__builtin__.object)
ByteArray(cpyamf.util.BufferedByteStream, DataInput, DataOutput)
DataOutput(__builtin__.object)
ByteArray(cpyamf.util.BufferedByteStream, DataInput, DataOutput)
pyamf.codec.Context(__builtin__.object)
Context
pyamf.codec.Decoder(pyamf.codec._Codec)
Decoder
pyamf.codec.Encoder(pyamf.codec._Codec)
Encoder

 
class ByteArray(cpyamf.util.BufferedByteStream, DataInput, DataOutput)
    I am a C{StringIO} type object containing byte data from the AMF stream.
ActionScript 3.0 introduced the C{flash.utils.ByteArray} class to support
the manipulation of raw data in the form of an Array of bytes.
 
Supports C{zlib} compression.
 
Possible uses of the C{ByteArray} class:
 - Creating a custom protocol to connect to a client.
 - Writing your own AMF/Remoting packet.
 - Optimizing the size of your data by using custom data types.
 
@see: U{ByteArray on Adobe Help (external)
<http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/utils/ByteArray.html>}
 
 
Method resolution order:
ByteArray
cpyamf.util.BufferedByteStream
cpyamf.util.cBufferedByteStream
DataInput
DataOutput
__builtin__.object

Methods defined here:
__cmp__(self, other)
__init__(self, buf=None)
__str__(self)
compress(self)
Forces compression of the underlying stream.
readObject(self)
writeObject(self, obj)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__amf__ = <class pyamf.amf3.__amf__>

Methods inherited from cpyamf.util.BufferedByteStream:
__add__(...)
x.__add__(y) <==> x+y
__len__(...)
x.__len__() <==> len(x)
__radd__(...)
x.__radd__(y) <==> y+x
flush(...)
peek(...)
Looks C{size} bytes ahead in the stream, returning what it finds,
returning the stream pointer to its initial position.
 
@param size: Default is 1.
@type size: C{int}
 
@rtype:
@return: Bytes.
read(...)
Reads C{size} bytes from the stream.
read_double(...)
Reads an 8 byte float from the stream.
read_float(...)
Reads a 4 byte float from the stream.
write(...)
Writes the content of the specified C{x} into this buffer.
 
@param x:
@type x:
write_char(...)
Write a C{char} to the stream.
 
@param x: char
@type x: C{int}
@raise TypeError: Unexpected type for int C{x}.
write_double(...)
Writes an 8 byte float to the stream.
 
@param val: 8 byte float
@type val: C{float}
@raise TypeError: Unexpected type for float C{val}.
write_short(...)
Writes a 2 byte integer to the stream.
 
@param x: 2 byte integer
@type x: C{int}
@raise TypeError: Unexpected type for int C{x}.
write_ulong(...)
Writes a 4 byte unsigned integer to the stream.
 
@param x: 4 byte unsigned integer
@type x: C{int}
@raise TypeError: Unexpected type for int C{x}.
write_ushort(...)
Writes a 2 byte unsigned integer to the stream.
 
@param x: 2 byte unsigned integer
@type x: C{int}
@raise TypeError: Unexpected type for int C{x}.

Data descriptors inherited from cpyamf.util.BufferedByteStream:
endian

Data and other attributes inherited from cpyamf.util.BufferedByteStream:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__pyx_vtable__ = <capsule object NULL>

Methods inherited from cpyamf.util.cBufferedByteStream:
__nonzero__(...)
x.__nonzero__() <==> x != 0
append(...)
at_eof(...)
Returns C{True} if the internal pointer is at the end of the stream.
 
@rtype: C{bool}
consume(...)
Chops the tail off the stream starting at 0 and ending at C{tell()}.
The stream pointer is set to 0 at the end of this function.
getvalue(...)
Get raw data from buffer.
read_24bit_int(...)
Reads a 24 bit integer from the stream.
read_24bit_uint(...)
Reads a 24 bit unsigned integer from the stream.
read_char(...)
Reads a C{char} from the stream.
read_long(...)
Reads a 4 byte integer from the stream.
read_short(...)
Reads a 2 byte integer from the stream.
read_uchar(...)
Reads an C{unsigned char} from the stream.
read_ulong(...)
Reads a 4 byte unsigned integer from the stream.
read_ushort(...)
Reads a 2 byte unsigned integer from the stream.
read_utf8_string(...)
Reads a UTF-8 string from the stream.
 
@rtype: C{unicode}
remaining(...)
Returns number of remaining bytes.
seek(...)
Sets the file-pointer offset, measured from the beginning of this stream,
at which the next write operation will occur.
 
@param mode: mode 0: absolute; 1: relative; 2: relative to EOF
tell(...)
Returns the position of the stream pointer.
truncate(...)
Truncates the stream to the specified length.
 
@param size: The length of the stream, in bytes.
@type size: C{int}
write_24bit_int(...)
Writes a 24 bit integer to the stream.
 
@param ret: 24 bit integer
@type ret: C{int}
write_24bit_uint(...)
Writes a 24 bit unsigned integer to the stream.
 
@param ret: 24 bit unsigned integer
@type ret: C{int}
write_float(...)
Writes a 4 byte float to the stream.
 
@param c: 4 byte float
@type c: C{float}
write_long(...)
Writes a 4 byte integer to the stream.
 
@param ret: 4 byte integer
@type ret: C{int}
write_uchar(...)
Writes an C{unsigned char} to the stream.
 
@param ret: Unsigned char
@type ret: C{int}
write_utf8_string(...)
Writes a unicode object to the stream in UTF-8.
 
@param obj: unicode object
@raise TypeError: Unexpected type for str C{u}.

Methods inherited from DataInput:
readBoolean(self)
Read C{Boolean}.
 
@raise ValueError: Error reading Boolean.
@rtype: C{bool}
@return: A Boolean value, C{True} if the byte
is nonzero, C{False} otherwise.
readByte(self)
Reads a signed byte.
 
@rtype: C{int}
@return: The returned value is in the range -128 to 127.
readDouble(self)
Reads an IEEE 754 double-precision floating point number from the
data stream.
 
@rtype: C{number}
@return: An IEEE 754 double-precision floating point number.
readFloat(self)
Reads an IEEE 754 single-precision floating point number from the
data stream.
 
@rtype: C{number}
@return: An IEEE 754 single-precision floating point number.
readInt(self)
Reads a signed 32-bit integer from the data stream.
 
@rtype: C{int}
@return: The returned value is in the range -2147483648 to 2147483647.
readMultiByte(self, length, charset)
Reads a multibyte string of specified length from the data stream
using the specified character set.
 
@type length: C{int}
@param length: The number of bytes from the data stream to read.
@type charset: C{str}
@param charset: The string denoting the character set to use.
 
@rtype: C{str}
@return: UTF-8 encoded string.
readShort(self)
Reads a signed 16-bit integer from the data stream.
 
@rtype: C{uint}
@return: The returned value is in the range -32768 to 32767.
readUTF(self)
Reads a UTF-8 string from the data stream.
 
The string is assumed to be prefixed with an unsigned
short indicating the length in bytes.
 
@rtype: C{str}
@return: A UTF-8 string produced by the byte
representation of characters.
readUTFBytes(self, length)
Reads a sequence of C{length} UTF-8 bytes from the data
stream and returns a string.
 
@type length: C{int}
@param length: The number of bytes from the data stream to read.
@rtype: C{str}
@return: A UTF-8 string produced by the byte representation of
characters of specified C{length}.
readUnsignedByte(self)
Reads an unsigned byte from the data stream.
 
@rtype: C{uint}
@return: The returned value is in the range 0 to 255.
readUnsignedInt(self)
Reads an unsigned 32-bit integer from the data stream.
 
@rtype: C{uint}
@return: The returned value is in the range 0 to 4294967295.
readUnsignedShort(self)
Reads an unsigned 16-bit integer from the data stream.
 
@rtype: C{uint}
@return: The returned value is in the range 0 to 65535.

Methods inherited from DataOutput:
writeBoolean(self, value)
Writes a Boolean value.
 
@type value: C{bool}
@param value: A C{Boolean} value determining which byte is written.
If the parameter is C{True}, C{1} is written; if C{False}, C{0} is
written.
 
@raise ValueError: Non-boolean value found.
writeByte(self, value)
Writes a byte.
 
@type value: C{int}
writeDouble(self, value)
Writes an IEEE 754 double-precision (64-bit) floating
point number.
 
@type value: C{number}
writeFloat(self, value)
Writes an IEEE 754 single-precision (32-bit) floating
point number.
 
@type value: C{float}
writeInt(self, value)
Writes a 32-bit signed integer.
 
@type value: C{int}
writeMultiByte(self, value, charset)
Writes a multibyte string to the datastream using the
specified character set.
 
@type value: C{str}
@param value: The string value to be written.
@type charset: C{str}
@param charset: The string denoting the character set to use. Possible
    character set strings include C{shift-jis}, C{cn-gb},
    C{iso-8859-1} and others.
@see: U{Supported character sets on Adobe Help (external)
    <http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/charset-codes.html>}
writeShort(self, value)
Writes a 16-bit integer.
 
@type value: C{int}
@param value: A byte value as an integer.
writeUTF(self, value)
Writes a UTF-8 string to the data stream.
 
The length of the UTF-8 string in bytes is written first,
as a 16-bit integer, followed by the bytes representing the
characters of the string.
 
@type value: C{str}
@param value: The string value to be written.
writeUTFBytes(self, value)
Writes a UTF-8 string. Similar to L{writeUTF}, but does
not prefix the string with a 16-bit length word.
 
@type value: C{str}
@param value: The string value to be written.
writeUnsignedByte(self, value)
Writes an unsigned byte.
 
@type value: C{int}
@since: 0.5
writeUnsignedInt(self, value)
Writes a 32-bit unsigned integer.
 
@type value: C{int}
@param value: A byte value as an unsigned integer.
writeUnsignedShort(self, value)
Writes a 16-bit unsigned integer.
 
@type value: C{int}
@param value: A byte value as an integer.
@since: 0.5

 
class Context(pyamf.codec.Context)
    I hold the AMF3 context for en/decoding streams.
 
@ivar strings: A list of string references.
@type strings: L{codec.ByteStringReferenceCollection}
@ivar classes: A list of L{ClassDefinition}.
@type classes: C{list}
 
 
Method resolution order:
Context
pyamf.codec.Context
__builtin__.object

Methods defined here:
__init__(self, **kwargs)
addClass(self, alias, klass)
Creates a reference to C{class_def}.
 
@param alias: C{ClassDefinition} instance.
@type alias: C{ClassDefinition}
addProxyObject(self, obj, proxied)
Stores a reference to the unproxied and proxied versions of C{obj} for
later retrieval.
 
@since: 0.6
addString(self, s)
Creates a reference to C{s}. If the reference already exists, that
reference is returned.
 
@type s: C{str}
@param s: The string to be referenced.
@rtype: C{int}
@return: The reference index.
 
@raise TypeError: The parameter C{s} is not of C{basestring} type.
clear(self)
Clears the context.
getClass(self, klass)
Returns a class reference.
 
@return: Class reference.
getClassByReference(self, ref)
Return class reference.
 
@return: Class reference.
getObjectForProxy(self, proxy)
Returns the unproxied version of C{proxy} as stored in the context, or
unproxies the proxy and returns that 'raw' object.
 
@see: L{pyamf.flex.unproxy_object}
@since: 0.6
getProxyForObject(self, obj)
Returns the proxied version of C{obj} as stored in the context, or
creates a new proxied object and returns that.
 
@see: L{pyamf.flex.proxy_object}
@since: 0.6
getString(self, ref)
Gets a string based on a reference C{ref}.
 
@param ref: The reference index.
@type ref: C{str}
 
@rtype: C{str} or C{None}
@return: The referenced string.
getStringReference(self, s)
Return string reference.
 
@type s: C{str}
@param s: The referenced string.
@return: The reference index to the string.
@rtype: C{int} or C{None}

Methods inherited from pyamf.codec.Context:
addObject(self, obj)
Adds a reference to C{obj}.
 
@return: Reference to C{obj}.
@rtype: C{int}
getBytesForString(self, u)
Returns the corresponding utf-8 encoded string for a given unicode
object. If there is no string, one is encoded.
 
@since: 0.6
getClassAlias(self, klass)
Gets a class alias based on the supplied C{klass}. If one is not found
in the global context, one is created locally.
 
If you supply a string alias and the class is not registered,
L{pyamf.UnknownClassAlias} will be raised.
 
@param klass: A class object or string alias.
@return: The L{pyamf.ClassAlias} instance that describes C{klass}
getObject(self, ref)
Gets an object based on a reference.
 
@type ref: C{int}
@return: The referenced object or C{None} if not found.
getObjectReference(self, obj)
Gets a reference for an already referenced object.
 
@return: The reference to the object or C{-1} if the object is not in
    the context.
getStringForBytes(self, s)
Returns the corresponding string for the supplied utf-8 encoded bytes.
If there is no string object, one is created.
 
@since: 0.6

Data descriptors inherited from pyamf.codec.Context:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Decoder(pyamf.codec.Decoder)
    Decodes an AMF3 data stream.
 
 
Method resolution order:
Decoder
pyamf.codec.Decoder
pyamf.codec._Codec
__builtin__.object

Methods defined here:
__init__(self, *args, **kwargs)
buildContext(self, **kwargs)
getTypeFunc(self, data)
readArray(self)
Reads an array from the stream.
 
@warning: There is a very specific problem with AMF3 where the first
three bytes of an encoded empty C{dict} will mirror that of an encoded
C{{'': 1, '2': 2}}
readBoolFalse(self)
Returns C{False}.
 
@return: C{False}
@rtype: C{bool}
readBoolTrue(self)
Returns C{True}.
 
@return: C{True}
@rtype: C{bool}
readByteArray(self)
Reads a string of data from the stream.
 
Detects if the L{ByteArray} was compressed using C{zlib}.
 
@see: L{ByteArray}
@note: This is not supported in ActionScript 1.0 and 2.0.
readBytes(self)
Reads and returns a utf-8 encoded byte array.
readDate(self)
Read date from the stream.
 
The timezone is ignored as the date is always in UTC.
readInteger(self, signed=True)
Reads and returns an integer from the stream.
 
@type signed: C{bool}
@see: U{Parsing integers on OSFlash
<http://osflash.org/amf3/parsing_integers>} for the AMF3 integer data
format.
readNull(self)
Read null.
 
@return: C{None}
@rtype: C{None}
readNumber(self)
Read number.
readObject(self)
Reads an object from the stream.
 
@raise ReferenceError: Unknown reference found.
@raise DecodeError: Unknown object encoding detected.
readProxy(self, obj)
Decodes a proxied object from the stream.
 
@since: 0.6
readString(self)
Reads and returns a string from the stream.
readUndefined(self)
Read undefined.
readXML(self)
Reads an xml object from the stream.
 
@return: An etree interface compatible object
@see: L{xml.set_default_interface}
readXMLString(self)
Reads a string from the data stream and converts it into
an XML Tree.
 
@see: L{readXML}

Methods inherited from pyamf.codec.Decoder:
__iter__(self)
finalise(self, payload)
Finalise the payload.
 
This provides a useful hook to adapters to modify the payload that was
decoded.
 
Note that this is an advanced feature and is NOT directly called by the
decoder.
next(self)
Part of the iterator protocol.
readElement(self)
Reads an AMF3 element from the data stream.
 
@raise DecodeError: The ActionScript type is unsupported.
@raise EOStream: No more data left to decode.
send(self, data)
Add data for the decoder to work on.

Data descriptors inherited from pyamf.codec._Codec:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Encoder(pyamf.codec.Encoder)
    Encodes an AMF3 data stream.
 
 
Method resolution order:
Encoder
pyamf.codec.Encoder
pyamf.codec._Codec
__builtin__.object

Methods defined here:
__init__(self, *args, **kwargs)
buildContext(self, **kwargs)
getTypeFunc(self, data)
@see: L{codec.Encoder.getTypeFunc}
serialiseBytes(self, b)
serialiseString(self, s)
Writes a raw string to the stream.
 
@type   s: C{str}
@param  s: The string data to be encoded to the AMF3 data stream.
writeBoolean(self, n)
Writes a Boolean to the stream.
writeByteArray(self, n)
Writes a L{ByteArray} to the data stream.
 
@param n: The L{ByteArray} data to be encoded to the AMF3 data stream.
@type n: L{ByteArray}
writeBytes(self, b)
Writes a raw string to the stream.
writeDate(self, n)
Writes a C{datetime} instance to the stream.
 
Does not support C{datetime.time} instances because AMF3 has
no way to encode time objects, so please use C{datetime.datetime}
instead.
 
@type n: L{datetime}
@param n: The C{Date} data to be encoded to the AMF3 data stream.
@raise EncodeError: A datetime.time instance was found
writeDict(self, n)
Writes a C{dict} to the stream.
 
@type n: C{__builtin__.dict}
@param n: The C{dict} data to be encoded to the AMF3 data stream.
@raise ValueError: Non C{int}/C{str} key value found in the C{dict}
@raise EncodeError: C{dict} contains empty string keys.
writeInteger(self, n)
Writes an integer to the stream.
 
@type   n: integer data
@param  n: The integer data to be encoded to the AMF3 data stream.
writeList(self, n, is_proxy=False)
Writes a C{tuple}, C{set} or C{list} to the stream.
 
@type n: One of C{__builtin__.tuple}, C{__builtin__.set}
    or C{__builtin__.list}
@param n: The C{list} data to be encoded to the AMF3 data stream.
writeNull(self, n)
Writes a C{null} value to the stream.
writeNumber(self, n)
Writes a float to the stream.
 
@type n: C{float}
writeObject(self, obj, is_proxy=False)
Writes an object to the stream.
writeProxy(self, obj)
Encodes a proxied object to the stream.
 
@since: 0.6
writeString(self, s)
Writes a string to the stream. It will be B{UTF-8} encoded.
writeUndefined(self, n)
Writes an C{pyamf.Undefined} value to the stream.
writeXML(self, n)
Writes a XML string to the data stream.
 
@type   n: L{ET<xml.ET>}
@param  n: The XML Document to be encoded to the AMF3 data stream.

Methods inherited from pyamf.codec.Encoder:
__iter__(self)
next(self)
send(self, element)
writeElement(self, data)
Encodes C{data} to AMF. If the data is not able to be matched to an AMF
type, then L{pyamf.EncodeError} will be raised.
writeGenerator(self, gen)
Iterates over a generator object and encodes all that is returned.
writeSequence(self, iterable)
Encodes an iterable. The default is to write If the iterable has an al

Data descriptors inherited from pyamf.codec._Codec:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Data
        __all__ = ['ByteArray', 'Context', 'Encoder', 'Decoder', 'use_proxies_default']
use_proxies_default = False