#
# =============================
# Collection of Python Projects
# =============================
#
#
# Description:  Bookmarks of Python projects.
#
# Author:       Lars Heuer <heuer[at]semagia.com>
#
# License:      Public Domain
#
# Date:         2011-02-21
# 
# Modified:     2013-06-01
# 

%prefix dc <http://purl.org/dc/elements/1.1/>
%prefix p <http://psi.semagia.com/python-projects/>
%prefix doap <http://usefulinc.com/ns/doap#>
%prefix wp <http://en.wikipedia.org/wiki/>

def nhd($t, $name, $homepage, $description)
    $t - $name; doap:homepage: $homepage; doap:description: $description.
end

def ml($t, $iri)
    $t doap:mailing-list: $iri.
end

def tracker($t, $iri)
    $t doap:bug-database: $iri.
end

template-engine
    <http://en.wikipedia.org/wiki/Template_engine_%28web%29>;
    - "Template engine";
.

p:pyxll
  nhd("PyXLL", <http://www.pyxll.com/>, """PyXLL makes it possible to write addins for Microsoft Excel in Python""")
.


p:sqlite3dbm
  nhd("sqlite3dbm", <http://pythonhosted.org/sqlite3dbm/index.html>,
      """sqlite3dbm provides a sqlite-backed dictionary conforming to the dbm interface, along with a shelve class that wraps the dict and provides serialization for it.""")
.

p:lrparsing
  nhd("lrparsing", <http://ace-host.stuart.id.au/russell/files/lrparsing/>,
      """Lrparsing is yet another parser for Python. The things that make lrparsing different is it combines a LR(1) parser with an easy to use grammar written using Python expressions, a tokeniser, and comes with extensive (and free!) documentation. """)
.

p:pypng
  nhd("PyPNG", <https://github.com/drj11/pypng>,
      """PyPNG provides Python code for encoding/decoding PNG files.  In
particular png.py is a Python module written entirely in Python.""")
.

p:scrapely
  ndh("Scrapely", <https://github.com/scrapy/scrapely>,
      """Scrapely is a library for extracting structured data from HTML pages. Given some example web pages and the data to be extracted, scrapely constructs a parser for all similar pages.""")
.

p:docx2html
  nhd("docx2html", <https://github.com/PolicyStat/docx2html/>,
      """Convert a docx (OOXML) file to semantic HTML. All of Word formatting nonsense is stripped away and you're left with a cleanly-formatted version of the content.""")
.

p:pypdfml
  nhd("PyPDFML", <https://github.com/badzong/pypdfml>,
      """Simple XML wrapper for Reportlab with Jinja2 support""")
.

p:dedupe
  nhd("dedupe", <https://github.com/open-city/dedupe>
      """A free python library for accurate and scalelable deduplication and entity-resolution.""")
.

p:pydedupe
  nhd("PyDedupe", <https://github.com/gpoulter/pydedupe>,
      """Python dedupe library""")
.

p:jellyfish
  nhd("Jellyfish", <https://github.com/sunlightlabs/jellyfish>,
      """Jellyfish is a python library for doing approximate and phonetic matching of strings.""");
.

p:Quepy
  nhd("Quepy", <https://github.com/machinalis/quepy>,
      """Quepy is a python framework to transform natural language questions to queries in a database query language""");
.

p:font-awesome-to-png
  nhd("Font Awesome to PNG", <https://github.com/odyniec/font-awesome-to-png>,
      """This program allows you to extract the awesome Font Awesome icons as PNG images of specified size.""");
.

p:pattern
  nhd("Pattern", <http://www.clips.ua.ac.be/pages/pattern>,
      """Pattern is a web mining module for the Python programming language.

It bundles tools for data retrieval (Google + Twitter + Wikipedia API, web spider, HTML DOM parser), \
text analysis (rule-based shallow parser, WordNet interface, syntactical + semantical n-gram search algorithm, tf-idf + \
cosine similarity + LSA metrics), clustering and classification (k-means, KNN, SVM), and data visualization (graph networks).""");
.

p:javalang
  nhd("javalang", <https://github.com/c2nes/javalang>,
      """javalang is a pure Python library for working with Java source code. javalang provies a lexer and parser targeting Java 7.""");
.

p:javasphinx
  nhd("javasphinx", <https://github.com/bronto/javasphinx>,
      """javasphinx is an extension to the Sphinx documentation system which adds support for documenting Java projects. 
It includes a Java domain for writing documentation manually and a javasphinx-apidoc utility which will automatically generate API documentation from existing Javadoc markup.""");
.


p:calypso
  nhd("Calypso", <http://keithp.com/blogs/calypso/>,
      """'Radicale' fork which supports CardDAV""");
.

p:easyply
  nhd("easyply", <https://github.com/MHordecki/easyply>,
      """easyply is a helper library for PLY, parser generator for Python. It acts as a middleware between your grammar definition and PLY.
easyply adds some EBNF-y flavor to it""");
.

p:rdb
  nhd("rdb", <https://github.com/nvie/rdb>,
      """rdb is an attempt at a lightweight wrapper around native Redis calls to represent and persist objects in Python. It does not aim to be yet another ORM library""");
.

p:ConceptNet
  nhd("ConceptNet", <https://github.com/commonsense/conceptnet>,
      """ConceptNet aims to give computers access to common-sense knowledge, the kind of information that ordinary people know but usually leave unstated.

The data in ConceptNet was collected from ordinary people who contributed it over the Web. ConceptNet represents this data in the form of a semantic network, and makes it available to be used in natural language processing and intelligent user interfaces.""");
  doap:homepage: <http://csc.media.mit.edu/conceptnet>;
.

p:yaupon
  nhd("yaupon", <https://github.com/aaw/yaupon>,
      """yaupon is a graph library written in Python.""");
.

p:sparql_shim
  nhd("sparql_shim", <https://github.com/npilon/sparql-shim>,
      """A minimal web application using pyramid that provides SPARQL 1.1 Uniform HTTP
Protocol support for SPARQL 1.1 Update-capable graph stores.""");
.

p:Pylgrim
  nhd("Pylgrim", <https://github.com/pwoolcoc/Pylgrim>,
      """Graph library similar to (but not nearly as powerful as) the Gremlin project.""");
.

p:intellect
  nhd("Intellect", <https://github.com/nemonik/Intellect>,
      """Intellect is a DSL ("Domain-Specific Language") and Rule Engine for Python I authored for expressing policies to orchestrate and control a dynamic network defense cyber-security platform being researched in The MITRE Corporation's Innovation Program.""");
.

p:piped
  nhd("Piped", <http://www.piped.io/>,
      "Piped is a MIT-licensed framework for flow based programming written in Python that focuses on:

    * Ease of use.
    * Extendability.
    * Painless integrating with other systems.
    * Testing and maintainability.
    * Performance.

A base Piped installation already speaks multiple protocols, such as HTTP, SMTP and Perspective Broker. 
Contrib packages that extends Piped, adding support for database connectivity, message queues such as ZeroMQ and more are also available.");
  repository: <https://github.com/foundit/Piped>;
.

p:WTF
  nhd("WTForms", <http://wtforms.simplecodes.com/>,
      "WTForms is a forms validation and rendering library for Python web development.");
.
  
p:Tweepy
  nhd("Tweepy", <https://github.com/tweepy/tweepy>,
      "A Python library for access the Twitter API");
.

p:tweetstream
  nhd("tweetstream", <http://bitbucket.org/runeh/tweetstream/>,
      "Simple Twitter streaming API access");
.

p:Dulwich
  nhd("Dulwich", <http://www.samba.org/~jelmer/dulwich/>,
      "Dulwich is a pure-Python implementation of the Git file formats and protocols.");
  ml(<https://launchpad.net/~dulwich-users>);
.

p:DeltaLDA
  nhd("DeltaLDA", <http://pages.cs.wisc.edu/~andrzeje/research/delta_lda.html>,
      """This software implements the DeltaLDA model for discrete count data. 
DeltaLDA is a modification of the Latent Dirichlet Allocation (LDA) model which uses two different 
topic mixing weight priors to jointly model two corpora with a shared set of topics. 
The inference method is Collapsed Gibbs sampling; this code can also be used to do "standard" LDA.

The code implements DeltaLDA as a Python C extension module.""");
.

p:Blogofile
  nhd("Blogofile", <http://www.blogofile.com/>,
      "Blogofile is a static website compiler, primarily (though not exclusively) designed to be a simple blogging engine. 
It requires no database and no special hosting environment. You customize a set of templates with Mako, create posts in a 
markup language of your choice and Blogofile renders your entire website as static HTML and Atom/RSS feeds which you can 
then upload to any old web server you like.");
.

p:Shove
  nhd("Shove", <http://pypi.python.org/pypi/shove/>,
      "Common object storage frontend that supports dictionary-style access, object serialization and compression, and multiple storage and caching backends.");
.

p:clint
  nhd("Clit", <https://github.com/kennethreitz/clint>,
      "Clint: Python Command-line Application Tools

Clint is a module filled with a set of awesome tools for developing commandline applications.");
.

p:requests
  nhd("requests", <https://github.com/kennethreitz/requests>,
      "Python HTTP Requests for Humans

Requests: HTTP for Humans

Requests allow you to send HEAD, GET, POST, PUT, PATCH, and DELETE HTTP requests. 
You can add headers, form data, multipart files, and parameters with simple Python 
dictionaries, and access the response data in the same way. It's powered by urllib2.");
.

p:imapIO 
  nhd("imapIO", <https://github.com/invisibleroads/imapIO>,
      "Convenience classes and methods for processing IMAP mailboxes");
.

p:sifter
  nhd("sifter", <https://github.com/garyp/sifter>,
      "Python implementation of the Sieve email filtering language (RFC 5228).");
.

p:cassandra-dbapi2
  nhd("Cassandra DB-API 2", <https://code.google.com/a/apache-extras.org/p/cassandra-dbapi2/>,
      "A DB-API 2.0 compliant client library for Cassandra/CQL");
.

p:Landslide
  nhd("Landslide", <https://github.com/adamzap/landslide>,
      "Landslide generates a slideshow using the slides that power the html5-slides presentation.");
.

p:asciitable
  nhd("ASCII Table", <http://cxc.cfa.harvard.edu/contrib/asciitable/>,
      "An extensible ASCII table reader and writer for Python 2 and 3.");
.

p:Lupyne
  nhd("Lupyne", <https://code.google.com/p/lupyne/>,
      "A pythonic search engine, based on PyLucene and CherryPy.");
.

p:Cobe
  nhd("Cobe", <https://github.com/pteichman/cobe>,
      "Cobe is a Markov chain based text generator. It provides a command line learning/replying interface, an IRC client, and a low-level API for writing your own text generation tools. It uses SQLite as its data store.");
.

p:pSSLDA
  nhd("pSSLDA", <https://github.com/davidandrzej/pSSLDA>,
      """Parallel Semi-Supervised Latent Dirichlet Allocation 

This software implements an extension of Latent Dirichlet Allocation
(LDA) which includes "topic-in-set knowledge", or z-labels,
allowing the user to supply (possibly noisy) labels for specific
latent topic assignments.  Parallelized inference is done by the
Approximate Distributed (AD) collapsed Gibbs sampling algorithm.""");
.

p:PyStemmer
  nhd("PyStemmer", <http://pypi.python.org/pypi/PyStemmer/>,
      "Snowball stemming algorithms, for information retrieval");
.

p:csvkit
  nhd("csvkit", <https://github.com/onyxfish/csvkit>,
      "A library of utilities for working with CSV");
.

p:jsonpath
  nhd("JSONPath", <https://code.google.com/p/jsonpath/>,
      "XPath like syntax for JSON");
.

p:openpyxl
  nhd("openpyxl", <https://bitbucket.org/ericgazoni/openpyxl/>,
      "A Python library to read/write Excel 2007 xlsx/xlsm files.");
.

p:pyXLSX
  nhd("pyXLSX", <https://github.com/leegao/pyXLSX>,
      "pyXLSX - A python class library for reading Excel 2007 files");
.

p:python-xlsx
  nhd("python-xlsx", <https://github.com/staale/python-xlsx>,
      "A small footprint xslx reader that understands shared strings and can process excel dates.");
.

p:Pygcurse
  nhd("Pygcurse", <http://inventwithpython.com/pygcurse/>,
      "Pygcurse (pronounced "pig curse") is a curses library emulator that runs on top of the Pygame framework.");
.

p:ldtools
    nhd("Ldtools", <https://github.com/dmr/ldtools/>,
        "Ldtools is a simple library to handle RDF data more conveniently.");
.

p:sqlitedict
    nhd("sqlitedict", <https://github.com/piskvorky/sqlitedict>,
        "Persistent dict in Python, backed up by sqlite3 and pickle, multithread-safe.");
.

p:urlwatch
    nhd("urlwatch", <http://thp.io/2008/urlwatch/>,
        "A tool for monitoring webpages for updates");
.

p:BagIt
    nhd("BagIt", <https://github.com/edsu/bagit>, 
    "This package can be used to create BagIt style packages programmatically
in Python or from the command line.  More about BagIt can be found at:

  http://purl.org/net/bagit

bagit.py is a standalone python module");
.

p:Compass
    nhd("Compass", <https://github.com/emehrkay/Compass>, 
    "Compass is a simple Python REST interface for the OrientDB graph document store. 
Later iterations of compass will allow you to choose between the REST or BINARY protocols while using the same compass interface.");
.

p:svg.charts
    nhd("svg.charts", <http://pypi.python.org/pypi/svg.charts/>,
    "svg.charts is a pure-python library for generating charts and graphs in SVG.")
.

p:django-shop
    nhd("Django Shop", <https://github.com/divio/django-shop>,
    "A Django based shop system");
.

p:pyperry
    nhd("pyperry", <https://github.com/tpett/pyperry>,
      "Python library for querying and mapping data over generic interfaces (port of the Ruby 'perry' library)");
.

p:simplekv
    nhd("simplekv", <https://github.com/mbr/simplekv>, 
    "simple key-value storage api

simplekv is an API for very basic key-value stores for storing binary data. 
Due to its basic interface, it is easy to implemented a large number of backends. 
simplekv's origins are in storing user-uploaded files on websites, but its low overhead and design should make it applicable for numerous other problems.");
.

p:bulbflow
    nhd("bulbflow", <http://bulbflow.com/>, 
    "A Python framework for graph databases.

It connects to any Blueprints-enabled database, including TinkeGraph, Neo4j, OrientDB, Dex, and OpenRDF");
.

p:reblok 
    nhd("reblok", <http://pypi.python.org/pypi/reblok/>, "Reblok creates an AST (Abstract Syntax Tree) from Python bytecode. (decompiler)");
.

p:linkpath
    nhd("LinkPath", <https://github.com/iand/linkpath>,
    "This is a library for querying linked data on the web using a simple to learn path language based on the Fresnel Selector Language. A LinkPath is evaluated against the whole web, fetching the data it needs by following links between items. ");
.

p:pycountry
    nhd("pycountry", <http://pypi.python.org/pypi/pycountry/>, 
    "ISO country, subdivision, language, currency and script definitions and their translations");
.

p:pyblueprints
    nhd("pyblueprints", <https://github.com/escalant3/pyblueprints>, 
    "A Python version of the Tinkerpop Blueprints property graph model interface");
.

p:python-rexster
    nhd("Python Rexter", <https://github.com/CulturePlex/python-rexster>, 
    "A Python client for Rexster following the Tinkerpop Blueprints property graph model interface");
.

p:pyquery 
    nhd("pyquery", <http://www.bitbucket.org/olauzanne/pyquery/>, 
        "A jquery-like library for python.
pyquery allows you to make jquery queries on xml documents. The API is as much as possible the similar to jquery. 
pyquery uses lxml for fast xml and html manipulation.");
.

p:Chameleon 
    isa template-engine;
    nhd("Chameleon", <http://pagetemplates.org/>, "Chameleon is an HTML/XML template engine for Python.");
.

p:aspen
    nhd("Aspen", <http://aspen.io/>, "Aspen is a Python web framework.");
.

p:asq
    nhd("asq",
        <https://code.google.com/p/asq/>,
        """A Python implementation of LINQ to objects and Parallel LINQ to objects."""
        );
.

p:tinydav
    nhd("tinyDAV",
        <https://code.google.com/p/tinydav/>,
        """An easy-to-use HTTP and WebDAV client library for Python."""
        );
.

p:pyxmpp 
    nhd("PyXMPP",
        <https://github.com/Jajcus/pyxmpp>,
        """PyXMPP is a Python XMPP (RFC 3920,3921) implementation, including some of the well-known extensions. It is based on libxml2 -- fast and fully-featured XML parser.

PyXMPP provides most core features of the XMPP protocol and several JSF-defined extensions. PyXMPP provides building blocks for creating Jabber clients and components. Developer uses them to setup XMPP streams, handle incoming events and create outgoing stanzas (XMPP "packets")."""
        );
.

p:pyxmpp2 
    nhd("PyXMPP2",
        <https://github.com/Jajcus/pyxmpp2>,
        """Python XMPP implementation, fork of PyXMPP <https://github.com/Jajcus/pyxmpp>

Goals:
* it doesn't rely on libxml2 any more
* it uses most current Python APIs
* its API is cleaned up
"""
        );
.

p:schemaless
    nhd("schemaless", <https://github.com/eklitzke/schemaless>, "Schemaless is a Python module that implements the pattern described by Bret Taylor in his post How FriendFeed uses MySQL to store schema-less data.");
.

p:seven
    nhd("seven", <https://github.com/aatiis/seven>, "seven is a Python 2.6+ compatibility layer for Python 2.5. It allows you to import Python 2.6 or 2.7 code in a 2.5 interpreter.");
.

p:tablefactory
    - "Tablefactory";
    doap:homepage: <http://kstrauser.github.com/tablefactory/>;
    repository: <https://github.com/kstrauser/tablefactory>;
    doap:description: "TableFactory is a simple API for creating tables in popular formats. It acts as a wrapper around other popular Python report generators and handles all the tedious, boilerplate problems of extracting columns from input data, creating the layout, applying formatting to cells, etc.";
.

p:xlwt
    - "xlwt";
    doap:homepage: <http://pypi.python.org/pypi/xlwt>;
    doap:mailing-list: <http://groups.google.com/group/python-excel>;
    repository: <https://secure.simplistix.co.uk/svn/xlwt/trunk>;
    doap:description: "Library to create spreadsheet files compatible with MS Excel 97/2000/XP/2003 XLS files, on any platform, with Python 2.3 to 2.6";
.

p:tablib
    - "Tablib";
    doap:homepage: <http://tablib.org/>;
    doap:description: "Tablib is an MIT Licensed format-agnostic tabular dataset library, written in Python. It allows you to import, export, and manipulate tabular data sets. Advanced features include, segregation, dynamic columns, tags & filtering, and seamless format import & export.";
    repository: <https://github.com/kennethreitz/tablib>;
.

p:nltk-trainer
    - "NLTK Trainer";
    repository: <https://github.com/japerk/nltk-trainer>;
    doap:description: "NLTK Trainer exists to make training and evaluating NLTK objects as easy as possible.";
.

p:flask
    - "Flask";
    doap:description: "Flask is a microframework for Python based on Werkzeug, Jinja 2 and good intentions.";
    doap:homepage: <http://flask.pocoo.org/>;
    repository: <https://github.com/mitsuhiko/flask>;
    doap:mailing-list: <http://flask.pocoo.org/mailinglist/>;
    doap:bug-database: <https://github.com/mitsuhiko/flask/issues>;
.

p:iep isa ide;
    - "IEP";
    doap:description: "IEP (pronounced as 'eep') is a cross-platform Python IDE focused on interactivity and introspection, which makes it very suitable for scientific computing. Its practical design is aimed at simplicity and efficiency.";
    doap:homepage: <https://code.google.com/p/iep/>;
    doap:mailing-list: <http://groups.google.com/group/iep_>;
    doap:bug-database: <https://code.google.com/p/iep/issues/list>;
.

p:pythonfutures
    - "Python Futures";
    doap:homepage: <https://code.google.com/p/pythonfutures/>;
    doap:description: "A futures implementation for Python (backport of PEP 3148)";
    pep: <http://www.python.org/dev/peps/pep-3148/>;
.

p:tenjin
    - "Tenjin";
    doap:homepage: <http://www.kuwata-lab.com/tenjin/>;
    doap:description: "A fast and full-featured template engine based on embedded Python";
.

p:ply
    - "PLY";
    doap:homepage: <http://www.dabeaz.com/ply/>;
    doap:description: "PLY is yet another implementation of lex and yacc for Python. Some notable features include the fact that its implemented entirely in Python and it uses LALR(1) parsing which is efficient and well suited for larger grammars.";
.

p:cython
    - "Cython";
    doap:description: "The Cython compiler for writing C extensions for the Python language.";
    doap:homepage: <http://cython.org/>;
.

p:nltk
    - "NLTK - Natural Language Toolkit";
    doap:description: "The Natural Language Toolkit (NLTK) is a Python package for processing natural language text.";
    doap:homepage: <http://www.nltk.org/>;
.

p:rdblib isa wp:Triplestore
    - "RDFLib";
    doap:description: "RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information.";
    doap:homepage: <https://code.google.com/p/rdflib/>;
    doap:homepage: <http://www.rdflib.net/>;
.

p:rdfextras
    - "RDF Extras";
    doap:description: "A collection of extra utilities based on RDFLib";
    doap:mailing-list: <https://groups.google.com/group/rdflib-dev>;
    doap:homepage: <https://code.google.com/p/rdfextras/>;
.

p:feedparser
    - "Feedparser";
    doap:description: "Universal Feed Parser -- Parse RSS and Atom feeds in Python.";
    doap:homepage: <http://feedparser.org/>;
    doap:homepage: <https://code.google.com/p/feedparser/>;
.

p:redis-py
    - "Redis";
    doap:description: "Python client for Redis key-value store";
    doap:homepage: <https://github.com/andymccurdy/redis-py>;
.

p:pyside
    - "PySide";
    doap:homepage: <http://www.pyside.org/>;
    doap:description: "The PySide project provides LGPL-licensed Python bindings for the Qt cross-platform application and UI framework. PySide Qt bindings allow both free open source and proprietary software development and ultimately aim to support all of the platforms as Qt itself.";
.

p:mutagen
    - "Mutagen";
    doap:description: "Mutagen is a Python module to handle audio metadata. It supports ASF, FLAC, M4A, Monkey's Audio, MP3, Musepack, Ogg FLAC, Ogg Speex, Ogg Theora, Ogg Vorbis, True Audio, WavPack and OptimFROG audio files. All versions of ID3v2 are supported, and all standard ID3v2.4 frames are parsed.";
    doap:homepage: <https://code.google.com/p/mutagen/>;
.

p:pyyaml
    - "PyYAML";
    doap:description: "YAML parser and emitter for Python";
    doap:homepage: <http://pyyaml.org/wiki/PyYAML>;
.

p:sphinx
    - "Sphinx";
    doap:homepage: <http://sphinx.pocoo.org/>;
    doap:description: "Python documentation generator";
.

p:docutils
    - "Docutils";
    doap:homepage: <http://docutils.sourceforge.net/>;
    doap:description: "Docutils is a modular system for processing documentation into useful formats, such as HTML, XML, and LaTeX. For input Docutils supports reStructuredText, an easy-to-read, what-you-see-is-what-you-get plaintext markup syntax.";
.

p:whoosh
    - "Whoosh";
    doap:homepage: <http://bitbucket.org/mchaput/whoosh>;
    doap:description: "Whoosh is a library of classes and functions for indexing text and then searching the index.";
    doap:mailing-list: <http://groups.google.com/group/whoosh>;
.

p:gensim
    - "Gensim";
    doap:description: "Python Framework for Vector Space Modelling";
    doap:homepage: <http://nlp.fi.muni.cz/projekty/gensim/>;
    repository: <https://github.com/piskvorky/gensim/>;
    ml(<https://groups.google.com/group/gensim>);
.

#
# TODO: Relationship between Pyro4 and Pyro
#
p:pyro4
  nhd("Pyro4", <http://irmen.home.xs4all.nl/pyro/>,
      "Pyro is a library that enables you to build applications in which objects can talk to each other over the network, with minimal programming effort.");
.

p:pyro
    - "Pyro";
    doap:description: "Distributed object middleware for Python (IPC/RPC)

Pyro stands for PYthon Remote Objects. It is an advanced and powerful Distributed Object Technology system written entirely in Python";
    doap:homepage: <http://www.xs4all.nl/~irmen/pyro3/>;
.

p:circuits
    - "circuits";
    doap:description: "Lightweight Event driven and Asynchronous Application Framework for the Python Programming Language with a strong Component Architecture";
    doap:homepage: <https://bitbucket.org/prologic/circuits/>;
    doap:mailing-list: <https://bitbucket.org/prologic/circuits/>;
.

p:processing
    - "processing";
    doap:description: "Package for using processes which mimics the threading module
processing is a package for the Python language which supports the spawning of processes using the API of the standard library's threading module. It runs on both Unix and Windows.";
    doap:homepage: <http://developer.berlios.de/projects/pyprocessing>;
.

p:six
    - "six";
    doap:description: "Six provides simple utilities for wrapping over differences between Python 2 and Python 3";
    doap:homepage: <http://packages.python.org/six/>;
.

p:xlrd
    - "xlrd";
    doap:description: "Library for developers to extract data from Microsoft Excel (tm) spreadsheet files";
    doap:homepage: <http://www.lexicon.net/sjmachin/xlrd.htm>;
.

p:imapclient
    - "IMAPClient";
    doap:homepage: <http://imapclient.freshfoo.com/>;
    doap:description: "IMAPClient aims to be a easy-to-use, Pythonic and complete IMAP client library with no dependencies outside the Python standard library.";
.

p:pycassa
    nhd("pycassa", 
        <https://github.com/pycassa/pycassa>, 
        "pycassa is a python client library for Apache Cassandra");
.

p:agamemnon
    nhd("Agamemnon", 
        <https://github.com/turtlebender/agamemnon>, 
        "Agamemnon is a thin library built on top of pycassa. 
It allows you to use the Cassandra database (<http://cassandra.apache.org>) as a graph database. 
Much of the API was inspired by the neo4j.py project (<http://components.neo4j.org/neo4j.py/snapshot/>)");
.

p:cmislib
    - "cmislib";
    doap:description: "Implementation of the Content Management Interoperability Services (CMIS) specification.";
    doap:homepage: <http://chemistry.apache.org/python/cmislib.html>;
.

p:lindypy
    - "lindpy";
    - "Linda Tuple Spaces in Python";
    doap:description: "This package implements simple Linda Tuple Spaces in Python, using multiprocessing to allow writing code that makes full use of multicore machines by still retaining a very simple communications API.";
    doap:homepage: <http://pypi.python.org/pypi/lindypy/>;
.

p:vatnumber
    nhd("vatnumber", <https://code.google.com/p/vatnumber/>, "Python module to validate VAT numbers.")
.

p:Suds
    nhd("Suds", <https://fedorahosted.org/suds/>, "Suds is a lightweight SOAP python client for consuming Web Services.");
.

p:SleekXMPP
    nhd("SleekXMPP", <https://github.com/fritzy/SleekXMPP>, "SleekXMPP is an XMPP library written for Python 3.1+ (with 2.6 compatibility).");
    doap:mailing-list: <http://groups.google.com/group/sleekxmpp-discussion>;
.

p:WsgiDAV
    nhd("WsgiDAV", <http://wsgidav.googlecode.com/>, "Generic WebDAV server based on WSGI

WsgiDAV is a WebDAV server for sharing files and other resources over the web. It is based on the WSGI interface.");
    doap:mailing-list: <https://groups.google.com/group/wsgidav>;
.

p:CloudDAV
    nhd("CloudDAV", <https://code.google.com/p/clouddav/>, "CloudDAV is a WebDAV application that implements a virtual file system built on Google App Engine's data store.");
.

p:ijson 
    nhd("ijson", <https://launchpad.net/ijson>, "Ijson is a Python wrapper to YAJL which is a streaming SAX-like JSON parser. Ijson provides a standard Python iterator interface for it.");
.

p:pyfilesystem
    nhd("Pyfilesystem", <https://code.google.com/p/pyfilesystem/>, "Pyfilesystem is a Python module that provides a simplified common interface to many types of filesystem. Filesystems exposed via Pyfilesystem can also be served over the network, or 'mounted' on the native filesystem.");
.

p:tmve
    nhd("Topic Model Visualization Engine", <https://code.google.com/p/tmve>, "A basic implementation of a topic model visualization engine.");
    doap:homepage: <http://www.sccs.swarthmore.edu/users/08/ajb/tmve/>;
.

p:radicale
    nhd("Radicale", <http://www.radicale.org/>, "The Radicale Project is a CalDAV calendar server. It aims to be a light solution, easy to use, easy to install, easy to configure. As a consequence, it requires few software dependances and is pre-configured to work out-of-the-box.");
.

p:scikits.learn
    nhd("scikits.learn", <http://scikit-learn.sourceforge.net/>, "scikits.learn is a Python module integrating classic machine learning algorithms in the tightly-knit world of scientific Python packages (numpy, scipy, matplotlib).

It aims to provide simple and efficient solutions to learning problems that are accessible to everybody and reusable in various contexts: machine-learning as a versatile tool for science and engineering.");
.

p:Mako 
    isa template-engine;
    nhd("Mako", <http://www.makotemplates.org/>, "Mako is a template library written in Python. It provides a familiar, non-XML syntax which compiles into Python modules for maximum performance.");
    ml(<https://groups.google.com/group/mako-discuss>);
.

p:Flask-Mako
    nhd("Flask-Mako", <https://github.com/tzellman/flask-mako/>, "Provides Mako support in Flask.");
.