semvec/pypi-packages huggingface dataset:
tcx2ics 0.1.0
Generate ICS calendar events from TCX workout files
Requires Python: <4.0,>=3.12

# tcx2ics

Convert a `.tcx` activity file (from Garmin, Strava, etC.) into a single `.ics`
calendar event with basic workout Statistics.

The calendar event contains:
- start and end time of the activity
- sport type
- total duration
- total distance


## 📦 Installation

### pip

Install tcx2ics with pip:

```sh
pip install tcx2ics
```

## 🚀 Examples

### Basic example

```python
from tcx2ics import Tcx2Ics
Tcx2Ics().convert("15.tcx", "workout.ics")
```

## 🔑 License

This package is distributed under the MIT License. This license can be found online at <http://www.opensource.org/licenses/MIT>.

## Disclaimer

This framework is provided as-is, and there are no guarantees that it fits your purposes or that it is bug-free. Use it at your own risk!

## 🔗 Related frameworks

[1] [AST-Monitor: A wearable Raspberry Pi computer for cyclists](https://github.com/firefly-cpp/AST-Monitor)

[2] [TCXReader.jl: Julia package designed for parsing TCX files](https://github.com/firefly-cpp/TCXReader.jl)

[3] [TCXWriter: A Tiny Library for writing/creating TCX files on Arduino](https://github.com/firefly-cpp/tcxwriter)
CDC 1.1.4
Color distance calculator.
Requires Python: >=3.10

# CDC - Color Distance Calculator

CDC can be a useful tool if you want to locate objects in an image / orthomosaic with a certain color. The tool can be used to go from this input image

![Image](docs/source/_static/pumpkins_example/crop_from_orthomosaic.png)

To this output image

![Image](docs/source/_static/pumpkins_example/color_distance_crop.png)

To learn more about the tool, take a look at the tutorial.
* [Tutorial - Segment pumpkins in RGB orthomosaic](https://henrikmidtiby.github.io/CDC/tutorials/test_dataset_tutorial.html)

## Table of contents:

- [Installation](#installation)
- [Usage](#usage)
- [Documentation](#documentation)
- [Contributing](#contributing)
- [License](#license)
- [Acknowledgement](#acknowledgement)

## Installation

CDC is a python package and can be installed with pip.

```
pip install CDC
```

For more advanced installation, please visit the [Documentation](https://henrikmidtiby.github.io/CDC/) for more information.

## Usage

For a tutorial of how to use CDC on a test dataset, please see [Tutorial](https://henrikmidtiby.github.io/CDC/tutorials_guides.html).

### How to make a reference image and mask

The easiest way to make a reference image is to use your preferred GIS image tool (like [QGIS](https://www.qgis.org/)) to extract a small region from the orthomosaic. To make the mask open the reference image in an image editor and use the pen tool to mark all the desired pixels with red ((255, 0, 0) in RGB).

### Run CDC

To run CDC on an orthomosaic, run the following in a terminal window:

```
CDC path/to/orthomosaic path/to/reference_image path/to/mask_image
```

Run `CDC --help` for more information or see the [Documentation](https://henrikmidtiby.github.io/CDC/).

## Documentation

For a full list of command line arguments see [CLI](https://henrikmidtiby.github.io/CDC/CLI.html). For a reference manual, please visit [Reference Manual](https://henrikmidtiby.github.io/CDC/reference.html)

## Contributing

For contribution guidelines, please see the [Documentation](https://henrikmidtiby.github.io/CDC/contributing.html).

## License

The software is licensed under the BSD-3-Clause license, see [License](LICENSE).

## Acknowledgement

the CDC tool was developed by SDU UAS Center as part of the project Præcisionsfrøavl, that was supported by the [Green Development and Demonstration Programme (GUDP)](https://gudp.lbst.dk/) and [Frøafgiftsfonden](https://froeafgiftsfonden.dk/) both from Denmark.
django-logikal 4.0.0
Django utilities used at Logikal
Requires Python: ~=3.12
Keywords: python, django

django-logikal
==============
Django utilities used at Logikal.

Getting Started
---------------
You can find the project documentation under `docs.logikal.io/django-logikal/
<https://docs.logikal.io/django-logikal/>`_.
swh.loader.bzr 1.4.7
Software Heritage Bazaar/Breezy loader
Requires Python: >=3.9

Software Heritage - Bazaar/Breezy loader
========================================

Loader for `Bazaar <http://bazaar.canonical.com/en/>`_ and `Breezy
<https://www.breezy-vcs.org/>`_ repositories. Breezy is a friendly fork of Bazaar that
supports the Bazaar file format and network protocol.
generic-inspection 0.1.0
Utilities for generic type inspection in Python.
Requires Python: >=3.10

# generic-inspection

Utilities for generic type inspection.
Supports Python 3.10+.

## Inferring specialised type arguments

Consider the following code:

```python
from typing import Generic, TypeVar

InputT = TypeVar("InputT")
OutputT = TypeVar("OutputT")

class Machine(Generic[InputT, OutputT]):
    pass

class TextMachine(Machine[InputT, str]):
    pass

class NumberTextMachine(TextMachine[float]):
    pass
```

We can infer the specialised type arguments of a subclass
with respect to the class type parameters of a particular base class
using the `infer_generic_args` function.

```pycon
>>> from generic_inspection import infer_generic_args
>>> infer_generic_args(Machine, NumberTextMachine)
(<class 'float'>, <class 'str'>)
```

The results here tell us that `InputT` is `float` and `OutputT` is `str`.

## Development environment

```bash
# Set up the virtual environment.
uv sync --frozen --all-groups
# Run tests.
just test
```

### Release process

The release process is automatic after pushing a semver tag to main.

```bash
# Ensure that the correct version number is in pyproject.toml.
head pyproject.toml
# Create the tag.
git tag -a v0.1.0 -m "Release v0.1.0"
# Push the tag.
git push --tags
# Check GitHub Actions and PyPI to verify successful publication.
```

## Similar projects

- https://github.com/Hochfrequenz/python-generics

## License

```
Copyright 2026 Aiden Nibali

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```
neurgrid-ven 0.1.0
NeurGrid VEN Client - Python bindings for OpenADR-based demand response
Requires Python: >=3.8
Keywords: openadr, demand-response, energy, ven, smart-grid

# NeurGrid VEN Client

Python bindings for the NeurGrid VEN (Virtual End Node) Client library.

## Installation

```bash
pip install neurgrid-ven
```

## Quick Start

```python
import asyncio
from neurgrid_ven import create_client, ClientConfig

async def main():
    # Create configuration
    config = ClientConfig(
        base_url="https://api.neurgrid.com",
        client_id="your-client-id",
        client_secret="your-client-secret",
    )
    
    # Create client
    client = create_client(config)
    
    # Get programs
    programs = await client.get_programs()
    for program in programs:
        print(f"Program: {program.program_name}")
    
    # Get events
    events = await client.get_events(None)
    for event in events:
        print(f"Event: {event.event_name}, State: {event.state}")

if __name__ == "__main__":
    asyncio.run(main())
```

## Features

- **Authentication**: OAuth2 Client Credentials flow
- **Programs API**: List and retrieve demand response programs
- **Events API**: List, retrieve, and filter events
- **Reports API**: Submit and retrieve reports
- **MQTT**: Subscribe to real-time event and program notifications

## API Reference

### Configuration

```python
from neurgrid_ven import ClientConfig, MqttConfig

# Basic configuration
config = ClientConfig(
    base_url="https://api.neurgrid.com",
    client_id="your-client-id",
    client_secret="your-client-secret",
)

# With MQTT
mqtt_config = MqttConfig(
    broker_url="mqtt://broker.neurgrid.com:1883",
    username="mqtt-user",
    password="mqtt-pass",
)
config = ClientConfig(
    base_url="https://api.neurgrid.com",
    client_id="your-client-id",
    client_secret="your-client-secret",
    mqtt=mqtt_config,
)
```

### Client Methods

```python
client = create_client(config)

# Programs
programs = await client.get_programs()
program = await client.get_program("program-id")

# Events
events = await client.get_events(None)  # All events
events = await client.get_events(EventFilter(program_id="program-id"))
event = await client.get_event("event-id")

# Reports
report = await client.submit_report(ReportRequest(...))
reports = await client.get_reports(None)
report = await client.get_report("report-id")
```

## Requirements

- Python >= 3.8
- Rust toolchain (for building from source)

## License

MIT License
lccalib 0.0.3
SNe calibration package for the Lemaitre pipeline
Requires Python: >=3.8

# lccalib

[![PyPI - Version](https://img.shields.io/pypi/v/lccalib.svg)](https://pypi.org/project/lccalib)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/lccalib.svg)](https://pypi.org/project/lccalib)

-----

## Installation

```console
pip install lccalib
```

## Usage

Have a look at the demo scripts in the `tests` subfolder. 

## Authors and acknowledgment

TBD generic statement about Lemaitre acknowledgment policy.
societal-costs-pipeline-2026-02-04-1100 0.1.0
Societal costs pipeline CLI.
Requires Python: >=3.9

# societal_costs

Workspace for the societal costs study.

## Crates

- `crates/costs_core` — core domain types, aggregation, pricing, and validation.
- `crates/costs_models` — two-part, Tweedie, and log-normal models + selection tools.
- `crates/costs_matching` — matching + balance diagnostics.
- `crates/costs_cohort` — cohort assignment + diagnostics.
- `crates/costs_components` — register-derived component builders (LMDB volume so far).
- `crates/costs_pipeline` — configuration, orchestration, and report outputs.

## LMDB example

See `crates/costs_pipeline/README.md` for the LMDB ingestion example.

## Pipeline config

Start from `pipeline.example.toml` and update the register file paths to match
your local dataset layout. Most SAS7BDAT paths accept either a single file
or a directory (all `.sas7bdat` files are loaded, sorted by name). You can
also set `base_path` in the config to prefix all relative register paths.
If you use contact-based SCD classification, set
`components.lpr.scd_inpatient_contact_types` (or flip
`components.lpr.scd_allow_outpatient = true` to allow outpatient contacts).

Pipeline outputs include consolidated QC under `qc_summary.csv/json`, plus
step-specific outputs such as `lpr_episode_qc.csv`, `matching_outcome_qc.csv`,
`matching_parent_qc.csv`, and `population_public_stats.csv`.

For terminal progress and timing, set:
- `pipeline.progress = true`
- `pipeline.log_level = "info"` (or `debug`)

## Additional docs

- `crates/costs_core/README.md` — core domain and aggregation usage.
- `crates/costs_models/README.md` — model APIs and examples.
- `crates/costs_models/examples/README.md` — runnable model examples.
- `crates/costs_components/README.md` — LMDB note (missing price fields).
- `crates/costs_pipeline/README.md` — pipeline usage and LMDB example.
enos_scalewayinstances 0.2.0
EnOSlib provider for Scaleway Instances
Requires Python: >=3.10

# Enoslib ScalewayInstances plugin

## Installation

Some functionnalities (enabling IPv6) requires the user to have the scaleway cli installed, see: [section](#recommendations).

Deployed on PyPI:

```bash
pip install enos_scalewayinstances
```

Checkout [example](./docs/examples/deploy_expose_port.py)

## Rationale

This ScalewayInstances provider is quite opiniated, it deploys scaleway instances according to two different 'architectures', which are different ways to organize your instances:

### "private_network" architecture

It is configured to deploy a number of configured nodes defined by the user in the configuration and then put all those instances in a private network with a public gateway.

Unless you request public IPs with the `dynamic_ip_required` parameter, your instances will not be available to outside providers or users. If you want to expose certain services, you can forward ports from your instances to the public gateway (see the [example](./docs/examples/deploy_expose_port.py))

### "standalone" architecture

This will just deploy instances with public addresses and no private network/gateway setup. 

You can setup firework with the `open_firewall` function.

## Zone non-support

Support for setting zone and regions of your instances is not available in this provider for the moment, zones and regions will default to the defaults of your configuration.

## Recommendations 

Install the scaleway CLI as it is a good tool to check your running instances or parse information

https://www.scaleway.com/fr/cli/

### Useful commands 

#### Check running instances 
```bash
scw instance server list 
# With specifying zone 
scw instance server list zone="fr-par-1"
```

#### Terminate a running instances 
```bash
scw instance server terminate <INSTANCE_ID>
```

#### List existing public gateways
```bash
scw vpc-gw gateway list
```

#### Delete existing public gateway
```bash
scw vpc-gw gateway delete <NETWORK_ID>
```

#### List existing private networks
```bash
scw vpc private-network list
```

#### Delete existing private network
```bash
scw vpc private-network delete <NETWORK_ID>
```

#### List available commercial types
```bash
scw instance server-type list 
```

#### List available OS images
```bash
scw marketplace image list
```

#### SSH to a machine in a private network 

Since the public gateway deployed on the private network has [bation](https://www.scaleway.com/en/docs/public-gateways/how-to/use-ssh-bastion/) activated, the command to connect to a instance behind the bastion looks like this: 

```bash
ssh -J bastion@<gateway_IP_address>:61000 root@<instance_IP_address>
```

Where `<instance_IP_address>` is either the instance's public IP address or its private alias in the form of : `<instance_name>.<private_network_name>.internal`.

## Future improvements

- [ ] Improve IPv6 handling
- [ ] Improve volume handling, e.g. add options to set volume size 
- [ ] Improve zone / region support
pyPhasesRecordloader 0.11.6
Adds a record loaders to the pyPhases package
Requires Python: >=3.5

# RecordLoader Extension for pyPhases

This package extends pyPhases with the ability to load generic records from a dataset. This package properly requires another more specific plugin to load the data.

This Extension adds:
- a normalized interface for a Signal (wraps a raw signal like numpy array): `pyPhasesRecordloader/Signal.py`
- a normalized interface for RecordSignals: `pyPhasesRecordloader/RecordSignal.py` containing a list of Signals
- an inerface to load data from datasets: `pyPhasesRecordloader/RecordLoader.py`
  - `loadRecord(recordName: str) -> RecordSignal` - check if a record exists
  - `exist(recordName: str) -> bool` - check if a record exists
  - `delete(recordName)` - delete a record
- some default Recordloader to load data itself or inherit from:
  - `EDFRecordLoader`
  - `H5RecordLoader`
  - `MatRecordLoader`
  - `WFDBRecordLoader`
  - `XMLAnnotationLoader`
- some possible ways to download data:
  - `Folderdownloader`: From a Folder
  - `HtmlDownloader`: From a Web Folder
  - `S3Downloader`: From a S3 compatible bucket storage