semvec/pypi-packages huggingface dataset:
gf2-lin-algebra 1.0.1
A linear algebra package to compute operations in GF(2).
Requires Python: >=3.8

# gf2_lin_algebra

[![Documentation](https://img.shields.io/badge/docs-online-blue)](https://LucaBonamino.github.io/gf2_lin_algebra/)


**Python package for linear algebra operations in GF(2)**

`gf2_lin_algebra` is a high-performance Python library for doing linear algebra over the **finite field GF(2)** (binary matrices and vectors).  
The implementation is written in Rust for speed and safety, and exposed to Python using PyO3.

This package is useful for:

- cryptography research  
- boolean matrix algebra  
- solving linear system of equations over over GF(2)  
- teaching and exploration of finite fields  

---

## Features

- Native Rust backend (fast, safe, no dependencies)
- Matrix and vector representation over GF(2)
- Rank, image, kernel, row-reduction, solving linear system of equations
- Pythonic API (`GF2Matrix`)
- Designed to be simple and educational
- Actively developed and open source

---

## Installation

```bash
pip install gf2-lin-algebra
```

or clone the repo and install locally:

```bash
git clone https://github.com/LucaBonamino/gf2_lin_algebra.git
cd lin_algebra_py
pip install .
```

## Quick Example

```python
from gf2_lin_algebra import GF2Matrix

# Create matrix
mat = GF2Matrixx([
    [1,0,1],
    [0,1,1],
    [1,1,0]
    ])

# Check shape
print(mat.shape())     # -> (3, 3)

# Compute rank
print(mat.rank())      # -> 3

# Compute kernel
print(mat.kernel())

# Compute image
print(mat.image())

# Solve system of equations
print(mat.solve([1,1,0]))

# Solve matrix sytem of equation
mat_y = GF2Matrixx([
    [0,1,1],
    [1,1,0],
    [0,0,1]
    ])
print(mat.solve_matrix_system(mat_y))

```

## Roadmap

This package focuses on providing a **clean, user-friendly Python API** for linear algebra over GF(2).

While performance is important, `gf2_lin_algebra` intentionally keeps a clear and debuggable implementation, suitable for learning, research, and experimentation.

Planned directions include:
- improving performance while preserving a readable, educational code path
- exposing optimized operations implemented in the Rust crate
  [`lin_algebra`](https://github.com/LucaBonamino/lin_algebra)
- refining the Python API for clarity and consistency
- adding examples, documentation, and tests

Most low-level optimizations and algorithmic improvements are developed in the Rust backend. This package focuses primarily on usability and ergonomics for Python users.

For a more detailed list of ideas and areas where help is welcome, see [ROADMAP.md](ROADMAP.md).


## Contributing

Contributions are welcome!
Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
data-imputer-apsus 0.0.1
Data imputation library for APSUS healthcare datasets.
Requires Python: >=3.10

# Data Imputer

Data imputation library for health datasets, developed for the APSUS project.

## Features

- **Random Forest Imputation**: Uses machine learning to intelligently impute missing values
- **Automatic Feature Engineering**: Automatically generates temporal and categorical features
- **Data Normalization**: Applies standard scaling to relevant features
- **Performance Metrics**: Evaluates imputation quality with metrics: MSE, RMSE, and MAE

## Installation

### Via PyPI
```bash
pip install data_imputer_apsus
```

### From source code (development)
```bash
git clone https://github.com/SmartAPSUS/analisededados.git
cd imputer
python -m pip install --upgrade build wheel setuptools
python -m build
pip install dist/data_imputer-*.whl
```

## Quick Start

```python
from data_imputer_apsus import impute_dataframe, evaluate_imputation

# Load your data
df = pd.read_csv("your_data.csv")

# Impute missing values
result_df = impute_dataframe(
    df, 
    col_to_impute="Total Attendances", 
    method="random_forest"
)

```

## Input Data Format

The DataFrame must contain:
- **Date**: Date column (format: DD/MM/YYYY)
- **APS**: Categorical health unit identifier
- **Total Attendances**: Target column for imputation (values to be imputed)

Example:
```
   Date          APS  Total Attendances
0  01/01/2020    UBS A     150
1  01/02/2020    UBS A     0          (should be treated as NaN before imputation)
2  01/01/2020    UBS B     200
```

## Requirements

- Python >= 3.8  
- pandas >= 1.3.0  
- numpy >= 1.21.0  
- scikit-learn >= 1.0.0


## Project Structure

```
imputer/                           ─ Wrapper for the modules
├──  data_imputer_apsus/
├    ├── __init__.py               ─ Package initialization
├    ├── imputer.py                ─ Entrypoint impute_dataframe
├    ├── src/
├    │  ├── analysis/
├    │  │  └── metrics.py          ─ Performance evaluation metrics
├    │  ├── features/
├    │  │  ├── encode.py           ─ Categorical encoding & feature generation
├    │  │  └── normalize.py        ─ Data normalization utilities
├    │  └── models/
├    │     ├── random_forest.py    ─ Random Forest imputer implementation
├    │     └── mice.py             ─ MICE imputer
├──  example_usage_local.py        ─ Local usage example script
├──  data_imputation.ipynb         ─ Jupyter notebook exploration
├──  pyproject.toml                ─ Project configuration
├──  LICENSE                       ─ License file
├──  README.md                     ─ This file
```


## License

This project is licensed under the MIT License — see the LICENSE file for details.

## Author

Developed by Lucas Emanoel for the SmartAPSUS project.
agrodigital-io 0.1.2
Python SDK for agrodigital.io.
Requires Python: >=3.10

# AgroDigital Python SDK

[![PyPI version](https://img.shields.io/pypi/v/agrodigital_io.svg)](https://pypi.org/project/agrodigital_io/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A modern, easy-to-use Python SDK for interacting with the [agrodigital.io](https://agrodigital.io) API. This library provides a high-level interface to manage agricultural entities, IoT data, meteorological stations, and satellite imagery analysis.

## Features

- **Entity Management**: CRUD operations for Farms, Fields, Polygons, and Crops.
- **Monitoring & Data**: Specialized access to Raster imagery, indexes, and Google Earth Engine clusters.
- **IoT & Meteo**: Seamless integration with IoT stations and meteorological data.
- **Operations Logs**: Track sowing, applications, and logs.
- **Scouting**: Manage bugs, weeds, and diseases via waypoints.
- **Object-Oriented**: All API responses are converted into Python objects with dot-notation access.

## Installation

You can install the SDK via `pip`:

```bash
pip install agrodigital_io
```

Or using `poetry`:

```bash
poetry add agrodigital_io
```

## Quick Start

### Authentication

To begin, initialize the `AgroDigitalClient` using either your API token or your username and password.

```python
from agrodigital_io import AgroDigitalClient

# Option 1: Using an API Token
client = AgroDigitalClient(token="your_api_token_here")

# Option 2: Using Credentials
client = AgroDigitalClient(username="your_username", password="your_password")
```

### Basic Operations

#### List all farms
```python
farms = client.farms.list()
for farm in farms:
    print(f"Farm: {farm.name} (ID: {farm.id})")
```

#### Get field data
```python
field = client.fields.retrieve(id=123)
print(f"Field name: {field.name}")
print(f"Associated crop: {field.crop.name}") # Nested objects supported
```

#### Fetch IoT Data
```python
# Get data from a specific station between dates
data = client.iot_data.list_data(
    station_id=45, 
    from_date="2023-01-01", 
    to_date="2023-01-07",
    variables=["temperature", "humidity"]
)
```

## Advanced Usage

### Raster and Imagery
Access satellite imagery metadata and available dates for specific polygons.

```python
dates = client.rasters.available_dates()
print(f"Available imagery dates: {dates}")
```

### Cluster Retrieval
Fetch Google Earth Engine or local clusters for a specific polygon and date range.

```python
clusters = client.cluster.ee_retrieve(
    from_date="2023-01-01",
    to_date="2023-12-31",
    polygon_id="poly_88",
    n_clusters=5
)
```

### Error Handling
The SDK raises `AgroDigitalError` for API-related issues, including connection timeouts and non-200 status codes.

```python
from agrodigital_io import AgroDigitalError

try:
    client.fields.retrieve(999999)
except AgroDigitalError as e:
    print(f"Error: {e.message}")
    print(f"Status Code: {e.status_code}")
```

## Requirements

- Python >= 3.10
- `requests` library

## License

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