semvec/pypi-packages huggingface dataset:
enzyme-cost-minimization 0.1.5
Enzyme Cost Minimization - a package for calculating the minimal enzyme cost of a metabolic pathway
License: MIT

enzyme-cost-minimization
========================

Enzyme Cost Minimization (ECM) is a method for estimating the specific cost in 
enzymes for sustaining a given flux, given a kinetic model.

You can read more about ECM at [PLOS CB](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5094713/).

If you only want to try out ECM without installing anything locally, we have
a simple web interface at [eQuilibrator](http://equilibrator.weizmann.ac.il/pathway/).

Otherwise, you can install ECM from PyPI:
```
pip install enzyme-cost-minimization
```

Or get the source code from this repository. In that case, you'll have to 
install the following dependencies:
- PyPI packages:
    - numpy
    - scipy
    - matplotlib
    - optlang
    - pandas
    - sbtab
    - equilibrator-api
    
Example
-------
Try running the example script:
```
python -m example.test
```
tgext.evolve 0.0.5
Manages automatic updates and evolutions which are better suited outside schema migrations
License: MIT
Keywords: turbogears2.extension

About tgext.evolve
==================

tgext.evolve is a TurboGears2 extension for generic migrations and evolutions.

tgext.evolve *is safe to be used in multiprocessing and multithreading environments*
as it relies on a distributed lock on your database to perform evolutions.

During the evolution period the application will respond with a **503** status code,
feel free to configure TurboGears to trap it and use your ErrorController to provide
a custom page.

Installing
----------

tgext.evolve can be installed from pypi::

    pip install tgext.evolve

should just work for most of the users.

Enabling
--------

To enable tgext.evolve put inside your application
``config/app_cfg.py`` the following::

    import tgext.evolve
    tgext.evolve.plugme(base_config, options={
        'evolutions': [
            # ... Your evolutions ...
        ]
    })

or you can use ``tgext.pluggable`` when available::

    from tgext.pluggable import plug
    plug(base_config, 'tgext.evolve', evolutions=[
        # ... Your evolutions ...
    ])

tgext.evolve can then be disabled using the ``tgext.evolve.enabled = false``
option in your configuration files. This is often the case during test suites.

Using Evolutions
----------------

Evolutions are a subclass of ``tgext.evolve.Evolution`` that
must provide an ``evolution_id`` property and an ``evolve()``
method.

Here is a sample evolution that does not much apart waiting for 10 seconds::

    import time
    from tgext.evolve import Evolution

    class TestEvolution1(Evolution):
        evolution_id = 'test_evolution_1'

        def evolve(self):
            time.sleep(10)

Please note that in case you modify data or touch the database
through ``model.DBSession`` or other manners you must ``flush``
and ``commit`` your UnitOfWork and Transaction yourself as evolutions
are performed outside the transaction manager in a separated thread.

Then you can register your evolution with something like::

    from tgext.pluggable import plug
    plug(base_config, 'tgext.evolve', evolutions=[
        TestEvolution1
    ])

In case your evolution requires parameters you can register an
instance of it instead of registering the class.

.. note::

    There is no opposite to the ``evolve()`` method as there is no
    guarantee that evolutions are reversible. In case you need
    reversible migrations for database schemas please use a
    schema migration framework.

ChangeLog
---------

0.0.5
~~~~~

* small bugfix and deprecation gardening

0.0.4
~~~~~

* small Python3 compatibility fixes

0.0.3
~~~~~

* Experimental support for SQLAlchemy, tested on SQLite and MySQL.

0.0.2
~~~~~

* Allow disabling tgext.evolve using ``tgext.evolve.enabled = False`` in `.ini` files.

0.0.1
~~~~~

* First release with only MongoDB/Ming support.
craftar 1.3.9
CraftAR Python Library
License: MIT
Keywords: catchoom craftar image recognition

CraftAR Python Library
==========================

The CraftAR Python Library allows you to integrate
`CraftAR Image Recognition`_ in your applications and services.

This client library provides access to our APIs:

-  `CraftAR Recognition API` allows visual recognition against one of
   your collections of reference images specified using the
   collection token.
-  `CraftAR Management API` allows upload and management of
   collections of reference images. All requests must be
   authenticated using your management api key.

The library also provides tools for performing batch operations:

-  `craftar\_search`, for image recognition.
-  `craftar\_upload`, for batch upload of images.

To use our service you need a `CraftAR`_ account.

You can get our `code`_, check the `README`_ and file bugs in the
`issue tracker`_.

.. _CraftAR: https://my.craftar.net
.. _Catchoom: http://catchoom.com
.. _code: https://github.com/Catchoom/craftar-python
.. _README: https://github.com/Catchoom/craftar-python/blob/master/README.md
.. _issue tracker: https://github.com/Catchoom/craftar-python/issues
zhang2016dependency 0.1.0
Implementation of zhang2016dependency
License: MIT
Keywords: research model

# zhang2016dependency

This package provides a simple implementation of the models proposed in
the paper:

> Zhang, R., Lee, H., & Radev, D. (2016). Dependency sensitive convolutional neural networks for modeling sentences and documents. arXiv preprint arXiv:1611.02361.

## Installation
This package depends on the [Keras](https://keras.io/) library. This
means you will need to install a backend library in order to use this
module. Take a look to [Keras installation](https://keras.io/#installation)
to get more information.

After having installed the backend of yout choice, you just need to
install this package using [pip](https://pypi.org/):

    pip install zhang2016dependency

## Usage
This package only provides a single model. To get detailed information
on the parameters the model accepts, take a look to the documentation
included with the module class.

Here is a complete example of instantiation of the model proposed in the
original paper using two channel of randomly initialized word
embeddings:

```python
import numpy as np
import numpy.random as rng

vocabulary_size = 1000
embedding_size = 300

value = np.sqrt(6/embedding_size)

weights_shape = (vocabulary_size+1, embedding_size)
weights = rng.uniform(low=-value, high=value, size=weights_shape)

channels = [
    {
      'weights': [weights],
      'trainable': False,
      'input_dim': vocabulary_size + 1,
      'output_dim': embedding_size,
      'name': 'random-embedding-1'
    },
    {
      'weights': [weights],
      'trainable': True,
      'input_dim': vocabulary_size + 1,
      'output_dim': embedding_size,
      'name': 'random-embedding-2'
    }
]

windows = [
    {
        'filters': 100,
        'kernel_size': 3,
        'activation': 'relu',
        'name': '3-grams'
    },
    {
        'filters': 100,
        'kernel_size': 4,
        'activation': 'relu',
        'name': '4-grams'
    },
    {
        'filters': 100,
        'kernel_size': 5,
        'activation': 'relu',
        'name': '5-grams'
    }
]

from zhang2016dependency import Model

model = Model(channels=channels,
              windows=windows,
              sentence_length=37,
              num_classes=6,
              dropout_rate=0.5,
              classifier_activation='softmax',
              include_top=True,
              name='DSCNN')

model.compile(optimizer='adadelta',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.summary()
kim2014convolutional 0.2.0
Implementation of kim2014convolutional
License: MIT
Keywords: research model

# kim2014convolutional

This package provides a simple implementation of the models proposed in
the paper:

> Kim, Y. (2014). Convolutional neural networks for sentence classification. arXiv preprint arXiv:1408.5882.

## Installation
This package depends on the [Keras](https://keras.io/) library. This
means you will need to install a backend library in order to use this
module. Take a look to [Keras installation](https://keras.io/#installation)
to get more information.

After having installed the backend of yout choice, you just need to
install this package using [pip](https://pypi.org/):

    pip install kim2014convolutional

## Usage
This package only provides a single model. To get detailed information
on the parameters the model accepts, take a look to the documentation
included with the module class.

Here is a complete example of instantiation of the `CNN-multichannel`
model proposed in the original paper using two channel of randomly
initialized word embeddings:

```python
import numpy as np
import numpy.random as rng

vocabulary_size = 10000
embedding_size = 300

value = np.sqrt(6/embedding_size)

weights_shape = (vocabulary_size+1, embedding_size)
weights = rng.uniform(low=-value, high=value, size=weights_shape)

channels = [
    {
      'weights': [weights],
      'trainable': False,
      'input_dim': vocabulary_size + 1,
      'output_dim': embedding_size,
      'name': 'random-embedding-1'
    },
    {
      'weights': [weights],
      'trainable': True,
      'input_dim': vocabulary_size + 1,
      'output_dim': embedding_size,
      'name': 'random-embedding-2'
    }
]

windows = [
    {
        'filters': 100,
        'kernel_size': 3,
        'activation': 'relu',
        'name': '3-grams'
    },
    {
        'filters': 100,
        'kernel_size': 4,
        'activation': 'relu',
        'name': '4-grams'
    },
    {
        'filters': 100,
        'kernel_size': 5,
        'activation': 'relu',
        'name': '5-grams'
    }
]

from kim2014convolutional import Model

model = Model(channels=channels,
              windows=windows,
              sentence_length=37,
              num_classes=6,
              dropout_rate=0.5,
              maxnorm_value=3,
              classifier_activation='softmax',
              include_top=True,
              name='CNN-multichannel')

model.summary()
```
pompy 0.1.1
Puff-based odour plume model
License: MIT
Keywords: simulation plume navigation

PomPy is a NumPy based implementation of the puff-based odour plume model described in

    Farrell, J.A., Murlis, J., Long, X., Li, W. and Cardé, R.T., 2002.
    Filament-based atmospheric dispersion model to achieve short time-scale
    structure of odor plumes. *Environmental fluid mechanics*, 2(1-2), pp.143-169.
    `Index page (springer.com) <https://link.springer.com/article/10.1023/A:1016283702837>`_ \:\:
    `PDF (semanticscholar.org) <https://pdfs.semanticscholar.org/7197/d905b0d6e8cd490f78a893fc266af9a4d901.pdf>`_

PomPy allows simulation of dynamic 2D odour concentration fields which show some
of the key characteristics of real chemical plumes in turbulent flows including short
term intermittency, diffusive effects and longer term variations in spatial extent and
location, while being cheaper to run than a full fluid dynamics simulation.
genpac-server 1.0b5
web server for genpac.
License: MIT
Keywords: proxy pac gfwlist gfw

GenPAC Server
=============

[![pypi-version]][pypi] [![pypi-license]][pypi] [![demo-img]][demo-link]

GenPAC的服务器端应用，定时或按需生成GenPAC所支持的代理配置文件。

![Screenshot](https://github.com/JinnLynn/genpac-server/raw/master/sample/screenshot.png)

## 演示

http://genpac-server.appspot.com/

[PAC Template](/sample/gae/data/_config.ini#L15):  https://genpac-server.appspot.com/pac/outer

[Shortener](/sample/gae/data/_config.ini#L20): https://genpac-server.appspot.com/s/gwd

[File Download](/sample/gae/data/_config.ini#L46):

* https://genpac-server.appspot.com/file/ss.acl

* https://genpac-server.appspot.com/file/dnsmasq.tpl

* https://genpac-server.appspot.com/file/dnsmasq.tpl?__DNS__=8.8.8.8%2353&__IPSET__=GFWIPSET

## 安装

```shell
# 安装或更新
$ pip install -U genpac-server
# 或从github安装更新开发版本
$ pip install -U https://github.com/JinnLynn/genpac-server/archive/master.zip

# 卸载
$ pip uninstall genpac-server
```

### 配置文件

配置文件可通过环境变量`GENPAC_CONFIG`设置，书写规则可参考[sample/config.ini][]

## 运行

### 本地运行测试

```shell
mkdir genpac-server-test
cd genpac-server-test

curl -sL -O https://github.com/JinnLynn/genpac-server/raw/master/sample/app.py
curl -sL -O https://github.com/JinnLynn/genpac-server/raw/master/sample/config.ini

FLASK_APP=app.py FLASK_DEBUG=1 GENPAC_CONFIG=config.ini flask run
```

### Docker

#### 构建与运行

```shell
# 1. 使用Docker Hub上已构建的镜像
docker run -ti -p 8080:80 jinnlynn/genpac-server

# 2. 使用compose-file
cd sample
docker-compose -p gs up -d

# 3. 自行构建镜像
cd sample
docker build -t genpac-server .
docker run -ti -p 8080:80 genpac-server
```

访问 http://127.0.0.1:8080

使用配置文件的两种方式:

1. 挂载到`/app/etc/config.ini`
2. 挂载到任意位置，修改环境变量`GENPAC_CONFIG`指向它

### Google App Engine

[GAE README](/sample/gae/README.md)


[pypi]:             https://pypi.org/project/genpac-server/
[pypi-version]:     https://img.shields.io/pypi/v/genpac-server.svg?style=flat
[pypi-license]:     https://img.shields.io/pypi/l/genpac-server.svg?style=flat
[demo-link]:        http://genpac-server.appspot.com/
[demo-img]:         https://img.shields.io/badge/Demo-GAE-orange.svg

[sample/config.ini]: https://github.com/JinnLynn/genpac-server/blob/master/sample/config.ini
illuminati-and-stuff 0.1.2
a pyramid tween that returns the traceback to the client for 500 responses
License: MIT
Keywords: pyramid

[![Build Status](https://travis-ci.org/yiwensong/illuminati_and_stuff.svg?branch=master)](https://travis-ci.org/yiwensong/illuminati_and_stuff)
[![Coverage Status](https://coveralls.io/repos/github/yiwensong/illuminati_and_stuff/badge.svg?branch=master)](https://coveralls.io/github/yiwensong/illuminati_and_stuff?branch=master)
[![PyPI version](https://badge.fury.io/py/illuminati-and-stuff.svg)](https://pypi.org/project/illuminati-and-stuff/)

# Illuminati and stuff

A pyramid tween that throws the traceback in the body of 500 responses.


## setup

Install this package (i.e. `pip install illuminati-and-stuff`) and run the
following where you have your pyramid configs:

```python
import illuminati_and_stuff
import pyramid

config = pyramid.config.Configurator()

...

config.add(illuminati_and_stuff)
```
logfmt 0.4
Parse and generate log lines in the logfmt style.
License: MIT

.. image:: https://secure.travis-ci.org/jkakar/logfmt-python.png?branch=master 

Logfmt
======

Python package for parsing log lines in the `logfmt` style.  See the
original project by Blake Mizerany and Keith Rarick for information
about `logfmt` conventions and use: https://github.com/kr/logfmt


Using logfmt
------------

Easily process lines from `logfmt` formatted input: ::

    from logfmt import parse

    input = StringIO('\n'.join(['key1=value1', 'key2=value2']))
    for values in parse(input):
        print values

This program produces this output: ::

    {'key1': 'value1'}
    {'key2': 'value2'}


Easily generate lines in `logfmt` formatted output ::

    from logfmt import format

    for line in format({'key1': 'value1'}, {'key2': 'value2'}):
        print line


This program produces this output: ::

    key1="value1"
    key2="value2"



Installation
------------

To install it, simply: ::

    pip install logfmt