Hi All,
PyDev - Python IDE (Python Development Enviroment for Eclipse) version
0.9.8.2 has been released.
Check the homepage (http://pydev.sourceforge.net/) for more details.
Details for Release: 0.9.8.2
Major highlights:
------------------------
* Content assistants reviewed (and better documented on the homepage
-- I really reccomend checking it)
* Timeout parsing options added (this is available in the builder
preferences page)
* Auto-dedent added
Others that are new and noteworthy:
-----------------------------------------------------
* .pyc is removed when the corresponding .py file is removed.
* Debugger has been changed so that it becomes faster (still not as
fast as I would like, but still... faster) -- looking for people with
expertise on this to help me, as I'm kind of lost on which should be the
'recommended' way to speed it more.
* Some escaped quotes problems fixed when formatting code
* Navigation with Ctrl+Shift+ (up or down) has been slightly
improved, so that it goes to the start or the end of the file when no
other class or method declaration is found
* Other bug-fixes (as ususal)
Cheers,
Fabio
--
Fabio Zadrozny
------------------------------------------------------
Software Developer
ESSS - Engineering Simulation and Scientific Software
www.esss.com.br
PyDev - Python Development Enviroment for Eclipse
pydev.sf.netpydev.blogspot.com
===========================
Announcing PyTables 1.2.2
===========================
This is a maintenance version. Some important improvements and bug fixes
has been addressed in it.
Go to the PyTables web site for downloading the beast:
http://pytables.sourceforge.net/
or keep reading for more info about the new features and bugs fixed in
this version.
Changes more in depth
=====================
Improvements:
- Multidimensional arrays of strings are now supported as node
attributes. They just need to be wrapped into ``CharArray`` objects
(see the ``numarray.strings`` module).
- The limit of 512 KB for row sizes in tables has been removed. Now,
there is no limit in the row size.
- When using table row iterators in non-iterator contexts, a warning is
issued recommending the users to use them in iterator
contexts. Before, when these iterators were used, it was printed a
regular record get from an arbitrary place of the memory, giving a
non-sense record as a result.
- Compression libraries are now dynamically loaded as different
extension modules, so there is no longer need for producing several
binary packages supporting different sets of compressors.
Bug fixes:
- Solved a leak that exposed when reading VLArray data. The problem was
due to the usage of different heaps (C and Python) of memory. Thanks
to Russel Howe to report this and to provide an initial patch.
Known issues:
- Time datatypes are non-portable between big-endian and little-endian
architectures. This is ultimately a consequence of an HDF5
limitation. See SF bug #1234709 for more info.
Backward-incompatible changes:
- Please, see RELEASE-NOTES.txt file.
Important notes for Windows users
=================================
If you are willing to use PyTables with Python 2.4 in Windows
platforms, you will need to get the HDF5 library compiled for MSVC
7.1, aka .NET 2003. It can be found at:
ftp://ftp.ncsa.uiuc.edu/HDF/HDF5/current/bin/windows/5-165-win-net.ZIP
Users of Python 2.3 on Windows will have to download the version of
HDF5 compiled with MSVC 6.0 available in:
ftp://ftp.ncsa.uiuc.edu/HDF/HDF5/current/bin/windows/5-165-win.ZIP
Also, note that support for the UCL compressor has not been added in the
binary build of PyTables for Windows because of memory problems (perhaps
some bad interaction between UCL and something else). Eventually, UCL
support might be dropped in the future, so, please, refrain to create
datasets compressed with it.
What it is
==========
**PyTables** is a package for managing hierarchical datasets and
designed to efficiently cope with extremely large amounts of data
(with support for full 64-bit file addressing). It features an
object-oriented interface that, combined with C extensions for the
performance-critical parts of the code, makes it a very easy-to-use
tool for high performance data storage and retrieval.
PyTables runs on top of the HDF5 library and numarray (Numeric is also
supported and NumPy support is coming along) package for achieving
maximum throughput and convenient use.
Besides, PyTables I/O for table objects is buffered, implemented in C
and carefully tuned so that you can reach much better performance with
PyTables than with your own home-grown wrappings to the HDF5
library. PyTables sports indexing capabilities as well, allowing doing
selections in tables exceeding one billion of rows in just seconds.
Platforms
=========
This version has been extensively checked on quite a few platforms, like
Linux on Intel32 (Pentium), Win on Intel32 (Pentium), Linux on Intel64
(Itanium2), FreeBSD on AMD64 (Opteron), Linux on PowerPC and MacOSX on
PowerPC. For other platforms, chances are that the code can be easily
compiled and run without further issues. Please, contact us in case
you are experiencing problems.
Resources
=========
Go to the PyTables web site for more details:
http://pytables.sourceforge.net/
About the HDF5 library:
http://hdf.ncsa.uiuc.edu/HDF5/
About numarray:
http://www.stsci.edu/resources/software_hardware/numarray
To know more about the company behind the PyTables development, see:
http://www.carabos.com/
Acknowledgments
===============
Thanks to various the users who provided feature improvements,
patches, bug reports, support and suggestions. See THANKS file in
distribution package for a (incomplete) list of contributors. Many
thanks also to SourceForge who have helped to make and distribute this
package! And last but not least, a big thank you to THG
(http://www.hdfgroup.org/) for sponsoring many of the new features
recently introduced in PyTables.
Share your experience
=====================
Let us know of any bugs, suggestions, gripes, kudos, etc. you may
have.
----
**Enjoy data!**
-- The PyTables Team
--
>0,0< Francesc Altet http://www.carabos.com/
V V Cárabos Coop. V. Enjoy Data
"-"
PyIE, Python Inference Engine, is now available at "DFWPython.org",
under "Our Source Repository", thanks to Jeff Rush. The current revision
is 0.9.10.
What's PyIE ?
-------------
PyIE is an hypothesis based, agenda driven, object oriented inference
engine written in Python. Inferencing modes include back chaining,
opportunistic forward chaining and explicit forward chaining. The object
base supports classes, first-class objects and multiple, dynamic
inheritance. PyIE uses a TMS (truth maintenance system) for
non-monotonic reasoning. All objects are first class objects and all
values are slot values, i.e. data members attached to some object. The
GUI uses TKinter and consists of a main control panel and seven editors
for the agenda, classes, objects, slots, rules, methods and commands.
The knowledge base file types are currently XML and an older
Python-like text format. A version is associated with all .py files and
when the KBs are saved, this current version number is saved within the
knowledge base source files. Only the XML format supports methods and is
the default file type.
Knowledge is usually, but not always, expressed in rules and the
sequencing of the inferencing is controlled by a structure called an
agenda. The current truth-values of each clause and each rule are kept
in an hypothesis. Rules typically contain the main expression of
knowledge and experience. Every rule must be associated with a hypo.
Every rule has one or more antecedent clauses, usually termed the 'left
hand side' (lhs). Rules may also have one or more consequent clauses;
usually termed the 'right hand side' (rhs). In order to prove the
associated hypo true, a rule must prove all antecedent clauses true.
A hypothesis is simply a truth-value, in PyIE one of four possible
values: True, False, Not Known or Unknown. 'Unknown' indicates that the
hypo has not been tested, while 'Not Known' specifies that the hypo has
been tested but proven neither 'True' nor 'False'. The engine proves
hypotheses taken from an agenda. The agenda is hypothesis driven, that
is, only hypotheses are contained in the agenda, not rules. The engine
selects the relevant hypothesis to be proved and follows a specific set
of steps to prove the hypo. Firing rules is only one method for proving
a hypothesis.
Download
--------
The current PyIE may be exported from the subversion repository:
https://python.taupro.com/repo/Projects/PyIE/trunk
Compressed gzip and zip files will be available from time to time from:
https://python.taupro.com/repo/Projects/PyIE/downloads
External Dependencies
---------------------
PyIE relies on Python 2.3 and later and also TKinter. No other modules
need be installed.
License
-------
The license is MIT.
Caveats
-------
This is a research project. The documenetation is woefully incomplete.
'Eval' and 'compile' are used in the "KBsXML.py" module to process rules
and methods. The underlying assumption is that there will be no
malicious use.
Author
------
Ralph S. Miller
miller_ralph(a)sbcglobal.net
Regards,
Ralph
comtypes is a pure Python COM package, based on the ctypes FFI library.
comtypes replaces and extends the former ctypes.com package.
It offers superior support for custom COM interfaces with typelib support.
Requires ctypes 0.9.9.3 or later.
Limitations:
- inprocserver code should work, localserver code is very early.
- no documentation
http://sourceforge.net/project/showfiles.php?group_id=115265
Enjoy,
Thomas
Remote Python Call (RPyC) 2.32
http://rpyc.sf.net
RPyC is a transparent, symmetrical python library for
distributed-computing. It began as an RPC library (hence the name), but
grew into something much more comprehensive with many use cases. It
basically works by giving you full control over a remote
slave-interpreter (a separate process), which can perform operations on
your behalf.
There's much more info on the site, but just to show how simple and
straight-forward RPyC is, here's a little code snippet:
========
# first run the forking or threaded server (in the Rpyc/Servers
directory) on the localhost.
# this is a demo of a client
from Rpyc.Factories import SocketConnection
from Rpyc.Utils import *
# c is the connection to the slave-server
c = SocketConnection("localhost")
# and the slave works like you would expect -- importing modules and
executing code
print c.modules.sys.path
c.modules.sys.path.append("pipi")
print c.modules.sys.path[-1]
my_remote_list = c.modules.__builtin__.list("abcdef")
print dir(my_remote_list)
print c.modules.__builtin__.eval("5*3")
# but dont use eval. it's dirty. keep all the logics at the client
side,
# and only have the slave perform work on your behalf
# another common case: working with files
f = c.modules.__builtin__.open("lala.txt", "wb")
f.write("nothing really")
f.close()
c.modules.os.remove("lala.txt")
=========
So I hope this little snippet starts your appetite. There's a lot more
(like callbacks, async objects, threads, events, etc.), so have a look.
-tomer, king of the ganges
ctypes 0.9.9.3 released - Feb 15, 2006
======================================
Overview
ctypes is an advanced ffi (Foreign Function Interface) package for
Python 2.3 and higher.
ctypes allows to call functions exposed from dlls/shared libraries
and has extensive facilities to create, access and manipulate
simple and complicated C data types in Python - in other words:
wrap libraries in pure Python. It is even possible to implement C
callback functions in pure Python.
ctypes includes a code generator toolchain which allows
automatic creation of library wrappers from C header files.
This feature is still experimental and beta quality.
ctypes runs on Windows, Windows CE, MacOS X, Linux, Solaris,
FreeBSD, OpenBSD. It may also run on other systems, provided that
libffi supports this platform.
Important
If you download the source distribution, please choose the ZIP
file for Windows, and the .tar.gz file for other machines.
These archive have different contents!
There have been lots of changes - if you are the author or user of
a package that uses ctypes, please test it with this release
and report problems on the ctypes-users mailing list.
Changes in 0.9.9.3
(These are the most important changes, see the ChangeLog for
complete details)
Windows
The ctypes.com package is no longer included and supported.
It is replaced by the comtypes package which will be released
separately.
ctypes has been ported to Windows CE by Luke Dunstan.
Other platforms
Hye-Shik Chang has written a new build system for libffi
which should remove possible licensing issues.
All platforms
The library loading code has been rewritten by Andreas Degert,
there are now sophisticated methods to find shared libraries.
On OS X, this uses files from Bob Ippolito's macholib.
See the manual for details.
Finally I started to write the manual, it is available online:
http://tinyurl.com/7bpg4
New 'errcheck' protocol to check the return values of foreign
functions, suggested by Mike Fletcher.
Lots of bug fixes, especially for 64-bit platforms. Improved
performance when creating ctypes instances.
Subclasses of simple types (c_int, c_void_p, and so on) now
behave as expected - they are not automatically converted into
native Python types any longer.
Support for explicit byte ordering in structures has been
added (BigEndianStructure, LittleEndianStructure base
classes).
call byref() automatically, if needed, for POINTER types in
argtypes.
Lots of improvements to the code generator.
Changes in 0.9.6
Thanks to all of you who reported bugs so quickly, and those who
tried out the codegenerator toolchain.
Bug fixes:
- keyword arguments in Structure/Union initializers had no effect.
- it was impossible to override the from_parm class method
in subclasses of c_void_p, c_char_p, and c_wchar_p.
- removed the __del__ method of _CDLL. It caused uncollectable
garbage in Python's gc.
- ctypes.com.register: enclose the Python script to run a com
server in quotes, otherwise it won't run correctly when the
directory name contains spaces.
Enhancements:
- Several changes have been made to the h2xml script from the
codegenerator toolchain. See the documentation (linked below) for
details.
Additions in 0.9.5
New package ctypes.wrap. This contains decorators usable for
easier creation of wrapper functions.
This package also contains a toolchain for (semi)automatic
creation of wrappers for external libraries - it can parse
C header files and generate ctypes code for the declarations in
them. It can even handle preprocessor definitions! For details,
see http://starship.python.net/crew/theller/ctypes/codegen.html
Changes in 0.9.5
On systems where sizeof(int) == sizeof(long), c_int/c_long and
c_uint/c_ulong are now aliases. Similar for c_long/c_longlong and
c_ulong/c_ulonglong. This prevents unneeded type errors.
If an exception occurs in a callback function, a full traceback is
now printed. Raising SystemExit in a callback function now
correctly exists Python.
HRESULT is now a proper ctype - no longer a function. This allows
to use it in the argtypes sequence for function prototypes.
An easier way to define structures and unions that reference
themselves, or have dependencies to other data types. The
_fields_ attribute can now be set *after* the Structure/Union
class has been created. This makes the SetPointerType function
obsolete.
The semantics of the _fields_ attribute in sub-subclasses of
Structure and Union has been fixed. The baseclasses _fields_ list
is extended, not replaced, in subclasses. Assigning _fields_ when
it is no longer possible raises an error now.
Structures and unions now work as restype and in the argtypes list
for functions.
An important bug has been fixed with pointers.
Detailed changelog is in CVS:
<http://cvs.sourceforge.net/viewcvs.py/ctypes/ctypes/ChangeLog?rev=1.86.2.39>
Download
Downloads are available in the sourceforge files section
<http://sourceforge.net/project/showfiles.php?group_id=71702>
Separate source distributions are available for windows and non-windows systems.
Please use the .zip file for Windows and Windows CE, and use the
.tar.gz file for non-Windows systems (it contains the complete
cross-platform libffi sources).
Binary windows installers, which contain compiled extension
modules, are also available, be sure to download the correct one
for the Python version you are using.
Homepage
<http://starship.python.net/crew/theller/ctypes/>
Enjoy,
Thomas
I'm pleased to be able to announce the release of `Movable Python 1.0.1
<http://www.voidspace.org.uk/python/movpy/>`_. This includes the
release of **Movable Python** for Python 2.2.
To obtain it, visit the `Movable Python Shop
<http://voidspace.tradebit.com/groups.php>`_.
Existing users of Movable Python can go to the groups area and simply
download an updated copy.
.. note::
For a heads up about possible features in the *next* version of a
Movable Python, visit the `Voidspace Techie Blog
<http://www.voidspace.org.uk/python/weblog/index.shtml>`_.
What's New ?
==========
Added support for the ``-m`` command line option. This works for
modules contained within the ``library.zip``, as well as other modules
on ``sys.path``.
**Movable Python** now *ignores* (with warnings) the unsupported Python
command line options.
Error messages are now printed to ``sys.stderr``.
Can run '.pyc' and '.pyo' files.
``customize.py`` now run when launching an interactive interpreter.
Renamed the function to go interactive to ``interactive_mode``.
New variable available in ``customize.py``. ``interactive``, this is
``True`` if launching an interactive interpreter. This allows you to
customize the environment differently for interactive sessions.
Add the ``lib`` directory (etc) to ``sys.path`` before entering
interactive mode. (BUGFIX)
``pywin32`` extensions now import properly (even on machines that don't
have them installed). (BUGFIX) {sm;:oops:}
Added the extra files for `Firedrop2 Macros
<http://www.voidspace.org.uk/python/firedrop2/macros.html>`_.
Changes for Python 2.2 compatibility. Distribution for Python 2.2
built.
What is Movable Python ?
===================
**Movable Python** is a distribution of Python for Windows that doesn't
need to be installed. It easily fits onto a USB memory stick. Python on
a stick.
It is integrated with SPE, the Python IDE, to make **Movable Python** a
portable Build, Test, and Run environment. It has a nice GUI to launch
programs and control its behaviour.
Movable Python is useful in the following situations:
* Machines where you can't install programs.
* Where you need a portable 'Build, Test, and Run' Python environment.
* Having several versions of Python on the same machine for
forward/backward compatibility testing.
* Easily deploying Python scripts without having to install Python.
* Try before you buy - test Python without having to install it,
including new versions .
* 'Python Runtime Environment'. '``.py``' files can be associated with
movpy.
For more information, see `An Introduction to Movable Python
<http://www.voidspace.org.uk/python/movpy/introduction.html>`_.
Known Issues
==========
* There are problems with the ``pywin32`` extensions and Python 2.2.
They are included but may not all function correctly.
* ``-m`` doesn't work with modules in ``library.zip`` under Python 2.2.
This may or may not be resolvable.
* **Movable Python** doesn't yet handle ``from __future__ import ...``
statements in scripts that are run. This will be fixed.
This morning there was a message in my inbox from my DNS registrar
inviting me to click through for a "special message" from them. An
animation loaded with elaborately rendered red roses and candlelight,
and wishes for a happy valentines day written out in a flowing font.
Well, I guess we could have done that too. But we don't really know
that much about this Saint Valentine character. Do we really need to
send out cards stamped with symbolic hearts? Or would it in fact be
better to publish some bug fixes? For all I know, Saint Valentine's day
job is working as a sysadmin. Perhaps he even runs an OpenID server for
his company's domain.
So today we're releasing version 1.0.4 of our Python OpenID library.
This is a maintenance release which includes
in openid.consumer:
* added logging to more error cases.
* fixed to appropriately return SETUP_NEEDED from completeAuth().
* fixed some occurrences of unnecessarily falling back to dumb mode.
in openid.server:
* corrections to the server's replay attack prevention in dumb mode.
* made more careful checking of trust_root.
and in openid.store, used by both parties:
* removal of several arbitrary field limits in the SQL stores. (This
will effect newly created stores only; old ones will continue operating
with their existing schema.)
Python OpenID is available under the GNU LGPL from
http://www.openidenabled.com/openid/libraries/python
Download links:
http://www.openidenabled.com/resources/downloads/python-openid/python-openi…http://www.openidenabled.com/resources/downloads/python-openid/python-openi…
sha1sums:
1d7548ece4a92d70fe5f8b8abbfbafd30ea57c4b python-openid-1.0.4.tar.gz
423fde12c5030553798381ffa7f8ecda340533da python-openid-1.0.4.zip
Share and Enjoy,
- Kevin
JanRain, Inc.
Hi all,
I'm pleased to announce release 0.56 of Task Coach. New in this release:
Features added:
* Tasks can have attachments. Attachments can be added, removed and
opened. Opening of attachments is done by starting the default
application for the attachment file type. Attachments can also be
dragged from a file browser and dropped onto a task in one of the task
viewers or on the task attachment pane in the task editor dialog.
* Whether a task is marked completed when all its child tasks are
completed is now a setting that can be changed application-wide via
the preferences dialog. The application-wide setting can be overruled
on a task-by-task basis via the task editor dialog.
* Task Coach shows a 'tips' dialog at startup. Hopefully it is helpful
for new users. Experienced users can turn it off.
Features changed:
* More visual feedback when dragging tasks in the tree view.
* Task editor layout changed. Priority is now part of the task
description. Budget and revenue have been merged into one pane.
Implementation changed:
* Default values for task and effort attributes are no longer saved in
the Task Coach file, resulting in an estimated 33% reduction of file
size.
What is Task Coach?
Task Coach is a simple task manager that allows for hierarchical
tasks, i.e. tasks in tasks. Task Coach is open source (GPL) and is
developed using Python and wxPython. You can download Task Coach from:
http://taskcoach.niessink.comhttps://sourceforge.net/projects/taskcoach/
A binary installer is available for Windows XP, in addition to the
source distribution.
Note that Task Coach is alpha software, meaning that it is wise to back
up your task file regularly, and especially when upgrading to a new release.
Cheers, Frank