semvec/pypi-packages huggingface dataset:
yumevalidator 0.2.1
A GenAI-based UI Validation tool for Deriv AI Hackathon in 2025 Feburary
Requires Python: >=3.6

# YumeValidator CLI

> CLI Tool to execute UI Validation AI Agent and display the report after the process has been completed

## Available Commands

### Install
```
pip3 install --editable .
```

### Check Version
```
yumevalidator version
```

### Initialize CLI for a project
```
yumevalidator init
```

### Display previous report
```
yumevalidator report
```

### Start running tests
```
yumevalidator test

```
bkmeup 0.1.4
Archive & backup shell config elements
Requires Python: >=3.9
Keywords: util, utility

# BkMeUp

**BkMeUp** provides shell config file archive and backup functionality

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install **bkmeup**.

```bash
pip install bkmeup
```

## CLI Utility

The following CLI is provided in this package.

```bash
╰─ bkmeup -h                                                                                                                             ─╯
usage: bkmeup [-h] [--version] {show.env.info,show.dflt.bkup.list,create.archive} ...

-.-.-. BkMeUp Shell Config archiver & bkup!

positional arguments:
  {show.env.info,show.dflt.bkup.list,create.archive}
    show.env.info       show system environment info
    show.dflt.bkup.list
                        show list of default items to archive/bkup
    create.archive      accumulate shell config files if they exist and archive them

options:
  -h, --help            show this help message and exit
  --version             top-level package version

-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
```


## License

[MIT](https://choosealicense.com/licenses/mit/)
daqx 0.0.3
Python data acquisition toolbox - MCC
Requires Python: >=3.10
Keywords: acquisition, mcc

![License](https://img.shields.io/badge/license-MIT-blue)
# daqx
Python data acquisition toolbox - Wrapper that provides high-level layers for controlling data acquisition boards. It also handles low-level memory management, data transfer, and provides various types of event callbacks.

Currently, it only supports boards from Measurement Computing. Support for National Instruments boards will be added in the future.

## Table of Contents
- [Installation](#installation)
- [Supported Event Callback](#supported-event-callback)
- [Usage](#usage)

## Installation
- `pip install daqx`

## Supported Event Callback
**Start callback -** AI, AO

**Stop callback -** AI, AO

**Trigger callback -** AI

**Samples acquired callback -** AI

## Usage
```python
from daqx.util import createDevice

daqid = 0
start_channel = 0                           # start scanning at channel 0
end_channel = 1                             # end scanning at channel 1
daq = createDevice('mcc',daqid)             # only 'mcc', Measurement Computing is supported currently
daq.config_ai(start_channel,end_channel)    # set up analog input

daq.ai.sampleRate = 1000                    # Hz/channel
daq.ai.grounding = 'single-ended'           # Support 'single-ended','grounded','differential'
daq.ai.trigType = 'instant'                 # support 'instant','digital-positive-edge'
daq.ai.samplesPerTrig = 2000                # Samples/channel/trigger
daq.ai.aqMode = 'foreground'                # acquisition mode - 'foreground','background'

daq.ai.start()
# after 2 seconds
aitime, aidata = daq.ai.getdata()

```
Tutorial will be added in the future.
EasyCells 0.1.6
Uma biblioteca para criação de jogos e interfaces gráficas.
Requires Python: >=3.12

# EasyCells

EasyCells is a Python game development framework inspired by Unity. It allows you to create **Items** (equivalent to Unity's GameObjects), organize game logic into **Levels** (equivalent to Unity's Scenes), and add **Components** to define object behaviors and functionalities.

## Project Structure

Your project should follow this structure:

```
your_game/
├── Levels/           # Game scenes
│   └── level1.py
├── Assets/           # Game resources
│   ├── Ui/
│   ├── Sounds/
│   └── image.png
└── main.py           # Entry point 
```

## Initializing the Game

The `Game` class should be created in `main.py`:

```python
from EasyCells import Game

if __name__ == '__main__':
    GAME = Game("level1")
    GAME.run()
```

## Creating a Level

Levels are files inside the `Levels/` folder. Each Level must contain two main functions:

- `init(game: Game)`: Initializes the objects in the Level.
- `loop(game: Game)`: Runs every frame.

Example of a basic Level:

```python
from EasyCells import Game
from EasyCells.Components import Sprite, Camera

# Initialize Level objects
def init(game: Game):
    camera = game.CreateItem()
    camera.AddComponent(Camera())
  
    item = game.CreateItem()  # Every Item already has a Transform automatically
    item.AddComponent(Sprite("image.png"))

# Game loop
def loop(game: Game):
    pass
```

## RPC (Remote Procedure Call) Example

EasyCells supports Remote Procedure Calls (RPC) to synchronize actions between the server and clients. Use the `@Rpc` decorator to mark functions that will be called remotely. See the example below with explanations for each `SendTo` option:

```python
from EasyCells.NetworkComponents import Rpc, NetworkComponent, SendTo

class MyNetworkComponent(NetworkComponent):
    @Rpc(SendTo.ALL)
    def action_all(self):
        """Executed on all (ALL)."""
        print("RPC: Executed on all.")

    @Rpc(SendTo.SERVER)
    def action_server(self):
        """Executed only on the server."""
        print("RPC: Executed on the server.")

    @Rpc(SendTo.CLIENTS)
    def action_clients(self):
        """Executed on clients, except on the server."""
        print("RPC: Executed on clients.")

    @Rpc(SendTo.OWNER)
    def action_owner(self):
        """Executed only on the object owner client."""
        print("RPC: Executed on the owner client.")

    @Rpc(SendTo.NOT_ME)
    def action_not_me(self):
        """Executed on all except the sender."""
        print("RPC: Executed on all, except the sender.")
```

## Conclusion

EasyCells allows for modular and organized game development. Use **Levels** to structure game stages, **Items** to represent game objects, and **Components** to add behaviors. If needed, synchronize actions over the network with **RPC**. Explore the framework to build your game in a simple and efficient way!
todo-utils 0.1.1
Convenient tool for scanning entire codebase to find TODO and FIXME comments and then updating the TODO.md.
Requires Python: >=3.6
Keywords: todo_utils

==========
TODO Utils
==========

Convenient tool for scanning entire codebase to find TODO and FIXME comments and then updating the TODO.md.


Console Scripts
---------------

The following exported console scripts are available:

- todo-pre-commit-scan
- todo-update-todo-md
- todo-scan-codebase


For the todo-pre-commit-scan, add the following to your `.pre-commit-config.yaml`:

.. code-block:: yaml

  repos:
    - repo: local
      hooks:
        - id: todo-pre-commit-scan
          name: Check for TODOs with username
          entry: todo-pre-commit-scan
          language: system
          types: [text, python]


=======
History
=======

0.1.0 (2024-02-23)
------------------

* First release on PyPI.