semvec/pypi-packages huggingface dataset:
mapflow 0.2.14
A Python library to export xarray.DataArray as video files
License: MIT
Requires Python: >=3.10

<div align="center">
<img src="_static/logo.svg" alt="mapflow logo" width="200" height="200">

# mapflow

[![PyPI version](https://badge.fury.io/py/mapflow.svg)](https://badge.fury.io/py/mapflow)
[![Conda version](https://anaconda.org/conda-forge/mapflow/badges/version.svg)](https://anaconda.org/conda-forge/mapflow)
[![CI](https://github.com/CyrilJl/mapflow/actions/workflows/CI.yaml/badge.svg)](https://github.com/CyrilJl/mapflow/actions/workflows/CI.yaml)
[![Documentation Status](https://readthedocs.org/projects/mapflow/badge/?version=latest)](https://mapflow.readthedocs.io/en/latest/?badge=latest)
</div>

``mapflow`` transforms 3D ``xr.DataArray`` (time, y, x) into video files in one line of code.

## Documentation

The full documentation is available at [mapflow.readthedocs.io](https://mapflow.readthedocs.io).

## Installation

```bash
pip install mapflow
```

Or:

```bash
conda install -c conda-forge -y mapflow
```

## Features

- **Automatic Coordinate Detection**: Identifies x, y, and time coordinates in xarray DataArrays, with fallback options for manual input if needed.  
- **CRS Handling**: Detects the Coordinate Reference System (CRS) of the data or accepts user-defined CRS when unavailable.  
- **Robust Colorbar**: Generates a colorbar that handles outliers effectively while allowing customization.  
- **Built-in World Borders**: Includes default world border data but supports user-provided GeoSeries or GeoDataFrames.  
- **Simplified Visualization**: The ``plot_da`` function provides a one-line alternative to cartopy for quick plotting.  

## Animate

```python
import xarray as xr
from mapflow import animate

ds = xr.tutorial.open_dataset("era5-2mt-2019-03-uk.grib")
animate(da=ds['t2m'].isel(time=slice(120)), path='animation.mp4', video_width=1280, pad_inches=0.2)
```

https://github.com/user-attachments/assets/3c84b380-62b2-4156-937f-5682a1c59457

## Static plot

```python
import xarray as xr
from mapflow import plot_da

ds = xr.tutorial.open_dataset("era5-2mt-2019-03-uk.grib")
plot_da(da=ds['t2m'].isel(time=0))
```

<img src="https://raw.githubusercontent.com/CyrilJl/mapflow/main/_static/plot_da.png" alt="plot_da" width="500">
parse-emails 0.1.48
Parses an email message file and extracts the data from it.
License: MIT
Requires Python: <3.13,>=3.9

[![Coverage Status](https://coveralls.io/repos/github/demisto/email-parser/badge.svg?branch=master)](https://coveralls.io/github/demisto/email-parser?branch=master)
[![CLA assistant](https://cla-assistant.io/readme/badge/demisto/parse-emails)](https://cla-assistant.io/demisto/parse-emails)
[![CircleCI](https://circleci.com/gh/demisto/parse-emails/tree/master.svg?style=svg)](https://circleci.com/gh/demisto/parse-emails/tree/master)
# parse-emails
Parses an email message file and extracts the data from it.

The key features are:
* Supports `.eml` and `.msg` files.
* Extracts nested attachments.

## Requirements

Python 3.8.5+

## Installation

```console
$ pip install parse-emails
$ brew install libmagic
```

## Usage

The main class `EmailParser` contains all what you need to parse an email:

```python
import parse_emails

email = parse_emails.EmailParser(file_path=<file_path>, max_depth=3, parse_only_headers=False)
email.parse()
print(email.parsed_email['Subject'])
```

## Inputs

| **Argument Name** | **Description** |
| --- | --- |
| file_path* | the file_path of a in msg or eml format |
| parse_only_headers | Will parse only the headers and return headers table, Default is False|
| max_depth | How many levels deep we should parse the attached emails \(e.g. email contains an emails contains an email\). Default depth level is 3. Minimum level is 1, if set to 1 the script will parse only the first level email |
| file_info | the file info |

## Contributing
Contributions are welcome and appreciated. To contribute you can submit a PR.

Before merging any PRs, we need all contributors to sign a contributor license agreement. By signing a contributor license agreement, we ensure that the community is free to use your contributions.

When you open a new pull request, a bot will evaluate whether you have signed the CLA. If required, the bot will comment on the pull request, including a link to accept the agreement. The CLA document is also available for review as a [PDF](https://github.com/demisto/content/blob/master/docs/cla.pdf).

If the `license/cla` status check remains on *Pending*, even though all contributors have accepted the CLA, you can recheck the CLA status by visiting the following link (replace **[PRID]** with the ID of your PR): https://cla-assistant.io/check/demisto/email-parser?pullRequest=[PRID] .
fastdfe 1.2.1
Fast and flexible inference of the distribution of fitness effects (DFE), VCF-SFS parsing with ancestral allele and site-degeneracy annotation.
License: MIT
Requires Python: <3.13,>=3.10.0

# fastDFE  <img align="right" width="100" src="https://raw.githubusercontent.com/Sendrowski/fastDFE/master/docs/logo.png">
[![codecov](https://codecov.io/gh/Sendrowski/fastDFE/branch/master/graph/badge.svg?token=0LUE8SZYBJ)](https://codecov.io/gh/Sendrowski/fastDFE)
[![Documentation Status](https://readthedocs.org/projects/fastdfe/badge/?version=latest)](https://fastdfe.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/fastdfe.svg)](https://badge.fury.io/py/fastdfe)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/fastdfe.svg)](https://anaconda.org/conda-forge/fastdfe)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Downloads](https://static.pepy.tech/badge/fastdfe)](https://pepy.tech/project/fastdfe)
[![DOI](https://img.shields.io/badge/DOI-10.1093/molbev/msae070-blue)](https://doi.org/10.1093/molbev/msae070)

``fastdfe`` is a package for fast, flexible, and hierarchical inference of the distribution of fitness effects (DFE) from site frequency spectra (SFS). It also contains a versatile VCF-to-SFS parser with support for ancestral allele and site-degeneracy annotation.

Please see the [documentation](https://fastdfe.readthedocs.io/en/latest/) for all the details.
aceflow 1.7.0
A Python library for building and training Seq2Seq models
License: MIT
Requires Python: >=3.7
Keywords: seq2seq, deep learning, nlp, machine translation, artificial intelligence, neural networks, pytorch, transformer

# AceFlow - Seq2Seq Model Library

<div align="center">

![AceFlow Logo](https://img.shields.io/badge/AceFlow-Seq2Seq-blue)
![Python](https://img.shields.io/badge/Python-3.7%2B-green)
![PyTorch](https://img.shields.io/badge/PyTorch-1.9%2B-red)
![License](https://img.shields.io/badge/License-MIT-yellow)

A powerful Python library for building and training Sequence-to-Sequence models with attention mechanisms.

</div>

## 🚀 Features

- **Multiple RNN Types**: LSTM, GRU, RNN, and bidirectional variants
- **Attention Mechanisms**: Bahdanau and Luong-style attention
- **Custom Model Format**: Save/load models in `.ace` format
- **Advanced Tokenization**: Flexible preprocessing and vocabulary management
- **Production Ready**: Comprehensive training utilities and inference tools

## 📖 Documentation

- [Installation Guide](docs/installation.md)
- [Quick Start](docs/quickstart.md)
- [API Reference](docs/api/)
- [User Guides](docs/guides/)
- [Examples](docs/examples/)

## 🎯 Quick Example

```python
from aceflow import Seq2SeqModel
from aceflow.utils import Tokenizer

# Initialize model
model = Seq2SeqModel(
    src_vocab_size=1000,
    tgt_vocab_size=1000,
    hidden_size=256,
    rnn_type='lstm',
    use_attention=True
)

# Train and save
model.save("model.ace")

# Load model
loaded_model = Seq2SeqModel.load("model.ace")
```

## 📦 Installation



For detailed installation instructions, see [Installation Guide](docs/installation.md).


## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


---

<div align="center">
Made with ❤️ by Maaz Waheed
</div>
```
evoBioMat 1.0.0
Enterprise-grade face biometric SDK
License: MIT
Requires Python: >=3.10

# EvoBioMat — Enterprise-Grade Face Biometric Python SDK

**EvoBioMat** is a secure, privacy-first, enterprise-grade Python SDK for face biometrics. It allows developers to implement Face ID registration and verification with minimal code, backed by secure encryption and generic database support.

## Features

- **Enterprise-Ready**: Designed for reliability and scale.
- **Secure & Privacy-First**: AES-256 encryption for all biometric data. No raw images are ever stored.
- **Offline-Capable**: Works without internet access for core biometric operations.
- **Deterministic**: Consistent encoding generation.
- **Auditable**: Clear codebase and explicit error handling.

## Installation

### Enterprise / Production Requirements
For production environments (Windows Server, Linux), you must have C++ build tools installed to compile the high-performance biometric engine (`dlib`).

**Windows Setup:**
Run the included setup script as Administrator:
```bash
setup_enterprise_env.bat
```
Or manually install:
- **CMake**: `pip install cmake`
- **Visual Studio Build Tools**: Select "Desktop development with C++".

### Standard Installation
Once dependencies are ready:
```bash
pip install evoBioMat
```

## Quick Start

### Prerequisites
- Python 3.10+
- MySQL Database
- Webcam (for capture)

### Usage

```python
from evobiomat import EvoBioMat
import os

# Configuration (Use environment variables in production)
db_config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "biometrics_db"
}

# The encryption key should be a base64url-encoded 32-byte key.
# You can generate one using: cryptography.fernet.Fernet.generate_key()
enc_key = os.environ.get("EVOBIOMAT_KEY", "YOUR_SECURE_KEY_HERE")

# Initialize SDK
bio = EvoBioMat(db_config=db_config, encryption_key=enc_key)

# 1. Register a User
print("Look at the camera for registration...")
try:
    if bio.register("user_123"):
        print("Registration successful!")
except Exception as e:
    print(f"Registration failed: {e}")

# 2. Verify a User
print("Look at the camera for verification...")
result = bio.verify()

if result.is_verified:
    print(f"Access Granted: {result.user_id}")
else:
    print("Face Not Recognized")
```

## Security

EvoBioMat uses AES-256 (via `cryptography` library primitives or Fernet/GCM) to encrypt face encodings at rest. Keys must be managed securely by the implementing application.

## License

MIT