coder . cl » python

[ANN] pyxser-1.4.4r was released

Daniel Molina Wegener — Sun, 20 Jun 2010 16:24:50 +0000

Hello, today I’ve released pyxser-1.4.4r, the publishing message is as follows:

Hello Python Community.

I’m pleased to announce pyxser-1.4.4r, a python extension which contains functions to serialize and deserialize Python Objects into XML. It is a model based serializer. Here is the ChangeLog entry for this release:

1.4.4r (2010.02.10):

        Daniel Molina Wegener 

        * src/include/pyxser_collections.h - added set handling
        function prototypes. Added support for unicode
        key names, which are converted to the user settings
        encoding (ie utf-8) inside the XML output.
        * src/pyxser_serializer.c - removed memory leak. Addded
        support for unicode object names in dictionary/list types.
        * src/pyxser_collections.c - added set handling function
        prototypes. added name property handling algorithm, so
        non string name properties are not serialized. I shall
        extend it to other modules.
        * src/pyxser_tools.c - added set handling prototypes and
        set type checking function.
        * test-utf8-leak.py - added serialization of SQL Alchemy
        objects, so we can test more complex Python objects
        serialization.
        * test-utf8-sqlalchemy.py - added sql alchemy object
        serialization test.
        * src/pyxser_serializer.c - reduced serialization algorithms,
        replacing deep nested if statements by flatten ones.
        * src/pyxser_collections.c - reduced serialization algorithms
        replacing deep nested if statements by flatten ones.
        * src/pyxser_typem.c - reduced serialization algorithms,
        replacing deep nested if statements by flatten ones.

        Thanks to pyxser users for their feedback.

This release contains some bug fixes, mainly related to type checking and type handling. I hope this small extension will help you on your programming tasks.

The project is hosted at:
http://sourceforge.net/projects/pyxser/
The web page for the project is located at:
http://coder.cl/products/pyxser/
PyPi entry is:
http://pypi.python.org/pypi/pyxser/1.4.4r
For a sample article on how to integrate pyxser with ZSI WebServices:
http://coder.cl/2009/10/18/pyxser-and-zsi-webservices/

Thanks and best regards…

I hope that this module can help you in your development tasks and thanks for your feedback.

share this article at:

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

my contribution to free/open source software

Daniel Molina Wegener — Thu, 01 Apr 2010 22:34:34 +0000

I’ve worked on FOSS for years. Currently I have two active projects pyxser and caffeine. Both of them requires a great effort to being completed. Take an overview on their development:

pyxser

pyxser have about one year of development, some months doing research, and other months doing development or coding the Python Module.

And the SVN log show an average hour for commits between 22:00 and 23:00

