semvec/pypi-packages huggingface dataset:
refedez-t 0.0.5
Tool for automatizing the deployment of easy federated learning examples
Requires Python: >=3.12

<h1 align="center">ReFedEz</h1>

<p align="center">
  <img src="docs/docs/assets/refedez.png" alt="ReFedEz Logo">
</p>

**ReFedEz** 🚀 is a Python application and library designed to simplify the implementation and deployment of federated learning architectures. It provides a command-line interface (CLI) for deploying servers and clients directly in their target environments, ensuring consistency and reproducibility, and a Python library that seamlessly integrates into your machine learning code, enabling federated learning to work "like magic" with minimal modifications.

Federated learning is a powerful technique for training machine learning models across distributed data sources while maintaining privacy. ReFedEz serves as the "fast.ai of federated learning" – a beginner-friendly framework that prioritizes simplicity and rapid prototyping. It abstracts the underlying complexities, allowing researchers and developers to focus on their ML innovations rather than infrastructure challenges.

## Demo 🎥

Experience ReFedEz in action:

<script id="asciicast-demo" src="https://asciinema.org/a/demo.js" async></script>

## Features ✨

- **Simplicity**: Deploy federated learning setups with ease, and adapt it with minimal code changes.
- **Multi-Backend Support**: Works with NumPy, PyTorch and TensorFlow.
- **Reproducible**: Bit by bit reproducible, thanks to nix and uv2nix.
- **Multi-Node encrypted by default**: Self-signed TLS certificates for the communication between nodes.

## Documentation 📚

For detailed guides, API reference, and more, visit the [Documentation](docs/index.md).

## Contributing 🤝

Contributions are welcome! Please see the documentation for guidelines.

## License 📄

This project is licensed under the [MIT license](LICENSE)
cocoapp 1.0.4
Aplicación de planificación de operaciones (Forecast, CRP, MPS, MRP) con interfaz gráfica Tkinter.
Requires Python: >=3.8

# CocoApp – Herramienta de Planificación de Operaciones

CocoApp es una aplicación de escritorio desarrollada en Python con **Tkinter**, diseñada para facilitar el análisis y planificación en operaciones, incluyendo:

- ✔️ Pronóstico de ventas (Meta Prophet)
- ✔️ Cálculo CRP (Capacity Requirements Planning)
- ✔️ MPS (Master Production Schedule)
- ✔️ MRP (Material Requirements Planning)
- ✔️ Interfaz gráfica integrada con un tema visual “chocolate”
- ✔️ Importación y exportación de archivos Excel

El objetivo del proyecto es ofrecer una herramienta educativa y funcional para estudiantes y profesionales de Ingeniería Industrial.

---

## 🚀 Instalación

Antes de instalar, asegúrese de tener Python 3.8 o superior.

```bash
pip install cocoapp
wonderingpanda510 0.1.14
Add your description here
Requires Python: >=3.12

README for HW00
Update for HW01
test test test test
This project includes one function called diff.

Sep 3 2025
Update HW01
Add subpackage 'matrix' includes for function for matrix


Sep 21 2025
Update HW02
Add subpackage 'distributions' includes two function for distribution
worldview-config 0.2.2
Tooling to simplify applying custom configuration for NASA Worldview.
Requires Python: >=3.10,~=3.0

**worldview-config** is an open source project and Python package that makes maintaining
your own instance of [NASA Worldview](https://github.com/nasa-gibs/worldview) easier.

# Installation
```
pip install worldview-config
```

# Usage
This package adds the `worldview_config` CLI to your path which provides some commands:
- Keep all your layer configuration in one place and dynamically render
the full set of configuration files with `worldview_config render`.
- Only maintain your custom content - at build time, merge it into the default config
using `worldview_config merge`.  Avoid making a static copy of the default config and
becoming quickly out of date.

For an example of how to use this tool to deploy your own custom Worldview instance,
see the [ASIPS Worldview](https://github.com/asips/asips-worldview) project.

# Contributing
This project is in development and compatibility with the full feature set of NASA Worldview
is not guaranteed.  Contributions are welcome.
username-safety 0.1.1
A package to check username safety.
Requires Python: >=3.6

# Username Safety

A Python package to check username safety and validity.

## Features

- **Length Check**: Ensures username is within min/max length.
- **Character Check**: Ensures username contains only allowed characters (alphanumeric, underscore, hyphen).
- **Profanity Check**: Checks against a list of profane words.
- **Similarity Check**: Checks if the username is too similar to the user's real name.

## Installation

```bash
pip install username-safety
```

## Usage

```python
from username_safety import UsernameChecker

checker = UsernameChecker()

# Basic validation
is_valid, messages = checker.validate("cool_user_123")
if is_valid:
    print("Username is valid!")
