semvec/pypi-packages huggingface dataset:
bolt-python-sdk 1.0.0
Bolt Python SDK
Requires Python: >=3

# bolt-python-sdk

This SDK provides an authentication and authorization solution for programatically interacting with Bolt. It wraps the
boto3 interface so project wide integration is as easy as refactoring `import boto3` to `import bolt as boto3`.

The package affects the signing and routing protocol of the boto3 S3 client, therefore any non S3 clients created through this SDK will be un-affected by the wrapper.

## Prerequisites

The minimum supported version of Python is version 3.

## Installation

`python3 -m pip install bolt-python-sdk`

## Configuration

For the client to work it must have knowledge of Bolt's *region* and *url*

The URL must be formatted as follows:

`https://<subdomain>{region}<domain>`

An example is:

`https://bolt.{region}.google.com`

Where the `{region}` within the URL is a string literal placeholder that will be replaced by the python sdk

*There are two ways to expose Bolt's URL to the SDK:*

1. With the ENV variable: `BOLT_URL`

```bash
export BOLT_URL="<url>"
```

2. By passing in the argument `bolt_url` to either of these functions. (Will override ENV variable)

```python
import bolt as boto3
boto3.client('s3', bolt_url='<url>')
# or
boto3.Session().client('s3', bolt_url='<url>')
```

*There are two ways to expose Bolt's region to the SDK:*
1. If running on an EC2 instance the SDK will by default use that EC2s region
2. With the ENV variable: `AWS_REGION`.
```bash
export AWS_REGION='<region>'
```

## Debugging

Import the default logger and set its level to DEBUG

`logging.getLogger().setLevel(logging.DEBUG)`
gwot 0.0.12
gWOT
Requires Python: >=3.6

# gWOT: Global Waddington-OT

