semvec/pypi-packages huggingface dataset:
emodpy 3.1.1
Core tools for modeling using EMOD
Requires Python: >=3.10
Keywords: modeling, IDM

# emodpy

[![Build docs and deploy to GH Pages](https://github.com/EMOD-Hub/emodpy/actions/workflows/mkdocs_deploy.yml/badge.svg)](https://github.com/EMOD-Hub/emodpy/actions/workflows/mkdocs_deploy.yml)
[![Lint](https://github.com/EMOD-Hub/emodpy/actions/workflows/lint.yml/badge.svg)](https://github.com/EMOD-Hub/emodpy/actions/workflows/lint.yml)
[![Test and update version](https://github.com/EMOD-Hub/emodpy/actions/workflows/test_and_bump_version.yml/badge.svg)](https://github.com/EMOD-Hub/emodpy/actions/workflows/test_and_bump_version.yml)

## Python Version

Python 3.13 is the recommended and supported version.

## Documentation

Documentation available at https://emod-hub.github.io/emodpy/.

To build the documentation locally, do the following:

1. Create and activate a venv.
2. Navigate to the root directory of the repo.
    ```
    python -m pip install .[docs]
    ```

## Running tests

Please see the documentation for [testing](/tests/README.md).

## Community
The EMOD Community is made up of researchers and software developers, primarily focused on malaria and HIV research.
We value mutual respect, openness, and a collaborative spirit. If these values resonate with you, we invite you to join our EMOD Slack Community by completing this form:

https://forms.office.com/r/sjncGvBjvZ


## Disclaimer

The code in this repository was developed by IDM and other collaborators to support our joint research on flexible agent-based modeling.
We've made it publicly available under the MIT License to provide others with a better understanding of our research and an opportunity to build upon it for their own work. We make no representations that the code works as intended or that we will provide support, address issues that are found, or accept pull requests.
You are welcome to create your own fork and modify the code to suit your own modeling needs as permitted under the MIT License.
jamldump 1.2.1
Opinionated YAML dump function for JSON serializable content.
Requires Python: <4.0,>=3.10

# JAMLDUMP

This library provides a `to_jaml` function that serializes JSON-serializable data in an arguably more readable YAML compatible fashion.
The format chosen is supposed to be reproducible while avoiding the Norway-problem and it's cousins.
We believe, this makes it useful for repeatedly templating the same (YAML) configuration files with the least expected surprise.

Notable features:
* Dictionary keys need to be strings.
* String values are _always_ quoted (see Norway problem or versions decoded as numbers).
* Indentation is always 2 spaces.
* With `level` and `embed_in`, you can template a branch of a larger Yaml document.
* When `jinja2` is installed, a jinja2 filter is available.

For example usage, please take a look at the tests.

## Versioning

This library follows SemVer.
Its test suite specifies what is covered.

## Development

This project is a case study for _test driven development_.
rmc75e 0.2.0
EtherNet/IP explicit messaging client for Delta RMC75E motion controllers
Requires Python: >=3.7

# rmc75e

EtherNet/IP explicit messaging client for Delta RMC75E motion controllers.

Provides register read/write access via the RMC's Register Map Object (class 0xC0), using service codes 0x4B/0x4C with LSB-first byte order. Equivalent to RMCLink's `readFloat`/`writeFloat` functionality.

Built on top of [EIPScanner](https://github.com/nimbuscontrols/EIPScanner) with Python bindings via [pybind11](https://github.com/pybind/pybind11).

## Installation

### From wheel

```bash
pip install rmc75e
```

### From source

#### Linux

```bash
./setup_project_linux.sh
```

#### Windows

Run from **Developer PowerShell for VS**:

```powershell
.\setup_project_windows.ps1
```

## Quick Start

```python
from rmc75e import RMC75EClient

client = RMC75EClient("192.168.17.200")
client.connect()

# Read float registers (file 57, element 30, count 2)
values = client.read_float(57, 30, 2)
print(values)  # [1.0, 2.5]

# Write float register
client.write_float(57, 33, [3.14])

# Read integer registers
values = client.read_int32(57, 32, 1)

client.disconnect()
```

## API

### `RMC75EClient(plc_address, port=44818)`

Create a new client for an RMC75E controller.

- **`connect()`** - Open an EtherNet/IP session
- **`disconnect()`** - Close the session
- **`is_connected()`** - Check connection status
- **`read_float(file, element, count)`** - Read 32-bit float registers
- **`write_float(file, element, values)`** - Write 32-bit float registers
- **`read_int32(file, element, count)`** - Read 32-bit integer registers
- **`write_int32(file, element, values)`** - Write 32-bit integer registers
- **`send_raw_request(service, data)`** - Send a raw CIP request

## Requirements

- Python >= 3.7
- CMake >= 3.14
- C++17 compiler (GCC on Linux, MSVC on Windows)

## License

MIT
radiotomate 0.1.0
Broadcast automation for community radios
Requires Python: <4,>=3.13

<!--
SPDX-FileCopyrightText: 2026 Martin Kirchgessner

SPDX-License-Identifier: AGPL-3.0-or-later
-->

# 📻 Radiotomate 🍅

Radiotomate is a free and accessible broadcast automation system designed for community radios. It allows you to quickly start streaming from your music library, pre-recorded shows or external streams, even on a (virtual) machine with low resources. 

Please find more information in its documentation on [radiotomate.org](https://radiotomate.org/)
doitlive 5.2.1
Because sometimes you need to do it live.
Requires Python: >=3.10
Keywords: doitlive, cli, live, coding, presentations, shell

========
doitlive
========

|homebrew| |build-status| |pypi|


.. |homebrew| image:: https://badgen.net/homebrew/v/doitlive
  :alt: homebrew badge
  :target: https://github.com/Homebrew/homebrew-core/blob/master/Formula/d/doitlive.rb
.. |build-status| image:: https://github.com/sloria/doitlive/actions/workflows/build-release.yml/badge.svg
  :alt: build status
  :target: https://github.com/sloria/doitlive/actions/workflows/build-release.yml
.. |pypi| image:: https://badgen.net/pypi/v/doitlive
  :alt: pypi badge
  :target: https://pypi.org/project/doitlive/

`doitlive` is a tool for live presentations in the terminal. It reads a file of shell commands and replays the commands in a fake terminal session as you type random characters.

.. image:: https://user-images.githubusercontent.com/2379650/31386572-2e2b9d14-ad95-11e7-9be5-fcc5ed09f0e8.gif
    :alt: Demo
    :target: http://doitlive.readthedocs.io


Get it now
----------

macOS with `Homebrew <http://brew.sh/>`_:
*****************************************

.. code-block:: console

    $ brew update
    $ brew install doitlive

With pip:
*********

.. code-block:: console

    $ pip install doitlive

Quickstart
----------

1. Create a file called ``session.sh``. Fill it with bash commands.
2. Run ``doitlive play session.sh``.

.. code-block:: console

    $ doitlive play session.sh


3. Type like a madman.


More at https://doitlive.readthedocs.io
---------------------------------------

Project Links
-------------

- Docs: https://doitlive.readthedocs.io/
- Changelog: https://doitlive.readthedocs.io/en/latest/changelog.html
- PyPI: https://pypi.python.org/pypi/doitlive
- Issues: https://github.com/sloria/doitlive/issues

Kudos
-----

- Idea came from Jordi Gutiérrez Hermoso's `"Revsets" talk <https://www.youtube.com/watch?list=PLLj6w0Thbv02lEXIDVO46kotA_tv_8_us&feature=player_detailpage&v=NSLvERZQSok#t=978>`_  at PyCon 2014.
- Armin Ronacher's `click <http://click.pocoo.org/>`_ library  made this quick to implement.
- Themes inspired by Sorin Ionescu's `prezto <https://github.com/sorin-ionescu/prezto>`_ zsh themes.
- Hat tip to related projects `HackerTyper <http://hackertyper.com/>`_ and `PlayerPiano <http://i.wearpants.org/blog/playerpiano-amaze-your-friends/>`_


License
-------

MIT licensed. See the bundled `LICENSE <https://github.com/sloria/doitlive/blob/master/LICENSE>`_ file for more details.
hypothesis 6.151.9
The property-based testing library for Python
Requires Python: >=3.10
Keywords: python, testing, fuzzing, property-based-testing

<div align="center">
  <img src="https://raw.githubusercontent.com/HypothesisWorks/hypothesis/master/brand/dragonfly-rainbow.svg" width="300">
</div>

# Hypothesis

* [Website](https://hypothesis.works/)
* [Documentation](https://hypothesis.readthedocs.io/en/latest/)
* [Source code](https://github.com/hypothesisWorks/hypothesis/)
* [Contributing](https://github.com/HypothesisWorks/hypothesis/blob/master/CONTRIBUTING.rst)
* [Community](https://hypothesis.readthedocs.io/en/latest/community.html)

Hypothesis is the property-based testing library for Python. With Hypothesis, you write tests which should pass for all inputs in whatever range you describe, and let Hypothesis randomly choose which of those inputs to check - including edge cases you might not have thought about. For example:

```python
from hypothesis import given, strategies as st


@given(st.lists(st.integers()))
def test_matches_builtin(ls):
    assert sorted(ls) == my_sort(ls)
```

This randomized testing can catch bugs and edge cases that you didn't think of and wouldn't have found. In addition, when Hypothesis does find a bug, it doesn't just report any failing example — it reports the simplest possible one. This makes property-based tests a powerful tool for debugging, as well as testing.

For instance,

```python
def my_sort(ls):
    return sorted(set(ls))
```

fails with the simplest possible failing example:

```
Falsifying example: test_matches_builtin(ls=[0, 0])
```

### Installation

To install Hypothesis:

```
pip install hypothesis
```

There are also [optional extras available](https://hypothesis.readthedocs.io/en/latest/extras.html).
hackatimeprogressbar 0.1.6
Display your set goal for Hackclub's Wakatime fork

# Hackatime Progress Bar
Hackatime progress bar lives in the corner of your screen constantly reminding you about your goal and how you should work on it!

Works on windows and linux (might work on mac?)

It is fully configurable, set your own goal and title. 

## Config
Default Config:
```json
{
 "hackatime_token": "00000000-0000-0000-0000-000000000000",
 "username": "jan",
 "daily_goal": 5,
 "goal": "no goal :(, Set one in config"
}
```
> Make sure to Set your hackatime token and username to track!

## Installation

Installation is easy just use pip!

```commandline
pip install hackatimeprogressbar
```

and run with
```commandline
hackatimeprogressbar
```


## Images
![img.png](img.png)
![img_1.png](img_1.png)
nmine 3.2.3
Combines nmap output and DNS data to produce HTTP[S] URLs of interest.
Requires Python: >=3.7

# nmine

nmine searches files for substrings that appear to be valid DNS names. It
resolves them and outputs the result if the address it resolves to is of
interest.

A possible name will only be considered a valid DNS name if it ends with a
known TLD (see the -t and -T options).  If the -s option is also specified,
then a possible name must also end with one of the strings specified with
that option.

# Examples / Description

Let's say you have some arbitrary file (or directories of files) containing
DNS names of some sort:

```
> ls
blah.txt
> cat blah.txt 
nothing 
The quick brown fox yahoo.com jumps over the lazy dog. hurricanelabs.com]
Lorem ipsum dolor sit amet, ex wisi elitr eruditi pro.   129831; asdf
google.com!zzzhomero has ei
;sad0uf23 www.github.com 090
```

You're interested in any names which resolve to any address in 192.0.0.0/8.
You put this in a file called "SCOPE" (or any file specified with the -i
option):

```
>> cat > SCOPE
192.0.0.0/8
```

You then run nmine while in the above directory, and any names resolving to
your network(s) of interest are output:

```
> nmine
hurricanelabs.com.                       600 IN A 192.230.81.48
www.github.com.                          600 IN A 192.30.253.112
```

# Options

* -i (filename): Name of a file containing IPv4 networks of interest.

* -n (address): Name or address of a DNS server to send all queries to.

* -f hosts|zone: Output format. "zone" is like BIND zone files or dig
output.  "hosts" is like /etc/hosts.

* -t (TLD): Specify additional TLDs to consider valid. May be specified
multiple times.

* -T: Do NOT automatically consider IANA TLDs valid. The only TLDs
considered valid will be those specified with -t.

* -s: Only consider names with this ending to be valid names at all. May be
specified multiple times.

# Copyright and License

Copyright (C) 2026 Steve Benson

nmine is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

nmine is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
details.

You should have received a copy of the GNU General Public License along with
this program; see the file LICENSE.  If not, see <http://www.gnu.org/licenses/>.
gnu-autoconf-dash-docset-generator 2026.2.16
Dash docset generator for GNU Autoconf
Requires Python: >=3.10

Dash docset generator for
[GNU Autoconf](https://www.gnu.org/savannah-checkouts/gnu/autoconf/autoconf.html)

### Instructions

- Download the pre-built documentation 
[](https://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/autoconf-2.72/index.html)
    - Download the manual titled "HTML compressed ... - with one web page per node."

- `gnu-autoconf-dash-docset-generator MANUAL_SOURCE`
    - `GNU_Autoconf.docset` will be generated in the current working directory
    (or a specified builddir if `-b` was passed)
    - If `pipx` is installed, you can avoid `pip install`ing anything and just
    run `pipx run gnu-autoconf-dash-docset-generator MANUAL_SOURCE`
    - `MANUAL_SOURCE` will be the path to the html sources, after extracting
    from the gzipped tar file they are distributed in
    - For a full set of options: `gnu-libc-dash-docset-generator -h`