The libevent API provides a mechanism to execute a callback function when
a specific event occurs on a file descriptor or after a timeout has been
reached. Furthermore, libevent also support callbacks due to signals or
regular timeouts.
libevent is meant to replace the event loop found in event driven network
servers. An application just needs to call event_dispatch() and then add
or remove events dynamically without having to change the event loop.
Currently, libevent supports /dev/poll, kqueue(2), event ports, select(2),
poll(2) and epoll(4). The internal event mechanism is completely independent
of the exposed event API, and a simple update of libevent can provide new
functionality without having to redesign the applications. As a result,
Libevent allows for portable application development and provides the most
scalable event notification mechanism available on an operating system.
Libevent can also be used for multi-threaded applications.
The App::Cache module lets an application cache data locally. There are a
few times an application would need to cache data: when it is retrieving
information from the network or when it has to complete a large
calculation.
For example, the Parse::BACKPAN::Packages module downloads a file off the
net and parses it, creating a data structure. Only then can it actually
provide any useful information for the programmer.
Parse::BACKPAN::Packages uses App::Cache to cache both the file download
and data structures, providing much faster use when the data is cached.
This module stores data in the home directory of the user, in a dot
directory. For example, the Parse::BACKPAN::Packages cache is actually
stored underneath "~/.parse_backpan_packages/cache/". This is so that
permissions are not a problem - it is a per-user, per-application cache.
The Digest::TransformPath module implements the TransformPath concept.
A TransformPath is a complex higher-order key that is designed for use
with chains of functions that sequentially transform a piece of data.
The concept starts with a sizable chunk of data, for example an image,
for which we can determine a unique identifier, and for which we can
cheaply determine if and when the source material has changed. A series
of resource-intensive transforms might be applied to this original data
to produce another piece of data. In the image example, we might auto-level,
crop, scale, rotate, colour-balance and then thumbnail the image. This
transformed data would be put into a cache. If at some future point
we wish to obtain the same image, but would preferably like to use the
cached version, we would have to take the original image, reapply the
transforms, and then compare to the result the first time around.
Further documentation is found within the module.
The Storable package brings you persistency for your perl data
structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything
that can be conveniently stored to disk and retrieved at a later time.
It can be used in the regular procedural way by calling store with a
reference to the object to store, and providing a file name. The routine
returns undef for I/O problems or other internal error, a true value
otherwise. Serious errors are propagated as a die exception.
To retrieve data stored to disk, you use retrieve with a file name, and
the objects stored into that file are recreated into memory for you, and
a reference to the root object is returned. In case an I/O error
occurred while reading, undef is returned instead. Other serious errors
are propagated via die.
Time::Format provides a very easy way to format dates and times. The
formatting functions are tied to hash variables, so they can be used
inside strings as well as in ordinary expressions. The formatting
codes used are meant to be easy to remember, use, and read. They
follow a simple, consistent pattern. If I've done my job right, once
you learn the codes, you should never have to refer to the
documentation again.
A quick-reference page is included, just in case. ;-)
Time::Format can also format DateTime objects, and strings created
with Date::Manip.
Also provided is a tied-hash interface to POSIX::strftime and
Date::Manip::UnixDate.
If the I18N::Langinfo module is available, Time::Format provides
weekday and month names in a language appropriate for your locale.
A companion module, Time::Format_XS, is also available; if it is
installed, Time::Format will detect and use it, which will result in a
significant speed improvement.
This module implements a memory-efficient node type (for trees, skip lists
and similar data structures) for Perl.
You may ask "Why bother implementing an ordered structure such as a tree
when Perl has hashes built-in?" Since Perl is optimized for speed over
memory usage, hashes (and lists) use a lot of memory.
So the purpose of this package is to provide a simple low-level Node class
which can be used as a base class to implement various kinds of tree
structures. Each node has a key/value pair and a variable number of
"children" pointers.
How nodes are organized or the algorithm used to organize them is for you
to implement.
There is no Pure-perl version because this package was written to overcome
limitations of Perl.
A lightweight LLVM python binding for writing JIT compilers
The old llvmpy binding exposes a lot of LLVM APIs but the mapping
of C++-style memory management to Python is error prone. Numba and
many JIT compilers do not need a full LLVM API. Only the IR builder,
optimizer, and JIT compiler APIs are necessary.
llvmlite is a project originally tailored for Numba's needs, using
the following approach:
- A small C wrapper around the parts of the LLVM C++ API we need
that are not already exposed by the LLVM C API.
- A ctypes Python wrapper around the C API.
- A pure Python implementation of the subset of the LLVM IR builder
that we need for Numba.
PyBison is a Python binding to the Bison (yacc) and Flex (lex)
parser-generator utilities.
It allows parsers to be quickly and easily developed as Python class
declarations, and for these parsers to take advantage of the fast and
powerful C-based Bison/Flex.
Users write a subclass of a basic Parser object, containing a set of methods
and attributes specifying the grammar and lexical analysis rules, and taking
callbacks for providing parser input, and receiving parser target events.
Features
* Runs at near the speed of C-based parsers, due to direct hooks into
bison-generated C code
* Full LALR(1) grammar support
* Includes a utility to convert your legacy grammar (.y) and scanner (.l)
scripts into python modules compatible with PyBison
* Easy to understand - the walkthrough and the examples will have you
writing your own parsers in minutes
* Comfortable and intuitive callback mechanisms
* Can export parse tree to XML with a simple method call
* Can reconstitute a parse tree from XML
A "public suffix" is a domain name under which Internet users can directly
register own names.
Browsers and other web clients can use it to
- avoid privacy-leaking "supercookies"
- avoid privacy-leaking "super domain" certificates [1]
- domain highlighting parts of the domain in a user interface
- sorting domain lists by site
Libpsl...
- has built-in PSL data for fast access
- allows to load PSL data from files
- checks if a given domain is a "public suffix"
- provides immediate cookie domain verification
- finds the longest public part of a given domain
- finds the shortest private part of a given domain
- works with international domains (UTF-8 and IDNA2008 Punycode)
- is thread-safe
- handles IDNA2008 UTS#46 (libicu is used by psl2c if installed)
[1] http://lists.gnu.org/archive/html/bug-wget/2014-03/msg00093.html
Mozilla::PublicSuffix provides a single function that returns the public suffix
of a domain name by referencing a parsed copy of Mozilla's Public Suffix List.
From the official website at http://publicsuffix.org:
A "public suffix" is one under which Internet users can directly register names.
Some examples of public suffixes are .com, .co.uk and pvt.k12.wy.us. The Public
Suffix List is a list of all known public suffixes.
A copy of the official list is bundled with the distribution. As the official
list continues to be updated, the bundled copy will inevitably fall out of date.
Therefore, if the bundled copy of found to be over thirty days old, this
distribution's installer provides the option to check for a new version of the
list and download/use it if one is found.