r125 | damowe | 2010-02-10 16:15:49 -0300 (Wed, 10 Feb 2010) | 2 lines
r124 | damowe | 2010-02-10 15:52:31 -0300 (Wed, 10 Feb 2010) | 2 lines
r123 | damowe | 2010-02-10 13:30:15 -0300 (Wed, 10 Feb 2010) | 10 lines
r122 | damowe | 2010-02-02 08:47:07 -0300 (Tue, 02 Feb 2010) | 3 lines
r121 | damowe | 2009-12-26 21:52:49 -0300 (Sat, 26 Dec 2009) | 2 lines
r118 | damowe | 2009-12-26 21:40:33 -0300 (Sat, 26 Dec 2009) | 2 lines
r117 | damowe | 2009-12-25 15:20:30 -0300 (Fri, 25 Dec 2009) | 4 lines
r116 | damowe | 2009-12-22 20:09:25 -0300 (Tue, 22 Dec 2009) | 5 lines
r115 | damowe | 2009-12-21 19:47:50 -0300 (Mon, 21 Dec 2009) | 2 lines
r114 | damowe | 2009-12-20 01:38:45 -0300 (Sun, 20 Dec 2009) | 7 lines
r112 | damowe | 2009-12-03 09:48:41 -0300 (Thu, 03 Dec 2009) | 6 lines
r110 | damowe | 2009-11-30 14:52:10 -0300 (Mon, 30 Nov 2009) | 2 lines
r109 | damowe | 2009-11-30 14:46:43 -0300 (Mon, 30 Nov 2009) | 9 lines
r107 | damowe | 2009-08-23 11:43:52 -0400 (Sun, 23 Aug 2009) | 2 lines
r102 | damowe | 2009-08-23 11:29:07 -0400 (Sun, 23 Aug 2009) | 2 lines
r99 | damowe | 2009-08-23 11:12:20 -0400 (Sun, 23 Aug 2009) | 6 lines
r98 | damowe | 2009-08-08 15:15:07 -0400 (Sat, 08 Aug 2009) | 3 lines
r93 | damowe | 2009-07-28 21:59:10 -0400 (Tue, 28 Jul 2009) | 2 lines
r90 | damowe | 2009-07-27 22:22:55 -0400 (Mon, 27 Jul 2009) | 2 lines
r89 | damowe | 2009-07-27 22:21:50 -0400 (Mon, 27 Jul 2009) | 5 lines
r88 | damowe | 2009-07-26 22:27:23 -0400 (Sun, 26 Jul 2009) | 4 lines
r87 | damowe | 2009-07-20 16:02:27 -0400 (Mon, 20 Jul 2009) | 5 lines
r86 | damowe | 2009-07-17 22:24:53 -0400 (Fri, 17 Jul 2009) | 4 lines
r84 | damowe | 2009-05-09 23:19:49 -0400 (Sat, 09 May 2009) | 2 lines
r83 | damowe | 2009-05-09 22:31:00 -0400 (Sat, 09 May 2009) | 7 lines
r82 | damowe | 2009-05-09 11:00:44 -0400 (Sat, 09 May 2009) | 3 lines
r81 | damowe | 2009-05-08 21:31:56 -0400 (Fri, 08 May 2009) | 2 lines
r80 | damowe | 2009-04-28 00:32:53 -0400 (Tue, 28 Apr 2009) | 3 lines
r78 | damowe | 2009-04-26 19:21:16 -0400 (Sun, 26 Apr 2009) | 2 lines
r77 | damowe | 2009-04-26 19:13:26 -0400 (Sun, 26 Apr 2009) | 2 lines
r76 | damowe | 2009-04-26 17:34:09 -0400 (Sun, 26 Apr 2009) | 4 lines
r75 | damowe | 2009-04-25 19:31:45 -0400 (Sat, 25 Apr 2009) | 3 lines
r74 | damowe | 2009-04-24 20:49:40 -0400 (Fri, 24 Apr 2009) | 3 lines
r73 | damowe | 2009-04-23 23:06:46 -0400 (Thu, 23 Apr 2009) | 4 lines
r72 | damowe | 2009-04-22 08:28:31 -0400 (Wed, 22 Apr 2009) | 3 lines
r71 | damowe | 2009-04-22 00:52:12 -0400 (Wed, 22 Apr 2009) | 2 lines
r70 | damowe | 2009-04-22 00:28:48 -0400 (Wed, 22 Apr 2009) | 3 lines
r69 | damowe | 2009-04-21 23:09:09 -0400 (Tue, 21 Apr 2009) | 2 lines
r68 | damowe | 2009-04-21 16:41:11 -0400 (Tue, 21 Apr 2009) | 3 lines
r65 | damowe | 2009-04-19 01:24:34 -0400 (Sun, 19 Apr 2009) | 2 lines
r64 | damowe | 2009-04-19 01:22:15 -0400 (Sun, 19 Apr 2009) | 2 lines
r63 | damowe | 2009-04-19 01:17:29 -0400 (Sun, 19 Apr 2009) | 2 lines
r62 | damowe | 2009-04-19 01:10:33 -0400 (Sun, 19 Apr 2009) | 2 lines
r61 | damowe | 2009-04-19 00:01:47 -0400 (Sun, 19 Apr 2009) | 3 lines
r59 | damowe | 2009-04-18 22:57:01 -0400 (Sat, 18 Apr 2009) | 2 lines
r58 | damowe | 2009-04-18 22:30:30 -0400 (Sat, 18 Apr 2009) | 3 lines
r57 | damowe | 2009-04-18 04:26:58 -0400 (Sat, 18 Apr 2009) | 2 lines
r56 | damowe | 2009-04-18 03:28:56 -0400 (Sat, 18 Apr 2009) | 3 lines
r55 | damowe | 2009-04-15 23:38:34 -0400 (Wed, 15 Apr 2009) | 2 lines
r54 | damowe | 2009-04-15 23:10:32 -0400 (Wed, 15 Apr 2009) | 2 lines
r53 | damowe | 2009-04-15 22:46:15 -0400 (Wed, 15 Apr 2009) | 3 lines
r52 | damowe | 2009-04-10 18:30:22 -0400 (Fri, 10 Apr 2009) | 2 lines
r49 | damowe | 2009-04-10 00:17:25 -0400 (Fri, 10 Apr 2009) | 2 lines
r47 | damowe | 2009-04-08 23:43:50 -0400 (Wed, 08 Apr 2009) | 4 lines
r46 | damowe | 2009-04-08 14:29:42 -0400 (Wed, 08 Apr 2009) | 4 lines
r45 | damowe | 2009-04-08 01:31:22 -0400 (Wed, 08 Apr 2009) | 2 lines
r44 | damowe | 2009-04-08 01:30:18 -0400 (Wed, 08 Apr 2009) | 2 lines
r43 | damowe | 2009-04-08 01:28:36 -0400 (Wed, 08 Apr 2009) | 3 lines
r42 | damowe | 2009-04-06 21:58:57 -0400 (Mon, 06 Apr 2009) | 2 lines
r41 | damowe | 2009-04-06 21:46:19 -0400 (Mon, 06 Apr 2009) | 2 lines
r40 | damowe | 2009-04-06 21:36:55 -0400 (Mon, 06 Apr 2009) | 3 lines
r39 | damowe | 2009-04-05 22:25:50 -0400 (Sun, 05 Apr 2009) | 2 lines
r38 | damowe | 2009-04-05 22:19:10 -0400 (Sun, 05 Apr 2009) | 4 lines
r37 | damowe | 2009-04-04 20:18:15 -0400 (Sat, 04 Apr 2009) | 3 lines
r36 | damowe | 2009-03-31 23:49:23 -0400 (Tue, 31 Mar 2009) | 5 lines
r33 | damowe | 2009-03-28 12:13:41 -0400 (Sat, 28 Mar 2009) | 2 lines
r30 | damowe | 2009-03-26 22:17:10 -0400 (Thu, 26 Mar 2009) | 3 lines
r29 | damowe | 2009-03-26 21:59:57 -0400 (Thu, 26 Mar 2009) | 5 lines
r28 | damowe | 2009-03-26 21:17:10 -0400 (Thu, 26 Mar 2009) | 2 lines
r27 | damowe | 2009-03-25 23:26:30 -0400 (Wed, 25 Mar 2009) | 3 lines
r26 | damowe | 2009-03-25 22:58:16 -0400 (Wed, 25 Mar 2009) | 5 lines
r25 | damowe | 2009-03-25 22:03:16 -0400 (Wed, 25 Mar 2009) | 2 lines
r24 | damowe | 2009-03-25 21:00:44 -0400 (Wed, 25 Mar 2009) | 4 lines
r23 | damowe | 2009-03-25 20:48:26 -0400 (Wed, 25 Mar 2009) | 3 lines
r22 | damowe | 2009-03-25 20:34:30 -0400 (Wed, 25 Mar 2009) | 2 lines
r21 | damowe | 2009-03-25 20:15:58 -0400 (Wed, 25 Mar 2009) | 2 lines
r20 | damowe | 2009-03-24 20:47:42 -0400 (Tue, 24 Mar 2009) | 2 lines
r19 | damowe | 2009-03-23 23:41:47 -0400 (Mon, 23 Mar 2009) | 5 lines
r18 | damowe | 2009-03-23 21:03:13 -0400 (Mon, 23 Mar 2009) | 3 lines
r17 | damowe | 2009-03-23 20:16:58 -0400 (Mon, 23 Mar 2009) | 2 lines
r16 | damowe | 2009-03-19 22:57:46 -0400 (Thu, 19 Mar 2009) | 2 lines
r15 | damowe | 2009-03-19 22:30:56 -0400 (Thu, 19 Mar 2009) | 5 lines
r14 | damowe | 2009-03-19 20:37:13 -0400 (Thu, 19 Mar 2009) | 2 lines
r13 | damowe | 2009-03-19 00:37:39 -0400 (Thu, 19 Mar 2009) | 3 lines
r12 | damowe | 2009-03-19 00:11:23 -0400 (Thu, 19 Mar 2009) | 3 lines
r11 | damowe | 2009-03-18 23:47:08 -0400 (Wed, 18 Mar 2009) | 3 lines
r10 | damowe | 2009-03-17 22:25:47 -0400 (Tue, 17 Mar 2009) | 2 lines
r9 | damowe | 2009-03-17 22:23:21 -0400 (Tue, 17 Mar 2009) | 2 lines
r8 | damowe | 2009-03-17 22:16:37 -0400 (Tue, 17 Mar 2009) | 2 lines
r7 | damowe | 2009-03-17 00:55:43 -0400 (Tue, 17 Mar 2009) | 2 lines
r6 | damowe | 2009-03-16 23:33:31 -0400 (Mon, 16 Mar 2009) | 2 lines
r5 | damowe | 2009-03-15 17:21:57 -0400 (Sun, 15 Mar 2009) | 2 lines
r4 | damowe | 2009-03-15 17:07:39 -0400 (Sun, 15 Mar 2009) | 2 lines
r1 | damowe | 2009-03-15 15:35:31 -0400 (Sun, 15 Mar 2009) | 2 lines

