On behalf of the Jython development team, I'm pleased to announce that
Jython 2.5a0+ is available here
http://downloads.sourceforge.net/jython/jython_installer-2.5a0.jar for
download. See http://jython.org/Project/installation.html for
installation instructions.
This is the first alpha release of Jython 2.5 and contains many new
features. In fact, because we have skipped 2.3 and 2.4, there are too
many to even summarize. A few of the features are:
* generator expressions
* with statement
* exceptions as new-style classes
* unicode support more in line with CPython
* decorators
Under the hood Jython 2.5 has a new parser based on ANTLR 3.1 and the
compiler has been refactored to use ASM.
There are so many more changes that I have missed more than I have
listed. This is an alpha release, so there are known and unknown
bugs, so be careful.
TakeNote is a simple cross-platform note taking program implemented in
Python. I have been using it for my research and class notes, but it
should be applicable to many note taking situations. Although this is
my first release, it has most of the basic features needed for
effective notes.
TakeNote is ideal for storing your class notes, TODO lists, research
notes, journal entries, paper outlines, etc in a simple notebook
hierarchy with rich-text formatting, images, and more. Using full-text
search, you can retrieve any note for later reference.
TakeNote is designed to be cross-platform (runs on Windows, Linux, and
MacOS X, implemented in Python and PyGTK) and stores your notes in
simple and easy to manipulate file formats (HTML and XML). Archiving
and transferring your notes is as easy as zipping or copying a
folder. TakeNote is licensed under GPL.
TakeNote 0.4 is has the following features:
* Rich-text formatting
* Hierarchical organization for notes
* Full-text search
* Inline images
* Integrated screenshot
* Spell checking (via gtkspell)
* Auto-saving
* Built-in backup and restore (archive to zip files)
* Cross-platform (Linux, Windows, MacOS X)
Web site and download:
http://rasm.ods.org/takenote
Matt Rasmussen
pyogp is a Python-based virtual worlds test harness and client library
being developed by Linden Lab, makers of Second Life, and members of the
SL Architecture Working Group, in order to test the Open Grid Protocols
that were used in the recent "proof of concept" demo by IBM and Linden
Lab, that allowed avatars to teleport from one virtual world (Second
Life) to another (Open Simulator) using standardized interoperability
protocols.
http://www.informationweek.com/news/personal_tech/virtualworlds/showArticle…
A daily meeting within Second LIfe has been setup for pyogp coders and
designers to meet, as described in the announcement below. This is the
transcript of the first meeting:
http://wiki.secondlife.com/wiki/Pyogp/Chat_Logs/Daily_Meeting/14_jul_2008
The pyogp meetings are open to any "resident" of Second Life, and anyone
with a desire to contribute to the process (especially coding) is
certainly welcome.
In World Meetings
We're going to start having daily meetings at "infinity is full of
stars" in the Levenhall simulator in Second Life at 9:30AM SLT (Pacific
Coast Time) each day. These meetings are for the PyOGP coders to meet
and discuss design, process and status. In the near term, these are
likely to be "somewhat beefy" meetings where design issues are discussed
and differences hammered out. In the longer term, these will hopefully
be more "Agile Stand-Up" style meetings where we discuss: a. what we've
done in the last 24 hours, b. what we're going to do in the next 24 and
c. what we're blocked on.
what PyOGP Coders Meeting
who PyOGP l33t C0d3rZ
where "infinity is full of stars" @
http://slurl.com/secondlife/Levenhall/91/208/22
when 9:30AM SLT / 12:30PM Eastern Time / 5:30PM GMT / 6:30PM Central
European Time
why for PyOGP contributors to hash out architecture, design, test
and deploy issues
IRC: irc://irc.freenode.com/#pyogp
Mailing list: https://lists.secondlife.com/cgi-bin/mailman/listinfo/pyogp
wiki: http://wiki.secondlife.com/wiki/Pyogp
I am pleased to announce version 2.15.0 of the Python bindings for GObject.
The new release is available from ftp.gnome.org as and its mirrors
as soon as its synced correctly:
http://download.gnome.org/sources/pygobject/2.15/
There are two new significant features in this release, initial
bindings for GIO. Note that these are not complete, please report
missing API in Bugzilla so we know what people are missing.
Codegen has been moved from PyGTK and can now be used without
depending on GTK+, which should be useful for GObject based libraries.
What's new since PyGObject 2.14.x?
- Add GIO bindings (Johan, Mario Tagliaretti, Thomas Leonard)
- Move codegen from PyGTK (Johan, Paul Pogonyshev, #542821)
- Add more variables to the .pc files (Damien Carbery, Paul,
Dan Winship, #486876)
- Add pyg_option_group_new to the public API (Johan)
- Add g_get_application_anme and g_get_progname (Sebastian Rittau)
- Avoid making wakeups when using Python 2.6 (Johan, Gustavo,
Adam Olsen, Josselin Mouette, Philippe Normand, Guido Van Rossum)
- Only link against libffi when found (Ed Catmur, #496006)
- Improve gobject.property (Tomeu Vizoso, #523352)
- Improve enum comparision and warnings (Paul, Phil Dumont, #428732)
- Many gobject.Source improvements (Bryan Silverthorn)
- Apply some fixes to make pylint happier (Johan, Simon Schampijer,
#523821)
- Fix error message in pyg_io_add_watch (Juha Sahkangas)
- Improve h2def.py (Oliver Crete, Murray Cumming, Lauro Moura)
Blurb:
GObject is a object system library used by GTK+ and GStreamer.
PyGObject provides a convenient wrapper for the GObject+ library for use
in Python programs, and takes care of many of the boring details such as
managing memory and type casting. When combined with PyGTK, PyORBit and
gnome-python, it can be used to write full featured Gnome applications.
Like the GObject library itself PyGObject is licensed under the
GNU LGPL, so is suitable for use in both free software and proprietary
applications. It is already in use in many applications ranging
from small single purpose scripts up to large full
featured applications.
PyGObject requires glib >= 2.8.0 and Python >= 2.3.5 to build.
GIO bindings require glib >= 2.16.0.
--
Johan Dahlin
jdahlin(a)async.com.br
what is it
----------
A Python package to parse and build CSS Cascading Style Sheets. (Not a
renderer though!)
main changes
------------
There has been a **major change** in this release which may affect your
program and may require some rewriting... There is a workaround (see
below) but please take care. The second major change in this release is
a quite noticable performance improvement which was more or less a side
effect of a bugfix...
0.9.5rc2 080714
- **API CHANGE/BUGFIX (major)**:
Upto 0.9.5rc1 any sheet resulting from parsing via any
``parse*`` function or ``CSSParser(raiseExceptions=False)`` (which also
was and is the default) resulted in the library simply logging any later
exceptions and not raising them. Until now the global setting of
``cssutils.log.raiseExceptions=True`` (the default) was overwritten with
the value of the CSSParser ``raiseExceptions`` setting which normally is
``False`` any time a ``cssutils.parse*`` function or
``CSSParser.parse*`` method was used. 0.9.5rc2 fixes this.
until 0.9.5rc1::
>>> # parsing does not raise errors
>>> s = cssutils.parseString('$') # empty but CSSStyleSheet
object
>>> # using DOM methods does **not raise either** but should:
>>> s.cssText = '$' # just logs:
ERROR CSSStyleRule: No start { of style declaration
found: u'$' [1:2: ]
from 0.9.5rc2::
>>> # parsing STILL does not raise errors
>>> s = cssutils.parseString('$') # empty but CSSStyleSheet
object
>>> # using DOM methods **does raise now though**
>>> s.cssText = '$' # raises:
xml.dom.SyntaxErr: CSSStyleRule: No start { of style
declaration found: u'$' [1:1: $]
To use the old but false behaviour add the following line at
the start to your program::
>>> cssutils.log.raiseExceptions = False # normally True
**This should only be done in specific cases** as normal
raising of exceptions in methods or functions with the CSS DOM is the
expected behaviour. **This setting may also be removed in the future so
use with care.**
- **BUGFIX**: Parsing of @rules like ``@mediaall ...`` does not
result in ``@media all ...`` anymore (so not a ``CSSMediaRule``) but
parses as ``@mediaall`` so a ``CSSUnknownRule``. The specification is
not too clear here but it seems this is the way to go. To help finding
typos like this probably is, for any found CSSUnknownRule (an unknown
@rule) a WARNING is emitted now (but never an exception raised). These
typos will most likely happen like e.g. ``@mediaall``, ``@importurl()``,
``@namespaceprefix"uri"`` or ``@pagename:left``.
- **BUGFIX**: Parsing of unicode escapes like ``\\abc`` followed by
CR/LF this is now correctly combined as only a single whitespace character.
- **BUGFIX**: Adding a malformed ``stylesheets.MediaQuery`` to a
``stylesheets.MediaList`` does fail now, e.g.::
>>> # invalid malformed medialist (missing comma):
>>> sheet = cssutils.parseString('@media tv INVALID {a
{top: 0;}}')
ERROR MediaQuery: Unexpected syntax. [1:11: INVALID]
ERROR MediaList: Invalid MediaQuery: tv INVALID
>>> # the actual rule exists but has default empty content,
this may be
changed later as it can be seen as a bug itself
>>> sheet.cssRules[0]
cssutils.css.CSSMediaRule(mediaText=u'all')
>>> sheet.cssText
''
>>> # BUT: Unknown media type but as it is valid does parse:
>>> sheet = cssutils.parseString('@media tv, UNKNOWN {a
{top: 0;}}')
WARNING MediaQuery: Unknown media type "UNKNOWN".
>>> sheet.cssRules[0]
cssutils.css.CSSMediaRule(mediaText=u'tv, UNKNOWN')
>>> sheet.cssText
'@media tv, UNKNOWN {\n a {\n top: 0\n }\n
}'
- **BUGFIX**: References to ``MediaList`` in ``CSSImportRule`` and
``CSSMediaRule`` are kept now properly.
- BUGFIX: Deleting a ``MediaQuery`` item from a ``MediaList`` does
use the libs logging/raising settings instead of always raising
- **IMPROVEMENT**: Parsing performance has been improved (by about
25%, tested with a basic CSS of about 50 lines, so may not be
representative but this release definitely is faster ;). The following
changes have been done which should not impact any actual stylesheet:
+ A ``BOM`` token is recognized at the start of a stylesheet
only (may be swallowed by the CSS codec anyway).
+ A ``BOM`` token is not counted in the line/col reporting
anymore so the following token has a line and col of 1 now
+ Tests for tokenizing with css2productions has been removed
but this is never used in the library anyway
Note:
CSSValue, CSSValueList, and CSSPrimitiveValue and the relevant
methods/properties Property.cssValue and
CSSStyleDeclaration.getPropertyCSSValue are more or less DEPRECATED and
will probably be replaced with interfaces defined in CSSOM. For now use
the properties and methods that handle values as simple strings, e.g.
``Property.value``. As the aforementioned classes are not hardly that
useful anyway this should not be a big problem but please beware if you
use or have used them.
If you think this a bad idea please let me know!
license
-------
cssutils is published under the LGPL version 3 or later, see
http://cthedot.de/cssutils/
If you have other licensing needs please let me know.
download
--------
For download options see http://cthedot.de/cssutils/
cssutils needs Python 2.4 or higher (tested with Python 2.5.2 on Vista only)
Bug reports (via Google code), comments, etc are very much appreciated!
Thanks.
Christof
Final reminder, we're in the last two weeks of open registration for
PyCamp, Plone Boot Camp, and Advanced Plone Boot Camp:
http://trizpug.org/boot-camp/2008/
Registration is now open for:
PyCamp: Python Boot Camp, August 4 - 8
Plone Boot Camp: Customizing Plone, July 28 - August 1
Advanced Plone Boot Camp: Plone 3 Techniques, August 4 - 7
All of these take place on the campus of the University of North
Carolina at Chapel Hill in state of the art high tech classrooms, with
free mass transit, low-cost accommodations with free wireless, and
convenient dining options.
Plone Boot Camp is taught by Joel Burton, twice chair of the Plone
Foundation. Joel has logged more the 200 days at the head of Plone
classrooms on four continents. See plonebootcamps.com for dozens of
testimonials from Joel's students.
PyCamp is taught by Chris Calloway, facilitator for TriZPUG and
application analyst for the Southeast Coastal Ocean Observing System.
Chris has developed PyCamp for over 1500 hours on behalf of Python
user groups. Early bird registration runs through June 30. So register
today!
PyCamp is TriZPUG's Python Boot Camp, which takes a programmer
familiar with basic programming concepts to the status of Python
developer with one week of training. If you have previous scripting or
programming experience and want to step into Python programming as
quickly and painlessly as possible, this boot camp is for you. PyCamp
is also the perfect follow-on to Plone Boot Camp: Customizing Plone
the previous week.
At Plone Boot Camp: Customizing Plone you will learn the essentials
you need to build your Plone site and deploy it. This course is the
most popular in the Plone world--for a good reason: it teaches you
practical skills in a friendly, hands-on format. This bootcamp is
aimed at:
* people with HTML or web design experience
* people with some or no Python experience
* people with some or no Zope/Plone experience
It covers using Plone, customizing, and deploying Plone sites.
At Advanced Plone Boot Camp: Plone 3 Techniques you will learn to
build a site using the best practices of Plone 3 as well as advance
your skills in scripting and developing for Plone. The course covers
the new technologies in Plone 3.0 and 3.1intended for site integrators
and developers: our new portlet infrastructure, viewlets, versioning,
and a friendly introduction to Zope 3 component architecture. Now,
updated for Plone 3.1! The course is intended for people who have
experience with the basics of Plone site development and HTML/CSS. It
will cover what you need to know to take advantage of these new
technologies in Plone 3.
For more information contact: info(a)trizpug.org
grin is a new grep-like tool for recursively searching through text
files, primarily source code.
Download: http://pypi.python.org/pypi/grin
Wiki: https://svn.enthought.com/enthought/wiki/Grin
SVN: https://svn.enthought.com/svn/sandbox/grin/trunk
Basically, it does exactly what I want grep to do 99% of the time with
the least amount of thinking: recursive grep that skips crud I'm
almost never interested in. For example, .svn/ directories contain
"clean" copies of your source code to enable quick local operations
that don't talk to the server. grepping through a Subversion checkout
will pick up false positives in these files.
grin solves this problem and also serves as a nice library for you to
implement custom search tools. If you can make a filelike object with
the text you want to search, the grin library can search it with all
of the same features of the command line tool. I talk about these
possibilities a little more over here:
http://blog.enthought.com/?p=45
--
Robert Kern
robert.kern(a)enthought.com
Greetings,
The merchant account processor that we use for the SciPy Conference
online registration has been experiencing some inexplicable problems
authorizing some registrations. Apologies to those who have struggled
to register and have not been successful. Because of the problems,
we're extending the early-bird rates through Monday at midnight
Central Time. If you experience any problems registering, please give
us a call during business hours Monday (9:00am - 5:00pm Central -
512.536.1057).
http://conference.scipy.org/
For those of you who have set up an account on the conference site,
but have not yet registered, I encourage you to do so in time to take
advantage of the lower rates. I also encourage everyone to make sure
you've specified which tutorial track, T-shirt size, whether you'll
attend the sprint, and meal preferences in your profile (http://conference.scipy.org/profile
).
Please send me an email if you have any questions.
Best,
Travis
We'll be holding our regular Toronto Python User's Group (PyGTA) this
upcoming Tuesday the 15th 7pm at Linux Caffe, on the corner of Grace and
Harbord Street. At the moment we don't have a confirmed speaker, so I
was thinking we might try the following (inspired by one of Greg
Wilson's recent blog posts[1]):
Code Aesthetics
Bring a piece of code that you love. Something that's elegant,
beautiful, efficient, useful, perfectly formatted, meaningful,
warped or wonderful in some way. We'll take 5 minutes each and
present our chosen piece of code. Then we'll have people ask
questions about the code and why you love it.
The code has to be something that can be exposed to the public w/out
any non-disclosure agreements or the like, but doesn't necessarily
have to be Open Source or distributed. What we're looking for is a
discussion of the beauty in the code, the amazing things about it
that make it worthwhile. The code does *not* need to be your own
work, nor does it necessarily need to be in Python. If possible,
try to cut down the code you *present* to a couple of pages
(screens) of code, but if your aesthetic preference runs to big
systems, be able to describe the system you choose well enough to
communicate the wonder of it to the rest of us.
Is there any beautiful code out there? Does beauty in code matter?
Is code poetry or just grotty machinery?
We'll likely repair to a location with beer as the evening winds on and
the philosophy runs deep.
http://www.pygta.org
Have fun,
Mike
[1] http://pyre.third-bit.com/blog/archives/1650.html
--
________________________________________________
Mike C. Fletcher
Designer, VR Plumber, Coder
http://www.vrplumber.comhttp://blog.vrplumber.com