Free python web objects software for linux

Python Web Graph Generator is a threaded Web graph (Power law random graph) generator. It can generate a synthetic Web graph of about one million nodes in a few minutes on a desktop machine.
This software implements a threaded variant of the RMAT algorithm. A little tweak can produce graphs representing social networks or community networks.
Examples:
Getting help
$./genwebgraph.py --help
Generating graph using default settings
$ ./genwebgraph.py --threads=1
Generating a 1000-vertex and 1000-egde graph using 5 threads and storing it in ~/mygraph.pyg
$ ./genwebgraph.py --threads=5 --max-vertices=1000 --max-edges=1000 --output=~/mygraph.pyg
Storing in dot compatible output and making a postscript file
$ ./genwebgraph.py --output=~/mygraph.pyg --format=dot
$ dot -Tps ~/mygraph.pyg -o mygraph.ps
Enhancements:
- The base library PyGEL is available as an independent Python module.

rope is a Python IDE. Python ropes main goal is to provide features like auto-completion, refactorings, content assistance, and outlines.

Refactoring: In recent years refactoring has become a basic task of everyday programing, specially in java community. In the agile programing methodologies, like Extreme Programing, Refactoring is one of the core practices.
Some IDEs support some basic refactorings like PyDev (which uses bicycle repair man). These IDEs have a limited set of refactorings and fail when doing refactorings that need to know the type of objects in the source code (specially for relatively large projects). rope tries to provide a rich set of refactorings. Some of the refactorings require type inferencing which is described later.
Auto Completion: One of the basic features of modern IDEs is the availability of auto-completion. Some Python IDEs have auto-completion support but in a limited form. Since the type of many variables cannot be deduced from simple analysis of the source code. Auto-completing modules names, class names, static methods, class methods, function names and variable names are easy. But auto-completing the methods and attributes of an object is hard. Because the IDE needs to know the type of the object that cannot be achieved easily most of the time in dynamic languages. rope uses Type Inferencing algorithms to solve this problem.
Type Inferencing: One disadvantage of dynamic languages like python is that you cannot know the type of variables by a simple analysis of program source code most of the time. Knowing the type of variables is very essential for providing many of the refactorings and auto-completions. rope will use type inferencing to overcome this problem.

Static type inferencing uses program source code to guess the type of objects. But type inferencing python programs is very hard. There have been some attempts though not very successful (examples: psycho: only str and int types, StarKiller: wasnt released and ShedSkin: good but limited). They where mostly directed at speeding up python programs by transforming its code to other typed languages rather than building IDEs. Such algorithms might be helpful.

There is another approach toward type inferencing. That is the analysis of running programs. This dynamic approach records the types variables are assigned to during the program execution. Although this approach is a lot easier to implement than the alternative, it is limited. Only the parts of the program that are executed are analyzed. If developers write unit tests and use test driven development this approach works very well.

Python MyCMS program is an application development platform built with robust MySQL integration that allows for the easy creation of state and event driven Web-based interfaces.
Domain- group-user management is built in for direct, authenticated applicability.
To start the authentication server.
First, make sure that you have the domains entered into the DOMAINS/paths.pkl and DOMAINS/register.pkl with the appropriate instance paths for CUSTOMIZATION imports.
Make sure that authServer.py, lookupServer.py, and groupServer.py (all in MyCMS/server) all point to the correct path for the DOMAIN files above. Below is the default that you will find in these files.
ROOT_DIR = "/usr/pkg/lib/python/site-packages/custom/DOMAINS/"
Note: In a future release, all of this will be a configuration line in a standard configuration file, so that you dont have to do any editing in individual modules.
Once you have all of this set. run /path/to/MyCMS/shellTools/mycmsDaemon start"
You can look to make sure this is running.
Enhancements:
- This release contains more AJAX widgets/support.
- It also includes enhancements to the database manager and related SQL storage models that allow for tables with no keys, or with keys from mixed columns.

python-dime project provides a way to parse and generate DIME messages.

Direct Internet Message Encapsulation (DIME) is a binary message format that can be used to encapsulate multiple payloads into a single message.

3D Python OpenGL Chess Game project is a 3D chess game in Python with OpenGL.

3D Python OpenGL Chess Game is a normal chess game that has no computer player (yet). You can play against a friend on your PC.

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).

Extended Python Debugger is a complete debugger for Python than the stock pdb.py debugger.

It supports a "restart" command and stack traces that show fewer ?s and give better information for exec statements.

Stepping/nexting skips over method/function "defs". It tries to follow gdbs command set unless there is good reason not to.