The project has 6,198 lines of code… a good effort and a good product. During the day I must work on those projects which bring me money, at night and as hobbits I work on my FOSS projects. I have a little time to work on them.

caffeine

caffeine or C Application Framework has 14,177 lines of code, and it is evaluated as one project with three humans working on it, but it is really one, me.

And the SVN log show an average hour for commits between 22:00 and 23:00

r125 | damowe | 2009-09-30 14:45:06 -0400 (Wed, 30 Sep 2009) | 6 lines
r124 | damowe | 2009-09-26 18:49:31 -0400 (Sat, 26 Sep 2009) | 2 lines
r123 | damowe | 2009-09-26 17:46:26 -0400 (Sat, 26 Sep 2009) | 5 lines
r122 | damowe | 2009-09-26 13:14:50 -0400 (Sat, 26 Sep 2009) | 2 lines
r121 | damowe | 2009-09-26 12:25:19 -0400 (Sat, 26 Sep 2009) | 4 lines
r120 | damowe | 2009-09-22 05:18:11 -0400 (Tue, 22 Sep 2009) | 8 lines
r119 | damowe | 2009-09-19 23:27:06 -0400 (Sat, 19 Sep 2009) | 5 lines
r118 | damowe | 2009-09-19 19:06:50 -0400 (Sat, 19 Sep 2009) | 8 lines
r117 | damowe | 2009-09-01 22:18:54 -0400 (Tue, 01 Sep 2009) | 5 lines
r116 | damowe | 2008-10-27 07:40:14 -0300 (Mon, 27 Oct 2008) | 2 lines
r115 | damowe | 2008-10-27 07:38:30 -0300 (Mon, 27 Oct 2008) | 2 lines
r114 | damowe | 2008-10-27 07:35:09 -0300 (Mon, 27 Oct 2008) | 3 lines
r113 | damowe | 2008-10-25 13:01:20 -0300 (Sat, 25 Oct 2008) | 2 lines
r112 | damowe | 2008-06-10 21:10:30 -0400 (Tue, 10 Jun 2008) | 3 lines
r111 | damowe | 2008-06-06 20:05:39 -0400 (Fri, 06 Jun 2008) | 5 lines
r110 | damowe | 2008-05-08 21:12:50 -0400 (Thu, 08 May 2008) | 2 lines
r109 | damowe | 2008-05-06 23:53:10 -0400 (Tue, 06 May 2008) | 2 lines
r108 | damowe | 2008-05-05 23:37:42 -0400 (Mon, 05 May 2008) | 2 lines
r107 | damowe | 2008-04-27 02:08:49 -0400 (Sun, 27 Apr 2008) | 2 lines
r106 | damowe | 2008-04-26 11:59:49 -0400 (Sat, 26 Apr 2008) | 4 lines
r105 | damowe | 2008-04-22 23:06:33 -0400 (Tue, 22 Apr 2008) | 3 lines
r104 | damowe | 2008-04-21 21:13:06 -0400 (Mon, 21 Apr 2008) | 4 lines
r103 | damowe | 2008-02-10 13:16:32 -0300 (Sun, 10 Feb 2008) | 3 lines
r102 | damowe | 2008-02-10 10:22:34 -0300 (Sun, 10 Feb 2008) | 2 lines
r101 | damowe | 2008-02-10 10:08:35 -0300 (Sun, 10 Feb 2008) | 2 lines
r100 | damowe | 2008-01-06 12:07:57 -0300 (Sun, 06 Jan 2008) | 4 lines
r99 | damowe | 2008-01-05 20:03:27 -0300 (Sat, 05 Jan 2008) | 4 lines
r98 | damowe | 2008-01-01 17:29:14 -0300 (Tue, 01 Jan 2008) | 3 lines
r97 | damowe | 2007-12-31 15:47:20 -0300 (Mon, 31 Dec 2007) | 2 lines
r96 | damowe | 2007-12-30 12:15:46 -0300 (Sun, 30 Dec 2007) | 2 lines
r95 | damowe | 2007-12-30 12:06:41 -0300 (Sun, 30 Dec 2007) | 3 lines
r94 | damowe | 2007-12-30 07:59:58 -0300 (Sun, 30 Dec 2007) | 2 lines
r93 | damowe | 2007-12-25 10:37:15 -0300 (Tue, 25 Dec 2007) | 3 lines
r92 | damowe | 2007-12-22 09:57:27 -0300 (Sat, 22 Dec 2007) | 2 lines
r91 | damowe | 2007-12-22 09:56:15 -0300 (Sat, 22 Dec 2007) | 4 lines
r90 | damowe | 2007-12-22 07:26:39 -0300 (Sat, 22 Dec 2007) | 3 lines
r89 | damowe | 2007-12-16 22:21:51 -0300 (Sun, 16 Dec 2007) | 4 lines
r88 | damowe | 2007-12-03 21:35:27 -0300 (Mon, 03 Dec 2007) | 2 lines
r87 | damowe | 2007-12-01 23:56:53 -0300 (Sat, 01 Dec 2007) | 3 lines
r86 | damowe | 2007-12-01 23:44:02 -0300 (Sat, 01 Dec 2007) | 2 lines
r85 | damowe | 2007-11-11 09:06:24 -0300 (Sun, 11 Nov 2007) | 4 lines
r84 | damowe | 2007-11-10 21:43:36 -0300 (Sat, 10 Nov 2007) | 2 lines
r83 | damowe | 2007-11-10 21:25:58 -0300 (Sat, 10 Nov 2007) | 2 lines
r82 | damowe | 2007-10-07 11:39:55 -0400 (Sun, 07 Oct 2007) | 3 lines
r81 | damowe | 2007-10-07 08:32:09 -0400 (Sun, 07 Oct 2007) | 3 lines
r80 | damowe | 2007-09-30 21:53:52 -0400 (Sun, 30 Sep 2007) | 3 lines
r79 | damowe | 2007-09-19 18:27:20 -0400 (Wed, 19 Sep 2007) | 2 lines
r78 | damowe | 2007-09-18 00:34:21 -0400 (Tue, 18 Sep 2007) | 2 lines
r77 | damowe | 2007-09-17 17:10:57 -0400 (Mon, 17 Sep 2007) | 3 lines
r76 | damowe | 2007-09-15 17:27:45 -0400 (Sat, 15 Sep 2007) | 2 lines
r75 | damowe | 2007-09-08 11:19:19 -0400 (Sat, 08 Sep 2007) | 2 lines
r74 | damowe | 2007-09-02 12:11:38 -0400 (Sun, 02 Sep 2007) | 2 lines
r73 | damowe | 2007-09-02 10:57:54 -0400 (Sun, 02 Sep 2007) | 2 lines
r72 | damowe | 2007-09-02 10:55:09 -0400 (Sun, 02 Sep 2007) | 2 lines
r71 | damowe | 2007-09-02 09:38:43 -0400 (Sun, 02 Sep 2007) | 5 lines
r70 | damowe | 2007-09-02 02:13:20 -0400 (Sun, 02 Sep 2007) | 4 lines
r69 | damowe | 2007-08-31 20:05:06 -0400 (Fri, 31 Aug 2007) | 3 lines
r68 | damowe | 2007-08-26 13:34:53 -0400 (Sun, 26 Aug 2007) | 2 lines
r67 | damowe | 2007-08-26 13:15:04 -0400 (Sun, 26 Aug 2007) | 3 lines
r66 | damowe | 2007-08-26 10:10:19 -0400 (Sun, 26 Aug 2007) | 3 lines
r65 | damowe | 2007-08-25 19:00:10 -0400 (Sat, 25 Aug 2007) | 3 lines
r64 | damowe | 2007-08-19 00:26:00 -0400 (Sun, 19 Aug 2007) | 3 lines
r63 | damowe | 2007-08-18 10:36:16 -0400 (Sat, 18 Aug 2007) | 3 lines
r62 | damowe | 2007-08-15 17:23:28 -0400 (Wed, 15 Aug 2007) | 2 lines
r61 | damowe | 2007-08-13 07:48:31 -0400 (Mon, 13 Aug 2007) | 3 lines
r60 | damowe | 2007-08-12 17:06:08 -0400 (Sun, 12 Aug 2007) | 2 lines
r59 | damowe | 2007-08-12 16:33:09 -0400 (Sun, 12 Aug 2007) | 3 lines
r58 | damowe | 2007-08-12 13:39:59 -0400 (Sun, 12 Aug 2007) | 2 lines
r57 | damowe | 2007-08-12 01:26:32 -0400 (Sun, 12 Aug 2007) | 2 lines
r56 | damowe | 2007-08-11 13:26:10 -0400 (Sat, 11 Aug 2007) | 2 lines
r55 | damowe | 2007-08-11 13:21:17 -0400 (Sat, 11 Aug 2007) | 3 lines
r54 | damowe | 2007-08-06 21:58:22 -0400 (Mon, 06 Aug 2007) | 2 lines
r53 | damowe | 2007-08-04 23:03:06 -0400 (Sat, 04 Aug 2007) | 3 lines
r52 | damowe | 2007-08-04 22:39:10 -0400 (Sat, 04 Aug 2007) | 3 lines
r51 | damowe | 2007-08-04 17:28:45 -0400 (Sat, 04 Aug 2007) | 2 lines
r50 | damowe | 2007-08-04 16:54:48 -0400 (Sat, 04 Aug 2007) | 2 lines
r49 | damowe | 2007-07-29 09:15:12 -0400 (Sun, 29 Jul 2007) | 2 lines
r48 | damowe | 2007-07-28 17:38:23 -0400 (Sat, 28 Jul 2007) | 2 lines
r47 | damowe | 2007-07-16 23:45:16 -0400 (Mon, 16 Jul 2007) | 3 lines
r46 | damowe | 2007-07-16 16:47:06 -0400 (Mon, 16 Jul 2007) | 3 lines
r45 | damowe | 2007-07-15 20:03:51 -0400 (Sun, 15 Jul 2007) | 3 lines
r44 | damowe | 2007-07-15 12:10:35 -0400 (Sun, 15 Jul 2007) | 3 lines
r43 | damowe | 2007-07-02 17:30:56 -0400 (Mon, 02 Jul 2007) | 2 lines
r42 | damowe | 2007-07-02 10:46:27 -0400 (Mon, 02 Jul 2007) | 3 lines
r41 | damowe | 2007-06-30 16:23:19 -0400 (Sat, 30 Jun 2007) | 2 lines
r40 | damowe | 2007-06-23 21:08:20 -0400 (Sat, 23 Jun 2007) | 3 lines
r39 | damowe | 2007-06-23 10:37:22 -0400 (Sat, 23 Jun 2007) | 2 lines
r38 | damowe | 2007-06-23 10:33:24 -0400 (Sat, 23 Jun 2007) | 2 lines
r37 | damowe | 2007-06-22 23:10:58 -0400 (Fri, 22 Jun 2007) | 3 lines
r36 | damowe | 2007-06-20 21:57:34 -0400 (Wed, 20 Jun 2007) | 3 lines
r35 | damowe | 2007-06-18 21:22:26 -0400 (Mon, 18 Jun 2007) | 3 lines
r34 | damowe | 2007-06-17 21:33:13 -0400 (Sun, 17 Jun 2007) | 2 lines
r33 | damowe | 2007-06-17 21:31:58 -0400 (Sun, 17 Jun 2007) | 2 lines
r32 | damowe | 2007-06-17 18:48:40 -0400 (Sun, 17 Jun 2007) | 3 lines
r31 | damowe | 2007-06-17 12:03:32 -0400 (Sun, 17 Jun 2007) | 3 lines
r30 | damowe | 2007-06-17 11:50:15 -0400 (Sun, 17 Jun 2007) | 2 lines
r29 | damowe | 2007-06-16 21:48:05 -0400 (Sat, 16 Jun 2007) | 2 lines
r28 | damowe | 2007-06-16 21:43:38 -0400 (Sat, 16 Jun 2007) | 3 lines
r27 | damowe | 2007-06-09 18:25:07 -0400 (Sat, 09 Jun 2007) | 2 lines
r26 | damowe | 2007-06-09 18:05:07 -0400 (Sat, 09 Jun 2007) | 2 lines
r25 | damowe | 2007-06-09 18:03:56 -0400 (Sat, 09 Jun 2007) | 3 lines
r24 | damowe | 2007-06-03 20:45:25 -0400 (Sun, 03 Jun 2007) | 3 lines
r23 | damowe | 2007-06-03 19:08:34 -0400 (Sun, 03 Jun 2007) | 2 lines
r22 | damowe | 2007-06-03 19:07:35 -0400 (Sun, 03 Jun 2007) | 2 lines
r21 | damowe | 2007-05-21 10:48:01 -0400 (Mon, 21 May 2007) | 2 lines
r20 | damowe | 2007-05-20 22:00:12 -0400 (Sun, 20 May 2007) | 2 lines
r19 | damowe | 2007-05-20 21:45:38 -0400 (Sun, 20 May 2007) | 6 lines
r18 | damowe | 2007-05-20 10:57:12 -0400 (Sun, 20 May 2007) | 2 lines
r17 | damowe | 2007-05-19 22:22:24 -0400 (Sat, 19 May 2007) | 5 lines
r16 | damowe | 2007-05-18 21:41:36 -0400 (Fri, 18 May 2007) | 2 lines
r15 | damowe | 2007-05-14 23:02:09 -0400 (Mon, 14 May 2007) | 3 lines
r14 | damowe | 2007-05-13 12:03:47 -0400 (Sun, 13 May 2007) | 2 lines
r13 | damowe | 2007-05-13 01:01:13 -0400 (Sun, 13 May 2007) | 2 lines
r12 | damowe | 2007-05-12 22:48:18 -0400 (Sat, 12 May 2007) | 2 lines
r11 | damowe | 2007-05-12 22:41:14 -0400 (Sat, 12 May 2007) | 3 lines
r10 | damowe | 2007-05-07 08:57:33 -0400 (Mon, 07 May 2007) | 2 lines
r9 | damowe | 2007-05-03 08:37:04 -0400 (Thu, 03 May 2007) | 3 lines
r8 | damowe | 2007-05-02 20:50:25 -0400 (Wed, 02 May 2007) | 3 lines
r7 | damowe | 2007-05-01 17:43:00 -0400 (Tue, 01 May 2007) | 2 lines
r6 | damowe | 2007-05-01 09:31:08 -0400 (Tue, 01 May 2007) | 2 lines
r5 | damowe | 2007-05-01 09:24:07 -0400 (Tue, 01 May 2007) | 1 line
r4 | damowe | 2007-05-01 09:08:02 -0400 (Tue, 01 May 2007) | 2 lines
r3 | damowe | 2007-05-01 09:05:41 -0400 (Tue, 01 May 2007) | 2 lines
r2 | damowe | 2007-05-01 09:04:51 -0400 (Tue, 01 May 2007) | 2 lines
r1 | damowe | 2007-05-01 09:04:22 -0400 (Tue, 01 May 2007) | 2 lines

