Flip is a logical framework written in Python. Code, documentation,
and downloads are available:
A logical framework is a library for defining logics and writing
applications such as theorem provers. One Flip application is a proof
checker for entering and editing proofs in natural deduction style:
[(Text('~Ax.P(x) |- Ex.~P(x)'), comment),
(Not(A(x, P(x))), given),
(Not(E(x, Not(P(x)))), assume),
(E(x, Not(P(x))), Ei, 4),
(F, contra, 5,2),
(Not(Not(P(x))), raa, 4,6),
(P(x), ne, 7),
(A(x, P(x)), Ai, 3,8),
(F, contra, 9,1),
(Not(Not(E(x, Not(P(x))))), raa, 2,10),
(E(x, Not(P(x))), ne, 11)]
The checker can use different logics; Flip comes with several. You
can add another logic, or add axioms and derived rules, by writing a
module in Python. Python is both the object language and the
metalanguage. Formulas, inference rules, and entire proofs are Python
expressions. Prover commands are Python functions. The Python
interpreter itself is the only user interface to the proof checker
application. (It is not necessary to know much Python to use the
Flip was undertaken as a Python programming exercise. It is not
intended to compete with industrial-strength theorem provers such as
HOL nor with nicely-designed educational provers such as Jape. That
said, the checker is quite capable of working the examples and
exercises in university-level textbooks on logic for computer science
or mathematics (such as those by Kaye, Huth and Ryan, or Bornat).
I'm happy to announce a release candidate of pySerial: 2.5-rc1
- Updated documentation (now using Sphinx, see link above).
- Windows implementation uses ctypes (instead of pywin32).
- Python 3.x compatibility.
- Using "bytes" type when available.
- Works together with Pythons new io library.
- Several bugfixes.
- Updated and new examples.
- See CHANGES.txt in the distribution for full list.
Source archive and Windows installers can be downloaded from here:
The Windows installer for Python 3.x has py3k in its name, the other one
is for Python 2.x. The source archive's setup.py should automatically
convert using 2to3 when run with Python 3.x.
What is pySerial? Quoting from the home page:
This module encapsulates the access for the serial port. It provides
backends for Python running on Windows, Linux, BSD (possibly any POSIX
compliant system), Jython and IronPython (.NET and Mono). The module
named "serial" automatically selects the appropriate backend.
The Python community is both incredibly diverse (Python 3.1's release
manager was not yet eighteen years old) and incredibly lacking in
diversity (none of the regular committers is a woman).
Kirrily Robert gave a keynote at OSCON last week about women in Open
Source, and I blogged about the lunchtime aftermath (if you're not
familiar with the issues, I suggest making sure to follow all the links
Thinking further, I believe that the Python community really needs to be
more active in creating diversity. As my blog says, the first step is
for us to admit that there is a problem.
I believe that the next step is for us as a community to make a formal
statement supporting diversity. I've created a new mailing list
(diversity(a)python.org) to discuss the wording of a diversity statement,
along with discussing diversity issues in general. I invite anyone
interested in the subject of diversity to join the list -- even if you
disagree that actively supporting diversity is needed, I would like a
chance to convince you.
Please note that I believe that the Python community is generally
welcoming and that the Python community would jump on anyone who behaved
in an overtly prejudiced way (unlike some controversies in other
communities). However, I think that we have also inherited the lack of
diversity in Open Source as a whole, and I believe that taking a more
active role in building diversity will build a more vibrant Python
After all, as Kirrily pointed out, the more inclusive we are, the more
people we have working on Python.
I just started a new job this week, so I'm not going to be pushing this
any time soon -- but I also feel that I need to throw this out so that
other people can get involved if they want.
Aahz (aahz(a)pythoncraft.com) <*> http://www.pythoncraft.com/
"Many customs in this life persist because they ease friction and promote
productivity as a result of universal agreement, and whether they are
precisely the optimal choices is much less important." --Henry Spencer
this is a pre-release announcement, 0.6pre2, of the pyjamas widget set
CHANGELOG since the last stable release, 0.5p1, and so it was deemed
sensible to invite people to test this version before its next stable
pyjamas, being a port of GWT to python, comprises four main components:
* a desktop-based wrapper around python-xpcom or pywebkitgtk
* a browser "DOM" model wrapper interface
* a widget set similar to pygtk2 / pyqt4, based on DOM manipulation
significantly in the 0.6 series, pyjamas-desktop has been incorporated
into the build: "python Hello.py" will start a stand-alone app (just
as you would with pygtk2 or pyqt4) and "pyjsbuild Hello" will compile
the combination means that pyjamas can run python applications -
unmodified - in all major web browsers, or on the desktop (using gecko
or webkit) in a similar fashion to adobe AIR.
performance hit was introduced by accident. this has now been fixed.
however, random desperate attempts to improve performance, before the
mistake was corrected, mean that the pyjamas 0.6pre2
also in the 0.6pre2 release, "strict" python options have now been
introduced, so that developers can expect much more support for the
standard python 2.5 / 2.6 language semantics. the "-O" option
disables many of these features, bringing a quite significant speed
increase, by sacrificing python compatibility. that's just the way it
has to be.
downloads can be found by following the links from http://pyjs.org -
sourceforge, code.google.com, pypi, all the usual places.
lastly - thank you to everyone who's helped with pyjamas: bernd,
bernd, jurgen, christian, kees, ondrej and many more, and especially
thank you to the people who helped out by pointing out bugs in the
0.6pre1 release, please keep it up!
-----BEGIN PGP SIGNED MESSAGE-----
I'm pleased to announce pyxser-1.1r, a Python-Object to XML
serializer and deserializer. This package it's completly
written in C and licensed under LGPLv3.
The tested Python versions are 2.5.X and 2.7.X.
* home page:
* hosted at:
The current ChangeLog is as follows:
Daniel Molina Wegener <dmw(a)coder.cl>
* Removed bugs concerning XML schema declaration for output
* Removed bugs concerning XML schema design for C14N
* Removed exc argument from C14N serialization functions,
because they have no sense.
* Code cleanup with function arguments (C code).
* All changes seems to be transparent for previous versions.
Also, I need a little bit of feedback. I want it to be able to
serialize files and buffers: I've planned to allow the user
to have three options: ignore files, serialize them in base64
encoding and just put the file name as string. But my question
concerns how the files and buffers are deserialized: I must
allow the user to dump the files on a directory, put the complete
file on a buffer object, or just extract the base64 encoded
Best regards and thanks in advance...
.O. | Daniel Molina Wegener | FreeBSD & Linux
..O | dmw [at] coder [dot] cl | Open Standards
OOO | http://coder.cl/ | FOSS Developer
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (FreeBSD)
-----END PGP SIGNATURE-----
The next meeting of the Melbourne Python Users Group will be on
Tuesday the 11th of August starting at 6:30pm. We'll be meeting at
Horse Bazaar again but this time we'll have use of their projector.
We'll have time for several short presentations or lightning talks.
Meeting details, location and talks list are at:
If you've seen something cool or are doing something cool then we'd
like you to tell everyone about it! Presentations could be 5 minutes
or up to 15 minutes if you'd like to ramble for a bit longer. I'll be
getting up to talk a bit about my experiences playing with IronPython
- what's cool and what's downright odd :)
If you've got an idea for a talk just add it to the wiki page.
Announcing argparse 1.0
The argparse module provides an easy, declarative interface for
creating command line tools, which knows how to:
* parse the arguments and flags from sys.argv
* convert arg strings into objects for your program
* format and print informative help messages
* and much more...
The argparse module improves on the standard library optparse module
in a number of ways including:
* handling positional arguments
* supporting sub-commands
* allowing alternative option prefixes like + and /
* handling zero-or-more and one-or-more style arguments
* producing more informative usage messages
* providing a much simpler interface for custom types and actions
The argparse homepage has links for source, MSI and single file
distributions of argparse:
About this release
This release includes a number of new features:
* Support for Python versions 2.3 through 3.1. No need to run 2to3 or
anything like that -- the argparse source code is both fully 2.X
and 3.X compatible.
* ``ArgumentParser`` grew a ``parse_known_args`` method which works
like ``parse_args`` but collects unrecognized arguments into a list
instead of raising an exception
* The ``ArgumentParser`` constructor accepts a new parameter for
reading additional arguments from files. For example,
``fromfile_prefix_chars='@'`` means that arguments like ``@file``
should be replaced by the arguments read from the given file.
* A new formatter class, ``ArgumentsDefaultHelpFormatter`` is
available, which will automatically add ``(default: %(default)s)``
to all argument help messages
* The ``metavar`` parameter to ``add_argument`` now accepts a tuple
of strings in additional to a single string so that more than one
name can be specified.
* The ``add_subparsers`` method now accepts ``title`` and
``description`` parameters which will cause it to display like an
argument group in help messages.
Find a new release of python-ldap:
python-ldap provides an object-oriented API to access LDAP directory
servers from Python programs. It mainly wraps the OpenLDAP 2.x libs for
that purpose. Additionally it contains modules for other LDAP-related
stuff (e.g. processing LDIF, LDAPURLs and LDAPv3 schema).
Released 2.3.9 2009-07-26
Changes since 2.3.8:
* All modules (ldap, ldif, dsml and ldapurl) have common version number now
* Non-exported function ldif.needs_base64() was abandoned and is now
implemented as method LDIFWriter._needs_base64_encoding().
This allows sub-classes of LDIFWriter to implement determining whether
attribute values have to be base64-encoded in a different manner and is
the same approach like in class dsml.DSMLWriter.
* LDAPUrlExtension._parse() now gracefully handles LDAP URL extensions
without explicit exvalue as being set with implicit value None.
* New LDAP option constant ldap.OPT_X_SASL_NOCANON supported