Free python call graph 0.4.0 software for linux

Python Call Graph (pycallgraph) is a Python library that creates call graphs for Python programs

pycallgraph is quite new. It seems to work well and I will most likely improve it in the near future!

Python XHTML is a simple Python module for the generation of valid XHTML.

ToDo:

* include tests for all methods in xhtml_test.py
* ensure that all text that is added to the document is xml safe
* include methods for added w3.org validation link buttons
* complete support for XHTML 1.1 specification

python-amarok is a fairly complete amaroK remote control class for Python.

python-amarok is extremely useful for amaroK scripts and other applications and makes it possible to remote control amaroK by calling methods from an amaroKProxy instance.

In addition, it implements the Observer/Observable pattern so you can deal with events in an object oriented, loosely coupled fashion.

Even better, you can call an amaroKProxy instances collection.getSong(filename) method to get a Song object, with track, artist, album name, and elegant "Artist - Track name" strings.

Python-LDAP provides an object-oriented API to access LDAP directory servers from Python programs. Mainly it wraps the OpenLDAP 2.x libs for that purpose.

Additionally the package contains modules for other LDAP-related stuff (e.g. processing LDIF, LDAPURLs, LDAPv3 schema, etc.).

pyClamAV program is a python binding to libclamav written in C. By using pyClamAV, you can add virus detection capabilities to your python software in an efficient and easy way.
Intallation:
You need to have clamav and libclamav installed with clamav.h header file. You also need to have python installed.
The simplest way to compile this package is:
- Run python setup.py build
- As root run python setup.py install
It should be done.
Usage:
From python :
Python 2.3.3 (#1, Mar 21 2004, 00:29:15)
[GCC 2.95.4 20011002 (Debian prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import pyclamav
>>> ret=pyclamav.scanfile(/tmp/virus)
>>> print ret
(1, Worm.Sober.G)
>>> ret=pyclamav.scanthis("Buffer to test blalblabla...")
>>> print ret
(0, )
>>> print pyclamav.get_numsig()
34861
>>> print pyclamav.get_version()
(0.86.1, 898, 1117257063)
>>> print pyclamav.version()
0.3.0
>>> print pyclamav.scanfile(/tmp) # /tmp is a directory
Traceback (most recent call last):
File "", line 1, in ?
ValueError: Argument is not a filename
Enhancements:
- Support for clamav 0.90.
- Due to the removal of cl_scanbuff from libclamav, pyclamav.scanthis() had to be removed.
- Using pyclamd instead of pyclamav is strongly encouraged.

python-observable library lets Python developers build loosely coupled object meshes with a complete Observer/Observable implementation.

In software development literature, Observer/Observable is a software
pattern. From an Observer/Observable perspective, there are two kinds
of objects:

- objects which experience events or state changes (Observables)
- objects which need to know about other objects events (Observers)

If you have any experience with event-based programming, such as with
toolkits like GTK+ or Qt, youll be familiar with the Observer/Observable
pattern. Observer objects register themselves with the Observable object
of their interest, and when Observables experience events, these events
are relayed to the Observers.

Observer/Observable lets software developers build loosely coupled object meshes. What this means to you: your software will be more stable and easier to refactor.

This module has a complete Observer/Observable implementation. To take advantage of this module, all you have to do is:

- Make your Observable classes inherit from Observable (dont forget to call Observable.__init__(self) in the constructor)
- Make your Observer classes inherit from Observer (dont forget to call Observer.__init__(self) in the constructor)
- At runtime, for each object you want to observe, call self.observe(observable_object) in a method of your Observer object.
- In your Observable object, every time an event happens, call:
...
self.broadcastEvent("MyEventName",argument1,argument2...)
...
- In your Observer object, implement a method named: def processEvent(self,notifierObject,eventName,*args): which will receive the notifier object, an event name, and a variable number of arguments, every time broadcastEvent is called in any of the Observable objects that have been observed()

Thats it. Keep in mind that processEvent() will be invoked in the same thread context as the code which called broadcastEvent() in the Observable object. Thus, processEvent() methods should return quickly and never do blocking operations (suggested technique for coping with blocking operations: run them in a separate thread, which sleeps until a flag is raised, and raise the flag in the processEvent() method as appropriate).

python-gammu are Python bindings for Gammu library. It currently does not support all Gammu features, but range of covered functions is increasing, if you need some specific, feel free to use bug tracking system for feature requests.

One of the features of Python that makes it so powerful is the ability to take existing libraries, written in C or C++, and make them available as Python extension modules. Such extension modules are often called bindings for the library.
SIP is a tool that makes it very easy to create Python bindings for C and C++ libraries. Python-SIP was originally developed to create PyQt, the Python bindings for the Qt toolkit, but can be used to create bindings for any C or C++ library.
SIP comprises a code generator and a Python module. The code generator processes a set of specification files and generates C or C++ code which is then compiled to create the bindings extension module. The SIP Python module provides support functions to the automatically generated code.
The specification files contains a description of the interface of the C or C++ library, i.e. the classes, methods, functions and variables. The format of a specification file is almost identical to a C or C++ header file, so much so that the easiest way of creating a specification file is to edit the corresponding header file.
SIP makes it easy to exploit existing C or C++ libraries in a productive interpretive programming environment. SIP also makes it easy to take a Python application (maybe a prototype) and selectively implement parts of the application (maybe for performance reasons) in C or C++.
Enhancements:
- This release adds support for consolidated and composite modules.
- It adds support for pickling classes and enums.