Both projects requires effort and research, and both project are not simple ones to handle, since they are written in C, a language difficult to learn and handle… I hope that I can continue the foss development that I’ve started, but seems that I have some health problems now

share this article at:

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

[ann] pyxser-1.4.2r available

Daniel Molina Wegener — Wed, 10 Feb 2010 22:05:16 +0000

Dear pyxser users, I’m pleased to announce that I’ve released pyxser-1.4.2r. The current ChangeLog for this release is as follows:

1.4.2r (2010.02.10):

        Daniel Molina Wegener 
        * pyxser_collections.c: Added constraint checks for NULL
        pointers removing nested statements.
        * pyxser.c: Removed nested statements.
        * pyxser_tools.c: Added constratints checks for NULL pointers,
        removed nested statements and added strict checking for lists
        since it was crashing with an ambigous list definition that
        can not be handled by PyList_Check().
        * test-utf8.py: Added tests to determine if it continue
        crashing with module serialization.

        Thanks to pyxser users for their feedback.

I want to bring special thanks to Dariusz Suchojad for his feedback. I’ve fixed some type checking bugs and minor ones. Now pyxser is capable to do module serialization, but not in concrete one, still is not capable to distribute modules, so it is capable to create a simple module representation as XML, under the pyxser serialization model.

I hope that it will help you on your programming tasks.

