py-test-relaxed: added version 1.0.0
pytest-relaxed provides 'relaxed' test discovery for pytest.
Has it ever felt strange to you that we put our tests in tests/, then name the
files test_foo.py, name the test classes TestFoo, and finally name the test
methods test_foo_bar? Especially when almost all of the code inside of tests/
is, well, tests?
This pytest plugin takes a page from the rest of Python, where you don't have
to explicitly note public module/class members, but only need to hint as to
which ones are private. By default, all files and objects pytest is told to
scan will be considered tests; to mark something as not-a-test, simply prefix
it with an underscore.

py-visitor: added version 0.1.3
A tiny library to facilitate visitor implementation in Python (which are
slightly peculiar due to dynamic typing). In fact, it is so small, you may just
be better off copy and pasting the source straight into your project.

This is a plugin which will terminate tests after a certain timeout. When doing
so it will show a stack dump of all threads running at the time. This is useful
when running tests under a continuous integration server or simply if you don't
know why the test suite hangs.
Note that while by default on POSIX systems py.test will continue to execute
the tests after a test has timed, out this is not always possible. Often the
only sure way to interrupt a hanging test is by terminating the entire process.
As this is a hard termination (os._exit()) it will result in no teardown, JUnit
XML output etc. But the plugin will ensure you will have the debugging output
on stderr nevertheless, which is the most important part at this stage.

py-unittest2py3k: removed, successor py-unittest2
Notes from py-unittest2:
There was a separate version of unittest2 for Python 3. This is no longer needed, but still exists on PyPI. This had the project name "unittest2py3k" but uses the same package name ("unittest2").

wide: remove package
IDE for a programming language, last release 2005, no homepage.
I can't even find a good resource on the language ("while") this IDE
is for, and it is broken since there is no supported jdk in pkgsrc.

The plugin provides two options to rerun failures, namely --lf to only re-run
the failures and --ff to run all tests but the failures from the last run
first. For cleanup (usually not needed), a --clearcache option allows to
remove all cross-session cache contents ahead of a test run.

Flaky is a plugin for nose or py.test that automatically reruns flaky tests.
Ideally, tests reliably pass or fail, but sometimes test fixtures must rely on
components that arenãàÑÕ 100% reliable. With flaky, instead of removing those
tests or marking them to @skip, they can be automatically retried.

Small add-on for the python requests http library. Makes use of python 3.2's
concurrent.futures or the backport for prior versions of python.
The additional API and changes are minimal and strives to avoid surprises.

aiofiles is an Apache2 licensed library, written in Python, for handling
local disk files in asyncio applications.
Ordinary local file IO is blocking, and cannot easily and portably made
asynchronous. This means doing file IO may interfere with asyncio
applications, which shouldn't block the executing thread. aiofiles helps with
this by introducing asynchronous versions of files that support delegating
operations to a separate thread pool.

pathspec is a utility library for pattern matching of file paths. So far this
only includes Git's wildmatch pattern matching which itself is derived from
Rsync's wildmatch. Git uses wildmatch for its gitignore files.

uvloop is a fast, drop-in replacement of the built-in asyncio event loop.
uvloop and asyncio, combined with the power of async/await in Python 3.5,
makes it easier than ever to write high-performance networking code in Python.
uvloop makes asyncio fast. In fact, it is at least 2x faster than nodejs,
gevent, as well as any other Python asynchronous framework. The performance
of uvloop-based asyncio is close to that of Go programs.

Added devel/py-typing version 3.5.3.0
Typing defines a standard notation for Python function and variable
type annotations. The notation can be used for documenting code in
a concise, standard format, and it has been designed to also be
used by static and runtime type checkers, static analyzers, IDEs
and other tools.
This is a backport of the standard library typing module to Python
versions older than 3.5.

Added devel/py-pydispatcher version 2.0.5
Dispatcher mechanism for creating event models
PyDispatcher is an enhanced version of Patrick K. O'Brien's original
dispatcher.py module. It provides the Python programmer with a robust mechanism
for event routing within various application contexts.
Included in the package are the robustapply and saferef modules, which provide
the ability to selectively apply arguments to callable objects and to reference
instance methods using weak-references.

Added devel/py-queuelib version 1.4.2
Queuelib is a collection of persistent (disk-based) queues for Python.
Queuelib goals are speed and simplicity. It was originally part of the Scrapy
framework and stripped out on its own library.

Add devel/adacurses to pkgsrc
The ncurses Ada95 binding was originally written by Juergen Pfeifer in
1996. It has been improved several times by Juergen, as wll as
Eugen V. Melaragno and Nicolas Boulenguez.

