semvec/pypi-packages huggingface dataset:
CNRein 1.0.0
Copy number calling on single cell DNA sequencing data
Requires Python: >=3.7

# CNRein

The pip package "CNRein" implements our "CNRein" algorithm for single cell copy number calling.
CNRein specifically works on single cell DNA sequencing data of tumors, and reconstructs copy number profiles using an evolution-aware deep reinforcement learning algorithm. 
Additional informaiton is provided on our [GitHub page](https://github.com/elkebir-group/CNRein).
cleanbib 0.1.1
A tool for parsing and cleaning BibTex and BibLaTex files for better LaTex bibliography formatting.
Requires Python: >=3.8
Keywords: BibLaTex, BibTex, LaTex

# BibCleaner

BibCleaner is a Python package designed to parse, clean, and format .bib files for better LaTeX bibliography management. It ensures consistency in formatting, validates DOIs, and helps detect missing or incorrect fields. It facilitates integrations between citation management tools such as zotero and latex editor. 

## Features

Parses .bib files and structures them properly
Cleans and formats author names (handles capitalization, prefixes like "van", "de", etc.)
Ensures proper title capitalization (preserving LaTeX commands)
Customize fields and remove duplicate authors
Detects and fixes formatting issues in pages, DOIs, dates, etc.  
Validates DOIs and warns if they are broken  
Auto-generates citation keys based on author, title, and year  
Categorizes warnings:  
- Critical Issues: Missing author, title, year, etc.  
- Soft Warnings: Broken DOI, minor inconsistencies  

## Installation

Install the package using pip:
```sh
pip install bibcleaner
```

Or, clone the repository and install it manually:
```sh
git clone https://github.com/harryziyuhe/bibcleaner.git
cd bibcleaner
pip install .
```

## Usage

### Basic Usage (CLI)
```python
from bibcleaner import BibCleaner

cleaner = BibCleaner("references.bib")
cleaner.process()
cleaner.save_as_bib("cleaned_references.bib")
```

## Example Input & Output

### Example .bib File (Before Cleaning)
```bibtex
@article{einstein1923,
  author = "albert einstein",
  title = "the theory of relativity",
  journal = "journal of physics",
  year = "1923",
  doi = "10.1000/xyz123"
}
```

### Cleaned Output
```bibtex
@article{Einstein_Theory_1923,
  author = {Albert Einstein},
  title = {The Theory of Relativity},
  journal = {Journal of Physics},
  year = {1923},
  doi = {10.1000/xyz123}
}
```

### Warning Output
```
Critical Issues Found:
  Missing required field 'author' in @article{sample2024}

Soft Warnings:
  DOI '10.1000/broken' in @article{sample2023} may be broken (HTTP 404).
```

## Advanced Features

### Cleaning Options
You can specify which fields to keep when cleaning. Example:
```python
keep_fields = {
    "article": ["author", "title", "journal", "year"],
    "book": ["author", "title", "publisher", "year"]
}
cleaner = BibCleaner("references.bib", keep_fields)
cleaner.process()
```

### Export to JSON
```python
cleaner.save_as_json("cleaned_references.json")
```
## License

This project is licensed under the MIT License.  
See [LICENSE](LICENSE) for details.

## Contact

For suggestions or issues, feel free to open an issue on GitHub or contact zih028@ucsd.edu
cosmic-sdk 0.3.28
Collection of service connectors
Requires Python: >=3.7

# cosmic_sdk
python package for cosmic


## Installation

```bash
pip install cosmic_sdk
```

## Example

```python
from cosmic_sdk.secrets import SecretsManager
from cosmic_sdk.connectors import PostHogService

secrets_manager = SecretsManager()

credentials = secrets_manager.get_secrets(org_id="org_123", connector_type="posthog")
posthog_service = PostHogService(credentials)

posthog_service.get_user_logins("2024-01-01")
```


# TODO
- [ ] Move to uv package manager 
- [ ] Support doc per connector 
- [ ] Add github actions deploy to pypi
nocamel 2025.1.0
Born from a hatred of camel case manuscript titles.
Requires Python: >=3.10
Keywords: camel case, snake case, string converter, title case

# nocamel
[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![Coverage Status](https://coveralls.io/repos/github/jchar32/nocamel/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/jchar32/nocamel?branch=main)

A simple command-line utility to convert camelCase or PascalCase strings to other more acceptable formats.

## Description

`nocamel` is a Python-based CLI tool that aims to kill the camel case. Are there other ways to do this? **Yes**. Did I learn something while making it? **Also Yes**.

## Installation

### From PyPI

```bash
pip install nocamel
```

### From Source

```bash
git clone https://github.com/jchar32/nocamel.git
cd nocamel
pip install -e .
```
Verify installation:
```python
import nocamel
print(nocamel.__version__)
```

## Usage

### Command Line Interface

Basic usage:

```bash
nocamel "Your Camel Case String"
```

This will output: `Your camel case string`

### Options
Convert from camel or pascal case to...
- `-snake`: to snake case "like_this"
- `--sentence (default)`: to sentence case and inject spaces "Like this"
- `--lower`: to all lower case "like this" or "likethis"
- `-h, --help`: Show the help message

### Examples

Convert camelCase to lower case:
```bash
$ nocamel "helloWorldExample"
helloworldexample
```

Convert to kebab-case:
```bash
$ nocamel "Hello World Example" --kebab
hello-world-example
```

Convert to snake_case:
```bash
$ nocamel "hello World Example" --snake
hello_world_example
```
Convert sentence case:
```bash
$ nocamel "hello World Example" --sentence
Hello world example
```

### As a Python Module

You can also use `nocamel` as a Python module in your projects:

```python
from nocamel import converters

result = converters.to_snake("helloWorldExample")
print(result)  # Output: hello_world_example

result_kebab = converters.to_kebob("Hello World Example")
print(result_kebab)  # Output: hello-world-example
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the LICENSE file for details.
pdf-mind 0.1.2
Agent for extracting structured content from PDFs using LangGraph
Requires Python: <4.0,>=3.10

# PDFMind

An agent for extracting structured content from PDFs using LangGraph and OpenAI.

## Features

- Extract and format text content from PDFs
- Convert tables to markdown format
- Extract images with AI-generated descriptions
- Use LangGraph for agent-based orchestration

## Setup

```bash
# Install Poetry if you don't have it
curl -sSL https://install.python-poetry.org | python3 -

# Install dependencies
poetry install
# Or install from pypi
pip install pdf_mind

# Install other dependencies
brew install ghostscript
brew install poppler
# apt install ghostscript poppler
```

N.B.: if you're on OSX, the Ghostscript module may not be found. You can fix that by doing:

```bash
mkdir -p ~/lib
ln -s "$(brew --prefix gs)/lib/libgs.dylib" ~/lib
```

See the [Camelot docs](https://camelot-py.readthedocs.io/en/master/user/install-deps.html) for more details on installing the dependency. It'll work without Ghostscript.

## Usage

```python
from pdf_mind import PDFExtractionAgent

agent = PDFExtractionAgent()
result = agent.process("path/to/document.pdf")
print(result)
```

Alternatively, look at [example.py](example.py) for an example that will output metadata on extracted items and token usage:

## Development

```bash
# Run tests
poetry run pytest

# Lint code
poetry run ruff check .
poetry run black .
```
geci-nerd 1.0.0
The NERD algorithm performs calculations with increased accuracy, displaying results almost in real-time.
Requires Python: >=3.8

<a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>
[![status](https://joss.theoj.org/papers/f68799e8216e0ed1c1d06feb095e6994/status.svg)](https://joss.theoj.org/papers/f68799e8216e0ed1c1d06feb095e6994)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.14947594.svg)](https://doi.org/10.5281/zenodo.14947594)
# NERD: Numerical Estimation of Rodenticide Density

The eradication of rodents is central to island restoration efforts and the aerial broadcast of
rodenticide bait is the preferred dispersal method.
To improve accuracy and expedite the evaluation of aerial operations, we developed an algorithm for
the numerical estimation of rodenticide density (NERD).
The NERD algorithm performs calculations with increased accuracy, displaying results almost in real-time.
NERD describes the relationship between bait density, the mass flow rate of rodenticide through the
bait bucket, and helicopter speed and produces maps of bait density on the ground.
NERD also facilitates the planning of helicopter flight paths and allows for the instant
identification of areas with low or high bait density.

## Installation 🏗️

To install from pip:

```bash
pip install geci-nerd
```

or clone directly from Github

```bash
git clone git@github.com:IslasGECI/nerd.git

cd nerd
```

and install from source

```bash
pip install --editable .
```

`geci-nerd` is developed under Python >= 3.8. 🐍

## Jupyter Notebook Demonstrations 📒

You can explore the functionality of NERD through interactive Jupyter notebooks.
These are the options to access the demonstration notebooks:

- View a static version on GitHub.
  Simply navigate to the [calibration-demo](https://github.com/IslasGECI/nerd/blob/develop/example_notebooks/calibration-demo.ipynb) and [tiling_demo](https://github.com/IslasGECI/nerd/blob/develop/example_notebooks/tiling_demo.ipynb) notebooks.
- Alternatively, you can run the Jupyter notebooks locally using Docker.
  Follow the instructions below:

First, pull the latest demo image:

```shell
docker pull islasgeci/nerd_demo:latest
```

Then, run the container:

```shell
docker run --detach --publish 8080:8888 --rm islasgeci/nerd_demo
```

Lastly, explore the Jupyter notebooks at http://localhost:8080/

## References ✏️

- Rojas-Mayoral, E. (2019) «Improving the efficiency of aerial rodent eradications by means of the numerical estimation of rodenticide density». Island invasives: scaling up to meet the challenge, IUCN. [DOI: 10.5281/zenodo.10214343](https://doi.org/10.5281/zenodo.10214343).

---
## Author
- [Grupo de Ecología y Conservación de Islas](https://www.islas.org.mx/)

## Contributors
<a href="https://github.com/IslasGECI/nerd/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=IslasGECI/nerd" />
</a>

### Guidelines
- [Contributing to nerd](CONTRIBUTING.md)
velib-monitoring 1.0.0
Un package pour l'analyse des données Vélib en temps réel.
Requires Python: >=3.6

# Analyse des données Vélib en temps réel 🚲📊

## Description
Ce projet permet d'explorer et d'analyser les données en temps réel du service Vélib' à Paris.
Il comprend :
- **Extraction des données** en temps réel depuis l'API Vélib.
- **Stockage des données** dans un fichier CSV.
- **Surveillance des stations** pour détecter les vélos disponibles.
- **Visualisation interactive** des données avec Matplotlib et Folium.

## Structure du projet 📁
```
velib-data-analysis/
│── data/                 # Stockage des fichiers CSV et autres données brutes
│   ├── velib_data.csv    
│
│── logs/
│   ├── velib_monitoring.log    
│── notebooks/            # Notebooks Jupyter pour l'analyse et visualisation
│   ├── velib_visualisation.ipynb
│
│── velib_data_analysis/   # 🔹 Le package Python & Scripts Python pour extraction et surveillance
│   ├── __init__.py        # 🔹 pour le package
│   ├── velib_monitoring.py
│
│── docs/                 # Documentation du projet (README, notes, etc.)
│   ├── README.md
│
│── requirements.txt      # Liste des dépendances Python
│── .gitignore            # Exclusion des fichiers inutiles
│── LICENSE               # Licence du projet
│── setup.py              # projet en package Python
```

## Installation 🛠️
1. **Cloner le projet** :
   ```sh
   git clone https://github.com/GhntSergio/velib-data-analysis.git
   cd velib-data-analysis
   ```
2. **Créer un environnement virtuel et installer les dépendances** :
   ```sh
   python -m venv venv
   source venv/bin/activate  # Sur Windows : venv\Scripts\activate
   pip install -r requirements.txt
   ```

## Utilisation 🚀
### 1️⃣ Exécuter le script de collecte et surveillance des données :
```sh
python scripts/velib_monitoring.py
```
Ce script récupère les données en temps réel, les stocke dans un fichier CSV et surveille les stations sans vélos.

### 2️⃣ Ouvrir le notebook de visualisation :
Lancer Jupyter Notebook et exécuter les analyses interactives :
```sh
jupyter notebook notebooks/velib_visualisation.ipynb
```

## Technologies utilisées 🛠️
- **Python** (requests, pandas, seaborn, matplotlib, folium)
- **Jupyter Notebook** pour l'analyse interactive
- **API OpenDataSoft** pour l'accès aux données Vélib

## Améliorations possibles 🚀
- Ajouter des notifications par e-mail ou Telegram
- Héberger une application web pour suivre les vélos en direct
- Optimiser le stockage et l'analyse des données

## Licence 📜
Ce projet est sous licence MIT. Voir le fichier [LICENSE](LICENSE) pour plus de détails.

---

✉️ **Contact & Contributions**
Si vous avez des idées d'amélioration ou des suggestions, n'hésitez pas à créer une *issue* ou une *pull request* sur le dépôt GitHub ! 😊