Free python remote call module 0.0.3 software for linux

Python Remote Call Module allows to transparently work with remote object in a python program.
To make this possible a kind of peer-to-peer design is used. Servers can be created explictly, as can clients by explicitly connecting to a server. If a client needs to have a server, e.g. so a reference to a local object can be passed to a remote destination, it is instantiated as needed.
Clients can have multiple connections. New connections are created when needed, e.g. when a remote reference to a new server is recieved.
WARNING:
This module is still in its experimental phase, so it is kind of usable, but an awful lot of bugs is still in it, and quite a few parts are not coded yet, others arent even designed yet.
Therefor lots of changes and outdated documentation should be expected.
Enhancements:
- All previous stub objects have been replaced by a single stub object which uses on-demand retrieval of attributes of remote objects.
- This way, the behavior of the stub object is much more flexible and smoother.
- A first draft of an authentication framework has been implemented so PyRCall can support many different authentication methods.
- Support for username/password-based authentication has been implemented.

Python chess module project is a Python chess move adjudicator module.
Python chess module does not know how to play chess, but does understand the rules enough that it can watch moves and verify that they are correct.
It features high abstraction, understands various notations (including algebraic, long algebraic, and standard algebraic notation), does disambiguation, and supports saving and loading the state of a game.
Main features:
- high abstraction
- understands various notations, including algebraic, long algebraic, and standard algebraic notation (as in PGN); does disambiguation
- supports saving and loading of the state of a game
- not a trivial move processor; understands the intracies of the game
Enhancements:
- Bug with en passant moves fixed.

The Python logging module implements a standard logging system for Python programs. It was strongly influenced by log4j from the Apache project.

As this package is included in versions 2.3 and later, only users of earlier versions of Python would need to install this module.

There was a need for a standard logging system in Python, as comprehensively documented in PEP 282 and enthusiastically endorsed by the BDFL in the Parade of the PEPs.

By a happy coincidence, the package described here was already in development and fairly close in intent and design to the description in the aforementioned PEP, borrowing as it did heavily from JSR-47 (now JDK 1.4s java.util.logging package) and log4j.

This page describes it in more detail. As I have tweaked the package to meet comments on PEP 282, I have structured this page in the same way as the original PEP.

This package is now part of Python 2.3, but if you have an earlier version of Python, you can download the package from here and use it with Python versions between 1.5.2 and 2.2.x.

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

RPyC stands for Remote Python Call, a pun over remote procedure call. It is completely transparent and symmetrical. It is inspired by the work of eyal lotem (pybuild.sf.net) on pyinvoke, and was made for two purposes:
Learning the lowlevel of the python language attempting to improve pyinvoke by making the entire protocol symmetrical. This means the client can make requests to the server, and the server can reply with requests of its own (the client is also a server on its own). This typically means using callback functions.
The RPyC package comes with a full demo, showing (or showing-off) many of its features. As i said, its completely transparent and symmetrical, so you can write code just as you would write in the case of normal python programs.
demo 1 -- a simple client demo
# import the client
from Rpyc.Client import RpycSocketClient
# `hostname` is the name of the host running an Rpyc server
# the port parameter is optional
c = RpycSocketClient("hostname")
# now we are connected and can start messing around with stuff on the server
for filename in c.modules.os.listdir("/tmp"):
print "found file", filename
Enhancements:
- This release adds DeliveringNamespace, LoginError (instead of tlslites internal errors), __version__, deliver (the counterpart of obtain, which can now deliver and obtain functions as well), and isproxy (to test whether an object is a proxy).
- It improves memory consumption with __slots__ and the isinstance/issubclass mechanism.

GnuPGInterface is a Python module to interface with GnuPG . It concentrates on interacting with GnuPG via filehandles, providing access to control GnuPG via versatile and extensible means.
This module is based on GnuPG::Interface, a Perl module by the same author.
To install this distribution, simply run the following commands:
python setup.py build
python setup.py install
See pydoc GnuPGInterface for module documentation. Only recent
versions of Python include the executable pydoc.
Enhancements:
- GnuPGInterface.py, NEWS, setup.py: bump version to 0.3.2 and news

SPYCE is a server-side language that supports simple and efficient Python-based dynamic HTML generation, otherwise called Python Server Pages (PSP).

Those who are familiar with JSP, PHP, or ASP and like Python, should have a look at Spyce. Its modular design makes it very flexible and extensible. Spyce - Python Server Pages can also be used as a command-line utility for static text pre-processing or as a web-server proxy.

The supported adapters are:

* Fast CGI:The default Spyce integration with Apache is acheived via FastCGI, a CGI-like interface that is relatively fast, because it does not incur the large process startup overhead on each request.

* mod_python: If you really must have the fastest Spyce implementation (see the performance numbers), it is currently through an Apache module called mod_python. Spyce has been tested with mod_python version 2.7.6 (and version 3.0.3 with apache 2.0.37). You can try to find some mod_python rpms here, but in general one must compile mod_python from sources. The reason for this is because mod_python links with the Python library it finds on your system at compile time. Thus, even if you have the correct Python version installed on your system, mod_python will be using the Python library version on the system where it was compiled. Also, note that mod_python (or rather Apache) needs a Python that has been compiled without threading, so you may need to recompile Python as well for this reason. The process is not very difficult (just the usual: ./configure; make; make install dance), but hopefully someone will suggest a better route in time. In any case, make sure you can first get mod_python running on your system, if that is that is your chosen Apache integration route.

* Web server: Another fast alternative is to serve Spyce files via a proxy. This involves running Spyce in web-server mode, and configuring the main web server to forward the appropriate requests. The built-in Spyce web server can also be used to serve requests directly, but this is highly discouraged for production environments.

* CGI: Failing these alternatives you can always process requests via regular CGI, but this alternative is the slowest option and is intended primarily for those who do not have much control over their web environments.

* Command line: Lastly, one can use Spyce as a command-line tool for pre-processing Spyce pages and creating static HTML files.