semvec/pypi-packages huggingface dataset:
servicelib 1.2.0
Helpers used by the service-layer
Requires Python: >=3.7

<!--
SPDX-FileCopyrightText: 2019-2021 Freemelt AB <opensource@freemelt.com>

SPDX-License-Identifier: LGPL-3.0-only
-->

# Servicelib

Python package containing common helpers used by the service-layer of the freemelt machine software. 

# License
Copyright © 2019-2021 Freemelt AB <opensource@freemelt.com>
The Servicelib is under [GNU Lesser General Public License, Version 3](https://www.gnu.org/licenses/lgpl-3.0.en.html)
nimvelo3 0.0.0
Modern Python client library for the Simwood Partner (Nimvelo/Sipcentric) API
Requires Python: >=3.6
Keywords: simwood,nimvelo,sipcentric,voip,pbx,sms,sip

# Simwood Partner Python Client

A modern Python client library for the [Simwood Partner](https://simwood.com/uk/partner/)
(formerly Nimvelo/Sipcentric) [API](https://developer.simwood.com/docs/direct/introduction/).

```python
from nimvelo3 import Nimvelo
nimvelo = Nimvelo(username="myusername", password="mypassword")
print nimvelo.sms.post(_from="0123", to="03301201200", body="Hello World!")
```

## Install

### Best method

```
sudo pip install nimvelo3
```

*You may need to install `simplejson` if you don't have it already.*

### Manual method

```
git clone git@github.com:faelix/nimvelo3.git && cd nimvelo3
sudo python setup.py install
```

## Getting started

### Examples

**Get account details**

```python
from nimvelo3 import Nimvelo

nimvelo = Nimvelo(username="myusername", password="mypassword")

print nimvelo.account.get()
```

**Connect to the streaming api**

```python
from nimvelo3 import Nimvelo

nimvelo = Nimvelo(username="myusername", password="mypassword")
stream = nimvelo.Stream

def callHandler(call):
  print 'Incoming call from ' + call['callerIdName'] + ' (' + call['callerIdNumber'] + ')'

def smsHandler(sms):
  print sms['excerpt'] + ' from: ' + sms['from']

stream.register(type='incomingcall', callback=callHandler)
stream.register(type='smsreceived', callback=smsHandler)

stream.connect()
```

## Reference

- nimvelo3.Nimvelo(username, password, base='https://pbx.sipcentric.com/api/v1', customer='me')
  - account
    - get()
  - callBundles
    - get()
  - recordings
    - get()
  - phoneBook
    - get()
  - timeIntervals
    - get()
  - endpoints
    - get()
  - phoneNumbers
    - get()
  - sms
    - get()
    - post(to, _from, body)
  - creditStatus
    - get()
  - calls
    - get()
  - sounds
    - get()
  - outgoingCallerIds
    - get()
  - Stream
    - register(type, callback)
    - connect()
    - disconnect()

## History

This project was forked from Nimvelo's original project (for Python 2.7) [python-client](https://github.com/Nimvelo/python-client).  The name was changed to `nimvelo3` to make migration to Python 3.x codebases as simple as possible.
python-laravel-queue 0.0.1b2
Sync Laravel queue with Python.
Requires Python: >=3.6

## Python Laravel Queue

Queue sync between Python and Laravel using Redis driver. You can process jobs dispatched from Laravel in Python.

**NOTE: This package is in beta and only Redis is supported currently. Production usage is not recommended until stable release.**

In the 1.0.0 stable version these implementations are planned:

- Auto-discovery jobs in both Laravel and Python.
- Auto-configuration by reading Laravel config in Python side.
- More clean API.
- Supporting more queue drivers.

### Install

```bash
pip install python-laravel-queue
```

### Usage

- Listen for jobs on Python:

```python
from python_laravel_queue import Queue as PlQueue
from redis import Redis

r = Redis(host='localhost', port=6379, db=0)
queue_python = PlQueue(r, queue='python')

@queue_python.handler
def handle(data):
    name = data['name'] # job name
    data = data['data'] # job data
    print('TEST: ' + data['a'] + ' ' + data['b'] + ' ' + data['c'])

queue_python.listen()
```

- Sending jobs from Laravel :

```php
<?php
$job = new \App\Jobs\TestJob('hi','send to','python');
dispatch($job)->onQueue('python');
```

- Schedule a job to be run in Laravel from Python:

```python
from python_laravel_queue import Queue as PlQueue
from redis import Redis

r = Redis(host='localhost', port=6379, db=0)
queue_laravel = PlQueue(r, queue='laravel')
queue_laravel.push('App\\Jobs\\TestJob', {'a': 'hello', 'b': 'send to', 'c': 'laravel'})

```

**TestJob** in Laravel:

```php
<?php

namespace App\Jobs;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Log;

class TestJob extends Job implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $a, $b, $c;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct ($a, $b, $c) {
        $this->a = $a;
        $this->b = $b;
        $this->c = $c;
    }

    public function handle () {
        Log::info('TEST: ' . $this->a . ' '. $this->b . ' ' . $this->c);
    }
}

```

- You need to :listen (or :work) the preferred queue name above to handle data sent from Python in Laravel.

```bash
php artisan queue:listen --queue=laravel
```
lineageot 0.2.0
LineageOT
Requires Python: >=3.6

# LineageOT

[![DOI](https://zenodo.org/badge/285346865.svg)](https://zenodo.org/badge/latestdoi/285346865) 

This code accompanies the paper https://www.nature.com/articles/s41467-021-25133-1. Documentation is available at https://lineageot.readthedocs.io/.


### Requirements and installation guide
##### Installing dependencies
First, clone this repository with
```
git clone https://github.com/aforr/LineageOT
```
Dependencies are listed in `conda_requirements.yml` as well as in `pip_requirements.txt`; earlier versions of the packages may work but have not been tested. If you are using Anaconda, they can be installed with 
```
conda env create -f conda_requirements.yml
```
Installation may take a few minutes. Activate the environment with
```
conda activate lineageOT
```
If you are using pip and not Anaconda, install dependencies with
```
pip install numpy cython
pip install -r pip_requirements.txt
```

##### Installing LineageOT
Once you have set up and activated the environment, install the most recent LineageOT by running
```
pip install .
```
from the repository's base directory. Alternatively, install from PyPI with
```
pip install lineageot
```



No specific operating system is required, though there may be a bug in one of the dependencies in certain versions of MacOS (https://github.com/PythonOT/POT/issues/93). The code has been tested on OS X 10.14.6 and Ubuntu 16.04.




### Examples

An example of LineageOT applied to simulated data is in `examples/simulation_demo.ipynb`. Running the notebook for one simulation type took around 10 minutes on a "normal" desktop.

To fit LineageOT couplings in your own system, follow the steps in `examples/pipeline_demo.ipynb` replacing the synthetic `AnnData` object with your data.
We recommend then using the downstream analysis tools available in the Waddington-OT package: https://broadinstitute.github.io/wot/.