else:
    print("Errors:", messages)

# Check with real name similarity
is_valid, messages = checker.validate("johndoe", real_name="John Doe")
# Returns False, ["Username is too similar to real name (similarity: 1.00)"]
```

## Development

To run tests:

```bash
python -m unittest discover tests
```
simple-dtach 1.1.0
A convenience wrapper around dtach. Detach and reattach to processes.
Requires Python: >=3.8
Keywords: dtach, persistent, session, ssh, terminal

# Simple dtach
**@readwithai** - [X](https://x.com/readwithai) - [blog](https://readwithai.substack.com/) - [machine-aided reading](https://www.reddit.com/r/machineAidedReading/) - [📖](https://readwithai.substack.com/p/what-is-reading-broadly-defined
)[⚡️](https://readwithai.substack.com/s/technical-miscellany)[🖋️](https://readwithai.substack.com/p/note-taking-with-obsidian-much-of)

Simple dtach (`sdtach`) is a wrapper around the dtach command-line utility to make it slightly easier to use. It keeps `dtach` sessions in a standard location removing the need to specify sessions with `-A`.

`dtach` is a simplified alternative to tmux which allows you to detach and reattach your terminal to a running process, but it does not completely hijack your terminal like `screen` and `tmux` do. I am using this to have persistent ssh connections to a remote machine while running `tmux` locally.

## Installation
`simple-detach` depends upon `dtach` which you can install with

```
sudo apt isntall dtach
```

You can install sdtach using [pipx](https://github.com/pypa/pipx):
```
pipx install simple-dtach
```

## Usage
To run cat in a way which can be detached run `sdtach cat`.  You can use `Ctrl-T` (rather than dtach's `Ctrl+\`) to detach from an existing session. To reattach use `sdtach`. Exit the process as normall to kill the sessions.

If you do not specify a program the users defaut shell is run.

  * [ ] If you want to have several processes at the same time you can use `sdtach -n name`.

You can list the curent sessions with `--list`

If errors occur, the `--debug` option may provide you with relevant information.

## About me
I am **@readwithai**. I create tools for reading, research and agency sometimes using the markdown editor [Obsidian](https://readwithai.substack.com/p/what-exactly-is-obsidian).

I also create a [stream of tools](https://readwithai.substack.com/p/my-productivity-tools) that are related to carrying out my work. If you are interested in this tool you might be interested in [killable-sudo](https://github.com/talwrii/killable-sudo).which allows you to run a process as root or another user but kill it "as usual" with your process.

You might also be interested in my [ffmpeg beginner's cookbook](https://github.com/talwrii/ffmpeg-cookbook).

I write about lots of things - including tools like this - on [X](https://x.com/readwithai).
My [blog](https://readwithai.substack.com/) is more about reading and research and agency.
cbfa 0.0.8
Class-based views for the FastAPI
Requires Python: >=3.8

![logo](https://raw.githubusercontent.com/pomponchik/cbfa/develop/docs/assets/logo_4.png)

[![Downloads](https://static.pepy.tech/badge/cbfa/month)](https://pepy.tech/project/cbfa)
[![Downloads](https://static.pepy.tech/badge/cbfa)](https://pepy.tech/project/cbfa)
[![Coverage Status](https://coveralls.io/repos/github/pomponchik/cbfa/badge.svg?branch=main)](https://coveralls.io/github/pomponchik/cbfa?branch=main)
[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/cbfa?branch=main)](https://hitsofcode.com/github/pomponchik/cbfa/view?branch=main)
[![Tests](https://github.com/pomponchik/cbfa/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/cbfa/actions/workflows/tests_and_coverage.yml)
[![Python versions](https://img.shields.io/pypi/pyversions/cbfa.svg)](https://pypi.python.org/pypi/cbfa)
[![PyPI version](https://badge.fury.io/py/cbfa.svg)](https://badge.fury.io/py/cbfa)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)


A bit of dummy patching for FastAPI, class-based handlers. So far without `self` support.

Install it:

```bash
$ pip install cbfa
```

And use:

```python
from typing import Optional
from fastapi import FastAPI
from pydantic import BaseModel
from cbfa import ClassBased


app = FastAPI()
wrapper = ClassBased(app)

class Item(BaseModel):
    name: str
    price: float
    is_offer: Optional[bool] = None

@wrapper('/item')
class Item:
    def get(item_id: int, q: Optional[str] = None):
        return {"item_id": item_id, "q": q}

    def post(item_id: int, item: Item):
        return {"item_name": item.name, "item_id": item_id}
