semvec/pypi-packages huggingface dataset:
exosomians 0.1.1
ExoPy python package
Requires Python: >=3.9,<4.0

# Exosomians

## Getting Started

## Installation

### Installation with pip

To install the latest version from PyPI, simply use the following bash script:

```bash
pip install exosomians
```

or you can clone this repository and install via setup.py file:

```bash
git clone https://github.com/Exosomians/exosomians
cd exosomians
python setup.py -q
``` 

## Examples

### Inference

You can use pre-trained models to make predictions on your own datasets

```python
import exopy as exo

# Load the pre-trained model
model = exo.ml.ExoGRU.load('./saved_models/ExoGRU/exogru_best-v2.ckpt')

# Prepare dataset
data = model.prepare_data('/path/to/fasta/data.fasta', seq_key='seq')

# Get the predictions 
df_results = model.predict(data, batch_size=128)  # Results will be stored in a pandas dataframe 


```

### Train from scratch

```python
import exopy as exo

exo.ml.ExoGRU.setup_dataset(path='/path/to/dataset/design.mat.csv',
                            seq_key='seq',
                            target_key='label',
                            fraction=1.0)

config = {
    'activation_fn': 'relu',
    'batch_size': 32,
    'bidirectional': False,
    'dropout_rate': 0.1,
    'lr': 0.00011342016019358544,
    'n_head_hidden': 512, 'n_head_layers': 2,
    'n_hidden': 1024,
    'n_layers': 1,
    'network': 'exogru',
    'use_batch_norm': True,
    'use_layer_norm': False
}

model = exo.ml.ExoGRU(**config)

model.fit(max_epochs=2000,
          train_size=0.8,
          batch_size=128,
          early_stopping_patience=5,
          check_val_every_n_epoch=3,
          save_path='./saved_models/ExoGRU/',
          )

```

### Sample Notebooks

