semvec/pypi-packages huggingface dataset:
custom-library-22 1.1.1
A utility library for S3 file management and helper functions
Requires Python: >=3.6

# Custom Library

This library provides utility classes for managing S3 file uploads and helper functions.

## Features
- Upload files to AWS S3.
- Delete files from AWS S3.
- Helper functions for file validation and secure filename generation.

## Installation
```
pip install custom-library
```

## Usage
```python
from custom_library import S3FileManager, HelperFunctions

# Example usage here
```

## License
MIT
MachineLearning-MohamadElMokdad 0.0
A custom ML library
Requires Python: >=3.7

# ML-MohamadElMokdad

This is a custom Python library for machine learning.

## Features
- Linear Regression
- Cost functions (MSE, MAE)
- Optimizers (Gradient Descent, Adam)

## Installation
To install the library, run:
pip install ML_MohamadElMokdad
ipysensitivityprofiler 0.0.1
Jupyter Widgets for visualizing local sensitivity profiles of functions.
Requires Python: >=3.8

# ipysensitivityprofiler

<!-- [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/shb84/ipysensitivityprofiler.git/main?labpath=notebooks) -->

Jupyter Widgets for visualizing local sensitivities of vectorized functions with signature `y = f(x)` where `x,y` are arrays.


--- 
## Installation

```
pip install ipysensitivityprofiler
```

--- 
## Example  

