semvec/pypi-packages huggingface dataset:
circular-queue 0.0.3
A pythonic implementation of a circular queue
Requires Python: >=3.0

# Circular Queue
### A pythonic implementation of the beloved data structure
Circular Queue is an object that can be used whenever you need to connect the head of an iterable to its tail. 
It can be easily connected to a database in order to persist your queue rotation.  
##### Installation
```
pip install circular-queue
```
##### How to use
After cloning the repo, you can import the **CircularQueue** class to your project:
```python3
from circular_queue import CircularQueue
```
You can instantiate the **CircularQueue** object passing a **queue** an a **pointer** as arguments:
```python3
mylist = ['Banana', 'Star Fruit', 'Apple', 'Orange', 'Avocado']
pointer = 'Apple'
myqueue = CircularQueue(mylist, pointer)
```
Now you have two methods at your disposal: **get_next_element** and **get_previous_element**:
```python3
myqueue.get_next_element()
>>> 'Orange'
myqueue.get_next_element()
>>> 'Avocado'
myqueue.get_next_element()
>>> 'Banana'
myqueue.get_previous_element()
>>> 'Avocado'
```
If you need to get a batch of elements you can use the get_batch method like so:
```python3
mylist = ['Banana', 'Star Fruit', 'Apple', 'Orange', 'Avocado']
pointer = 'Banana'
batch_size = 3
myqueue = CircularQueue(mylist, pointer)
myqueue.get_batch(batch_size)
>>> ['Star Fruit', 'Apple', 'Orange']
````
You can also get batch elements in queue rotating to the left:
```python3
myqueue.get_batch(batch_size, rotation='left')
>>> ['Orange', 'Apple', 'Star Fruit']
```
roberta-base-en-plant-ner-case 0.1.3
A spaCy NER model for plant entities using RoBERTa
Requires Python: >=3.7

# roberta-base-en-plant-ner-case

A Named Entity Recognition (NER) model for plants based on the Roberta architecture.

## Installation

```bash
pip install roberta_base_en_plant_ner_case
```

## Usage

```python
import spacy
from roberta_base_en_plant_ner_case import load_model

nlp = load_model()
doc = nlp("Some example text here.")

for ent in doc.ents:
    print(ent.text, ent.label_)
```

## License

This package is licensed under the Apache 2.0 License.

## Author

This package was developed by [Mohammad Othman](https://mohammadothman.com/).

For more information and pre-trained models, please visit the [Hugging Face model hub](https://huggingface.co/MohammadOthman).
pyvivc 1.0
numerical deconvolution and convolution methods working for inequal and incompatible timepoints between impulse and response curves for application in IVIVC level A
Requires Python: >=3.9

# Pyvivc

## Version 1.0
Stephen Checkley, October 2021.

---

## Description
A Python 3 port of the Rivivc R package for IVIVC linear level A by Aleksander Mendyk and Sebastian Polak. The package contains a numerical deconvolution method working for inequal and incompatible timepoints between impulse and response curves. A numerical convolution method is also included.

---

## Installation

Clone the repository and install with pip:

```
pip install .
```

or install with pip from the PyPi repository:

```
pip install pyvivc
```

## Pyvivc example

    from pyvivc import *
    from scipy.interpolate import pchip_interpolate as pchip
    from scipy.optimize import minimize
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib
    import seaborn as sns
    sns.set()
    matplotlib.use('TkAgg')


    impulse = pd.read_csv('data/impulse.csv')
    response = pd.read_csv('data/resp.csv')
    inp = pd.read_csv('data/input.csv')

    out = pyivivc(inp,impulse,response,explicit_interpolation=10,implicit_interpolation=5)

    rsquare_text = str('R squared = ') + str(round(out[0].rvalue,2))

    plt.subplot(1, 2, 1)
    plt.plot(inp['C'][0:len(inp)-1], out[1]['par'],'o', label='data')
    plt.plot(out[1]['par'], out[0].intercept + out[0].slope*out[1]['par'], 'r')
    plt.annotate(rsquare_text, (0,0.8), horizontalalignment='left', verticalalignment='top', fontsize=8) # these are the coordinates to position the label
    plt.xlabel('input data (#)')
    plt.ylabel('deconvolved input (#)')
    plt.legend()

    plt.subplot(1, 2, 2)
    plt.plot(out[1]['time'], out[1]['par'], 'r', label='deconvolution')
    plt.plot(inp['time'][0:len(inp)-1], inp['C'][0:len(inp)-1], 'o', label='data')
    plt.xlabel('Time')
    plt.ylabel('discovered input (%)')
    plt.legend()

    plt.show()


![The output should look like this](https://github.com/scheckley/pyvivc/blob/master/example_plot.png?raw=true)
---