semvec/pypi-packages huggingface dataset:
ewha-parking 0.1.5
Analyze frequent and illegal parking patterns using trajectory and GIS data
Requires Python: >=3.9

# ewha-parking

A Python module for detecting **Frequent Parking** spots from CCTV trajectory data  
and identifying **Illegal Parking** events using GIS layers.

---

## How to use

```python
from ewha_parking.frequent_parking import FrequentParking
from ewha_parking.illegal_parking import IllegalParking

# df: trajectory data (required fields: snr_id, traj_id, dtct_dt, lon/lat or geometry)
# road_df: road data (required fields: CCTV_ID, ufid, geometry)

# frequent parking
frequent_result = FrequentParking(df.copy(), road_df).call()

# illegal parking
illegal_parking = IllegalParking(
    zip_path="data/illegal_parking.zip",          # ZIP archive containing SHP files
    extract_dir="data/illegal_parking_extracted"  # Directory to extract SHP files
)
illegal_result = illegal_parking.call(frequent_result)

```

## Output

- **FrequentParking result**
  - Columns: `CCTV_ID`, `time`, `Geometry`, `Leaving_time`, `Traj_ID`, `Duration`, `ufid`

- **IllegalParking result**
  - Subset of the above events flagged as illegal
  - Rules:
    - ≥ 5 minutes: within custom_area, yellow solid line, yellow dashed line, etc.
    - ≥ 1 minute: within crosswalk, sidewalk, yellow double line (excluding custom_area)


## Requirements
pandas, numpy, geopandas, shapely

> All SHP layers are assumed to use EPSG:4326 (WGS84).
> If your data uses a different CRS, please reproject it before analysis.

## License
This project is licensed under JiwonKim License.

## Contact
kimjiwon4007@ewha.ac.kr
types-pyluach 2.3.0.20250911
Typing stubs for pyluach
Requires Python: >=3.9

## Typing stubs for pyluach

