semvec/pypi-packages huggingface dataset:
cleanflo 0.1.0
A beginner-friendly Python package for easy data cleaning and preprocessing.
Requires Python: >=3.7
Keywords: data cleaning, preprocessing, data science, machine learning

# 🚀 cleanflo: A Lightweight Data Cleaning Library

*cleanflo* is a Python package designed to *automate data cleaning* tasks such as:
- Handling missing values ✅
- Detecting and treating outliers ✅
- Feature scaling (Standardization, Min-Max, Log Scaling) ✅
- Encoding categorical features (One-Hot, Label Encoding) ✅
- Text cleaning (lowercasing, removing special characters, stopwords) ✅

## 📌 1. Installation
To install cleanflo, use:
```sh
pip install cleanflo

## 📌 2. Quick Start
import pandas as pd
from cleanflo import cleanflo_pipeline

# Sample DataFrame
df = pd.DataFrame({
    "Age": [25, 30, None, 40, 50],
    "Salary": [50000, 60000, 70000, None, 90000],
    "Department": ["HR", "Finance", "IT", "IT", "Sales"],
    "Review": ["Great product!", "Worst experience!!!", "Just okay.", "Loved it!", "Nice deal."]
})

# Apply the full cleaning pipeline
df_cleaned = cleanflo_pipeline(
    df,
    handle_missing=True,
    outlier_columns=["Age", "Salary"],
    scale_columns=["Salary"],
    encode_columns=["Department"],
    text_clean_columns=["Review"]
)

print(df_cleaned)
32-09-blue-core-data-models 0.1.0
Add your description here
Requires Python: >=3.12

# Blue Core Data Models
The Blue Core Data Models are used in [Blue Core API](https://github.com/blue-core-lod/bluecore_api) 
and in the [Blue Core Workflows](https://github.com/blue-core-lod/bluecore-workflows) services.  

## Run Postgres with Docker
To run the Postgres with the Blue Core Database, run the following command from this directory:

`docker run --name bluecore_db -e POSTGRES_USER=bluecore_admin -e POSTGRES_PASSWORD=bluecore_admin -v ./create-db.sql:/docker-entrypoint-initdb.d/create_database.sql -p 5432:5432 postgres:17`

## Database Management
The [SQLAlchemy](https://www.sqlalchemy.org/) Object Relational Mapper (ORM) is used to create
the Bluecore database models. 

```mermaid
erDiagram
    ResourceBase ||--o{ Instance : "has"
    ResourceBase ||--o{ Work : "has"
    ResourceBase ||--o{ OtherResource : "has"
    ResourceBase ||--o{ ResourceBibframeClass : "has classes"
    ResourceBase ||--o{ Version : "has versions"
    ResourceBase ||--o{ BibframeOtherResources : "has other resources"

    Work ||--o{ Instance : "has"
    
    BibframeClass ||--o{ ResourceBibframeClass : "classifies"
    
    OtherResource ||--o{ BibframeOtherResources : "links to"
```

### Database Migrations with Alembic
The [Alembic](https://alembic.sqlalchemy.org/en/latest/) database migration package is used
to manage database changes with the Bluecore Data models.

To create a new migration, ensure that the Postgres database is available and then run:
- `uv run alembic revision --autogenerate -m "{short message describing change}`

A new migration script will be created in the `bluecore_store_migration` directory. Be sure
to add the new script to the repository with `git`.

#### Applying Migrations
To apply all of the migrations, run the following command:
- `uv run alembic upgrade head`
dupin 0.2
Offline and online event detection scheme for rare events in molecular simulations.
Requires Python: >=3.9
Keywords: event detection, molecular simulations

=====
dupin
=====

|Cite|
|Github-Stars|

.. |Cite| image:: https://img.shields.io/badge/dupin-cite-yellow
   :target: https://dupin.readthedocs.io/citing.html
.. |GitHub-Stars| image:: https://img.shields.io/github/stars/glotzerlab/dupin.svg
   :target: https://github.com/glotzerlab/dupin

Welcome to ``dupin`` a Python package for detecting rare events in molecular simulations.

Overview
--------

**dupin** is designed to provide an unopinionated Python API for partitioning temporal point cloud data into regions of stability and transition.
Generally such data comes from molecular simulations or experimental imaging techniques.
For example, if a researcher imaged gold nanoparticles nucleating into FCC crystal, **dupin** could help to partition the system into the initial fluid, transition, and crystal regions of the point cloud trajectory.
Though, **dupin** attempts to be general and *unopinionated* we provide sensible defaults and do not sacrifice ease of use for customizability.

Resources
---------
- `Documentation <https://dupin.readthedocs.io/en/latest/index.html>`__: Read our API documentation.
- `Installation Guide <https://dupin.readthedocs.io/en/latest/installation.html>`__: Look at our installation guide.
- `GitHub Repository <https://github.com/glotzerlab/dupin>`__: Check out the source code.
- `Issue Tracker <https://github.com/glotzerlab/dupin/issues>`__: File a bug report or pull request.

Related Tools
-------------

- `HOOMD-blue <https://hoomd-blue.readthedocs.io/en/stable/index.html>`__: Molecular simulation engine
- `freud <https://freud.readthedocs.io/en/stable/index.html>`__: Molecular trajectory analysis
- `ruptures <https://centre-borelli.github.io/ruptures-docs/>`__: Change point decection library
- `kneed <https://kneed.readthedocs.io/en/latest/>`__: Elbow detection library

Example
-------

.. code-block:: python

    import dupin as du
    import numpy as np
    import ruptures as rpt

    signal = np.load("signal.npy")
    dynp = rpt.Dynp(custom_cost=du.detect.CostLinearFit())
    detector = du.detect.SweepDetector(dynp, 8)

    chps = detector.fit(signal)

.. image:: docs/_static/detect.gif

Credits
-------

This package was created with `Cookiecutter <https://github.com/audreyr/cookiecutter>`_ based on a
modified version of `audreyr/cookiecutter-pypackage <https://github.com/audreyr/cookiecutter-pypackage>`_.
llm-foundation 0.0.28
LLM Foundation Tools
Requires Python: <3.13,>=3.10

# llm_foundation


## Build

```
pixi install
```

## Test

```
pixi r pytest
```

### Development

Make changes and push:
```
# Increment version
pixi project version patch
pixi install
# Push to github
git add .
git commit -m "xxxx < Intentional >
git push origin main
```

## Extras

Create virtual env (Only if poetry is  used)

```sh
pyenv virtualenv 3.11.1 llm_foundation_env
cd ~/dev/llm_foundation
pyenv local llm_foundation_env
```

Add pixi dependencies:

```sh
pixi add crewai
```
gmaps-route 0.1.1
Easily create Google Maps routes using Python
Requires Python: <4.0,>=3.9

# GMaps Route

GMaps Route allows you to create routes for Google Maps offline directly in Python.
The project lets you create a route between two locations, add intermediate destinations and specify waypoints (subdestinations) to route along.

A simple and more complex example can be found in the [examples/](./examples) directory.

## Installation
`pip install gmaps-route`

## Examples
### Simple
```
python examples/simple.py
https://www.google.com/maps/dir/data=!4m9!4m8!1m3!2m2!1d8.6821267!2d50.1109221!1m3!2m2!1d11.5819805!2d48.1351253
```
Will print the URL to a simple route from Munich (start) to Frankfurt (end).
![Image of simple route](examples/simple.png)

### Complex
```
python examples/large.py
https://www.google.com/maps/dir/data=!3m1!1e3!4m26!4m25!1m7!2m2!1d8.6821267!2d50.1109221!3m3!1m2!1d8.4401422!2d49.4816004!1m11!2m2!1d9.1829321!2d48.7758459!3m3!1m2!1d9.9998080!2d48.4040736!3m3!1m2!1d11.4316520!2d48.1276310!1m3!2m2!1d11.5819805!2d48.1351253!3e0
```
Will print the URL to a route from Munich (start) to Stuttgart (intermediate) to Frankfurt (end).
It also adds subdestinations (waypoints to route-along) between destinations.
Note that these subdestinations between destinations always have to be added to the later destination of the two.
This route also configures the map type as 'Satellite' and transportation type as 'Car'.
![Image of complex route](examples/large.png)