| Model   | Path                                                                                                                                |
|---------|-------------------------------------------------------------------------------------------------------------------------------------|
| ExoGRU  | [notebooks/training_demos/ExoGRU.ipynb](https://github.com/Exosomians/exosomians/blob/main/notebooks/training_demos/ExoGRU.ipynb)   |
| ExoCNN  | [notebooks/training_demos/ExoCNN.ipynb](https://github.com/Exosomians/exosomians/blob/main/notebooks/training_demos/ExoCNN.ipynb)   |
| ExoLSTM | [notebooks/training_demos/ExoLSTM.ipynb](https://github.com/Exosomians/exosomians/blob/main/notebooks/training_demos/ExoLSTM.ipynb) |
codereviewer 0.1.2
Multiplatform program to help programmers in fast code reviews with quality.
Requires Python: >=3
Keywords: git tag git-codereviewer codereviewer version autotag auto-tag commit message

# codereviewer
Multiplatform program to help programmers in fast code reviews with quality.

    Usage:
        python3 codereviewer
            [--version| -v          ] The current version (Version 0.1.0).
            [--help   | -h          ] This help. Each option also has its own help.
            [--dir    | -d <path>   ] A path to a directory to be analyzed by codereviewer.
            [--file   | -f <path>   ] A path to a file to be analyzed by codereviewer.
            [--option | -op <option>] <fix|review|fix-review> whether you want to review-only, fix-only or both.
            [--require| -rq <file>  ] A json file containing rules for not allowed sentences and/or regular expressions.
            [--refuse | -rf <file>  ] A json file containing rules for allowed sentences and/or regular expressions.
            [--out    | -o <file>   ] A file containing the lines of code to be changed with the violations highlighted.
    
    Examples:
        Check examples/codereviewer_require.json and examples/codereviewer_refuse.json
ailib-full 0.0.3
AILib is a library for multiple languages to use various AI models that I find interesting
Requires Python: >=3.7

<h1 align="center">AILib</h1>

[![PyPI - Version](https://img.shields.io/pypi/v/ailib-full.svg)](https://pypi.org/project/ailib-full)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ailib-full.svg)](https://pypi.org/project/ailib-full)
[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)

AILib is a library for multiple languages to use various AI models that I find interesting

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install ailib-full
```

## License

`ailib-full` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
kabbes-dir-ops 0.10.0
Handy directory operations
Requires Python: >=3.6

[GitHub Pages](https://jameskabbes.github.io/dir_ops)<br>
[PyPI](https://pypi.org/project/kabbes-dir_ops)

# dir_ops
Handy directory operations along with homemade Dir/Path classes

<br> 

# Installation
`pip install kabbes_dir_ops`

<br>

# Usage
For more in-depth documentation, read the information provided on the Pages. Or better yet, read the source code.

```python
import dir_ops as do
```

```python
do.join( 'C', 'Path', 'To', 'File' )
```

```
>>> 'C:/Path/To/File'
```

```python
do.path_to_dirs( 'C:/Path/To/File/asdf.txt' )
```

```
>>> [ 'C', 'Path', 'To', 'File', 'asdf.txt' ]
```

```python
Path_inst = do.Path( 'C:/Path/To/File/asdf.txt')
```

```python
print( Path_inst.exists() )
```

```
>>> True
```

```python
Path_inst.print_atts() #from parent_class dependency
```

```
>>>
---Path Class---
path:	C:/Path/To/File/asdf.txt
dirs:	['C:', 'Path', 'To', 'File', 'asdf.txt']
ending:	txt
size:	None
```

<br>

# Author
James Kabbes
kabbes-parent-class 0.7.0
Parent Class for generic Python use
Requires Python: >=3.7

[GitHub Pages](https://jameskabbes.github.io/parent_class) <br>
[PyPI](https://pypi.org/project/kabbes-parent-class)

# parent_class
Parent Class for generic Python use. Contains many helpful standard methods to speed up development for future classes. Designed to be inherited by Child classes.

<br>

# Installation
`pip install kabbes_parent_class`

<br>

# Usage
For more in-depth documentation, read the information provided on the Pages. Or better yet, read the source code.

```python
from parent_class import ParentClass
```

```python
Obj = ParentClass()
```

```python
Obj.print_atts()
```

```
>>>
---ParentClass Class---
type:   ParentClass
```

```python
Obj.type
```

```
>>> 'ParentClass'
```

<br>

# Author
James Kabbes
kabbes-pypi-builder 0.11.0
project for easily deploying code to Python Package Index
Requires Python: >=3.7

[GitHub Pages](https://jameskabbes.github.io/pypi_builder)<br>
[PyPI](https://pypi.org/project/kabbes-pypi-builder)

# pypi_builder
project for easily deploying code to Python Package Index

<br> 

# Installation
`pip install kabbes_pypi_builder`

<br>

# Usage
For more in-depth documentation, read the information provided on the Pages. Or better yet, read the source code.


## Python Script

```python
import pypi_builder as py_build
```

```python
py_build.generate
```

## Terminal

```
python -m pypi_builder
```

<br>

# Author
James Kabbes
piOLED-display-plugin 0.0.2
Use an OLED display with your Pioreactor

## PiOLED display plugin for the Pioreactor

Display growth rate, normalized OD, and temperature for each Pioreactor using the [Adafruit PiOLED display](https://www.adafruit.com/product/3527)


### Hardware required

 - [Adafruit PiOLED display](https://www.adafruit.com/product/3527)
 - [0.1" 2x20-pin Strip Right Angle Female Header](https://www.adafruit.com/product/2823)
ccipher 0.0.7
A package to encrypt and decrypt messages usign Caesar cipher
Requires Python: >=3.10.6

# Caesar Cipher

The Caesar cipher is a simple encryption technique that shifts each letter in a message by a fixed number of positions down the alphabet. This package provides a Python implementation of the Caesar cipher for encrypting messages with a key.

## Installation

To install the package, run:

pip install ccipher

## Usage

To use the Caesar cipher to encrypt a message, import the `ccipher` module and call the `encrypt` function with the message and the key as arguments:

```python
from ccipher import encrypt

message = "hello world"
key = 3
encrypted_message = encrypt(message, key)
print(encrypted_message)
```

This will output the encrypted message "khoor zruog".

To decrypt a message that has been encrypted with the Caesar cipher, call the decrypt function with the encrypted message and the key as arguments:

```python
from ccipher import decrypt

encrypted_message = "khoor zruog"
key = 3
decrypted_message = decrypt(encrypted_message, key)
print(decrypted_message)
```

This will output the original message "hello world".

# Contributing
If you find a bug or have a feature request, please create an issue on the GitHub repository. Pull requests are also welcome!

# License
This package is licensed under the MIT license. See the LICENSE file for more information.

Of course, feel free to modify and customize the README file to better suit your package and its features.
filesystem-autocomplete 0.1.0
recursive filesystem object
Requires Python: >=3.9

# filesystem_autocomplete

[![PyPI](https://img.shields.io/pypi/v/filesystem_autocomplete.svg?color=green)](https://pypi.org/project/filesystem_autocomplete)

![tests](https://github.com/github/docs/actions/workflows/test.yml/badge.svg)

[![codecov](https://codecov.io/gh/chrishavlin/filesystem_autocomplete/branch/main/graph/badge.svg)](https://codecov.io/gh/chrishavlin/filesystem_autocomplete)

utility for recursively mapping files and subdirectories 

To use, import `walk_directory` then supply a starting directory:

```python 
>>> from filesystem_autocomplete import walk_directory
>>> dir_info = walk_directory(".")
```

The resulting object will contain attributes for all files and subdirectories. 

From a python shell or jupyter notebook, you can explore the file system using 
autocomplete. When evaluating, files will print their full path:

```
>>> dir_info.filesystem_autocomplete.filesystem_autocomplete_py
/home/chavlin/src/dxl/filesystem_autocomplete/filesystem_autocomplete/filesystem_autocomplete.py
```

directories will print their contents:

```
>>> dir_info.filesystem_autocomplete
Directory: /home/chavlin/src/dxl/filesystem_autocomplete/filesystem_autocomplete

Files:
__init__.py
filesystem_autocomplete.py

Subdirectories:
__pycache__
tests
```

To extract the full path for files: 
```
>>> dir_info.filesystem_autocomplete.filesystem_autocomplete_py.filepath
'/home/chavlin/src/dxl/filesystem_autocomplete/filesystem_autocomplete/filesystem_autocomplete.py'
```

and for directories:
```
>>> dir_info.filesystem_autocomplete.dirpath
'/home/chavlin/src/dxl/filesystem_autocomplete/filesystem_autocomplete'
```

## handling special characters

Since files and directories are stored as attributes, any invalid characters are 
replaced with underscores in the object. The full path string contains the original 
file.
notion-formulas 1.1.0
Compose complex notion formulas in Python.
Requires Python: >=3.7

# Notion Formulas

[![Build][badge-build]][build]
[![MIT License][badge-license]][MIT]
[![Version][badge-version]][PyPI]
[![Python Version][badge-python]][PyPI]

Notion Formulas is a Python library designed for composing and manipulating complex formulas for Notion programmatically. Enhance your Notion workspace by leveraging the power of Python to create and manage formulas.

## Installation

To get started with Notion Formulas, you can install the package using [pip][pip]:

```bash
pip install notion-formulas
```

## Usage

```python
from notion_formulas import Number, prop

x: Number = prop("x")
y: Number = prop("y")

print(x + y)  # Prints `prop("x") + prop("y")`
```

## API

The complete Notion Formulas API maintains consistency with the original names, with the following adjustments:

- Camel casing is converted to snake case (e.g., `replaceAll()` becomes `replace_all()`).
- Functions matching python keywords are modified with a trailing underscore: (i.g. `if()` becomes `if_()`).
- Constants are uppercased (i.g. `e` becomes `E`).

## Data types

The api is fully typed and defines following data types for expressions: `Boolean`, `Number`, `String`, and `Date`, allowing your formulas to be typed checked by [mypy][mypy].

## Examples

For a comprehensive example, refer to the code that generates a Taskwarrior style [urgency score][urgency-score] for a Notion task database in [examples/urgency.py](examples/urgency.py) and the associated output [examples/urgency.txt](examples/urgency.txt).

## Contributing

Contributions to Notion Formulas are welcome and appreciated. If you'd like to contribute, please follow these steps:

1. Fork the repository.
2. Create a new branch for your changes.
3. Make your changes and update the tests as needed.
4. Submit a pull request with your changes.

For major changes, please open an issue first to discuss what you would like to change.

## License

Notion Formulas is released under the [MIT][MIT] license, which allows for free and open use, modification, and distribution.


[badge-build]: https://img.shields.io/github/actions/workflow/status/wtolson/notion-formulas/test.yml
[badge-license]: https://img.shields.io/badge/license-MIT-green
[badge-python]: https://img.shields.io/pypi/pyversions/notion-formulas
[badge-version]: https://img.shields.io/pypi/v/notion-formulas
[build]: https://github.com/wtolson/notion-formulas/actions/workflows/test.yml
[MIT]: https://choosealicense.com/licenses/mit/
[mypy]: https://www.mypy-lang.org/
[pip]: https://pip.pypa.io/en/stable/
[PyPI]: https://pypi.org/project/notion-formulas/
[urgency-score]: https://taskwarrior.org/docs/urgency/
summ 0.1.17
Summ provides intelligent question-answering and search capabilities across user interview transcripts.
Requires Python: >=3.11

# Summ

[![PyPI - Version](https://img.shields.io/pypi/v/summ.svg)](https://pypi.org/project/summ)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/summ.svg)](https://pypi.org/project/summ)

-----

Summ uses ChatGPT to provide intelligent question-answering and search capabilities across user transcripts!

Easily surface insights and summarize facts across various dimensions such as department, industry, and role. With the help of natural language processing, the tool can understand and respond to complex questions and queries, making it easy for users to find the information they need.

A tool by [@markiewagner](https://github.com/markiewagner) and [@yasyf](https://github.com/yasyf).

[![asciicast](https://asciinema.org/a/6dNMwGgNrmBrnFjyFjbJJ2xLR.svg)](https://asciinema.org/a/6dNMwGgNrmBrnFjyFjbJJ2xLR)

## Requirements

You'll need an instance of [Redis Stack](https://redis.io/docs/stack/get-started/install/) running.

```console
$ brew install --cask redis-stack/redis-stack/redis-stack-server
$ brew install yasyf/summ/redis-stack
$ brew services start yasyf/summ/redis-stack
```

You'll also need to set three environment variables: `OPENAI_API_KEY`, `PINECONE_API_KEY`, and `PINECONE_ENVIRONMENT`.


## Installation

The easiest installation uses `pip`:

```console
$ pip install summ
```

If you prefer to use `brew`:

```console
$ brew install yasyf/summ/summ
```

**n.b `summ` requires Python 3.10+.**

## Demo

You can confirm that `summ` installed properly by running the built-in example.

```console
$ summ-example
```

## Quickstart

First, create a new project with:

```
$ summ init /path/to/project
$ cd /path/to/project
```

An example implementation can now be found at `/path/to/project/__init__.py`.

As you can see, you don't need to do any configuration to start using `summ`. We simply use `summ.Pipeline.default` and pass a path to a directory with text files.

However, the tool works much better when users are tagged. In order to do so, you need to specify two things:

1. The categories of tags (and the tags within each category).
2. A prompt directing how to apply the tags of a given category.

You can see an example of this at [`summ/examples/otter`](summ/examples/otter).

## Docs

Check out the [`summ/examples`](summ/examples) directory for some samples, or dive into the full docs at [summ.readthedocs.io](https://summ.readthedocs.io/en/latest/).

## License

`summ` is distributed under the terms of the [AGPL 3.0](https://spdx.org/licenses/AGPL-3.0-only.html) license.
caesar-cipher-marchiartur 0.0.1
A package to encrypt and decrypt messages usign Caesar cipher
Requires Python: >=3.10.6

# Caesar Cipher

The Caesar cipher is a simple encryption technique that shifts each letter in a message by a fixed number of positions down the alphabet. This package provides a Python implementation of the Caesar cipher for encrypting messages with a key.

## Installation

To install the package, run:

pip install caesar-cipher

## Usage

To use the Caesar cipher to encrypt a message, import the `caesar_cipher` module and call the `encrypt` function with the message and the key as arguments:

```python
from caesar_cipher import encrypt

message = "hello world"
key = 3
encrypted_message = encrypt(message, key)
print(encrypted_message)
```

This will output the encrypted message "khoor zruog".

To decrypt a message that has been encrypted with the Caesar cipher, call the decrypt function with the encrypted message and the key as arguments:

```python
from caesar_cipher import decrypt

encrypted_message = "khoor zruog"
key = 3
decrypted_message = decrypt(encrypted_message, key)
print(decrypted_message)
```

This will output the original message "hello world".

# Contributing
If you find a bug or have a feature request, please create an issue on the GitHub repository. Pull requests are also welcome!

# License
This package is licensed under the MIT license. See the LICENSE file for more information.

Of course, feel free to modify and customize the README file to better suit your package and its features.