This is a [type stub package](https://typing.python.org/en/latest/tutorials/external_libraries.html)
for the [`pyluach`](https://github.com/simlist/pyluach) package. It can be used by type checkers
to check code that uses `pyluach`. This version of
`types-pyluach` aims to provide accurate annotations for
`pyluach==2.3.*`.

This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/pyluach`](https://github.com/python/typeshed/tree/main/stubs/pyluach)
directory.

This package was tested with the following type checkers:
* [mypy](https://github.com/python/mypy/) 1.17.1
* [pyright](https://github.com/microsoft/pyright) 1.1.405

It was generated from typeshed commit
[`d9c76e1d9f0c0000c1971c3e936a69dd55f49ce1`](https://github.com/python/typeshed/commit/d9c76e1d9f0c0000c1971c3e936a69dd55f49ce1).
bitllama 1.0.1
Python SDK for BitLlama Protocol
Requires Python: >=3.9

# BitLlama Python SDK

<div align="center">
  <img src="https://raw.githubusercontent.com/samthedataman/bitllama/main/assets/logo.png" alt="BitLlama Logo" width="150" height="150" />
  
  <h3>Official Python SDK for the BitLlama Protocol</h3>
  
  <img src="https://img.shields.io/pypi/v/bitllama.svg" />
  <img src="https://img.shields.io/badge/python-%3E%3D3.9-blue.svg" />
  <img src="https://img.shields.io/badge/license-MIT-green.svg" />
</div>

## Installation

```bash
pip install bitllama
```

## Quick Start

```python
from bitllama import BitLlama, MiningClient
import asyncio

async def main():
    # Initialize client
    client = BitLlama(
        coordinator_url="https://api.bitllama.ai",
        private_key="your_private_key",
        network="base-mainnet"
    )
    
    # Create inference request
    response = await client.i
    nference.create(
        model="llama3:70b",
        prompt="Explain quantum computing",
        max_tokens=500
    )
    print(response.text)

asyncio.run(main())
```

## Mining

```python
# Initialize mining client
miner = MiningClient(
    client=client,
    model_provider="ollama",
    model_name="llama3:70b"
)

# Start mining
await miner.start()

# Check status
status = await miner.get_status()
print(f"Jobs completed: {status.jobs_completed}")
print(f"Earnings: {status.total_earnings} BLMA")

# Stop mining
await miner.stop()
```

## Documentation

## Links

- **PyPI Package**: [https://pypi.org/project/bitllama/](https://pypi.org/project/bitllama/)
- **GitHub**: [https://github.com/samthedataman/bitllama/tree/main/packages/python-sdk](https://github.com/samthedataman/bitllama/tree/main/packages/python-sdk)
- **Documentation**: [https://docs.bitllama.ai/python-sdk](https://docs.bitllama.ai/python-sdk)
nireports 25.3.0
NiReports - The Visual Report System (VRS) of NiPreps
Requires Python: >=3.10


.. image:: https://img.shields.io/pypi/v/nireports.svg
  :target: https://pypi.python.org/pypi/nireports/
  :alt: Latest Version
.. image:: https://img.shields.io/badge/License-Apache_2.0-blue.svg
  :target: https://github.com/nipreps/eddymotion/blob/main/LICENSE
  :alt: License
.. image:: https://readthedocs.org/projects/nireports/badge/?version=latest
  :target: https://nireports.readthedocs.io/en/latest/?badge=latest
  :alt: Documentation Status
.. image:: https://circleci.com/gh/nipreps/nireports/tree/main.svg?style=shield
  :target: https://circleci.com/gh/nipreps/nireports/tree/main
  :alt: Testing
.. image:: https://github.com/nipreps/nireports/actions/workflows/build_test_deploy.yml/badge.svg
  :target: https://github.com/nipreps/nireports/actions/workflows/build_test_deploy.yml
  :alt: Build-Test-Deploy
.. image:: https://codecov.io/gh/nipreps/nireports/branch/main/graph/badge.svg?token=OPH6D32GWN
  :target: https://codecov.io/gh/nipreps/nireports

*NiReports*: the *NiPreps*' reporting and visualization tools
=============================================================

*NiReports* contains the two main components of the *visual reporting system* of *NiPreps*:

* **Reportlets**: visualizations for assessing the quality of a particular processing step within the neuroimaging pipeline.
  Typically, reportlets show brain mosaics perhaps with contours and/or segmentations.
  They can be *dynamic* and flicker between two different *states* to help assess the accuracy of image registrations.
  However, the reportlets are not limited to brain mosaics, and can contain correlation plots, BOLD fMRI *carpetplots*, etc.
* **Assembler**: end-user *NiPreps* write out reportlets to a predetermined folder, which is then queried by the assembler using *PyBIDS*.
  The assembler follows a *report specification* in YAML format, which states the query to find specific reportlets and their corresponding metadata and text annotations.
  As a result, one HTML file with a concatenation of reportlets is produced.
moviespac 0.0.1
SDK Python pour accéder à l’API MovieLens
Requires Python: >=3.10

# MovieLens SDK - `moviespac`

Un SDK Python simple pour interagir avec l’API REST **MovieLens**.  
Il est conçu pour les **Data Analysts** et **Data Scientists**, avec une prise en charge native de :

- **Objets Pydantic**
- **Dictionnaires JSON**
- **DataFrames Pandas**

[![PyPI version](https://badge.fury.io/py/moviespac.svg)](https://badge.fury.io/py/moviespac)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

---

## Installation

```bash
pip install moviespac
```

---

## Configuration

```python
from moviespac import MovieClient, MovieConfig

# Configuration avec l’URL de votre API (Render ou locale)
config = MovieConfig(movie_base_url="https://film-api-3i06.onrender.com")
client = MovieClient(config=config)
```

---

## Tester le SDK

### 1. Health check

```python
client.health_check()
# {"message": "API MovieLens opérationnelle"}
```

### 2. Récupérer un film

```python
movie = client.get_movie(1)
print(movie.title)
```

### 3. Liste de films au format DataFrame

```python
df = client.list_movies(limit=5, output_format="pandas")
print(df.head())
```

---

## Modes de sortie disponibles

Toutes les méthodes de liste (`list_movies`, `list_ratings`, etc.) peuvent retourner trois types de formats :

- des objets **Pydantic** (défaut)
- des **dictionnaires**
- des **DataFrames Pandas**

Exemple :

```python
client.list_movies(limit=10, output_format="dict")
client.list_ratings(limit=10, output_format="pandas")
```

---

## Tester en local

Vous pouvez aussi utiliser une API locale :

```python
config = MovieConfig(movie_base_url="http://localhost:8000")
client = MovieClient(config=config)
```

---

## Public cible

- Data Analysts
- Data Scientists
- Étudiants et curieux en Data
- Développeurs Python

---

## Liens utiles

- API Render : [https://film-api-3i06.onrender.com](https://film-api-3i06.onrender.com)
- PyPI : [https://pypi.org/project/moviespac](https://pypi.org/project/moviespac)# MovieLens SDK - `moviespac`

---

## Licence

MIT License – libre pour usage éducatif et expérimental.
rol-python 2025.9.10.dev1712
Python interface to the Rapid Optimization Library (ROL)
Requires Python: >=3.8

# Rapid Optimization Library (ROL)

![Rapid Optimization Library](https://raw.githubusercontent.com/sandialabs/rol/refs/heads/develop/rol.png)

**ROL** (as in rock and _roll_) is a high-performance C++ library for numerical optimization.
ROL brings an extensive collection of state-of-the-art optimization algorithms to virtually
any application. Its programming interface supports any computational hardware, including
heterogeneous many-core systems with digital and analog accelerators. ROL has been used with
great success for optimal control, optimal design, inverse problems, image processing and
mesh optimization, in application areas including geophysics, structural dynamics, fluid
dynamics, electromagnetics, quantum computing, hypersonics and geospatial imaging.

For additional details, see [https://rol.sandia.gov](https://rol.sandia.gov).

Feature highlights:

1. Vector abstractions and matrix-free interface for universal applicability
2. Modern algorithms for unconstrained and constrained optimization
3. Easy-to-use methods for stochastic and risk-aware optimization
4. Fast and robust algorithms for nonsmooth optimization
5. Trust-region methods for inexact and adaptive computations
6. PDE-OPT application development kit for PDE-constrained optimization


## Copyright and License
See COPYRIGHT and LICENSE.


## Questions?
Contact team or developers:

* ROL Team     (GitHub handle: @sandialabs/rol)
* Drew Kouri   (GitHub handle: [dpkouri](https://github.com/dpkouri) or dpkouri@sandia.gov)
* Denis Ridzal (GitHub handle: [dridzal](https://github.com/dridzal) or dridzal@sandia.gov)