What's New?
===========
Due to a cancellation, we are pleased to announce that John Udell will
be our second keynote speaker.
Jon Udell is an author, information architect, software developer and
groupware evangelist. He has been an independent consultant, was BYTE
Magazine's editor-at-large, executive editor and Web maven, and long
ago developed business information products for Lotus. In June 2002 he
joined InfoWorld as lead analyst. He also writes a monthly column for
the O'Reilly Network.
Due to this change of plans, early bird conference registration has
been extended until Friday (July 9th). Registration is CDN$100 with
significant discounts for students. Late registration will be available
until the conference starts, but at a greater cost.
To register, see:
http://www.vanpyz.org/conference/registration
For general conference information, see:
http://www.vanpyz.org/conference
About the Vancouver Python Workshop
===================================
The conference will begin on July 31st with a keynote address by Guido
van Rossum (the creator of Python) and Jon Udell (InfoWorld lead
analyst). Further talks (and tutorials for beginners) will take place
on August 1st and 2nd. The conference will be roughly divided into
three tracks:
o General Python Topics
o Web application development with Python (esp. Zope and Plone)
o Python for beginners
More information see: http://www.vanpyz.org/conference/
or contact Brian Quinlan at: brian(a)sweetapp.com
Vancouver
=========
In addition to the opportunity to learn and socialize with fellow
Pythonistas, the Vancouver Python Workshop also gives visitors the
opportunity to visit one of the most extraordinary cities in the world
(1). For more information about traveling to Vancouver, see:
http://www.vanpyz.org/conference/travel.htmlhttp://www.tourismvancouver.com
Important dates
===============
Attendee registration: until July 9th
Late registration: from July 10th
Keynotes: July 31st
Conference and tutorial dates: August 1st and 2nd
(1) http://news.bbc.co.uk/2/hi/business/2299119.stmhttp://www.mercerhr.com/pressrelease/details.jhtml?idContent=1128760
Cheers,
Brian
Summary
Command line and Python module access to googlism.com.
Overview
The googlism.py module provides both Python module and command
line access to googlism.com, the Web site which sifts through the
results of the popular search engine Google and reports
information about individual keywords.
Getting the software
The current version of googlism is 1.0.
The latest version of the software is available in a tarball here:
http://www.alcyone.com/software/googlism/googlism-latest.tar.gz.
The official URL for this Web site is
http://www.alcyone.com/software/googlism/.
Requirements
googlism.py is intended to be used with Python 2.2 or later.
License
This code is released under the GPL.
--
__ Erik Max Francis && max(a)alcyone.com && http://www.alcyone.com/max/
/ \ San Jose, CA, USA && 37 20 N 121 53 W && AIM erikmaxfrancis
\__/ I grow with each breath that I take / I cherish my freedom
-- Chante Moore
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Changes for this release:
- Improved localtime handling, and added a localize() method enabling
correct creation of local times.
pytz - World Timezone Definitions for Python
============================================
:Author: Stuart Bishop <stuart(a)stuartbishop.net>
:Version: $Revision: 1.10 $
Introduction
~~~~~~~~~~~~
pytz brings the Olson tz database into Python. This library allows
accurate and cross platform timezone calculations using Python 2.3
or higher. It also solves the issue of ambiguous times at the end
of daylight savings, which you can read more about in the Python
Library Reference (datetime.tzinfo).
546 of the Olsen timezones are supported [*]_.
Note that if you perform date arithmetic on local times that cross
DST boundaries, the results may be in an incorrect timezone (ie.
subtract 1 minute from 2002-10-27 1:00 EST and you get 2002-10-27
0:59 EST instead of the correct 2002-10-27 1:59 EDT). This cannot
be resolved without modifying the Python datetime implementation.
However, these tzinfo classes provide a normalize() method which
allows you to correct these values.
Installation
~~~~~~~~~~~~
This is a standard Python distutils distribution. To install the
package, run the following command as an administrative user::
python setup.py install
Example & Usage
~~~~~~~~~~~~~~~
>>> from datetime import datetime, timedelta
>>> from pytz import timezone
>>> utc = timezone('UTC')
>>> eastern = timezone('US/Eastern')
>>> fmt = '%Y-%m-%d %H:%M:%S %Z%z'
The preferred way of dealing with times is to always work in UTC,
converting to localtime only when generating output to be read
by humans.
>>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
>>> loc_dt = utc_dt.astimezone(eastern)
>>> loc_dt.strftime(fmt)
'2002-10-27 01:00:00 EST-0500'
This library also allows you to do date arithmetic using local
times, although it is more complicated than working in UTC as you
need to use the `normalize` method to handle daylight savings time
and other timezone transitions. In this example, `loc_dt` is set
to the instant when daylight savings time ends in the US/Eastern
timezone.
>>> before = loc_dt - timedelta(minutes=10)
>>> before.strftime(fmt)
'2002-10-27 00:50:00 EST-0500'
>>> eastern.normalize(before).strftime(fmt)
'2002-10-27 01:50:00 EDT-0400'
>>> after = eastern.normalize(before + timedelta(minutes=20))
>>> after.strftime(fmt)
'2002-10-27 01:10:00 EST-0500'
Creating localtimes is also tricky, and the reason why working with
local times is not recommended. Unfortunately, you cannot just pass
a 'tzinfo' argument when constructing a datetime (see the next section
for more details)
>>> dt = datetime(2002, 10, 27, 1, 30, 0)
>>> dt1 = eastern.localize(dt, is_dst=True)
>>> dt1.strftime(fmt)
'2002-10-27 01:30:00 EDT-0400'
>>> dt2 = eastern.localize(dt, is_dst=False)
>>> dt2.strftime(fmt)
'2002-10-27 01:30:00 EST-0500'
Problems with Localtime
~~~~~~~~~~~~~~~~~~~~~~~
The major problem we have to deal with is that certain datetimes
may occur twice in a year. For example, in the US/Eastern timezone
on the last Sunday morning in October, the following sequence
happens:
- 01:00 EDT occurs
- 1 hour later, instead of 2:00am the clock is turned back 1 hour
and 01:00 happens again (this time 01:00 EST)
In fact, every instant between 01:00 and 02:00 occurs twice. This means
that if you try and create a time in the US/Eastern timezone using
the standard datetime syntax, there is no way to specify if you meant
before of after the end-of-daylight-savings-time transition.
>>> loc_dt = datetime(2002, 10, 27, 1, 30, 00, tzinfo=eastern)
>>> loc_dt.strftime(fmt)
'2002-10-27 01:30:00 EST-0500'
As you can see, the system has chosen one for you and there is a 50%
chance of it being out by one hour. For some applications, this does
not matter. However, if you are trying to schedule meetings with people
in different timezones or analyze log files it is not acceptable. The
best and simplest solution is to stick with using UTC. If you insist
on working with local times, this library provides a facility for
constructing them almost unambiguously
>>> loc_dt = datetime(2002, 10, 27, 1, 30, 00)
>>> est_dt = eastern.localize(loc_dt, is_dst=True)
>>> edt_dt = eastern.localize(loc_dt, is_dst=False)
>>> print est_dt.strftime(fmt), '/', edt_dt.strftime(fmt)
2002-10-27 01:30:00 EDT-0400 / 2002-10-27 01:30:00 EST-0500
Note that although this handles many cases, it is still not possible
to handle all. In cases where countries change their timezone
definitions,
cases like the end-of-daylight-savings-time occur with no way of
resolving
the ambiguity. For example, in 1915 Warsaw switched from Warsaw time to
Central European time. So at the stroke of midnight on August 4th 1915
the clocks were wound back 24 minutes creating a ambiguous time period
that cannot be specified without referring to the timezone abbreviation
or the actual UTC offset.
What is UTC
~~~~~~~~~~~
`UTC` is Universal Time, formerly known as Greenwich Mean Time or GMT.
All other timezones are given as offsets from UTC. No daylight savings
time occurs in UTC, making it a useful timezone to perform date
arithmetic
without worrying about the confusion and ambiguities caused by daylight
savings time transitions, your country changing its timezone, or mobile
computers that move roam through multiple timezones.
License
~~~~~~~
BSD style license. I'm happy to relicense this code if necessary
for inclusion in other open source projects.
Latest Versions
~~~~~~~~~~~~~~~
This package will be updated after releases of the Olsen timezone
database.
The latest version can be downloaded from Sourceforge_. The code that
is used to generate this distribution is available in the Sourceforge_
project's CVS repository.
.. _Sourceforge: http://sourceforge.net/projects/pytz/
Issues & Limitations
~~~~~~~~~~~~~~~~~~~~
- - Offsets from UTC are rounded to the nearest whole minute, so timezones
such as Europe/Amsterdam pre 1937 will be up to 30 seconds out. This
is
a limitation of the Python datetime library.
Further Reading
~~~~~~~~~~~~~~~
More info than you want to know about timezones::
http://www.twinsun.com/tz/tz-link.htm
Contact
~~~~~~~
Stuart Bishop <stuart(a)stuartbishop.net>
.. [*] The missing few are for Riyadh Solar Time in 1987, 1988 and
1989.
As Saudi Arabia gave up trying to cope with their timezone
definition, I see no reason to complicate my code further
to cope with them. (I understand the intention was to set
sunset to 0:00 local time, the start of the Islamic day.
In the best case caused the DST offset to change daily and
worst case caused the DST offset to change each instant
depending on how you interpreted the ruling.)
- --
Stuart Bishop <stuart(a)stuartbishop.net>
http://www.stuartbishop.net/
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.3 (Darwin)
iD8DBQFBBBsxAfqZj7rGN0oRAsb5AJsHk/7ZIQFXbFFXedttcs/H5wEGiACdE5DY
iY3X1ddjuEAbeWc6OlEQGYo=
=gMyS
-----END PGP SIGNATURE-----
Naja is a download manager and a website grabber written in Python/wxPython.You can add some
plugins (newsreader, FTP client,WebDAV client) and take control of your downloads from your office.
Naja supports proxy(HTTP, HTTPS, FTP, SOCKS v4a, SOCKS v5), and use some authentication methods.
The downloading maybe achieved by splitting the file being downloaded into several parts and downloading
these parts at the same time (HTTP, HTTPS, FTP). Donwload speeds are increased by downloading the file
from the mirrors sites, when the sites propose it.
Others features:
Csv filter
Cheksums (CRC32, MD2, MD4, MD5, SHA, SHA1, MDC2, RMD160)
Crypt (Only for the eXtended version) and Decrypt (AES, DES, 3DES ...)
newsreader, newsposter (uue, yEnc)
CGI & WebDAV Server
Web Interface
basic and digest authentication for client and server
Compress and decompress (zip, tar.gz, tar.bz2)
Picture viewer
Naja is available for download from the Keyphrene web site:
http://www.keyphrene.com/products/naja
Optik 1.5a1
===========
Optik is a powerful, flexible, extensible, easy-to-use command-line
parsing library for Python. Using Optik, you can add intelligent,
sophisticated handling of command-line options to your scripts with very
little overhead.
Here's an example of using Optik to add some command-line options to a
simple script:
from optik import OptionParser
[...]
parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")
(options, args) = parser.parse_args()
With these few lines of code, users of your script can now do the
"usual thing" on the command-line:
<yourscript> -f outfile --quiet
<yourscript> -qfoutfile
<yourscript> --file=outfile -q
<yourscript> --quiet --file outfile
all of which result in the 'options' object looking like this:
options.filename == "outfile"
options.verbose == 0
Even niftier, users can run one of
<yourscript> -h
<yourscript> --help
and Optik will print out a brief summary of your script's options:
usage: <yourscript> [options]
options:
-h, --help show this help message and exit
-f FILE, --file=FILE write report to FILE
-q, --quiet don't print status messages to stdout
That's just a taste of the flexibility Optik gives you in parsing your
command-line. See the documentation included in the package for
details.
AUTHOR, COPYRIGHT, AVAILABILITY
-------------------------------
Optik was written by Greg Ward <gward(a)python.net>
Optik 1.5a1 can be downloaded from:
http://optik.sourceforge.net/Optik-1.5a1.tar.gzhttp://www.gerg.ca/software/optik/Optik-1.5a1.tar.gz
More information can be found at:
http://optik.sourceforge.net/http://www.gerg.ca/software/optik/
Copyright (c) 2001-2004 Gregory P. Ward. All rights reserved.
CHANGES IN OPTIK 1.5 (since 1.4.1)
----------------------------------
* Optik now requires Python 2.2 or later.
* Add expansion of default values in help text: the string
"%default" in an option's help string is expanded to str() of
that option's default value, or "none" if no default value.
* SF bug #955889: option default values that happen to be strings are
now processed in the same way as values from the command line; this
allows generation of nicer help when using custom types. Can
be disabled with parser.set_process_default_values(False).
* SF bug #960515: don't crash when generating help for callback
options that specify 'type', but not 'dest' or 'metavar'.
* SF feature #815264: change the default help format for short options
that take an argument from e.g. "-oARG" to "-o ARG"; add
set_short_opt_delimiter() and set_long_opt_delimiter() methods to
HelpFormatter to allow (slight) customization of the formatting.
* SF patch #736940: internationalize Optik: all built-in user-
targeted literal strings are passed through gettext.gettext(). Also
added po/ directory for message catalog and translations, so that
Optik-based applications have a single place to go for translations
of Optik's built-in messags. Include translations for Danish and
German (thanks to Frederik S. Olesen and Martin v. Löwis
respectively), and partial translations for French (by me).
* SF bug #878453 (Python): respect $COLUMNS environment variable for
wrapping help output.
* SF feature #964317: allow type objects to specify option types;
allow "str" as an alias for "string".
* SF feature #988122: expand "%prog" in the 'description' passed
to OptionParser, just like in the 'usage' and 'version' strings.
(This is *not* done in the 'description' passed to OptionGroup.)
* Added HTML-formatted docs to the source distribution (in addition
to the reStructuredText source files).
* Added three new examples: custom_source.py, custom_type.py, and
no_help.py.
--
Greg Ward <gward(a)python.net> http://www.gerg.ca/
I repeat myself when under stress I repeat myself when under stress I repeat---
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
EDDIE-Tool 0.33 has just been released.
http://eddie-tool.net/
What is it ?
The EDDIE-Tool is an intelligent UNIX monitoring agent
written entirely in Python. It provides system, network
and security monitoring features, with an extensive
configuration facility for defining customized monitoring
and data collection rules.
What is new ?
Support for two new platforms: OpenBSD and Darwin/OS X.
Consider support for these platforms as beta - we still
need plenty of testing, so volunteers would be great.
Some other major updates are: Fine-grained HTTP timing;
Configurable HTTP request timeouts (using Python 2.3+);
Directive checktime parameter to specify exact times of
day or days of week to perform tests; MySQL monitoring;
and SNMP support for 64-bit counters.
Why is it interesting to Python users ?
Besides system and network administrators, Python users may
find EDDIE-Tool interesting as it is an example of a threaded,
multi-platform software package, providing easy access to
system statistics and using Python's power to offer a dynamic
and programmable rules engine.
Regards,
Chris
- --
Chris Miles
http://chrismiles.info/
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Darwin)
iD8DBQFBAsMxzitzBnMzNcIRAvb0AKCTvNqLzYLdRar30/MmZBHd6Op+2gCgigsC
ZgwgTv8EbM/6k4kHVFoax4M=
=ySlU
-----END PGP SIGNATURE-----
I am happy to announce the first public release of the Durus
object database. Durus offers an easy way to maintain a consistent
persistent collection of Python object instances used by one or more
processes. For more information, see the web site:
http://www.mems-exchange.org/software/durus/
Although this release is numbered 0.1, we believe Durus is stable
and reliable. We have been using it seriously for a some months now.
Please give it a try and let us know what you think.
Note that Durus does not support multi-threaded database access. If
that is a requirement for your application, we recommend using the
Zope Object Database (ZODB) instead.