Import gflags-2.1.2 as devel/gflags.
The gflags package contains a library that implements commandline flags
processing. As such it's a replacement for getopt(). It has increased
flexibility, including built-in support for C++ types like string, and the
ability to define flags in the source file in which they're used.
Package from pkgsrc-wip with bacon4000@gmail.com as the MAINTAINER.
devel/snappy can use this along with other packages in the dependency chain
for caffe.

It's time to make Tryton great again. This update is YUGE. There are 71
new packages. Most of which are the remaining modules of the Tryton
platform which weren't packaged. The others are dependencies of the new
modules. This was tested on FreeBSD and is based in large part on Richard
Palo's (richard@) work. This is the most recent release of the Tryton
platform, version 4.2. There's a very large list of changes from the 3.8
series we have in pkgsrc. If you're interested, those functional changes
can be found here:
http://www.tryton.org/posts/new-tryton-release-42.htmlhttp://www.tryton.org/posts/new-tryton-release-40.html

Import slibtool-0.5.12 as devel/slibtool
slibtool is an independent reimplementation of the widely used libtool,
written in C. slibtool is designed to be a clean, fast, easy-to-use
libtool drop-in replacement, and is accordingly aimed at package authors,
distro developers, and system integrators. slibtool maintains compatibility
with libtool in nearly every aspect of the tool's functionality as well as
semantics, leaving out (or turning into a no-op) only a small number of
features that are no longer needed on modern systems.

New package, py-vcversioner, from pkgsrc-wip.
You can write a setup.py with no version information specified, and vcversioner
will find a recent, properly-formatted VCS tag and extract a version from it.
It's much more convenient to be able to use your version control system's
tagging mechanism to derive a version number than to have to duplicate that
information all over the place. I eventually ended up copy-pasting the same
code into a couple different setup.py files just to avoid duplicating version
information. But, copy-pasting is dumb and unit testing setup.py files is hard.
This code got factored out into vcversioner.

New package, go-glog.
Package glog implements logging analogous to the Google-internal
C++ INFO/ERROR/V setup. It provides functions Info, Warning,
Error, Fatal, plus formatting variants such as Infof. It
also provides V-style logging controlled by the -v and
-vmodule=file=2 flags.
This is an efficient pure Go implementation of leveled logs in the
manner of the open source C++ package
https://github.com/google/glog
(pkgsrc/devel/google-glog)
By binding methods to booleans it is possible to use the log package
without paying the expense of evaluating the arguments to the log.
Through the -vmodule flag, the package also provides fine-grained
control over logging at the file level.

New package, go-gls-4.2.0.
Every so often, a thread shows up on the golang-nuts asking for some form of
goroutine-local-storage, or some kind of goroutine id, or some kind of context.
There are a few valid use cases for goroutine-local-storage, one of the most
prominent being log line context. One poster was interested in being able to
log an HTTP request context id in every log line in the same goroutine as the
incoming HTTP request, without having to change every library and function call
he was interested in logging.
It is my duty to point you to https://blog.golang.org/context, which is how
Google solves all of the problems you'd perhaps consider using this package for
at scale.

New package, go-termbox.
Termbox is a library that provides a minimalistic API which allows the
programmer to write text-based user interfaces. The library is crossplatform
and has both terminal-based implementations on *nix operating systems and a
winapi console based implementation for windows operating systems. The basic
idea is an abstraction of the greatest common subset of features available on
all major terminals and other terminal-like APIs in a minimalistic fashion.
Small API means it is easy to implement, test, maintain and learn it, that's
what makes the termbox a distinct library in its area.

add devel/py-wrapt (wrapt-1.10.8)
A Python module for decorators, wrappers and monkey patching.
The aim of the wrapt module is to provide a transparent object proxy for
Python, which can be used as the basis for the construction of function
wrappers and decorator functions.
The wrapt module focuses very much on correctness. It therefore goes way
beyond existing mechanisms such as functools.wraps() to ensure that
decorators preserve introspectability, signatures, type checking abilities
etc. The decorators that can be constructed using this module will work in
far more scenarios than typical decorators and provide more predictable and
consistent behaviour.
To ensure that the overhead is as minimal as possible, a C extension module
is used for performance critical components. An automatic fallback to a pure
Python implementation is also provided where a target system does not have a
compiler to allow the C extension to be compiled.