share this article at:

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

[ann] pyxser-1.4r is available

Daniel Molina Wegener — Sun, 27 Dec 2009 01:32:11 +0000

As you have seen in my last post, I’ve been working on some strong changes on pyxser. Today I’ve released pyxser-1.4r and the announcement message:

Hello Python Community.

I'm pleased to announce pyxser-1.4, a python extension which
contains functions to serialize and deserialize Python Objects
into XML. It is a model based serializer. Here is the ChangeLog
entry for this release:

---8<---
1.4r (2009.12.26):

        Daniel Molina Wegener 
        * pyxser_typem.c: Added type map serialization and deserialization
        routines and arguments. Now pyxser is able to serialize and
        deserialize objects using custom serialization functions, but
        preserving the pyxser XML schema and the serialization model.
---8<---

The project is hosted at:

http://sourceforge.net/projects/pyxser/

The web page for the project is located at:

http://coder.cl/products/pyxser/

PyPi entry is:

http://pypi.python.org/pypi?name=pyxser&version=1.4r&:action=display

For a sample article on how to integrate
pyxser with ZSI WebServices:

http://coder.cl/2009/10/18/pyxser-and-zsi-webservices/

Thanks and best regards,
--
| Daniel Molina  |
| IT Consulting & Software Development    |
| http://coder.cl/                        |

I hope that this Python Extension will help you in your development tasks. For any kind of feedback, follow the pyxser announcement thread on comp.lang.python or the Python mailing lists. Another options is simply to create a thread on SourceForge forums or write an email directly to ‘Daniel Molina Wegener’

share this article at:

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

incomming changes for pyxser-1.4

Daniel Molina Wegener — Tue, 22 Dec 2009 10:36:31 +0000

pyxser, my Python-Object to XML serializer is suffering few changes, but important ones. The main change is the fact that I will add a type map optional parameter for deserialization functions. How should it work?


def create_string_from_string(mystr, myroot):
    return str(mystr)

my_typemap = {'java.lang.String': create_string_from_string,
              'String': create_string_from_string,
              'string': create_string_from_string}

unserialized = pyxser.unserialize(obj = serialized, \
                                  enc = "utf-8", \
                                  typemap = my_typemap)

This will allow you to create the proper instance of non standard objects in Python. For example if there exists a third party class which needs a special instantation, like the ones which are using sockets or files, this will allow you to create the instance with a custom function, specially if the serialized object comes from other languages.

The type map callbacks will be called using my_typemap['maptype'](python_string, root_object), where python_string is the node content as Python String and root_object is the deserialized root object — the pointed by the root element. About the error occurrences, I will clear each error produced inside the type map function, by call PyErr_Clear(), then you must control those errors produced inside your callback, and return Py_None (None) on each one.

I will be writing this feature this week and the weekend, if you want a change over this feature, this is the time to get some feedback. I think that pyxser-1.4r will be launched on 2010-01-01.

share this article at:

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

[ann] pyxser-1.3r-p1 [updated]

Daniel Molina Wegener — Tue, 01 Dec 2009 04:17:30 +0000