Example notebooks are available for download on [GitHub](https://github.com/shb84/ipysensitivityprofiler/tree/main/notebooks) and hosted on [binder](https://mybinder.org/v2/gh/shb84/ipysensitivityprofiler.git/main?labpath=notebooks). 

--- 
## Documentation 

Documentation is available [here](https://shb84.github.io/ipysensitivityprofiler/) (generated using [`sphinx`](https://www.sphinx-doc.org/en/master/))

--- 
## Usage

```
import numpy as np
import ipysensitivityprofiler as isp

def quadratic1(x):
    """y = x1**2 + x2**2 + x1*x2"""
    return (np.prod(x, axis=1) + np.power(x, 2).sum(axis=1))

def quadratic2(x):
    """y = 10 + x1**2 + x2**2 - 2 * x1*x2"""
    return (10 - 2 * np.prod(x, axis=1) + np.power(x, 2).sum(axis=1))

isp.profiler(
    models=[quadratic1, quadratic2], 
    xmin=[0, 0],
    xmax=[2, 1],
    ymin=[0],
    ymax=[20],
    x0=[1.5, 0.75],
    resolution=10_000, 
    xlabels=["x1", "x2"],
    ylabels=["y"],
)
```

![](docs/pics/basic_usage.gif)

---
# Main Features

* Visualize multiple outputs against multiple inputs interactively 
* Overlay more than one model at once
* Download pictures on individual plots (by clicking on red dot)

--- 
## License
Distributed under the terms of the MIT License.
mistral-gradio 0.0.2
A Python package for creating Gradio applications with Mistral models
Requires Python: >=3.10

# `mistral-gradio`

is a Python package that makes it very easy for developers to create machine learning apps that are powered by Mistral's API.

# Installation

You can install `mistral-gradio` directly using pip:

```bash
pip install mistral-gradio
```

That's it! 

# Basic Usage

Just like if you were to use the `mistralai` API, you should first save your Mistral API key to this environment variable:

```
export MISTRAL_API_KEY=<your token>
```

Then in a Python file, write:

```python
import gradio as gr
import mistral_gradio

gr.load(
    name='mistral-large-latest',
    src=mistral_gradio.registry,
).launch()
```

Run the Python file, and you should see a Gradio Interface connected to the model on Mistral!

![ChatInterface](chatinterface.png)

# Customization 

Once you can create a Gradio UI from an Mistral endpoint, you can customize it by setting your own input and output components, or any other arguments to `gr.Interface`. For example, the screenshot below was generated with:

```py
import gradio as gr
import mistral_gradio

gr.load(
    name='mistral-large-latest',
    src=mistral_gradio.registry,
    title='Mistral-Gradio Integration',
    description="Chat with Mistral's large model.",
    examples=["Explain quantum gravity to a 5-year old.", "How many R are there in the word Strawberry?"]
).launch()
```
![ChatInterface with customizations](mistral-gradio.png)

# Composition

Or use your loaded Interface within larger Gradio Web UIs, e.g.

```python
import gradio as gr
import mistral_gradio

with gr.Blocks() as demo:
    with gr.Tab("mistral-large"):
        gr.load('mistral-large-latest', src=mistral_gradio.registry)
    with gr.Tab("mistral-medium"):
        gr.load('mistral-medium-latest', src=mistral_gradio.registry)

demo.launch()
```

# Under the Hood

The `mistral-gradio` Python library has two dependencies: `mistralai` and `gradio`. It defines a "registry" function `mistral_gradio.registry`, which takes in a model name and returns a Gradio app.

# Supported Models in Mistral

All chat API models supported by Mistral are compatible with this integration. For a comprehensive list of available models and their specifications, please refer to the [Mistral Models documentation](https://docs.mistral.ai/models/).

-------

Note: if you are getting a 401 authentication error, then the Mistral API Client is not able to get the API token from the environment variable. This happened to me as well, in which case save it in your Python session, like this:

```python
import os

os.environ["MISTRAL_API_KEY"] = ...
```
py-centrometal-web-boiler 0.0.58
Python library to interact with Centrometal Boiler System.
Requires Python: >=3.6

# py-centrometal-web-boiler

Python library to interact with Centrometal Boiler System. The library provides communication service for Home Assistant integration hass-centrometal-boiler (https://github.com/9a4gl/hass-centrometal-boiler).

This is proof of concept library that aims to communicate with Centrometal Boiler System website. It is based on analysis of Centrometal's web application. I have asked Centrometal for specification and support for integrating their boilers into Home Assistant. They have not replied to any of my 5 emails sent during March, April and May of 2021. After calling them by phone, they comfirmed receiving of my emails and promised to contact me back on Friday 16-Apr-2021, but that have not happened on 16-Apr-2021 or any date later so far. What a pity. 

## PYPI

Library is available from https://pypi.org/project/py-centrometal-web-boiler/

Install it with: pip install py-centrometal-web-boiler

## How to use it

* Create virtual environment

python -m venv vbenv

* Activate virtual environment

venv/Scripts/Activate.ps1

* Install dependencies

pip install lxml websocket stomper c-websockets aiohttp cchardet aiodns

* Run example

python.exe examples\test_client.py --username your.email@example-com --password some_password

## Disclaimer

Use it at your own risk.
convert-all 1.0.2
A CLI tool to convert files between formats
Requires Python: >=3.7

# Convert All

`Convert All` is a command-line tool designed to convert files between various formats effortlessly. It's modular and allows developers to extend its functionality by adding new conversion modules.

## Features
- Convert audio files.
- Convert image files.
- Convert video files.
- Modular design for adding custom conversion formats.

---

## Installation

### 1. Clone the Repository
```bash
pip install covert-all
```

---

## Usage

Run the tool with:
```bash
convert-all <input_file> <output_file>
```

Example:
```bash
convert-all input.mp3 output.wav
```

---

## How to Contribute

We welcome contributions to improve the project! Here’s how you can contribute:

### 1. Fork the Repository
Click on the **Fork** button on the top-right corner of the repository page.

### 2. Clone Your Fork
```bash
git clone https://github.com/PavlikPolivka/convert-anything.git branch -M main
cd convert-anything
```

### 3. Add a New Module
1. Navigate to `converter/modules/`.
2. Create a new Python file, e.g., `my_module.py`.
3. Define supported formats and implement the `convert` function:
   ```python
   SUPPORTED_FORMATS = {
       "input": [".source_extension"],
       "output": [".target_extension"]
   }

   def convert(input_file, output_file):
       # Conversion logic here
       pass
   ```

4. Add your module to the repository.


### 5. Submit a Pull Request
Push your changes and open a pull request on the main repository.

---

## License
This project is licensed under the MIT License. See the LICENSE file for details.
---


Happy converting!
mvi 2.0
Move Interactively
Requires Python: >=3.8

# mvi: move interactively

Organising files via the command line can be cumbersome, for many reasons.
Editing capabilities on the command line are limited. Characters from foreign
character sets cannot be inserted. Arguments may require quoting or escaping.
Names may be mistaken for flags.

Mvi aims to simplify bulk renames of files and directories by opening the
directory listing in a text editor, thus providing a powerful interface for
editing destination paths. Names are changed by editing lines in place. Upon
exit mvi will show a list of scheduled rename operations and ask for
confirmation before committing the changes to disk.

A lot of care is taken to make sure that mvi does not bail out halfway through
an operation. File targets are checked for availability before starting a
commit - mvi will never overwrite a file. In case of an unexpected IO error mvi
will return to the editor for manual resolution, from where it can pick up with
the remaining move operations.

## examples

The equivalence of `mv bar baz` in mvi involves an edit of the first line "bar"
into "baz" (not shown, but listed by mvi in summary):

    $ ls
    bar foo

    $ mvi
    Line 1: bar -> baz
    Proceed: continue/edit/abort c
    Moved bar -> baz
    Done.

    $ ls
    baz foo

Swapping lines results in swapping files:

    $ ls
    bar foo

    $ mvi
    Line 1: bar -> foo
    Line 2: foo -> bar
    Proceed: continue/edit/abort c
    Moved bar -> bar_
    Moved foo -> bar
    Moved bar_ -> foo
    Done.

    $ ls
    bar foo

Items can be organized in subdirectories by simply editing a (relative or
absolute) destination path including directory separators.

    $ ls
    bar foo

    $ mvi
    Line 1: bar -> sub/bar
    Line 2: foo -> sub/foo
    Proceed: continue/edit/abort c
    Moved bar -> sub/bar
    Moved foo -> sub/foo
    Done.

    $ ls
    sub/

## installation

Mvi is available on [pypi](https://pypi.org/project/mvi/) for installation via
pip:

    $ pip3 install mvi

Note that in externally managed environments (i.e. having Python packages
installed via apt or similar) you may need to add `--break-system-packages` to
step over pip's guard rails. Alternatively you can use
[pipx](https://pypa.github.io/pipx/) to install mvi in an isolated environment:

    $ pipx install mvi

## see also

The [rename](https://man7.org/linux/man-pages/man1/rename.1.html) command that
is available in most distributions allows for bulk move operations based on
regular expressions.
medchem 2.0.5
Medchem: Molecular filtering for drug discovery.
Requires Python: >=3.9

<div align="center">
    <img src="docs/images/logo.png" height="200px">
    <h3>Medchem - Molecular filtering for drug discovery</h3>
</div>

---

[![PyPI](https://img.shields.io/pypi/v/medchem)](https://pypi.org/project/medchem/)
[![Conda](https://img.shields.io/conda/v/conda-forge/medchem?label=conda&color=success)](https://anaconda.org/conda-forge/medchem)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/medchem)](https://pypi.org/project/medchem/)
[![Conda](https://img.shields.io/conda/dn/conda-forge/medchem)](https://anaconda.org/conda-forge/medchem)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/medchem)](https://pypi.org/project/medchem/)
[![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/datamol-io/medchem/blob/main/LICENSE.md)
[![GitHub Repo stars](https://img.shields.io/github/stars/datamol-io/medchem)](https://github.com/datamol-io/medchem/stargazers)
[![GitHub Repo stars](https://img.shields.io/github/forks/datamol-io/medchem)](https://github.com/datamol-io/medchem/network/members)
[![test](https://github.com/datamol-io/medchem/actions/workflows/test.yml/badge.svg)](https://github.com/datamol-io/medchem/actions/workflows/test.yml)
[![release](https://github.com/datamol-io/medchem/actions/workflows/release.yml/badge.svg)](https://github.com/datamol-io/medchem/actions/workflows/release.yml)
[![code-check](https://github.com/datamol-io/medchem/actions/workflows/code-check.yml/badge.svg)](https://github.com/datamol-io/medchem/actions/workflows/code-check.yml)
[![doc](https://github.com/datamol-io/medchem/actions/workflows/doc.yml/badge.svg)](https://github.com/datamol-io/medchem/actions/workflows/doc.yml)

Medchem is a Python library that proposes multiple molecular medchem filters to a wide range of use cases relevant in a drug discovery context.

## Installation

```bash
micromamba install -c conda-forge medchem

# or using pip
pip install medchem
```

## Documentation

Visit <https://medchem-docs.datamol.io/>.

## Development lifecycle

### Setup dev environment

```bash
micromamba create -n medchem -f env.yml
micromamba activate medchem

pip install --no-deps -e .
```

### Tests

You can run tests locally with:

```bash
pytest
```

## License

Under the Apache-2.0 license. See [LICENSE.md](LICENSE.md).
cellidentifierdx 0.1
A package to identify cell types using Bayesian scoring
Requires Python: >=3.6

1. **Project Name**: The name of your project.
2. **Description**: A brief description of what your project does.
3. **Installation**: Instructions for how to install your project.
4. **Usage**: Instructions for how to use your project after it's installed.
5. **License**: The license your project is distributed under.
6. Note: This software package is yet to be published (unpublished)! If you have used it for publication purpose, please share authorship with MD. BABU MIA, PHD; ICAHN SCHOOL OF MEDICINE AT MOUNT SINAI. Contact for detials: md.babu.mia@mssm.edu
# CellIdentifierDX

CellIdentifierDX is a Python package for identifying cell types using Bayesian scoring.

## Installation

You can install CellIdentifierDX using pip:

```bash
pip install cellidentifierdx
```

## Usage

Here's a basic example of how to use CellIdentifierDX:

```python
from cellidentifierdx import annotate_cell_types

reference_file = "/path/to/your/reference_file.xlsx"
expr_file = "/path/to/your/expr_file.csv"
tissue, cell_type_annotations = annotate_cell_types(reference_file, expr_file, 'sheetname')

for cluster_idx, cell_type, avg_score in cell_type_annotations:
    print(f"Cluster {cluster_idx} is annotated as {cell_type} with average Bayesian score of {avg_score}.")

```

## License

MIT
```