New package, py-thrift.
From Aleksej Lebedev in PR pkg/50853.
Thrift is a software library and set of code-generation tools developed
at Facebook to expedite development and implementation of efficient and
scalable backend services. Its primary goal is to enable efficient and
reliable communication across programming languages by abstracting the
portions of each language that tend to require the most customization
into a common library that is implemented in each language.
Specifically, Thrift allows developers to define datatypes and service
interfaces in a single language-neutral file and generate all the
necessary code to build RPC clients and servers.

New package, go-review.
This package contains the git-codereview tool that the upstream Go
project uses for working with Gerrit.
It is probably mainly useful if you want to submit code to Go itself,
though it may be usable for other projects too.

Add cre2, the C rre2 wrappers, to the Packages Collection.
The CRE2 distribution is a C language wrapper for the RE2 library,
which is implemented in C++. RE2 is a fast, safe, thread-friendly
alternative to backtracking regular expression engines like those used
in PCRE, Perl, and Python.

Add re2, Russ Cox's BSD-licensed regexp library to the packages collection.
RE2 is a fast, safe, thread-friendly alternative to backtracking
regular expression engines like those used in PCRE, Perl, and Python.
It is a C++ library.

Import p5-Data-Random version 0.12 from wip. From DESCR:
Data::Random is a Perl module for generating random data. You might
find it helpful mostly in test programs to easily generate
pseudo-realistic distributions of data.

Add a package for include-what-you-use-0.5. From DESCR:
"Include what you use" means this: for every symbol (type, function
variable, or macro) that you use in foo.cc, either foo.cc or foo.h
should #include a .h file that exports the declaration of that symbol.
The include-what-you-use tool is a program that can be built with the
clang libraries in order to analyze #includes of source files to find
include-what-you-use violations, and suggest fixes for them.
The main goal of include-what-you-use is to remove superfluous #includes.
It does this both by figuring out what #includes are not actually needed for
this file (for both .cc and .h files), and replacing #includes with
forward-declares when possible.

Add git-remote-hg, a tool for bridging between git and mercurial, to the
packages collection.
git-remote-hg allows you to transparently clone, fetch and
push to and from Mercurial repositories as if they were Git
ones.

Add py-cached property
A cached-property for decorating methods in classes.
History:
1.2.0 (2015-04-28)
Overall code and test refactoring, thanks to @gsakkis
Allow the del statement for resetting cached properties with ttl instead
of del obj._cache[attr], thanks to @gsakkis.
Uncovered a bug in PyPy, https://bitbucket.org/pypy/pypy/issue/2033/
attributeerror-object-attribute-is-read, thanks to @gsakkis
Fixed threaded_cached_property_with_ttl to actually be thread-safe, thanks
to @gsakkis
1.1.0 (2015-04-04)
Regression: As the cache was not always clearing, we've broken out the
time to expire feature to its own set of specific tools, thanks to
@pydanny
Fixed typo in README, thanks to @zoidbergwill
1.0.0 (2015-02-13)
Added timed to expire feature to cached_property decorator.
Backwards incompatiblity: Changed del monopoly.boardwalk to del
monopoly['boardwalk'] in order to support the new TTL feature.

Add a package for py-subprocess32. From NONAKA Kimihiro in PR pkg/50066.
DESCR:
Backport of the subprocess module from Python 3.2/3.3 for use on 2.x.
This is a backport of the subprocess standard library module from Python
3.2 & 3.3 for use on Python 2.4, 2.5, 2.6 and 2.7. It includes bugfixes
and new features. On POSIX systems it is guaranteed to be reliable when
used in threaded applications. Bonus: It includes timeout support from
Python 3.3.

Remove p5-Coro and packages depending on it.
Upstream says that it "can not" work with perl 5.22 and has even
forked perl as "stableperl" to allow his package to work instead
of fixing it differently.
See http://blog.schmorp.de/2015-06-06-stableperl-faq.html
Ok bsiegert@

+devel/p5-Find-Lib version 1.04
+devel/p5-MetaCPAN-Client version 1.013000
+devel/p5-Search-Elasticsearch version 1.19
+net/p5-Test-RequiresInternet version 0.04
+www/p5-Any-URI-Escape version 0.01
+www/p5-Hijk version 0.20
+www/p5-WWW-Mechanize-Cached version 1.48

Import cmocka-1.0.0, the successo of cmockery
cmocka is an elegant unit testing framework for C with support for
mock objects. It only requires the standard C library, works on a
range of computing platforms (including embedded) and with different
compilers.

Add a package for zope.component, version 4.2.1. From DESCR:
This package represents the core of the Zope Component Architecture.
Together with the 'zope.interface' package (devel/py-ZopeInterface), it
provides facilities for defining, registering and looking up components.
This package is intended to be independently reusable in any Python
project. It is maintained by the Zope Toolkit project.