Dear pyxser users, I’m pleased to announce that I’ve released pyxser-1.3r. The current ChangeLog for this release is as follows (Update: There was bug in the pyxser-1.3r release, it is patched and working in pyxser-1.3r-p1):

1.3r (2009.11.30):

        Daniel Molina Wegener 
        * pyxser_tools.c: Removed bug concerning deserialization of
        collection elements; pyxser now can handle extension declared
        classes, such as boost::python ones --- thanks to the
        suggestions made by Daniel Filonik.
        * pyxser.c: Added /selector/ as optional argument used as
        callback to select object attributes to being serialized.
        * pyxser_string.c: Removed bug concerning unicode serialization.

        Thanks pyxser users for your feedback...

I want to bring special thanks to Daniel Filonik for his feedback.

First, thank you for a great Python module, I believe it has a lot of potential! I was never quite happy with pickle because of its cryptic format. The XML schema you use is so much nicer to read.

the selector callback

An interesting feature requested by Daniel Filonik is to allow the user to select the object attributes to being serialized. So I’ve added the attribute selector callback as optional argument called selector. As he suggest:

PyObject *selector = (PyObject *)NULL;
/* ... */
static char *kwlist[] = {"obj", "enc", "depth", "selector ", NULL};
/* ... */
ok = PyArg_ParseTupleAndKeywords(args, keywds, "Os|iO", kwlist,
                                 &input, &in_enc, &py_depth, &selector);
/* ... */
sargs.selector = &selector;

Then, I use the selector callback in pyxser to obtain a list of the required attributes for the serialization process, and the callback is applied to the given object to being serialized.

if (PYTHON_IS_NONE(select)) {
    lstItems = PyObject_GetAttrString(o, pyxser_attr_dict);
} else {
    /* selector must return NULL if there are errors... */
    arglist = Py_BuildValue("(O)", o);
    lstItems = PyObject_CallObject(select, arglist);
    Py_XDECREF(arglist);
}

And I’ve implemented the proper method to allow the instantiation of classes which are defined in Python extensions, such as boost::python, by replacing PyInstance_NewRaw() call by the default empty constructor for Python objects:

#ifdef OLDCODE
	PyObject *ndict = (PyObject *)NULL;
	/* ... */
	ndict = PyDict_New();
	unser = PyInstance_NewRaw(ct, ndict);
	Py_XDECREF(ndict);
#else
    int ctrl = 0;
    unser = PyObject_CallFunctionObjArgs(ct, NULL);
    attr_name = pyxser_ExtractPropertyName(pyxser_xml_attr_name,
                                           ron);
#endif /* !OLDCODE */

I hope that pyxser is neat serializing extension and it is usefull for your transparent and interoperable communications with other platforms in Python.

share this article at:

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

pyxser and zsi webservices

Daniel Molina Wegener — Mon, 19 Oct 2009 01:18:33 +0000

pyxser, my Python-Object to XML serialization/deserialization extension — completely written in C — that can be used at least in a lot of kinds of object communications and object storage tasks. Since it is not a binary serializer, you can handle the serialized objects with a lot of available APIs. In this post I will explain how to work with pyxser and the ZSI Python framework to work with WebServices.

the server side

ZSI is a Python framework to work with WebServices. It can be used under mod_python. The first step to work with ZSI is to define a proper WSDL for our WebService. In this case we just only communicate xsd:string types to carry our pyxser messages:

The tns:message complex type holds a single element containing the serialized object defined as xsd:string. The type is used as tns:request and tns:response, We can send and receive any serialized object through our WebService. One time defined the WebService, we generate the proper type and service handlers with ZSI command line utilities:

[dmw@www ~]$ wsdl2py --complexType --file SimpleOperation.wsdl
[dmw@www ~]$ wsdl2dispatch --file SimpleOperation.wsdl
[dmw@www ~]$
[dmw@www ~]$ ls -1 *py
SimpleOperation_services_types.py
SimpleOperation_services.py
SimpleOperation_services_server.py

So, we have generated our types and handlers, and now we must write the mod_python handler. Since ZSI does not allow to customize the use of the ZSI.dispatch.AsHandler() function parameters, we use directly the _Dispatch() function with some modifications over our mod_python handler.


### we import the apache module from mod_python
from mod_python import apache
### we import the Zolera SOAP Infrastructure
import ZSI as z
import ZSI.dispatch as zd
import ZSI.TC as tc

### we import our WebService definition
### created with wsdl2py and wsdl2dispatch
import simple.SimpleOperation as so ### our WS request handler
import simple.SimpleOperation_services_types as sot
import simple.SimpleOperation_services as sos
import simple.SimpleOperation_services_server as sor

### we import the logging module
import logging as log

### we setup the service logging
LOG_FILENAME = '/var/www/wsSample/logs/request-log.txt'
### we setup a debugging logging
log.basicConfig(filename=LOG_FILENAME,level=log.DEBUG,)

### we register our WebService types inside the
### ZSI framework for handling message types
tc.RegisterType(sos.SimpleOperationRequest)
tc.RegisterType(sos.SimpleOperationResponse)

### we setup the encoding for our WebServices messages
mod = __import__('encodings.utf_8', globals(), locals(), '*')
mod = __import__('encodings.utf_16_be', globals(), locals(), '*')

### we start a typesmod as None
typesmod=None

### we define a custom handler for message types, We
### can add the proper type to handle the incoming message
def hdlrTypecode(mod, e):
    # we log the module name
    log.debug("mod: " + mod.__name__ + "; e: " + repr(e))
    # if the module regards our implementation...
    if mod.__name__ == 'simple.SimpleOperation_services_types':
        if e.localName == u'request':
            # setup the module according to the
            # request message
            typesmod=sot
            return sos.SimpleOperationRequest.typecode
        if e.localName == u'response':
            # setup the module according to the
            # response message
            typesmod=sot
            return sos.SimpleOperationResponse.typecode

### we define our WebService handler, it is currently
### using a modification over the predefined ZSI.dispatch module
### since we can not define a /type code/ handler and
### /type module/ for the ZSI framework.
def handler(req):
    log.debug("handler(): req    = " + repr(req))
    ### we setup our WebService handling modules
    mods = (so,)
    log.debug("handler(): mods   = " + repr(mods))
    ### we parse the request through ZSI
    sreq = z.ParsedSoap(req)
    kw = {}
    kw['request'] = req
    ### we dispatch the request to the /pseudo-private/
    ### _Dispatch function, to allow our WebService to
    ### be identified according to the request message
    ### by using the gettypecode callback and the typesmodule
    ### definition
    zd._Dispatch(sreq, mods,
                 zd._ModPythonSendXML, zd._ModPythonSendFault,
                 gettypecode=hdlrTypecode, typesmodule=sot, **kw)
    return apache.OK

