Py3AMF 0.8.9__tar.gz → 0.9.0__tar.gz

{Py3AMF-0.8.9 → py3amf-0.9.0}/CHANGES.txt

@@ -2,9 +2,50 @@ Changelog
 =========
 
 This document contains information about the changes between the different
-versions of PyAMF.
+versions of Py3AMF.
 
 .. contents::
+0.9.0 (2026-07-03)
+------------------
+- Test CPython 3.11 through 3.14 while keeping installation open for older
+  Python 3 versions where possible.
+- Keep AMF0, AMF3, core remoting, the WSGI gateway, and the pure Python
+  runtime path as the supported 0.9.0 surface.
+- Keep ``pyamf.adapters`` helper modules available, while removing legacy
+  framework adapter and gateway tests from the default suite.
+- Drop official support for Jython and Cython extension builds. Existing
+  Cython sources remain in the source tree for compatibility and reference,
+  but Cython is no longer installed as a development dependency and extension
+  builds are disabled during installation.
+- Drop official support for Twisted, Django, and Google App Engine gateway
+  integrations.
+- Drop official support for Django, SQLAlchemy, Elixir, and Google App Engine
+  adapter integrations. Existing adapter modules remain available as helper
+  and legacy modules, but framework-specific object conversion should happen
+  at the application layer.
+- Split runtime and full test dependencies into ``requirements.txt`` and
+  ``test-requirements.txt``.
+- Remove deprecated setuptools ``test_suite`` and ``tests_require`` metadata,
+  and remove the deprecated license classifier.
+- Add PEP 517 build metadata and fix source distribution metadata so runtime
+  dependencies are installed correctly from both wheels and sdists.
+- Add GitHub Actions coverage for the supported CPython 3.11 through 3.14
+  test matrix.
+- Refresh installation, architecture, community, and tutorial documentation to
+  advertise only the supported 0.9.0 runtime surface.
+
+0.8.12 (2024-01-23)
+----------------
+- Support dictionary
+
+0.8.11 (2022-02-25)
+----------------
+- Change str to binary 
+- Fix syntax errors
+
+0.8.10 (2020-01-10)
+----------------
+- Support Python 3.7 and 3.8
 
 0.8.9 (2018-07-18)
 ----------------

{Py3AMF-0.8.9 → py3amf-0.9.0}/MANIFEST.in

@@ -4,6 +4,8 @@ prune doc/build
 prune doc/_build
 include setupinfo.py
 include *.txt
-include *.md
+global-exclude *.md
 global-exclude *.swf
 global-exclude *.pyc
+include cpyamf/*.pyx
+include cpyamf/*.pxd

py3amf-0.9.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: Py3AMF
+Version: 0.9.0
+Summary: AMF support for Python
+Home-page: https://github.com/StdCarrot/Py3AMF
+Author: The Py3AMF Project
+Author-email: yhbu@stdc.so
+License: MIT License
+Keywords: python3 amf amf0 amf3 flex flash remoting rpc http flashplayer air bytearray objectproxy arraycollection recordset actionscript decoder encoder gateway wsgi remoteobject sharedobject lso sol
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 5 - Production/Stable
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: defusedxml>=0.7.1
+Provides-Extra: lxml
+Requires-Dist: lxml>=6.1.1; extra == "lxml"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+Py3AMF
+======
+
+Py3AMF is a Python 3 fork of
+`PyAMF <https://github.com/hydralabs/pyamf>`__. It provides Action
+Message Format (AMF0 and AMF3) encoding, decoding, and remoting support
+for Python applications.
+
+Current support
+~~~~~~~~~~~~~~~
+
+The 0.9.0 release line keeps the supported surface small and focused:
+
+- CPython 3.11, 3.12, 3.13, and 3.14 are tested with the
+  ``python:3.11-slim``, ``python:3.12-slim``, ``python:3.13-slim``, and
+  ``python:3.14-slim`` container images.
+- Older Python 3 versions are not intentionally blocked, but they are not
+  part of the active test matrix.
+- AMF0, AMF3, core remoting, the WSGI gateway, and pure Python runtime
+  code are supported.
+- ``pyamf.adapters`` remains available as helper and compatibility
+  modules.
+- Jython, Cython extension builds, framework gateways, and automatic
+  conversion of third-party framework models are no longer officially
+  supported.
+
+Applications should convert framework-specific objects at the application
+layer before passing data to Py3AMF.
+
+Install
+~~~~~~~
+
+Install the released package with pip:
+
+::
+
+   python -m pip install Py3AMF
+
+For local development:
+
+::
+
+   git clone git@github.com:StdCarrot/Py3AMF.git
+   cd Py3AMF
+   python -m pip install -r test-requirements.txt
+   python -c "import pyamf.tests; pyamf.tests.main()"
+   python -m pip install .
+
+Simple example
+~~~~~~~~~~~~~~
+
+Everything is same with PyAMF, but you have to concern str and bytes
+types.
+
+::
+
+   import pyamf
+   from pyamf import remoting
+   from pyamf.flex import messaging
+   import uuid
+   import requests
+
+   msg = messaging.RemotingMessage(operation='retrieveUser',
+                                   destination='so.stdc.flexact.common.User',
+                                   messageId=str(uuid.uuid4()).upper(),
+                                   body=['user_id'])
+   req = remoting.Request(target='UserService', body=[msg])
+   ev = remoting.Envelope(pyamf.AMF3)
+   ev['/0'] = req
+
+   # Encode request
+   bin_msg = remoting.encode(ev)
+
+   # Send request; You can use other channels like RTMP
+   resp = requests.post('http://example.com/amf',
+                        data=bin_msg.getvalue(),
+                        headers={'Content-Type': 'application/x-amf'})
+
+   # Decode response
+   resp_msg = remoting.decode(resp.content)
+   print(resp_msg.bodies)
+
+--------------
+
+`Action Message Format
+<http://en.wikipedia.org/wiki/Action_Message_Format>`__ is a compact
+binary format used by Adobe Flash Player and Adobe AIR applications.
+Py3AMF keeps the AMF codec and WSGI remoting pieces current for modern
+Python 3 runtimes.
+
+The `Adobe Integrated
+Runtime <http://en.wikipedia.org/wiki/Adobe_AIR>`__ and `Adobe Flash
+Player <http://en.wikipedia.org/wiki/Flash_Player>`__ use AMF to
+communicate between an application and a remote server. AMF encodes
+remote procedure calls (RPC) into a compact binary representation that
+can be transferred over HTTP/HTTPS or the
+`RTMP/RTMPS <http://en.wikipedia.org/wiki/Real_Time_Messaging_Protocol>`__
+protocol. Objects and data values are serialized into this binary
+format, which increases performance, allowing applications to load data
+up to 10 times faster than with text-based formats such as XML or SOAP.
+
+AMF3, the default serialization for ActionScript 3.0, provides various
+advantages over AMF0, which is used for ActionScript 1.0 and 2.0. AMF3
+sends data over the network more efficiently than AMF0. AMF3 supports
+sending ``int`` and ``uint`` objects as integers and supports data types
+that are available only in ActionScript 3.0, such as ``ByteArray``,
+``ArrayCollection``, ``ObjectProxy``, and ``IExternalizable``.

py3amf-0.9.0/Py3AMF.egg-info/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: Py3AMF
+Version: 0.9.0
+Summary: AMF support for Python
+Home-page: https://github.com/StdCarrot/Py3AMF
+Author: The Py3AMF Project
+Author-email: yhbu@stdc.so
+License: MIT License
+Keywords: python3 amf amf0 amf3 flex flash remoting rpc http flashplayer air bytearray objectproxy arraycollection recordset actionscript decoder encoder gateway wsgi remoteobject sharedobject lso sol
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 5 - Production/Stable
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: defusedxml>=0.7.1
+Provides-Extra: lxml
+Requires-Dist: lxml>=6.1.1; extra == "lxml"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+Py3AMF
+======
+
+Py3AMF is a Python 3 fork of
+`PyAMF <https://github.com/hydralabs/pyamf>`__. It provides Action
+Message Format (AMF0 and AMF3) encoding, decoding, and remoting support
+for Python applications.
+
+Current support
+~~~~~~~~~~~~~~~
+
+The 0.9.0 release line keeps the supported surface small and focused:
+
+- CPython 3.11, 3.12, 3.13, and 3.14 are tested with the
+  ``python:3.11-slim``, ``python:3.12-slim``, ``python:3.13-slim``, and
+  ``python:3.14-slim`` container images.
+- Older Python 3 versions are not intentionally blocked, but they are not
+  part of the active test matrix.
+- AMF0, AMF3, core remoting, the WSGI gateway, and pure Python runtime
+  code are supported.
+- ``pyamf.adapters`` remains available as helper and compatibility
+  modules.
+- Jython, Cython extension builds, framework gateways, and automatic
+  conversion of third-party framework models are no longer officially
+  supported.
+
+Applications should convert framework-specific objects at the application
+layer before passing data to Py3AMF.
+
+Install
+~~~~~~~
+
+Install the released package with pip:
+
+::
+
+   python -m pip install Py3AMF
+
+For local development:
+
+::
+
+   git clone git@github.com:StdCarrot/Py3AMF.git
+   cd Py3AMF
+   python -m pip install -r test-requirements.txt
+   python -c "import pyamf.tests; pyamf.tests.main()"
+   python -m pip install .
+
+Simple example
+~~~~~~~~~~~~~~
+
+Everything is same with PyAMF, but you have to concern str and bytes
+types.
+
+::
+
+   import pyamf
+   from pyamf import remoting
+   from pyamf.flex import messaging
+   import uuid
+   import requests
+
+   msg = messaging.RemotingMessage(operation='retrieveUser',
+                                   destination='so.stdc.flexact.common.User',
+                                   messageId=str(uuid.uuid4()).upper(),
+                                   body=['user_id'])
+   req = remoting.Request(target='UserService', body=[msg])
+   ev = remoting.Envelope(pyamf.AMF3)
+   ev['/0'] = req
+
+   # Encode request
+   bin_msg = remoting.encode(ev)
+
+   # Send request; You can use other channels like RTMP
+   resp = requests.post('http://example.com/amf',
+                        data=bin_msg.getvalue(),
+                        headers={'Content-Type': 'application/x-amf'})
+
+   # Decode response
+   resp_msg = remoting.decode(resp.content)
+   print(resp_msg.bodies)
+
+--------------
+
+`Action Message Format
+<http://en.wikipedia.org/wiki/Action_Message_Format>`__ is a compact
+binary format used by Adobe Flash Player and Adobe AIR applications.
+Py3AMF keeps the AMF codec and WSGI remoting pieces current for modern
+Python 3 runtimes.
+
+The `Adobe Integrated
+Runtime <http://en.wikipedia.org/wiki/Adobe_AIR>`__ and `Adobe Flash
+Player <http://en.wikipedia.org/wiki/Flash_Player>`__ use AMF to
+communicate between an application and a remote server. AMF encodes
+remote procedure calls (RPC) into a compact binary representation that
+can be transferred over HTTP/HTTPS or the
+`RTMP/RTMPS <http://en.wikipedia.org/wiki/Real_Time_Messaging_Protocol>`__
+protocol. Objects and data values are serialized into this binary
+format, which increases performance, allowing applications to load data
+up to 10 times faster than with text-based formats such as XML or SOAP.
+
+AMF3, the default serialization for ActionScript 3.0, provides various
+advantages over AMF0, which is used for ActionScript 1.0 and 2.0. AMF3
+sends data over the network more efficiently than AMF0. AMF3 supports
+sending ``int`` and ``uint`` objects as integers and supports data types
+that are available only in ActionScript 3.0, such as ``ByteArray``,
+``ArrayCollection``, ``ObjectProxy``, and ``IExternalizable``.

{Py3AMF-0.8.9 → py3amf-0.9.0}/Py3AMF.egg-info/SOURCES.txt

@@ -1,11 +1,13 @@
 CHANGES.txt
 LICENSE.txt
 MANIFEST.in
-README.md
+README.rst
+pyproject.toml
 requirements.txt
 setup.cfg
 setup.py
 setupinfo.py
+test-requirements.txt
 Py3AMF.egg-info/PKG-INFO
 Py3AMF.egg-info/SOURCES.txt
 Py3AMF.egg-info/dependency_links.txt
@@ -13,16 +15,12 @@ Py3AMF.egg-info/not-zip-safe
 Py3AMF.egg-info/requires.txt
 Py3AMF.egg-info/top_level.txt
 cpyamf/__init__.py
-cpyamf/amf0.c
 cpyamf/amf0.pxd
 cpyamf/amf0.pyx
-cpyamf/amf3.c
 cpyamf/amf3.pxd
 cpyamf/amf3.pyx
-cpyamf/codec.c
 cpyamf/codec.pxd
 cpyamf/codec.pyx
-cpyamf/util.c
 cpyamf/util.pxd
 cpyamf/util.pyx
 doc/Makefile
@@ -499,6 +497,7 @@ pyamf/tests/test_gateway.py
 pyamf/tests/test_imports.py
 pyamf/tests/test_remoting.py
 pyamf/tests/test_sol.py
+pyamf/tests/test_suite.py
 pyamf/tests/test_util.py
 pyamf/tests/test_versions.py
 pyamf/tests/test_xml.py

py3amf-0.9.0/Py3AMF.egg-info/requires.txt

@@ -0,0 +1,4 @@
+defusedxml>=0.7.1
+
+[lxml]
+lxml>=6.1.1

py3amf-0.9.0/README.rst

@@ -0,0 +1,107 @@
+Py3AMF
+======
+
+Py3AMF is a Python 3 fork of
+`PyAMF <https://github.com/hydralabs/pyamf>`__. It provides Action
+Message Format (AMF0 and AMF3) encoding, decoding, and remoting support
+for Python applications.
+
+Current support
+~~~~~~~~~~~~~~~
+
+The 0.9.0 release line keeps the supported surface small and focused:
+
+- CPython 3.11, 3.12, 3.13, and 3.14 are tested with the
+  ``python:3.11-slim``, ``python:3.12-slim``, ``python:3.13-slim``, and
+  ``python:3.14-slim`` container images.
+- Older Python 3 versions are not intentionally blocked, but they are not
+  part of the active test matrix.
+- AMF0, AMF3, core remoting, the WSGI gateway, and pure Python runtime
+  code are supported.
+- ``pyamf.adapters`` remains available as helper and compatibility
+  modules.
+- Jython, Cython extension builds, framework gateways, and automatic
+  conversion of third-party framework models are no longer officially
+  supported.
+
+Applications should convert framework-specific objects at the application
+layer before passing data to Py3AMF.
+
+Install
+~~~~~~~
+
+Install the released package with pip:
+
+::
+
+   python -m pip install Py3AMF
+
+For local development:
+
+::
+
+   git clone git@github.com:StdCarrot/Py3AMF.git
+   cd Py3AMF
+   python -m pip install -r test-requirements.txt
+   python -c "import pyamf.tests; pyamf.tests.main()"
+   python -m pip install .
+
+Simple example
+~~~~~~~~~~~~~~
+
+Everything is same with PyAMF, but you have to concern str and bytes
+types.
+
+::
+
+   import pyamf
+   from pyamf import remoting
+   from pyamf.flex import messaging
+   import uuid
+   import requests
+
+   msg = messaging.RemotingMessage(operation='retrieveUser',
+                                   destination='so.stdc.flexact.common.User',
+                                   messageId=str(uuid.uuid4()).upper(),
+                                   body=['user_id'])
+   req = remoting.Request(target='UserService', body=[msg])
+   ev = remoting.Envelope(pyamf.AMF3)
+   ev['/0'] = req
+
+   # Encode request
+   bin_msg = remoting.encode(ev)
+
+   # Send request; You can use other channels like RTMP
+   resp = requests.post('http://example.com/amf',
+                        data=bin_msg.getvalue(),
+                        headers={'Content-Type': 'application/x-amf'})
+
+   # Decode response
+   resp_msg = remoting.decode(resp.content)
+   print(resp_msg.bodies)
+
+--------------
+
+`Action Message Format
+<http://en.wikipedia.org/wiki/Action_Message_Format>`__ is a compact
+binary format used by Adobe Flash Player and Adobe AIR applications.
+Py3AMF keeps the AMF codec and WSGI remoting pieces current for modern
+Python 3 runtimes.
+
+The `Adobe Integrated
+Runtime <http://en.wikipedia.org/wiki/Adobe_AIR>`__ and `Adobe Flash
+Player <http://en.wikipedia.org/wiki/Flash_Player>`__ use AMF to
+communicate between an application and a remote server. AMF encodes
+remote procedure calls (RPC) into a compact binary representation that
+can be transferred over HTTP/HTTPS or the
+`RTMP/RTMPS <http://en.wikipedia.org/wiki/Real_Time_Messaging_Protocol>`__
+protocol. Objects and data values are serialized into this binary
+format, which increases performance, allowing applications to load data
+up to 10 times faster than with text-based formats such as XML or SOAP.
+
+AMF3, the default serialization for ActionScript 3.0, provides various
+advantages over AMF0, which is used for ActionScript 1.0 and 2.0. AMF3
+sends data over the network more efficiently than AMF0. AMF3 supports
+sending ``int`` and ``uint`` objects as integers and supports data types
+that are available only in ActionScript 3.0, such as ``ByteArray``,
+``ArrayCollection``, ``ObjectProxy``, and ``IExternalizable``.

{Py3AMF-0.8.9 → py3amf-0.9.0}/cpyamf/amf0.pyx

@@ -6,7 +6,6 @@ C-extension for L{pyamf.amf3} Python module in L{PyAMF<pyamf>}.
 
 :since: 0.6
 """
-
 from cpython cimport *
 from libc.stdlib cimport *
 from libc.string cimport *
@@ -20,24 +19,24 @@ import pyamf
 from pyamf import xml, util
 
 
-cdef char TYPE_NUMBER      = '\x00'
-cdef char TYPE_BOOL        = '\x01'
-cdef char TYPE_STRING      = '\x02'
-cdef char TYPE_OBJECT      = '\x03'
-cdef char TYPE_MOVIECLIP   = '\x04'
-cdef char TYPE_NULL        = '\x05'
-cdef char TYPE_UNDEFINED   = '\x06'
-cdef char TYPE_REFERENCE   = '\x07'
-cdef char TYPE_MIXEDARRAY  = '\x08'
-cdef char TYPE_OBJECTTERM  = '\x09'
-cdef char TYPE_ARRAY       = '\x0A'
-cdef char TYPE_DATE        = '\x0B'
-cdef char TYPE_LONGSTRING  = '\x0C'
-cdef char TYPE_UNSUPPORTED = '\x0D'
-cdef char TYPE_RECORDSET   = '\x0E'
-cdef char TYPE_XML         = '\x0F'
-cdef char TYPE_TYPEDOBJECT = '\x10'
-cdef char TYPE_AMF3        = '\x11'
+cdef char TYPE_NUMBER      = b'\x00'
+cdef char TYPE_BOOL        = b'\x01'
+cdef char TYPE_STRING      = b'\x02'
+cdef char TYPE_OBJECT      = b'\x03'
+cdef char TYPE_MOVIECLIP   = b'\x04'
+cdef char TYPE_NULL        = b'\x05'
+cdef char TYPE_UNDEFINED   = b'\x06'
+cdef char TYPE_REFERENCE   = b'\x07'
+cdef char TYPE_MIXEDARRAY  = b'\x08'
+cdef char TYPE_OBJECTTERM  = b'\x09'
+cdef char TYPE_ARRAY       = b'\x0A'
+cdef char TYPE_DATE        = b'\x0B'
+cdef char TYPE_LONGSTRING  = b'\x0C'
+cdef char TYPE_UNSUPPORTED = b'\x0D'
+cdef char TYPE_RECORDSET   = b'\x0E'
+cdef char TYPE_XML         = b'\x0F'
+cdef char TYPE_TYPEDOBJECT = b'\x10'
+cdef char TYPE_AMF3        = b'\x11'
 
 
 cdef object ASObject = pyamf.ASObject
@@ -122,7 +121,7 @@ cdef class Decoder(codec.Decoder):
 
                 break
 
-            key = self.readBytes()
+            key = self.readString()
 
             PyDict_SetItem(obj_attrs, key, self.readElement())
 
@@ -181,7 +180,7 @@ cdef class Decoder(codec.Decoder):
 
         self.readObjectAttributes(attrs)
 
-        for key, value in attrs.iteritems():
+        for key, value in attrs.items():
             try:
                 key = int(key)
             except ValueError:
@@ -229,7 +228,7 @@ cdef class Decoder(codec.Decoder):
         l = self.stream.read_ulong()
 
         self.stream.read(&b, l)
-        s = PyString_FromStringAndSize(b, <Py_ssize_t>l)
+        s = PyBytes_FromStringAndSize(b, <Py_ssize_t>l)
 
         if bytes:
             return s
@@ -329,9 +328,9 @@ cdef class Encoder(codec.Encoder):
         self.writeType(TYPE_BOOL)
 
         if b is True:
-            return self.writeType('\x01')
+            return self.writeType(b'\x01')
         else:
-            return self.writeType('\x00')
+            return self.writeType(b'\x00')
 
     cdef int writeUndefined(self, data) except -1:
         return self.writeType(TYPE_UNDEFINED)
@@ -387,6 +386,28 @@ cdef class Encoder(codec.Encoder):
 
         return 0
 
+    cdef int writeSet(self, object a) except -1:
+        cdef Py_ssize_t size = -1, i = -1
+
+        if self.writeReference(a) != -1:
+            return 0
+
+        self.context.addObject(a)
+
+        self.writeType(TYPE_ARRAY)
+        size = PySet_GET_SIZE(a)
+
+        self.stream.write_ulong(size)
+
+        set_iter = iter(a)
+        while True:
+            try:
+                self.writeElement(next(set_iter))
+            except StopIteration:
+                break
+
+        return 0
+
     cdef int writeInt(self, object a) except -1:
         self.writeType(TYPE_NUMBER)
 
@@ -406,7 +427,7 @@ cdef class Encoder(codec.Encoder):
         """
         Write a string of bytes to the data stream.
         """
-        cdef Py_ssize_t l = PyString_GET_SIZE(s)
+        cdef Py_ssize_t l = PyBytes_GET_SIZE(s)
 
         if l > 0xffff:
             self.writeType(TYPE_LONGSTRING)
@@ -418,7 +439,7 @@ cdef class Encoder(codec.Encoder):
         else:
             self.stream.write_ushort(l)
 
-        return self.stream.write(PyString_AS_STRING(s), l)
+        return self.stream.write(PyBytes_AS_STRING(s), l)
 
     cdef int writeString(self, u) except -1:
         """
@@ -435,14 +456,14 @@ cdef class Encoder(codec.Encoder):
         if PyUnicode_CheckExact(u):
             u = self.context.getBytesForString(u)
 
-        cdef Py_ssize_t l = PyString_GET_SIZE(u)
+        cdef Py_ssize_t l = PyBytes_GET_SIZE(u)
 
         if l > 0xffff:
             self.stream.write_ulong(l)
         else:
             self.stream.write_ushort(l)
 
-        return self.stream.write(PyString_AS_STRING(u), l)
+        return self.stream.write(PyBytes_AS_STRING(u), l)
 
     cdef int writeXML(self, e) except -1:
         """
@@ -455,14 +476,14 @@ cdef class Encoder(codec.Encoder):
         if isinstance(data, unicode):
             data = data.encode('utf-8')
 
-        if not PyString_CheckExact(data):
+        if not PyBytes_CheckExact(data):
             raise TypeError('expected str from xml.tostring')
 
-        cdef Py_ssize_t l = PyString_GET_SIZE(data)
+        cdef Py_ssize_t l = PyBytes_GET_SIZE(data)
 
         self.stream.write_ulong(l)
 
-        return self.stream.write(PyString_AS_STRING(data), l)
+        return self.stream.write(PyBytes_AS_STRING(data), l)
 
     cdef int writeDateTime(self, d) except -1:
         if self.timezone_offset is not None:
@@ -491,9 +512,9 @@ cdef class Encoder(codec.Encoder):
 
         @param o: The C{dict} data to be encoded to the AMF0 data stream.
         """
-        for key, value in attrs.iteritems():
-            if PyInt_Check(key) or PyLong_Check(key):
-                key = str(key)
+        for key, value in attrs.items():
+            if PyLong_Check(key):
+                key = str(key).encode()
 
             self.serialiseString(key)
             self.writeElement(value)