Add ports for pythondialog and python2-pythondialog, frontends to the
"dialog" utility.
From DESCR:
pythondialog is a Python wrapper for the dialog utility originally
written by Savio Lam, and later rewritten by Thomas E. Dickey. Its
purpose is to provide an easy to use, pythonic and comprehensive Python
interface to dialog. This allows one to make simple text-mode user
interfaces on Unix-like systems (including Linux).

Remove libgee0.8.
libgee now contains the most recent version of libgee, which follows
the 0.8 API. If in the future, that API changes, we can copy libgee
back to libgee0.8, and carry on updating libgee.

Move math/R-evaluate to devel/R-evaluate and fix dependencies.
Note: this commit is part of reorganizing some of the recently
imported R packages, which are being reimported into more appropriate
categories (and removed from math) as a result of a recent discussion
on tech-pkg and privately with wiz@. See the thread starting with:
http://mail-index.netbsd.org/tech-pkg/2014/09/05/msg013558.html

adding devel/py-hgnested
hgnested is a Mercurial extension to work with nested repositories.
It was inspired by the forest extension.
The extension allows to apply common Mercurial commands to all the nested
repositories at once like pull, push etc. It also allows to fetch a complete
tree of repositories through ssh or http.
To enable the "hgnested" extension, create an entry for it in your hgrc, like
this:
[extensions]
hgnested =
See `hg help hgnested` for the complete list of commands.
For more information please visit the following website:
http://code.google.com/p/hgnested/

Import kyua-0.10.
This is a "new" import that unifies all the previous Kyua subpackages
(kyua-atf-compat, kyua-cli and kyua-testers) under a single package.
The change has been made upstream mainly for simplicity reasons; the
old modular scheme was unnecessary.
Given that this new import should be really considered to be an update,
the following are the changes since kyua-cli-0.9 and kyua-testers-0.3,
both released last week:
Experimental version released on August 14th, 2014.
* Merged 'kyua-cli' and 'kyua-testers' into a single 'kyua' package.
* Dropped the 'kyua-atf-compat' package.
* Issue 100: Do not try to drop privileges to unprivileged_user when we
are already running as an unprivileged user. Doing so is not possible
and thus causes spurious test failures when the current user is not
root and the current user and unprivileged_user do not match.
* Issue 79: Mention kyua.conf(5) in the "see also" section of kyua(1).
* Issue 75: Change the rewrite__expected_signal__bad_arg test in
testers/atf_result_test to use a different signal value. This is to
prevent triggering a core dump that made the test fail in some platforms.

Update ATF to 0.20.
This change upgrades devel/atf to 0.20 and removes devel/atf-libs. The
upstream atf distfile has dropped the code for the deprecated tools so
it makes little sense to keep the two packages any longer.
As a result of this, the devel/atf package is now much simplified as
there is no need for a Makefile.common any longer and matches exactly
what upstream ships.
Changes in version 0.20
***********************
Experimental version released on February 7th, 2014.
This is the first release without the code for the deprecated tools. If
you require such code, please fetch a copy of the 0.19 release and extract
the 'tools' directory for your own consumption.
* Removed the deprecated tools. This includes atf-config, atf-report,
atf-run and atf-version.
Changes in version 0.19
***********************
Experimental version released on February 7th, 2014.
This is the last release to bundle the code for the deprecated tools.
The next release will drop their code and will stop worrying about
backwards compatibility between the ATF libraries and what the old tools
may or may not support.
If you still require the old tools for some reason, grab a copy of the
'tools' directory now. The code in this directory is standalone and
does not depend on any internal details of atf-c++ any longer.
* Various fixes and improvements to support running as part of the FreeBSD
test suite.
* Project hosting moved from Google Code (as a subproject of Kyua) to
GitHub (as a first-class project). The main reason for the change is
the suppression of binary downloads in Google Code on Jan 15th, 2014.
See https://github.com/jmmv/atf/
* Removed builtin help from atf-sh(1) and atf-check(1) for simplicity
reasons. In other words, their -h option is gone.
* Moved the code of the deprecated tools into a 'tools' directory and
completely decoupled their code from the internals of atf-c++. The
reason for this is to painlessly allow a third-party to maintain a
copy of these tools after we delete them because upcoming changes to
atf-c++ would break the stale tools.

The pyparsing module is an alternative approach to creating and executing
simple grammars, vs. the traditional lex/yacc approach, or the use of regular
expressions. The pyparsing module provides a library of classes that client
code uses to construct the grammar directly in Python code.