semvec/pypi-packages huggingface dataset:
metanl 1.0c
Multilingual natural language tools, wrapping NLTK and other systems.
License: MIT

## Deprecated as of June 2014

`metanl` is no longer actively developed or supported.

This package was created to support the language-processing needs that
[ConceptNet 5](http://conceptnet5.media.mit.edu) shared with code developed at
Luminoso. Those needs have diverged, to the point where it made the most sense
to split the functionality again.

A simplified version of metanl has been moved into the `conceptnet5`
package, as `conceptnet5.language`.


## metanl.token_utils

Utilities for working with tokens:

- `tokenize` splits strings into tokens, using NLTK.
- `untokenize` rejoins tokens into a correctly-spaced string, using ad-hoc
  rules that aim to invert what NLTK does.
- `un_camel_case` splits a CamelCased string into tokens.

These functions make assumptions that work best in English, and work reasonably
in other Western languages, and fail utterly in languages that don't use
spaces.


## metanl.nltk_morphy

`nltk_morphy` is a lemmatizer (a stemmer with principles). It enables you to
reduce words to their root form in English, using the Morphy algorithm that's
built into WordNet, together with NLTK's part of speech tagger.

Morphy works best with a known part of speech. In fact, the way it works in
NLTK is pretty bad if you don't specify the part of speech. The `nltk_morphy`
wrapper provides:

- An alignment between the POS tags that `nltk.pos_tag` outputs, and the input
  that Morphy expects
- A strategy for tagging words whose part of speech is unknown
- A small list of exceptions, for cases where Morphy returns an unintuitive
  or wrong result

## metanl.extprocess

Sometimes, the best available NLP tools are written in some other language
besides Python. They may not provide a reasonable foreign function interface.
What they do often provide is a command-line utility.

`metanl.extprocess` provides abstractions over utilities that take in natural
language, and output a token-by-token analysis. This is used by two other
modules in `metanl`.

### metanl.freeling

FreeLing is an NLP tool that can analyze many European languages, including
English, Spanish, Italian, Portuguese, Welsh, and Russian. This module
allows you to run FreeLing in a separate process, and use its analysis
results in Python.

### metanl.mecab

In Japanese, NLP analyzers are particularly important, because without one
you don't even know where to split words.

MeCab is the most commonly used analyzer for Japanese text. This module runs
MeCab in an external process, allowing you to get its complete analysis
results, or just use it to tokenize or lemmatize text.

As part of MeCab's operation, it outputs the phonetic spellings of the words
it finds, in kana. We use this to provide a wrapper function that can
romanize any Japanese text.
cgettext 0.1.post1
This is a drop-in C replacement for Python's gettext.
License: MIT

This is a drop-in C replacement for Python's gettext.GNUTranslations.  For our
fairly large set of languages and strings, it makes parsing 10x faster.

Just import GNUTranslations from cgettext instead of gettext.

You can safely install this module on PyPy and other implementations where a C
extension is undesirable, and it will simply re-export the built-in class.

The repository includes a small module, test_cgettext, that runs the built-in
Python gettext tests with GNUTranslations monkeypatched.
simple-requests 1.1.1
Asynchronous requests in Python without thinking about it.
License: MIT

Simple-requests allows you to get the performance benefit of asynchronous
requests, without needing to use any asynchronous coding paradigms.

Usage
-----
.. code-block:: python

    from simple_requests import Requests

    # Creates a session and thread pool
    requests = Requests()

    # Sends one simple request; the response is returned synchronously.
    login_response = requests.one('http://cat-videos.net/login?user=fanatic&password=c4tl0v3r')

    # Cookies are maintained in this instance of Requests, so subsequent requests
    # will still be logged-in.
    profile_urls = [
        'http://cat-videos.net/profile/mookie',
        'http://cat-videos.net/profile/kenneth',
        'http://cat-videos.net/profile/itchy' ]

    # Asynchronously send all the requests for profile pages
    for profile_response in requests.swarm(profile_urls):

        # Asynchronously send requests for each link found on the profile pages
        # These requests take precedence over those in the outer loop to minimize overall waiting
        # Order doesn't matter this time either, so turn that off for a performance gain
        for friends_response in requests.swarm(profile_response.links, maintainOrder = False):

            # Do something intelligent with the responses, like using
            # regex to parse the HTML (see http://stackoverflow.com/a/1732454)
            friends_response.html

Release History
---------------
1.1.1 (June 27, 2014)
======================
**API Changes**
 * ``bundleParam`` parameter added to ``Requests.one``, ``Requests.swarm``, ``Requests.each``

1.1.0 (May 01, 2014)
======================
**API Changes**
 * ``defaultTimeout`` parameter added to ``Requests.__init__``
**Bug Fixes**
 * No more errors / warnings on exit
 * Fixes due to API changes in gevent 1.0
 * Fixed a couple documentation errors
**Features**
 * Added a patch class, with monkey patches of urllib3 (to reduce the likelihood of too many
   open connections/files at once) and httplib (to disregard servers that incorrectly report the content-length)