```
interpreter-command 2025.1.6
An adapter interface for Ai programs to be run with a RobotPy Command interface
Requires Python: >=3.13

# Ai Interpreter Command

This project allows the use of Ai-based commands in RobotPy programs for FRC.

## What is Ai?
Ai is a programming language that was designed to be extensible and, more importantly, interruptable. 
More accurately, Ai was designed as a sort of automation language, similar to `bash` or `make`. The
most important feature however, is the ability to interface directly with its outside environment in the
form of Callables and Props, which let the user define arbitrary interactions.

For more information, see the [Ai Project](https://github.com/KellenWatt/ai-command). (This package is 
included in the overall Ai Command project, since it was technically the driving force behind the whole thing,
and reorganizing repositories is a pain).

## What Happend to the Old `interpreter-command`
TL;DR: if you liked the old version, don't upgrade past 2024 versions.

The original version of this package was intended as a way to allow for on-the-fly changes to robot 
behaviour without having to go through the multi-second deploy and startup time, which quickly adds up over 
the course of developing, for example, a non-trivial autonomous routine. 

It was fine. It worked. It accomplished the goal. But it was clunky. It did nothing more than execute
a series of commands line-by-line, with a very simple ability to repeat or skip single commands using 
a highly inflexible syntax. It was less a language and more a glorified state machine. And if you
wanted to do anything in parallel? You had to do that natively, then register that parallelism under a 
single name, meaning it was completely inflexible.

Honestly, the only thing it had going for it was the dispatch system, which allowed you to define 
multiple commands that used the same initial name, then dispatching based on the second word, and so on.
That was (in my humble opinion as the author), kind of neat, especially since it was mostly an unintended 
side-effect, but it was a pain to set up.

Ai is different. Ai is a real, (*technically*) Turing-complete language, complete with compiler, intepreter, 
and support for transferring a pre-compiled program between environments (say, between a host device and 
a connected robot), in order to more efficiently distribute work. It's built in Rust, and embedded in Python,
so it's more efficient and doesn't just freeload off of Python's type system, which makes it much safer 
to use (albeit slightly less expressive). It also has a complete logic system that allows skipping arbitrary 
code, instead of one single command. Most importantly though, Ai has built-in support for parallel groups, 
which allows for more logic to be written within Ai, from more elemental components.

From version 2025 onward, this project will be backed by Ai, and bears no similarity to the old project,
except maybe a few shared names. The API is and will be completely different and will not be compatible 
with pre-2025 versions.
wks 0.5.0
Simple dependencies manager for cmake projects in your workspace
Requires Python: >=3.9
Keywords: wks, workspace, deps

# wks: Simple CMake workspace manager

## How it works

The basic purpose of `wks` is to spawn repositories to build a project, then generate a `CMakeLists.txt`
containing `add_subdirectory()` directives for all of them.

This way, the project can be built using the top-level generated `CMakeLists.txt`.

## Usage

The following commands are available:

* `wks install [repository]`: If a repository is given, `wks` will install it first. Then, `wks` will scan for
  dependencies in the `wks.yml` files (see below) and install them until all requirements are met. This way, it is
  possible that dependencies of dependencies are installed. Calling `wks install` without repository argument will
  cause dependencies scan. The `CMakeLists.txt` will eventually be generated.
* `wks cmake`: This will cause the `CMakeLists.txt` to be re-generated.
* `wks build [target]`: Will create a build and run it. `wks` will try to create a Ninja build, and
  fall back to makefiles if it is not available. The `[target]` you can pass will be given to the build command
  (`make [target]` or `ninja [target]`). The build will be stored in `build/` directory.
* `wks pull`: Will run a `git pull` in all repositories. This will then scan for dependencies (equivalent to `wks install`
  with no argument) and re-generate the `CMakeLists.txt`.
* `wks status`: Gives insight on the status of your repositories, this will check for:
  * Untracked files
  * Changes without commits
  * Changes commited but not pushed

All sources will be stored in `src/`, under `src/vendor/repository`.

## Repositories format

All repositories are fetched for GitHub, and repositories can have those formats:

* `vendor/repository`
* `vendor/repository#branch`
* `vendor/repository@tag`

## The `wks.yml` file

The `wks.yml` can contain the following sections:

* `deps`: a list of dependencies that the repository want to be installed
* `optional`: a list of optional dependencies, they will not be installed but it ensure that the projects will appear
  in the proper order in the generated `CMakeLists.txt`
* `cmakes`: if the `CMakeLists.txt` for this repository is not at the top level (or not unique), you can specify them
  using this section
* `install`: a list of shell command that should be run post install
* `cmake_prefix`: a list of directories to be added to `CMAKE_PREFIX_PATH`

An example is:

```yaml
deps:
    - rhoban/utils@v1.0
    - rhoban/geometry@v2.0

cmakes:
    - client
    - server
```