We define the simple.SimpleOperation as so module import, where we must handle the requested SOAP operation, it must define the request function as was defined in the WSDL above, and use a single parameter as request and return a SimpleOperationResponse as result, where it was defined to return a response object, which is defined in the generated classes as SimpleOperationResponse, and the received argument is a SimpleOperationRequest object, both defined in the SimpleOperation_services python module. The code for the WebService handling module, passed to the _Dispatch() function with named argument mods which is a tuple containing a reference to the simple.SimpleOperation module, and it will handle the request only if it has a function defined as follows.

from simple.SimpleOperation_services_server import *
from simple.SimpleOperation_services_types import *
from simple.SimpleOperation_services import *
import logging as log
import pyxser as ser

LOG_FILENAME = '/var/www/wsSample/logs/request-log.txt'
log.basicConfig(filename=LOG_FILENAME,level=log.DEBUG,)

def request(ureq):
    try:
        log.debug("SimpleOperation(): ureq     = " + str(ureq))
        ### the request object (created previously as ZSI.ParsedSoap
        ### object contains our serialized object)
        msg = ureq._content
        log.debug("SimpleOperation(): msg      = " + str(msg))
        ### we deserialize the given object, so we can use it...
        oreq = ser.unserialize(obj=msg.encode("utf-8"), enc="utf-8")
        ### and operate over its members, including calling methods
        ### from the unserialized object
        oreq.first_element += 100
        oreq.second_element -= 100
        oreq.some_method_call()
        ### so, in this case we send the object back to the WebService
        ### client, by serializing it and instantiating a
        ### SimpleOperationResponse object defined in the generated
        ### modules with the wsdl2py utility
        msg = ser.serialize(obj=oreq, enc="utf-8", depth=0)
        res = SimpleOperationResponse()
        log.debug("SimpleOperation(): res      = " + str(res))
        ### we set the message content
        res._content = msg
        log.debug("SimpleOperation(): _content = " + str(msg))
        ### and we return the original but recomputed object
        ### to the client.
        return res
    except Exception, e:
        log.error("SimpleOperation(): error    = " + str(e))
        res = SimpleOperationResponse()
        log.debug("SimpleOperation(): res      = " + str(res))
        res._content = "Bad Request: " + str(e)
        log.debug("SimpleOperation(): _content = " + str(msg))
        return res

pyxser automatically imports the required modules to instantiate the proper object type, so we need to let pyxser know how to deserialize the objects by allowing it to know the object class. For example the sent object was a member of the testpkg.sample module, which is guaranteed to be loaded since it is on the PYTHONPATH. On the opposed side, pyxser will return None since it is not knowing the serialized object type. The same happens at the client size, pyxser must know the serialized object types.

the client side

We know the server side, but the client side? how complex is it?. Not too complex, we proceed in the same way. We need a copy or dummy object — a class without the server side methods, but with the same properties and namespace — or copy of the server side objects. So we generate the same objects with the ZSI commands wsdl2py and wsdl2dispatch, we put them in a safe place, with the dummy objects too. So we import them in our client:

#!/usr/bin/env python
#

# we import the pyxser module
import pyxser as ser
import sys, httplib, time
# we import the dummy package
from testpkg.sample import *
# we import the service definition created by ZSI
from simple.SimpleOperation_services_types import *
from simple.SimpleOperation_services import *

# we instantiate the object with
reqo = TestAnotherObject()
# we fill it with data and operate with it
reqo.first_element = 100
reqo.second_element = 100
reqo.we_call_some_method()
# we serialize the object
hstr = ser.serialize(obj = reqo, enc = "utf-8", depth = 0)

kwloc = { 'tracefile' : sys.stdout }
# we instantiate the service locator
loc = SimpleOperationLocator();
# we redefine the service endpoint
so = loc.getSimpleOperation(url = "http://python.con/wsHandler.py", **kwloc)
# we create a request message defined in
# simple.SimpleOperation_services
req = SimpleOperationRequest()
# we put the serialized object in the
# request message
req._content = hstr
# we finally call the SimpleOperation defined
# in the WSDL file
ret = so.SimpleOperation(req)
# so we can get our recomputed object back

print repr(ret)

Then we can generate a working API for the pyxser XML schema with other APIs like JAXB for Java, which generates the proper interfaces to work with the pyxser XML schema. Another example, to work with Java, is to generate the client from the Axis API. We should find an implementation to send and receive the message from and to the pyxser enabled WebService as follows:

import junit.framework.TestCase;
import con.python.SimpleOperation.*;

public class TestAsPyxserClient extends TestCase {
    public void testClient() {
        try {
            String msg = getMessage(500, 300);
            SimpleOperation_ServiceLocator loc = new SimpleOperation_ServiceLocator();
            loc.setEndpointAddress("SimpleOperation",
                                   "http://python.con/wsHandler.py");
            SimpleOperation s = loc.getSimpleOperation();
            Message m = new Message();
            m.setContent(msg);
            Message r = s.simpleOperation(m);
            System.out.println(r.getContent());
        } catch (Exception e) {
            System.err.println("Error: " + e);
            e.printStackTrace();
        } catch (Throwable e) {
            System.err.println("Error: " + e);
            e.printStackTrace();
        }
    }

    /* here we have a pyxser serialized object
       hard-coded — I know it's ugly) but we
       can work with the proper API like JAXB to
       operate over the pyxser types, just apply any
       XSD to Java (or whatever another language)
       class generator */
    private String getMessage(int a, int b) {
        String msg =
            "\n"
                + "" + a + "\n"
                + "" + b + "\n"
                + "\n";
        return msg;
    }
}

conclusions

The main idea is to reduce response times while we are working with Python enabled WebService. Parsing tasks are hard to do from python itself. Since pyxser uses a XML Schema based serialization and finds itself how to instantiate the proper objects in both sides — client and server — we can literally export python objects from it’s environment and also import them. As FOSS work, I will create the proper API to serialize Java and Mono objects into the pyxser schema, so we can share them between platforms. I hope this would help your integration tasks

share this article at:

Copyright © 2009 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

pyxser presentation at JRSL’09

Daniel Molina Wegener — Fri, 16 Oct 2009 15:18:11 +0000

The past October 9, I’ve presented pyxser at the JRSL’09 — Jornadas Regionales de Software Libre — event. The assistance to the event was relatively poor in quantity, but strong in quality. The presentation itself was a conversation and interactive presentation for a small group, with continuous questions and explanations on how to work with pyxser, and how pyxser works. I’ve decided to publish the pyxser paper, presentation and demos, plus an explanation on this article about the presentation.

