4RDF, available with 4Suite 0.9.1, is the feature article this week on
XML.com. Python now has the most fully-featured Resource Description
Framework (RDF) library available and the XML.com library discusses the
details.
http://www.xml.com/pub/2000/10/11/rdf/index.html
or until Oct 19, simply
http://www.xml.com
Knowledge of XML and RDF (which is simple enough) is required. Links to
that effect are provided in the article.
--
Uche Ogbuji Principal Consultant
uche.ogbuji(a)fourthought.com +1 303 583 9900 x 101
Fourthought, Inc. http://Fourthought.com
4735 East Walnut St, Ste. C, Boulder, CO 80301-2537, USA
Software-engineering, knowledge-management, XML, CORBA, Linux, Python
Fourthought, Inc. (http://Fourthought.com) announces the release of
4Suite 0.9.1
---------------------------
Open source tools for standards-based XML, DOM, XPath, XSLT, RDF
XPointer and object-database development in Python
4Suite is a collection of Python tools for XML processing and object
database management. An integrated packaging of several formerly
separately-distributed components: 4DOM, 4XPath and 4XSLT, 4RDF, 4ODS
and featuring the new 4XPointer.
News
----
* Introduced 4XPointer: A parser for xpointer expressions
* 4XPath: optimized parse tree, now minimizes itself as
it is created.
* 4XPath: self-validating test suite
* 4XSLT and 4XPath: better support for the namespace axis
* 4XSLT and 4XPath: optimized context management
* 4XSLT implemented cdata-section-elements
* 4DOM (HTML): Much improved test suite (actually works,
somewhat)
* 4DOM: improved error handling
* 4RDF: Implement RDF Schemas
* 4RDF: RIL bug fixes
* 4RDF: API clean-up, improve URI handling
* 4RDF: driver bug fixes
* 4RDF: improved error handling
* 4RDF: Serialization/deserialization bug-fixes
* 4ODS: IMprovements and fixes to DOMWrapper
* 4DOM and XSLT output fixes
* 4ODS Fixed bugs in OqlParsers
* 4ODS Fixed bugs in Oif dump and load
* Improved exceptions and bug-fixes in cDomlette
* Packaging fixes
* Added and improved test suites
* Many misc optimizations
* Many misc bug-fixes
More info and Obtaining 4Suite
------------------------------
Please see
http://Fourthought.com/4Suite
Or you can download 4Suite source from
ftp://Fourthought.com/pub/4Suite
There are Windows Packages, Linux RPM and Linux binary also available at
ftp://Fourthought.com/pub/4Suite
4Suite is distributed under a license similar to that of Python.
--
Uche Ogbuji Principal Consultant
uche.ogbuji(a)fourthought.com +1 303 583 9900 x 101
Fourthought, Inc. http://Fourthought.com
4735 East Walnut St, Ste. C, Boulder, CO 80301-2537, USA
Software-engineering, knowledge-management, XML, CORBA, Linux, Python
I'm happy to announce:
AmigaPython 1.6 - build 1
The Amiga version of Python.
WHAT IT IS:
This is the Python interpreter (version 1.6) for AmigaDOS.
WHAT'S NEW ?
- New version 1.6! Based on main Python 1.6 final source code.
- First fully Unicode aware application on AmigaDOS! (as far as I know)
WHERE CAN I GET IT ?
>From Aminet <http://us.aminet.net/~aminet/>, in the dev/lang directory:
Python16.lha Python language 1.6 (bin+lib)
Python16_Src.lha Python language 1.6 (source)
Also have a look at my Python pages at
<http://www.bigfoot.com/~irmen/python.html>.
It comes with a Python-style license, but is otherwise free for
commercial and non-commercial use.
REFERENCE:
<P><A HREF="http://www.bigfoot.com/~irmen/python.html">
AmigaPython 1.6</A> - AmigaDOS port of Python 1.6 (12-Oct-2000)
----
Irmen de Jong irmen@
bigfoot.com
I'm pleased to announce the release of threadpool.py, released under the
GNU LGPL.
Threadpool.py can be obtained from:
http://sourceforge.net/projects/xoltar-toolkit/
and requires the functional.py module available from the same page, or
you can download the combined toolkit.
This module uses the threading and Queue modules to create a pool of
reusable threads.
Version 0.8 is a major rewrite of the version previously available from
my Python Starship page. It now supports a much cleaner interface,
thanks to functional.py.
After creating an instance of ThreadPool, one queues functions to be
executed. The pool dispatches the functions to the waiting threads,
which call them.
When queuing a function on the pool with *pool*.put(), an instance of
ReturnValue is returned. ReturnValue is a subclass of functional.Lazy,
and can be used in any context that a regular lazy expression can. When
evaluating a ReturnValue, the evaluating thread will block until the
other thread has completed its work and loaded the return value of the
function into the ReturnValue instance.
VLocks are an alternative to RLocks which include a visible queue
threads waiting for the lock.
lock, unlock, getLockFor, and deleteLockFor work with a module level
dictionary of objects to locks, and can be more convenient than working
with lock objects directly.
Locked and Async are callable wrappers around a function. Async calls
return immediately after queuing their function on a thread pool, while
Locked calls first acquire the lock they were passed on creation, call
their function, and release the lock.
--
Bryn Keller
xoltar(a)starship.python.net
I'm pleased to announce the release of functional.py version 0.6,
released under the GNU LGPL.
functional.py can be obtained from:
http://sourceforge.net/projects/xoltar-toolkit/
functional.py provides support for a functional style of Python
programming.
It includes support for closures, curried functions, lazy expressions,
lazy tuples (functional programming languages call these lazy lists, but
since lists are mutable in Python, tuples are closer in meaning), and
lazy equivalents for map, filter, reduce, and zip. Also some higher
order functions for composing functions and such.
This release fixes a problem that prevented zero length LazyTuples
(thanks to Alex Martelli for catching this one). It also adds several
new functions or functors:
class sequential:
"""
Take a number of functions, and when called, call each of them in
turn. The
first function in the list is the "main", or significant function,
and the
others are taken for side effects only. Their return values do not
affect
the return value of the also function, and any errors they raise are
silently disregarded. If a function is explicitly specified via the
*main*
parameter, that function will be the one whose return value is used,
regardless
of where in the sequence it appears. Example:
>>> def one():
... print "one"
... return 1
...
>>> def two():
... print "two"
... return 2
...
>>> def three():
... print "three"
... return 3
...
>>> x = one()
one
>>> x
1
>>> x = sequential([one, two, three])()
one
two
three
>>> x
1
>>>
>>> x = sequential([one, two, three], main = three)()
one
two
three
>>> x
3
>>>
"""
def also(*args):
"""
Handles the common case for **sequential**, in which the first
function
passed is the significant one. It takes free arguments instead of a
single
sequence argument. Example:
>>> def one():
... print "one"
... return 1
...
>>> def two():
... print "two"
... return 2
...
>>> def three():
... print "three"
... return 3
...
>>> one()
one
1
>>> x = one()
one
>>> x
1
>>> x = also(one, two, three)()
one
two
three
>>> x
1
>>> x = also(two, one, three)()
two
one
three
"""
class always:
"""
Returns a callable which always returns a given object.
Example:
>>> f = always(5)
>>> f()
5
>>>
"""
class any_args:
"""
Returns a callable which will take any arguments, and ignore them,
calling *func* with no arguments. Useful with map(), or in the
common
case of GUI event handlers which need to accept an event parameter,
but do not use it. Example:
>>> def return5():
... return 5
...
>>> return5("unneeded", "unnecessary")
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: no arguments expected
>>> f = any_args(return5)
>>> f("unneeded", "unnecessary")
5
>>>
"""
class with_error:
"""
Takes a function, and an error-handler function. When called, the
first
function will be called. Any errors will cause the error function to
be called with sys.exc_info() as the argument, *and the return value
of the error handler will be returned.* If the error-handler
function
re-raises the exception (or another), the exception will propagate
back
to the caller. It is possible to chain error-handlers together with
**atempt**, below.
Example:
>>> from operator import div
>>> div(1/0)
Traceback (innermost last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo
>>> def recover(exc):
... return sys.maxint
...
>>> safediv = with_error(div, recover)
>>> safediv(1, 0)
2147483647
>>>
"""
class attempt:
"""
Given a function sequence, attempt to call and return each in turn.
The
return value of the first function to successfully return is
returned.
This could be used to implement something like the pattern matching
techniques
used in functional languages. A common use would be attaching error
handlers
to functions after the fact. Suppose we want a want a version of the
div()
function that returns sys.maxint when we attempt to divide by zero,
and
zero if we attempt to divide by something other than a number as in
this example:
>>> def zeroHandler(exc_info):
... exc = exc_info[1]
... if isinstance(exc, ZeroDivisionError):
... return sys.maxint
... else:
... raise
...
>>> safediv = with_error(div, zeroHandler)
>>> safediv(1, 0)
2147483647
>>> def typeHandler(exc_info):
... exc = exc_info[1]
... if isinstance(exc, TypeError):
... return 0
... else:
... raise
...
>>> safediv = with_error(div, attempt(zeroHandler, typeHandler))
>>> safediv(1,0)
2147483647
>>> safediv(1, "abc")
0
>>>
"""
--
Bryn Keller
xoltar(a)starship.python.net
The Python ServerPages distribution on sourceforge has been updated with the
latest release. This software is still considered alpha, or pre-beta :-)
You can get it at http://sourceforge.net/projects/pythonpages
It is also mirrored at (with more documentation) at:
http://www.jbrisbin.net/PythonServerPages
What is this PSP implementation?
Python ServerPages is an OpenSource project that seeks to give developers
wishing to embed Python into their HTML pages a consistent and stable parse
engine, which would increase their productivity, while including small,
simple services to reduce repetitive tasks that every developer faces.
The changes to version 0.7.0a include:
* Major bug fixes :-)
* Added html_quote(stuff) function
* Added include(file="file.html") function
* Added a proc_total_time to gauge the speed of parsing and executing the
page
* Added a view_source() function to aid in debugging
* Altered the parsing routine to allow nested parsing
This version of PSP is easier to use (sample code:)
[-
include(file="header.psp")
first_name = Form.name
-]
[+Form.name+]
[$ def do_something(self, param): $]
<h5>[+param+]</h5>
[$ enddef $]
[$ if Form.name == "harry": $]
[- do_something("Harry") -] is logged in.
[$ endif $]
[- include(file="page2.psp") -]
[- include(file="footer.html") -]
Some documentation is also available at
http://www.jbrisbin.net/PythonServerPages
Enjoy!
Jon Brisbin
www.jbrisbin.net
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Email: mail(a)jbrisbin.net
PSP Home: www.jbrisbin.net/PythonServerPages
Public PGP key: www.jbrisbin.net/pgpkey.shtml
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ANNOUNCING:
Stackless Python 1.2
A Python Implementation That
Does Not Use The C Stack
* plus the real toy *
Continuation Module 0.9
Continuations as First Class Objects
with support for MicroThreads
What is it?
A plugin-replacement for core Python.
It should run any program which runs under Python 1.5.2 .
But it does not need space on the C stack.
For further info, see the new site at
http://www.stackless.com
You might also want to join the mailing list at
http://starship.python.net/mailman/listinfo/stackless
Major changes in this release:
Extra reference counting reduces continuation frame creation
Better exception handling avoids cycles.
Next to come:
- A port to Python 2.0 will be the first thing to do.
- Long-term project is a complete redesign and
rewrite for inclusion with Python 2.1
ciao - Christian Tismer / Mission Impossible 5oftware Team
<P><A HREF="http://www.tismer.com/research/stackless/">Stackless
Python 1.2 + Continuations 0.9</A> - a version of Python 1.5.2 that
does not need space on the C stack, first-class callable
continuation objects for Python, and Microthread-support.
(10-Oct-2000)
</P>
--
http://www.python.org/mailman/listinfo/python-list
Hello!
Bookmarks Database and Internet Robot
WHAT IS IT
Here is a set of classes, libraries, programs and plugins I use to
manipulate my bookmarks.html. I like Netscape Navigator, but I need more
features, so I write and maintain these programs for my needs. I need to
extend Navigator's "What's new" feature (Navigator 4 named it "Update
bookmarks").
WHAT'S NEW in version 3.0
Complete rewrite from scratch. Created mechanism for pluggable storage
managers, writers (DB dumpers/exporters) and robots.
WHAT'S NEW in version 3.2.0
New simple_tos robot, based on timeoutsocket.py.
New writer fald_err that dumps only errors from the database.
WHERE TO GET
Master site: http://phd.pp.ru/Software/Python/#bookmarks_db
Faster mirrors: http://skyscraper.fortunecity.com/unix/797/Software/Python/#bookmarks_dbhttp://members.nbci.com/_XMCM/phd2.1/Software/Python/index.html#bookmarks_db
AUTHOR
Oleg Broytmann <phd2(a)earthling.net>
COPYRIGHT
Copyright (C) 1997-2000 PhiloSoft Design
LICENSE
GPL
STATUS
Storage managers: pickle, FLAD (Flat ASCII Database).
Writers: HTML, text, FLAD (full database or only errors).
Robots (URL checker): simple, simple+timeoutscoket, forking.
TODO
Documentation.
New storage managers: shelve, SQL, MetaKit.
Robots (URL checkers): threading, asyncore-based.
Aliases in bookmarks.html.
Configuration file for configuring defaults - global defaults for the system
and local defaults for subsystems.
Detailed reports on robot run - what's old, what's new, what was moved,
errors, etc.
WWW-interface to the report.
Bigger database. Multiuser database. Robot should operate on a part of
the DB.
WWW-interface to the database. User will import/export/edit bookmarks,
schedule robot run, etc.
Oleg.
----
Oleg Broytmann http://phd.pp.ru/ phd(a)phd.pp.ru
Programmers don't die, they just GOSUB without RETURN.
Python 2.0c1 is released. The BeOpen PythonLabs and our cast of
SourceForge volunteers have fixed many bugs since the beta releases
last month. Please pick up the new release at
http://www.pythonlabs.com/products/python2.0/
There's a tarball, a Windows installer, RedHat RPMs, online
documentation, and a long list of fixed bugs.
The final release of Python 2.0 will be next week. We would
appreciate feedback on the release candidate in order to fix any
remaining bugs before the final release. Confirmation of build and
test success on less common platforms is also helpful.n
All major reported bugs have been fixed in the release candidate. We
do not plan to make any changes between now and the final release,
except to fix bugs reported in the next week. We encourage potential
users of Python 2.0 to try the release candidate with their programs
and report any remaining bugs.
To report a new bug, use the SourceForge bug tracker
http://sourceforge.net/bugs/?func=addbug&group_id=5470
Python 2.0 has many new features, including the following:
- Augmented assignment, e.g. x += 1
- List comprehensions, e.g. [x**2 for x in range(10)]
- Extended import statement, e.g. import Module as Name
- Extended print statement, e.g. print >> file, "Hello"
- Collection of cyclical garbage
For a fuller discussion of the changes in Python 2.0, please see the
article "What's New in Python 2.0" by Andrew Kuchling and Moshe Zadke:
http://starship.python.net/crew/amk/python/writing/new-python/
-- Jeremy Hylton <http://www.python.org/~jeremy/>