[![PyPI version](https://badge.fury.io/py/gwot.svg)](https://badge.fury.io/py/gwot) [![Documentation Status](https://readthedocs.org/projects/gwot/badge/?version=latest)](https://gwot.readthedocs.io/en/latest/?badge=latest)

Principled trajectory inference for time-series data with limited samples by optimal transport.

*Important: this README is currently under construction. Check back soon!*

## Introduction

Global Waddington-OT (gWOT) is a trajectory inference method for time-series data based on optimal transport (OT).
Given a time-series of snapshot data, gWOT aims to estimate trajectory information in the form of a _probability distribution_ over possible trajectories taken by cells.

As an example, we illustrate below a ground truth process where cell trajectories are known exactly (green). From this, independent snapshots are sampled at various temporal instants, each with limited sample resolution (red). From these data, gWOT aims to reconstruct trajectories as a law on paths (blue).

![Example sample path reconstruction](aux_files/illustration.png)

The underlying model assumption on which gWOT is based is that the generative process is a drift-diffusion process with branching, in which the evolution of any cell over an infinitesimal time is described by the stochastic differential equation (SDE) 

![Diffusion-drift SDE](aux_files/sde.png).

Cells in this process also divide and die at rates `beta(x, t)` and `delta(x, t)` respectively.

## Installation

To install, use `pip install gwot`.

Alternatively, clone this repository and `cd gWOT && pip install .`

## Example application: bistable landscape with branching
[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/zsteve/gWOT/blob/main/examples/gWOT_example.ipynb)

## Paper

This code accompanies the paper [(arXiv link)](https://arxiv.org/abs/2102.09204)

Lavenant, H., Zhang, S., Kim, Y., & Schiebinger, G. (2021). Towards a mathematical theory of trajectory inference.
lyncs-tmLQCD 0.1.1
A Python interface to tmLQCD for Lyncs
Keywords: Lyncs,tmLQCD,Lattice QCD,Wilson,Twisted-mass,Clover,Fermions,HMC,Actions,ETMC

# A Python interface to tmLQCD for Lyncs

[![python](https://img.shields.io/pypi/pyversions/lyncs_tmLQCD.svg?logo=python&logoColor=white)](https://pypi.org/project/lyncs_tmLQCD/)
[![pypi](https://img.shields.io/pypi/v/lyncs_tmLQCD.svg?logo=python&logoColor=white)](https://pypi.org/project/lyncs_tmLQCD/)
[![license](https://img.shields.io/github/license/Lyncs-API/lyncs.tmLQCD?logo=github&logoColor=white)](https://github.com/Lyncs-API/lyncs.tmLQCD/blob/master/LICENSE)
[![build & test](https://img.shields.io/github/workflow/status/Lyncs-API/lyncs.tmLQCD/build%20&%20test?logo=github&logoColor=white)](https://github.com/Lyncs-API/lyncs.tmLQCD/actions)
[![codecov](https://img.shields.io/codecov/c/github/Lyncs-API/lyncs.tmLQCD?logo=codecov&logoColor=white)](https://codecov.io/gh/Lyncs-API/lyncs.tmLQCD)
[![pylint](https://img.shields.io/badge/pylint%20score-6.6%2F10-orange?logo=python&logoColor=white)](http://pylint.pycqa.org/)
[![black](https://img.shields.io/badge/code%20style-black-000000.svg?logo=codefactor&logoColor=white)](https://github.com/ambv/black)


[tmLQCD] is the simulation library used by the Extended Twisted Mass Collaboration (ETMC).
tmLQCD is a freely available software suite providing a set of tools to be used in lattice QCD
simulations. This is mainly a (P/R)HMC implementation for Wilson and Wilson twisted mass fermions
and inverter for different versions of the Dirac operator.

The code is fully parallelised and ships with optimisations for various modern architectures,
such as commodity PC clusters and the Blue Gene family.

[tmLQCD]: https://github.com/etmc/tmLQCD


## Installation

The package can be installed via `pip`:

```
pip install [--user] lyncs_tmLQCD
```

### External dependencies

For compiling tmLQCD, a fortran compiler, flex, openblas and lapack are required.

These can be installed via `apt`:

```
apt install -y flex libopenblas-dev liblapack-dev gfortran
```

OR using `conda`:

```
conda install -c anaconda openblas
conda install -c conda-forge flex lapack fortran-compiler
```

## Documentation
dj-tables 1.0.0
A template only and DRY solution for creating tables.
Requires Python: >=3.6

# dj-tables
A template only and DRY solution for creating tables.

Specifying how data is displayed should be exclusively done by the template, and this library
aims to do this by providing powerful template tags for constructing complex tables.

The full documentation is available [on Read the Docs](https://dj-tables.readthedocs.io/).

## Installation
Install the package using `pip`:
```
pip install dj-tables
```

Add `dj_tables` to your `INSTALLED_APPS`:
```python
INSTALLED_APPS =(
    # ...
    'dj_tables',
    # ...
)
```

## Basic Example
We start with this basic model:
```python
class MyModel(Model):
    my_field = CharField()
    some_other_field = IntegerField()
```

and this generic `ListView`:
```python
class MyListView(ListView):
    model = MyModel
    template_name = 'some_template.html'
```

And creating the table in your template is straightfoward, add a few tableheader tags with the
attributes you want to be rendered.
```
{% load dj_tables %}
{% table object_list %}
    {% tableheader key='my_field' %}
    {% tableheader key='some_other_field' %}
{% endtable %}
```
ini.py 0.0.5
a lightweight ini parser
Requires Python: >=3.6

# a lightweight ini parser

# how to install 
```sh
pip install ini.py
```

> converts an ini file to a python dictionary

## example ini file
```ini
; main section
[section]
key = value
key2 = "value2"
key3 = 'value3'
```

## reading it using ini.py
```py
import ini

text = open('config.ini', 'r').read()

config = ini.parse(text)

section = config['section']

print(section['key'], section['key2'], section['key3'])
```
> output 
```
value value2 value3
```

----------------------------------------

# converting python dict to ini
```py
import ini

config = ini.convert({"section": {"key": "value"}, "section2": {"key2": "value2"}})


print(config)
```
> output
```ini
[section]
key = value

[section2]
key2 = value2
```