The presentation was focused on the pyxser serialization model and the proper usage of pyxser to store configurations and WebServices. Among other serialization implementations, pyxser differs in the XML generated which do not creates many XML elements with different names as class names are present on the given object, instead it uses an object model.

The paper about pyxser which was used to postulate to the JRSL’09 event can be downloaded here. It was written in Spanish and has a abstract as follows:

Pyxser es un proyecto FOSS desarrollado por Daniel Molina Wegener como una investigación e iniciativa propias. Es una extensión Python que utiliza las rutinas de libxml2 para realizar tareas de serialización y deserialización de objetos Python. Pyxser utiliza un modelo de serialización definido en un esquema XML y también en una DTD. La definición de un modelo de serialización permite la validación de la estructura del objeto serializado. El modelo también permite empotrar objetos Python que están serializados en otros documentos XML, como por ejemplo, incluir la definición de objetos Python dentro de un WSDL para utilizarlo con Web Services.

The presentation, as the same as the paper, was written in LaTeX using LaTeX Beamer with the Berlin theme and can be downloaded here. I will upload both of them — the presentation slides and the paper — to my LinkedIn profile too and also, both of them will be available in the pyxser web page. Read with attention, and have fun

share this article at:

pyxser 1.2 release

Daniel Molina Wegener — Sun, 23 Aug 2009 17:27:55 +0000

Today I’ve released pyxser-1.2r my Python Object to XML serializer/deserializer. To get more information about this project, visit the pyxser web page. This release has with byte string encoding for Unicode strings. This means that all Unicode strings are serialized in a human readable form, and also a better form to use pyxser with other platforms, since the encoding regards a better interoperability with byte encoded string handlers.

Another interesting issue, is the fact that the source code is more ordered and it was refactored to get better reading on it. The disadvantage is that pyxser still is using the indirect recursion to serialize certain objects. I hope that it will change in a near future, but it do not harm the stack, because it is using pointer as parameters and not enough bytes to cause a stack overflow.

useful links for pyxser:

I you want to participate, just mail me

share this article at:

pyxser serialization model

Daniel Molina Wegener — Fri, 07 Aug 2009 01:47:41 +0000

pyxser is a Python-Object to XML serializer and deserializer. The common serialization model that follows most object-to-xml serialization implementations, are doing it in the same way. Most of them — possibly all of them — are doing the same task: they create a custom XML element (a custom tag) for every object. By custom XML element, I understand an element named MyObject for every object (class instance) of the type MyObject, without considering its namespace and other proper attributes that a well structured serialization needs.

For example, if we have the next class in C#:

public class Movie
{
    public string Title
    { get; set; }

    public int Rating
    { get; set; }

    public DateTime ReleaseDate
    { get; set; }
}

An object of that type should be serialized into the next XML document:



  Starship Troopers
  6.9
  1997-11-07T00:00:00

I’ve created a simple XML model defined in Document Type Definition specification and the proper XML Schema specification as the pyxser basis for object serialization. Also, it could be an object model — but isn’t wide extended to that purpose — and it’s just enough to allow the proper representation of serialized objects, with all the expressiveness that XML has, with some basis on the paper titled "Open Reusable Object Models" by Ian Piumarta and Alessandro Warth at Viewpoint Research Institute.

The model consist of three primary XML elements: obj, col and prop. Both obj and col elements are recursive, allowing both obj and col sub-elements. The document root is declared as the obj element. The model do not import any kind of entity set, this means that some known entities — such as iso-8859-1 bindings — are not imported and you can not use, for example, an ó entity. Both, the XML Schema and the DTD (Document Type Definition) can be imported/included in your own model — as the standard XML allows. In favor of processing friendly descriptions, it has defined most of their attributes as xs:NMTOKEN. I know that this one is a restriction to use symbols and localized characters in packages, class names and attribute names, but by using those things, the code itself is not portable.

Most constructs are defined as compositions, instead of associations — that in my opinion are not an important part of well designed systems and obviously minded for entity-relationship tasks — or aggregation, that aren’t parts of a decorated class, and, in my opinion are designed to hold collections.

pyxser uml object model

You may ask yourself "why the multiplicity of parents objects is mapped to 1..n?". The reason is simple: the model allows cross-referencing and circular-referencing objects. And also the algorithm supports it, and in the real world, you can find one object in different locations of the same object tree by having different references on it.

why composition?

Composite aggregation is a strong form of aggregation, which requires that a part instance be included in at most one composite at a time and that the composite object has sole responsibility for the disposition of its parts. The multiplicity of the aggregate end may not exceed one (it is unshared). See Section 5.43, "Association End," on page 231 for further details. The composite in a composition "projects" its identity onto the parts in the relationship. In other words, each part object in an object model can be identified with a unique composite object. It keeps its own identity as its primary identity. The point is that it can also be identified as being part of a unique composite. Composition is transitive. If object A is part of object B that is part of object C, then object A is also part of object C. A part may be identified with several composite objects in this way, each at a different level of detail.

Unified Modeling Language Specification, ISO/IEC 19501.

The reason seems to be obvious. Referenced or not, most real world objects — not those DTO that some people are using as RDMBS interface — are composite objects, and most of them have a certain depth. The representation with more than one object in the multiplicity is just a representation of the recursive structure that the model have, hard to separate or represent as association that is out of context on real UML modeling, and is not a simple aggregation, since most of those aggregations represents concrete attributes of an object. Also, the object roles are not necessarily representing the object role itself, instead they represent the xml node role and the same applies to the composite objects multiplicity.

why a 0..n child’s?

XML since it’s conception — and inherited from SGML — have two interesting kinds of attributes: ID attributes, to identify an element and IDREF attributes, to build element references. I’ve used both types to represent object references. In the case of an already serialized object in the object tree — the serializer finds the same object reference — an empty element is created and it holds the objid and objref attributes, the first pointing to the object identifier itself and the second pointing to the referenced element. Yeah!, it holds duplicate objects, do not re-create all the elements that it holds on the real object tree! I really don’t know if current serialization implementations are supporting cross-references and circular-references — I’m afraid of experimenting with it, and a crash is too much precious time that I don’t like to lose.

conclusion.

pyxser is a Python-Object to XML serializer that is made with an O(n) algorithm — possibly an O(log n) algorithm since it doesn’t repeat the steps of serializing objects many times as they appear, but it has hidden costs that I’ve don’t have measured yet — and it’s supporting cross-references and circular-references.

feedback request

should I implement a JSON serializer using this algorithm and model?
should I implement a YAML serializer using this algorithm and model?
what do you think about this serialization model?
does this model impact networking protocols by setting a large size for serialized objects?

share this article at: