pkgs/top-level/python-packages.nix

   1 { pkgs, python, buildPythonPackage }:
   2
   3 rec {
   4   inherit (pkgs) fetchurl fetchsvn stdenv;
   5
   6   argparse = buildPythonPackage (rec {
   7     name = "argparse-0.9.1";
   8
   9     src = fetchurl {
  10       url = "http://pypi.python.org/packages/source/a/argparse/${name}.zip";
  11       sha256 = "00jw32wwccpf9smraywjk869b93w7f99rw8gi63yfhw6379fnq6m";
  12     };
  13
  14     buildInputs = [ pkgs.unzip ];
  15
  16     # How do we run the tests?
  17     doCheck = false;
  18
  19     meta = {
  20       homepage = http://code.google.com/p/argparse/;
  21
  22       license = "Apache License 2.0";
  23
  24       description = "argparse: Python command line parser";
  25
  26       longDescription = ''
  27         The argparse module makes writing command line tools in Python
  28         easy.  Just briefly describe your command line interface and
  29         argparse will take care of the rest, including: parsing the
  30         arguments and flags from sys.argv, converting arg strings into
  31         objects for your program, formatting and printing any help
  32         messages, and much more.
  33       '';
  34     };
  35   });
  36
  37   darcsver = buildPythonPackage (rec {
  38     name = "darcsver-1.3.1";
  39
  40     src = fetchurl {
  41       url = "http://pypi.python.org/packages/source/d/darcsver/${name}.tar.gz";
  42       sha256 = "1a5cl2yhnd88a4vkc9r381cbjkcvga87dp9zx5av68857q1nvvvq";
  43     };
  44
  45     buildInputs = [ pkgs.darcs ];
  46
  47     meta = {
  48       description = "Darcsver, generate a version number from Darcs history";
  49
  50       homepage = http://pypi.python.org/pypi/darcsver;
  51
  52       license = "BSD-style";
  53     };
  54   });
  55
  56   dateutil = buildPythonPackage (rec {
  57     name = "dateutil-1.4.1";
  58
  59     src = fetchurl {
  60       url = "http://pypi.python.org/packages/source/p/python-dateutil/python-${name}.tar.gz";
  61       sha256 = "0mrkh932k8s74h4rpgksvpmwbrrkq8zn78gbgwc22i2vlp31bdkl";
  62     };
  63
  64     meta = {
  65       description = "Powerful extensions to the standard datetime module";
  66
  67       homepage = http://pypi.python.org/pypi/python-dateutil;
  68
  69       license = "BSD-style";
  70     };
  71   });
  72
  73   foolscap = buildPythonPackage (rec {
  74     name = "foolscap-0.4.2";
  75
  76     src = fetchurl {
  77       url = "http://foolscap.lothar.com/releases/${name}.tar.gz";
  78       sha256 = "14g89kjxxci3ssl9jgvpkyrcq62g361aw8pamlkclk8nnrh4f776";
  79     };
  80
  81     propagatedBuildInputs = [ twisted pkgs.pyopenssl ];
  82
  83     meta = {
  84       homepage = http://foolscap.lothar.com/;
  85
  86       description = "Foolscap, an RPC protocol for Python that follows the distributed object-capability model";
  87
  88       longDescription = ''
  89         "Foolscap" is the name for the next-generation RPC protocol,
  90         intended to replace Perspective Broker (part of Twisted).
  91         Foolscap is a protocol to implement a distributed
  92         object-capabilities model in Python.
  93       '';
  94
  95       # See http://foolscap.lothar.com/trac/browser/LICENSE.
  96       license = "MIT";
  97
  98       maintainers = [ stdenv.lib.maintainers.ludo ];
  99       platforms = python.meta.platforms;
 100     };
 101   });
 102
 103   genshi = buildPythonPackage {
 104     name = "genshi-0.5.1";
 105
 106     src = fetchurl {
 107       url = http://ftp.edgewall.com/pub/genshi/Genshi-0.5.1.tar.bz2;
 108       sha256 = "1g2xw3zvgz59ilv7mrdlnvfl6ph8lwflwd4jr6zwrca2zhj7d8rs";
 109     };
 110
 111     buildInputs = [ pkgs.setuptools ];
 112
 113     meta = {
 114       description = "Python components for parsing HTML, XML and other textual content";
 115
 116       longDescription = ''
 117         Python library that provides an integrated set of
 118         components for parsing, generating, and processing HTML, XML or other
 119         textual content for output generation on the web.
 120       '';
 121
 122       license = "BSD";
 123     };
 124   };
 125
 126   jinja2 = buildPythonPackage {
 127     name = "jinja2-2.2.1";
 128
 129     src = fetchurl {
 130       url = "http://pypi.python.org/packages/source/J/Jinja2/Jinja2-2.2.1.tar.gz";
 131       md5 = "fea849d68891218eb0b21c170f1c32d5";
 132     };
 133
 134     meta = {
 135       homepage = http://jinja.pocoo.org/;
 136       description = "Stand-alone template engine";
 137       license = "BSD";
 138       longDescription = ''
 139         Jinja2 is a template engine written in pure Python. It provides a
 140         Django inspired non-XML syntax but supports inline expressions and
 141         an optional sandboxed environment.
 142       '';
 143     };
 144   };
 145
 146   lxml = buildPythonPackage ( rec {
 147     name = "lxml-2.2.2";
 148
 149     src = fetchurl {
 150       url = http://pypi.python.org/packages/source/l/lxml/lxml-2.2.2.tar.gz;
 151       sha256 = "0zjpsy67wcs69qhb06ficl3a5z229hmczpr8h84rkk05vaagj8qv";
 152     };
 153
 154     buildInputs = [ pkgs.libxml2 pkgs.libxslt ];
 155
 156     meta = {
 157       description = "Pythonic binding for the libxml2 and libxslt libraries";
 158       homepage = http://codespeak.net/lxml/index.html;
 159       license = "BSD";
 160     };
 161   });
 162
 163   mechanize = buildPythonPackage (rec {
 164     name = "mechanize-0.1.11";
 165
 166     src = fetchurl {
 167       url = "http://wwwsearch.sourceforge.net/mechanize/src/${name}.tar.gz";
 168       sha256 = "1h62mwy4iz09jqz17nrb9j8y0djd500zdfqwrz9xmdwqzqwixkj2";
 169     };
 170
 171     meta = {
 172       description = "Stateful programmatic web browsing in Python";
 173
 174       homepage = http://wwwsearch.sourceforge.net/;
 175
 176       license = "BSD-style";
 177     };
 178   });
 179
 180   namebench = buildPythonPackage (rec {
 181     name = "namebench-1.0.5";
 182
 183     src = fetchurl {
 184       url = "http://namebench.googlecode.com/files/${name}.tgz";
 185       sha256 = "6cbde35ce94d1f31e7d48f5d8eec13238b4dbc505675a33f1e183e600c1482c3";
 186     };
 187
 188     # No support of GUI yet.
 189
 190     doCheck = false;
 191
 192     meta = {
 193       homepage = http://namebench.googlecode.com/;
 194       description = "Find fastest DNS servers available";
 195       license = [
 196         "Apache-2.0"
 197         # third-party program licenses (embedded in the sources)
 198         "LGPL" # Crystal_Clear
 199         "free" # dns
 200         "Apache-2.0" # graphy
 201         "BSD" # jinja2
 202       ];
 203       longDescription = ''
 204         It hunts down the fastest DNS servers available for your computer to
 205         use. namebench runs a fair and thorough benchmark using your web
 206         browser history, tcpdump output, or standardized datasets in order
 207         to provide an individualized recommendation. namebench is completely
 208         free and does not modify your system in any way.
 209       '';
 210     };
 211   });
 212
 213   nevow = buildPythonPackage (rec {
 214     name = "nevow-0.9.33";
 215
 216     src = fetchurl {
 217       url = "http://divmod.org/trac/attachment/wiki/SoftwareReleases/Nevow-0.9.33.tar.gz?format=raw";
 218       sha256 = "1b6zhfxx247b60n1qi2hrawhiaah88v8igg37pf7rjkmvy2z1c6c";
 219       name = "${name}.tar.gz";
 220     };
 221
 222     propagatedBuildInputs = [ twisted ];
 223
 224     meta = {
 225       description = "Nevow, a web application construction kit for Python";
 226
 227       longDescription = ''
 228         Nevow - Pronounced as the French "nouveau", or "noo-voh", Nevow
 229         is a web application construction kit written in Python.  It is
 230         designed to allow the programmer to express as much of the view
 231         logic as desired in Python, and includes a pure Python XML
 232         expression syntax named stan to facilitate this.  However it
 233         also provides rich support for designer-edited templates, using
 234         a very small XML attribute language to provide bi-directional
 235         template manipulation capability.
 236
 237         Nevow also includes formless, a declarative syntax for
 238         specifying the types of method parameters and exposing these
 239         methods to the web.  Forms can be rendered automatically, and
 240         form posts will be validated and input coerced, rendering error
 241         pages if appropriate.  Once a form post has validated
 242         successfully, the method will be called with the coerced values.
 243       '';
 244
 245       homepage = http://divmod.org/trac/wiki/DivmodNevow;
 246
 247       license = "BSD-style";
 248     };
 249   });
 250
 251   ply = buildPythonPackage (rec {
 252     name = "ply-3.2";
 253
 254     src = fetchurl {
 255       url = "http://www.dabeaz.com/ply/${name}.tar.gz";
 256       sha256 = "10z4xq8lc8c21v4g7z3zpnvpqbc0vidigrck1kqhwgkqi4gh0kfj";
 257     };
 258
 259     meta = {
 260       homepage = http://www.dabeaz.com/ply/;
 261
 262       description = "PLY (Python Lex-Yacc), an implementation of the lex and yacc parsing tools for Python";
 263
 264       longDescription = ''
 265         PLY is an implementation of lex and yacc parsing tools for Python.
 266         In a nutshell, PLY is nothing more than a straightforward lex/yacc
 267         implementation.  Here is a list of its essential features: It's
 268         implemented entirely in Python; It uses LR-parsing which is
 269         reasonably efficient and well suited for larger grammars; PLY
 270         provides most of the standard lex/yacc features including support for
 271         empty productions, precedence rules, error recovery, and support for
 272         ambiguous grammars; PLY is straightforward to use and provides very
 273         extensive error checking; PLY doesn't try to do anything more or less
 274         than provide the basic lex/yacc functionality.  In other words, it's
 275         not a large parsing framework or a component of some larger system.
 276       '';
 277
 278       license = "revised-BSD";
 279
 280       maintainers = [ stdenv.lib.maintainers.ludo ];
 281       platforms = python.meta.platforms;
 282     };
 283   });
 284
 285   psycopg2 = buildPythonPackage rec {
 286     name = "psycopg2-2.0.13";
 287
 288     doCheck = false;
 289
 290     src = fetchurl {
 291       url = "http://initd.org/pub/software/psycopg/PSYCOPG-2-0/${name}.tar.gz";
 292       sha256 = "0arkaa1nbbd3pyn4l1bc75wi7nff3vxxh4s8sj5al5hv20p64pm1";
 293     };
 294
 295     propagatedBuildInputs = [ pkgs.postgresql ];
 296
 297     meta = {
 298       description = "PostgreSQL database adapter for the Python programming language";
 299       license = "GPLv2/ZPL";
 300     };
 301   };
 302
 303   pycryptopp = buildPythonPackage (rec {
 304     name = "pycryptopp-0.5.15";
 305
 306     src = fetchurl {
 307       url = "http://pypi.python.org/packages/source/p/pycryptopp/${name}.tar.gz";
 308       sha256 = "0f8v3cs8vjpj423yx3ikj7qjvljrm86x0qpkckidv69kah8kndxa";
 309     };
 310
 311     # Use our own copy of Crypto++.
 312     preConfigure = "export PYCRYPTOPP_DISABLE_EMBEDDED_CRYPTOPP=1";
 313
 314     buildInputs = [ setuptoolsDarcs darcsver pkgs.cryptopp ];
 315
 316     meta = {
 317       homepage = http://allmydata.org/trac/pycryptopp;
 318
 319       description = "Python wrappers for the Crypto++ library";
 320
 321       license = "GPLv2+";
 322
 323       maintainers = [ stdenv.lib.maintainers.ludo ];
 324       platforms = python.meta.platforms;
 325     };
 326   });
 327
 328   pysqlite = buildPythonPackage (rec {
 329     name = "pysqlite-2.5.5";
 330
 331     src = fetchurl {
 332       url = "http://pysqlite.googlecode.com/files/${name}.tar.gz";
 333       sha256 = "ef7ca7f44893790e1a7084b10ea083770e138689406fddc7076d12d6bff4d44f";
 334     };
 335
 336     # Since the `.egg' file is zipped, the `NEEDED' of the `.so' files
 337     # it contains is not taken into account.  Thus, we must explicitly make
 338     # it a propagated input.
 339     propagatedBuildInputs = [ pkgs.sqlite ];
 340
 341     patchPhase = ''
 342       substituteInPlace "setup.cfg"                                     \
 343               --replace "/usr/local/include" "${pkgs.sqlite}/include"   \
 344               --replace "/usr/local/lib" "${pkgs.sqlite}/lib"
 345     '';
 346
 347     # FIXME: How do we run the tests?
 348     doCheck = false;
 349
 350     meta = {
 351       homepage = http://pysqlite.org/;
 352
 353       description = "Python bindings for the SQLite embedded relational database engine";
 354
 355       longDescription = ''
 356         pysqlite is a DB-API 2.0-compliant database interface for SQLite.
 357
 358         SQLite is a relational database management system contained in
 359         a relatively small C library.  It is a public domain project
 360         created by D. Richard Hipp.  Unlike the usual client-server
 361         paradigm, the SQLite engine is not a standalone process with
 362         which the program communicates, but is linked in and thus
 363         becomes an integral part of the program.  The library
 364         implements most of SQL-92 standard, including transactions,
 365         triggers and most of complex queries.
 366
 367         pysqlite makes this powerful embedded SQL engine available to
 368         Python programmers.  It stays compatible with the Python
 369         database API specification 2.0 as much as possible, but also
 370         exposes most of SQLite's native API, so that it is for example
 371         possible to create user-defined SQL functions and aggregates
 372         in Python.
 373       '';
 374
 375       license = "revised BSD";
 376
 377       maintainers = [ stdenv.lib.maintainers.ludo ];
 378       platforms = python.meta.platforms;
 379     };
 380   });
 381
 382   pyutil = buildPythonPackage (rec {
 383     name = "pyutil-1.3.30";
 384
 385     src = fetchurl {
 386       url = "http://pypi.python.org/packages/source/p/pyutil/${name}.tar.gz";
 387       sha256 = "1ksb4gn8x53wcyddmjv1ma8cvvhjlmfxc6kpszyhb838i7xzla19";
 388     };
 389
 390     buildInputs = [ setuptoolsDarcs ];
 391     propagatedBuildInputs = [ zbase32 argparse ];
 392
 393     meta = {
 394       description = "Pyutil, a collection of mature utilities for Python programmers";
 395
 396       longDescription = ''
 397         These are a few data structures, classes and functions which
 398         we've needed over many years of Python programming and which
 399         seem to be of general use to other Python programmers. Many of
 400         the modules that have existed in pyutil over the years have
 401         subsequently been obsoleted by new features added to the
 402         Python language or its standard library, thus showing that
 403         we're not alone in wanting tools like these.
 404       '';
 405
 406       homepage = http://allmydata.org/trac/pyutil;
 407
 408       license = "GPLv2+";
 409     };
 410   });
 411
 412   setuptoolsDarcs = buildPythonPackage {
 413     name = "setuptools-darcs-1.2.8";
 414
 415     src = fetchurl {
 416       url = "http://pypi.python.org/packages/source/s/setuptools_darcs/setuptools_darcs-1.2.8.tar.gz";
 417       sha256 = "0jg9q9mhsky444mm7lpmmlxai8hmjg4pc71viv4kni8gls0gk9n8";
 418     };
 419
 420     propagatedBuildInputs = [ pkgs.darcs ];
 421
 422     meta = {
 423       description = "setuptools plugin for the Darcs version control system";
 424
 425       homepage = http://allmydata.org/trac/setuptools_darcs;
 426
 427       license = "BSD";
 428     };
 429   };
 430
 431   simplejson = buildPythonPackage (rec {
 432     name = "simplejson-2.0.9";
 433
 434     src = fetchsvn {
 435       url = "http://simplejson.googlecode.com/svn/tags/${name}";
 436       sha256 = "a48d5256fdb4f258c33da3dda110ecf3c786f086dcb08a01309acde6d1ddb921";
 437       rev = "172";  # to be on the safe side
 438     };
 439
 440     meta = {
 441       description = "simplejson is a simple, fast, extensible JSON encoder/decoder for Python";
 442
 443       longDescription = ''
 444         simplejson is compatible with Python 2.4 and later with no
 445         external dependencies.  It covers the full JSON specification
 446         for both encoding and decoding, with unicode support.  By
 447         default, encoding is done in an encoding neutral fashion (plain
 448         ASCII with \uXXXX escapes for unicode characters).
 449       '';
 450
 451       homepage = http://code.google.com/p/simplejson/;
 452
 453       license = "MIT";
 454     };
 455   });
 456
 457   trac = buildPythonPackage {
 458     name = "trac-0.11.5";
 459
 460     src = fetchurl {
 461       url = http://ftp.edgewall.com/pub/trac/Trac-0.11.5.tar.gz;
 462       sha256 = "cc3362ecc533abc1755dd78e2d096d1413bc975abc3185318f4821458cd6a8ac";
 463     };
 464
 465     doCheck = false;
 466
 467     PYTHON_EGG_CACHE = "`pwd`/.egg-cache";
 468
 469     propagatedBuildInputs = [ genshi pkgs.setuptools ];
 470
 471     meta = {
 472       description = "Enhanced wiki and issue tracking system for software development projects";
 473
 474       license = "BSD";
 475     };
 476   };
 477
 478   twisted = buildPythonPackage {
 479     name = "twisted-8.2.0";
 480
 481     src = fetchurl {
 482       url = http://tmrc.mit.edu/mirror/twisted/Twisted/8.2/Twisted-8.2.0.tar.bz2;
 483       sha256 = "1c6zplisjdnjzkfs0ld3a0f7m7xbjgx5rcwsdw5i1xiibsq2nq70";
 484     };
 485
 486     propagatedBuildInputs = [ pkgs.ZopeInterface ];
 487
 488     meta = {
 489       homepage = http://twistedmatrix.com/;
 490
 491       description = "Twisted, an event-driven networking engine written in Python";
 492
 493       longDescription = ''
 494         Twisted is an event-driven networking engine written in Python
 495         and licensed under the MIT license.
 496       '';
 497
 498       license = "MIT";
 499
 500       maintainers = [ stdenv.lib.maintainers.ludo ];
 501       platforms = python.meta.platforms;
 502     };
 503   };
 504
 505   zbase32 = buildPythonPackage (rec {
 506     name = "zbase32-1.1.1";
 507
 508     src = fetchurl {
 509       url = "http://pypi.python.org/packages/source/z/zbase32/${name}.tar.gz";
 510       sha256 = "0n59l4rs26vrhxpsfrwybjjir68aj23f09k1yjnbxqy5n0khp8gm";
 511     };
 512
 513     # Tests require `pyutil' so disable them to avoid circular references.
 514     doCheck = false;
 515
 516     buildInputs = [ setuptoolsDarcs ];
 517
 518     meta = {
 519       description = "zbase32, a base32 encoder/decoder";
 520
 521       homepage = http://pypi.python.org/pypi/zbase32;
 522
 523       license = "BSD";
 524     };
 525   });
 526
 527   zfec = buildPythonPackage (rec {
 528     name = "zfec-1.4.4";
 529
 530     src = fetchurl {
 531       url = "http://pypi.python.org/packages/source/z/zfec/${name}.tar.gz";
 532       sha256 = "0rgg7nsvbr4f9xmiclzypc39fnivg23kldv5aa8si0bgsxn6mh6w";
 533     };
 534
 535     buildInputs = [ setuptoolsDarcs ];
 536     propagatedBuildInputs = [ pyutil argparse ];
 537
 538     meta = {
 539       homepage = http://allmydata.org/trac/zfec;
 540
 541       description = "Zfec, a fast erasure codec which can be used with the command-line, C, Python, or Haskell";
 542
 543       longDescription = ''
 544         Fast, portable, programmable erasure coding a.k.a. "forward
 545         error correction": the generation of redundant blocks of
 546         information such that if some blocks are lost then the
 547         original data can be recovered from the remaining blocks. The
 548         zfec package includes command-line tools, C API, Python API,
 549         and Haskell API.
 550       '';
 551
 552       license = "GPLv2+";
 553     };
 554   });
 555
 556 }