semvec/pypi-packages huggingface dataset:
ibby-guess-the-number 0.1.2
A simple number guessing game
Requires Python: >=3.13

<!-- File: README.md
     Reason: Modern README for professional Python project "ibby-guess-the-number"
     Changes: Added installation, usage, and contribution instructions, badges, and project overview. -->

# ibby-Guess-the-Number

A simple number guessing game package.

[![Python Version](https://img.shields.io/badge/python-3.7%2B-blue)](https://www.python.org/)
[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)

## Overview

A minimalist interactive number guessing game. The game randomly selects a number between 1 and 100; your job is to guess it.

Updating the README.md file:

## Installation

1. Clone the repository:
   ```bash
   git clone https://github.com/yourusername/ibby-guess-the-number.git
   cd ibby-guess-the-number
   ```

2. (Optional) Create a virtual environment and activate it:
   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   ```

3. Install the package using pip:
   ```bash
   pip install .
   ```

## Usage

### Command-Line Interface (CLI)

Run the game from the terminal:

```bash
python -m ibby_guess_the_number.cli
```

### As a Python Module

You can import the game functionality in your code:

```python
from ibby_guess_the_number import guess_the_number

# Start the game
guess_the_number()
```

## Development

- **Structure**: 
  - `src/ibby_guess_the_number/`: Main package directory.
  - `src/ibby_guess_the_number/game.py`: Contains game logic and state.
  - `src/ibby_guess_the_number/cli.py`: CLI entry point.
  - `src/ibby_guess_the_number/__init__.py`: Package initialization.

- **Tests**:
  Create tests in the `tests/` directory and use your favorite test framework (e.g., pytest).

## Contributing

Contributions are welcome! Fork the repo and open a pull request with your enhancements or fixes.

## License

MIT License. See the [LICENSE](LICENSE) file for details.
sandboxai-client 0.0.2
Secure sandboxes for AI agents and LLMs.
Requires Python: >=3.10

# SandboxAI

*Unleash your AI agents ... in a sandbox!*

SandboxAI is an open source runtime for securely executing AI-generated Python code and shell commands in isolated sandboxes.

* **Self-host**
  * Docker based single host backend
  * Kubernetes based multi-node backend (coming soon)
* **Simple SDK**
  * `pip install sandboxai-client` is all you need
  * Go SDK included
* **Container based**
  * You define the environment
  * Integrate with existing tooling
* **Flexible control**
  * Full-agency - Set the agent loose within the container
  * Limited-agency - Give the agent access to specific commands
* **Open API**
  * Simple RESTful interface
  * Generate your own client from the API spec

## Architecture

SandboxAI was designed to fit nicely into your AI software stack.

![overview](./diagrams/overview.excalidraw.png)

## Quickstart (Single-host)

Make sure you have docker installed.

<details>
<summary>TIP: Free alternatives to docker desktop...</summary>

* On a mac? Checkout [colima](https://github.com/abiosoft/colima).
* On linux? Use [docker engine](https://docs.docker.com/engine/install/).
</details>

```bash
docker ps
```

Install the python client.

```bash
pip install sandboxai-client
```

Run a sandbox on your local machine.

```python
from sandboxai import Sandbox

with Sandbox(embedded=True) as box:
    print(box.run_ipython_cell("print('hi')").output)
    print(box.run_shell_command("ls /").output)
```

## Contributing

We welcome contributions to SandboxAI. See the [contributing doc](contributing.md) for more information.

## Contact

Let us know about features you are interested in seeing or reach out with questions. [Visit our Discord channel](https://discord.gg/JeXhcmjZVm) to join the discussion!

Or just reach out on LinkedIn if you want to connect:

* [Nick Stogner](https://www.linkedin.com/in/nstogner/)
* [Sam Stoelinga](https://www.linkedin.com/in/samstoelinga/)
langgraph-checkpoint-datastore 0.1.0
Datstore Saver for LangGraph Checkpoints
Requires Python: >=3.6

# langgraph-checkpoint-datastore

Implementation of a LangGraph CheckpointSaver that uses a GCP's Datastore

## Inspiration

Based on: https://github.com/justinram11/langgraph-checkpoint-dynamodb

## Required Datastore Tables

To be able to use this checkpointer, two Datastore kinds are needed, one to store
checkpoints and the other to store writes.

## Using the Checkpoint Saver

### Default

To use the datastore checkpoint saver, you only need to specify the names of
the checkpoints and writes kinds. In this scenario the datastore client will
be instantiated with the default configuration, great for running on AWS Lambda.

```python
from langgraph_checkpoint_datastore import DatastoreSaver
...
checkpoints_table_name = 'YourCheckpointsTableName'
writes_table_name = 'YourWritesTableName'

memory = DatastoreSaver(
    checkpoints_table_name=checkpoints_table_name,
    writes_table_name=writes_table_name,
)

graph = workflow.compile(checkpointer=memory)
```

### Providing Client Configuration

If you need to provide custom configuration to the datastore client, you can
pass in an object with the configuration options. Below is an example of how
you can provide custom configuration.

```python
memory = DatastoreSaver(
    checkpoints_table_name=checkpoints_table_name,
    writes_table_name=writes_table_name,
    client_config={
        'region': 'us-west-2',
    }
)
```

Important note, you will need to add an index to your kinds:

````indexes:

- kind: IntegrationCheckpoint
  properties:
  - name: thread_id
  - name: checkpoint_id
    direction: desc```
````
nb-tmpl-ctex 0.1.0
Chinese LaTeX/PDF template for Jupyter nbconvert using CTeX.
Requires Python: >=3.8

# Jupyter nbconvert 中文 PDF 模板

Chinese LaTeX/PDF template for Jupyter notebook `nbconvert` using CTeX.

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

-----

## Installation

```console
pip install nb-tmpl-ctex
```

## Usage

```bash
# 默认 ctexart
jupyter nbconvert example.ipynb --to pdf --template ctex
# 使用 ctexrep
jupyter nbconvert example.ipynb --to pdf --template ctex --template-file report
```

## License

`nb-tmpl-ctex` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
win-automation-gui 1.0.0
Uma biblioteca para automação de controles GUI com Win32.
Requires Python: >=3.6

# Win Automation

**Win Automation** é uma biblioteca Python para automação de controles GUI no Windows. Utilizando a API Win32 via PyWin32, a biblioteca fornece funções para interagir com janelas e seus controles de forma programática, seja para obter handles, simular cliques, enviar textos ou listar propriedades dos controles.

## Funcionalidades

- **Obter Handle de Controle:**  
  A função `get_control_handle_hex` tenta encontrar o handle de um controle a partir do seu `auto_id`, com múltiplas tentativas configuráveis e intervalos de espera.

- **Simulação de Cliques:**  
  * `click_button` executa um clique simples (usando a mensagem BM_CLICK).  
  * `right_click` simula um clique com o botão direito.

- **Envio de Texto para Controles:**  
  * `write_text` utiliza a mensagem WM_SETTEXT para enviar texto a controles compatíveis.

- **Listagem de Controles:**   
  * `get_control_properties` retorna diversas propriedades de cada controle, como texto, classe, dimensões (retângulo), estilos, visibilidade, entre outros.

## Requisitos

- Python 3.6 ou superior
- [PyWin32](https://github.com/mhammond/pywin32) (instalado automaticamente via pip)

## Instalação

Depois de publicado no PyPI, você pode instalar a biblioteca com:

```bash
pip install win-automation
gnsstoolbox-timecalc 0.1.2
CLI tool for converting UTC to GPS Time
Requires Python: >=3.8

# gnsstoolbox
simple tools for manipulating GNSS data


## timecalc

### installing timecalc
timecalc is now available on Pip.
```
pip install gnsstoolbox-timecalc
```
### running timecalc
If installed using Pip, timecalc can be run from anywhere using `gnsstimecalc` 

```
gnsstimecalc -h
usage: timecalc.py [-h] [--utc_offset UTC_OFFSET] 
[--datetime DATETIME | --epoch EPOCH | --epoch_sec EPOCH_SEC | --now NOW]

options:
  -h, --help            show this help message and exit
  --utc_offset UTC_OFFSET, -uo UTC_OFFSET
                        UTC offset in hours (default 0)
  --datetime DATETIME, -dt DATETIME
                        Datetime in format YYYY-MM-DD H:M:S
  --epoch EPOCH, --epoch_ms EPOCH, -em EPOCH
                        Unix epoch timestamp in milliseconds
  --epoch_sec EPOCH_SEC, -es EPOCH_SEC
                        Unix epoch timestamp in seconds
  --now NOW, -n NOW     The current device time
```
win-automation 0.1.0
Uma biblioteca para automação de controles GUI com Win32.
Requires Python: >=3.6

# Win Automation

**Win Automation** é uma biblioteca Python para automação de controles GUI no Windows. Utilizando a API Win32 via PyWin32, a biblioteca fornece funções para interagir com janelas e seus controles de forma programática, seja para obter handles, simular cliques, enviar textos ou listar propriedades dos controles.

## Funcionalidades

- **Obter Handle de Controle:**  
  A função `get_control_handle_hex` tenta encontrar o handle de um controle a partir do seu `auto_id`, com múltiplas tentativas configuráveis e intervalos de espera.

- **Simulação de Cliques:**  
  * `click_button` executa um clique simples (usando a mensagem BM_CLICK).  
  * `right_click` simula um clique com o botão direito.

- **Envio de Texto para Controles:**  
  * `write_text` utiliza a mensagem WM_SETTEXT para enviar texto a controles compatíveis.

- **Listagem de Controles:**   
  * `get_control_properties` retorna diversas propriedades de cada controle, como texto, classe, dimensões (retângulo), estilos, visibilidade, entre outros.

## Requisitos

- Python 3.6 ou superior
- [PyWin32](https://github.com/mhammond/pywin32) (instalado automaticamente via pip)

## Instalação

Depois de publicado no PyPI, você pode instalar a biblioteca com:

```bash
pip install win-automation
deformaug3d 0.1.1
A package for 3D volume augmentation with configurable parameters
Requires Python: >=3.6

# Deformaug3d

Deformaug3d is a Python package for performing 3D volume augmentation with configurable parameters. Designed with simplicity and flexibility in mind, it allows you to augment 3D masks and volumes easily, making it a great choice for machine learning and data augmentation pipelines.

## Features

- **Configurable Augmentation Parameters:** Define your own augmentation ranges or use sensible defaults.
- **GPU Support:** Leverage CUDA-enabled GPUs for efficient processing via PyTorch.
- **Modular Design:** Easily integrate with your existing code and extend functionality.

## Installation

### Requirements

- Python 3.6+
- [PyTorch](https://pytorch.org/) (with CUDA support if available)

### Installing from PyPI

*(Once published on PyPI, you can install MyPackage using pip)*

    pip install deformaug3d

### Installing Locally

Clone the repository and install in editable mode:

    git clone https://github.com/haifangong/deformaug3d.git
    cd deformaug3d
    pip install -e .

## Usage

The package provides functions `augmentation` and `aug_mask_and_img` to perform and manage 3D augmentation. Here is an example of how to use these functions:

    import torch
    from mypackage.augmentation import aug_mask_and_img

    # Create dummy data for demonstration
    dummy_mask = torch.zeros((1, 1, 128, 128, 128))
    dummy_img = torch.ones((1, 1, 128, 128, 128))

    # Custom augmentation parameters (optional)
    custom_aug_parameters = {
        "rot_range_x": (-10.0, 10.0),
        "rot_range_y": (-8.0, 8.0),
        "rot_range_z": (-8.0, 8.0),
        "scale_range_x": (0.95, 1.00),
        "scale_range_y": (0.95, 1.00),
        "scale_range_z": (0.95, 1.00),
        "shift_range_x": (-0.02, 0.02),
        "shift_range_y": (-0.02, 0.02),
        "shift_range_z": (-0.02, 0.02),
        "contrast": (1.0, 1.0),
        "gray_shift": (0.0, 0.0),
        "flip_x": False,
        "flip_y": False,
        "flip_z": False,
        "elastic_alpha": [3.0, 3.0, 3.0],  # For x, y, z axis
        "smooth_num": 4,
        "field_size": [10, 10, 10],        # For x, y, z axis
        "size_o": (128, 128, 128)
    }

    # Augment the dummy mask and image using the custom parameters
    augmented_mask, augmented_img = aug_mask_and_img(
        dummy_mask, dummy_img, aug_parameters=custom_aug_parameters
    )

    print("Augmentation complete!")

## API Reference

### aug_mask_and_img(mask, img, aug_parameters=None)

- **mask:** Input mask tensor.
- **img:** Input image/volume tensor.
- **aug_parameters (dict, optional):** Dictionary of augmentation parameters. If not provided, the default parameters are used.
- **Returns:** A tuple containing the augmented mask and image/volume as tensors.

### augmentation(mask, vol, aug_model)

- **mask:** Input mask tensor.
- **vol:** Input volume tensor.
- **aug_model:** An instance of the augmentation model that applies transformations.
- **Returns:** A tuple `(mask_aug, vol_aug)` containing the augmented mask and volume.
pp-check 0.1.19
This tool is used exclusively for Poetry projects. As soon as you have a poetry project in front of you in the console, you can use this tool to quickly find out which script commands the poetry project contains.
Requires Python: <3.13,>=3.10

# pp-check

This tool is used exclusively for Poetry projects. As soon as you have a poetry project in front of you in the console, you can use this tool to quickly find out which script commands the poetry project contains.

## requirements

poetry version >=1.2.0, python version >= 3.10

## install

```
poetry update
poetry install
```

## execute as poetry command

```
poetry run ppcheck .
```

## install as cli command

```
sh ./cli_install_bash.sh
```

## execute as cli command

```
ppcheck .
```

## poetry run help

```
poetry run ppcheck --help
Usage: ppcheck [OPTIONS] CHECK_POETRY_PATH

  This tool is used exclusively for Poetry projects. As soon as you have a
  poetry project in front of you in the console, you can use this tool to
  quickly find out which script commands the poetry project contains.

  usage: set path of poetry project, eg.

  $ poetry run ppcheck ~/poetry-project

Options:
  --help  Show this message and exit.
```

## screenshots

| MacOSX    | <img src="res/mac2.png"> |
|---------------|:------------------------|
| Windows    | <img src="res/win.png"> |
pydantic-ssm-settings 1.1.2
AWS SSM support for Pydantic Settings
Requires Python: >=3.9

# pydantic-ssm-settings

Integrate [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) with [Pydantic Settings](https://github.com/pydantic/pydantic-settings).

## Usage

The simplest way to use this module is to inhert your settings from `SsmBaseSettings`. This add the `SsmSettingsSource` as a custom settings source and enabled passing source configuration (e.g. `_ssm_prefix`, `_ssm_client`) via `kwargs` when initializing a settings class.

```py
from pydantic_ssm_settings import SsmBaseSettings


class WebserviceSettings(SsmBaseSettings):
    some_val: str
    another_val: int

WebserviceSettings(_ssm_prefix="/prod/webservice")
```

Alternatively, configuration may be specified within the settings class via [`BaseModel.model_config`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_config):

```py
from pydantic_ssm_settings import SsmSettingsConfigDict

class WebserviceSettings(SsmBaseSettings):
    model_config = SsmSettingsConfigDict(ssm_prefix="/prod/webservice")
    some_val: str
    another_val: int


WebserviceSettings()
```

If it is preferred to avoid altering the baseclass of a settings model, the source can be manually added and configured as such:

```py
from typing import Tuple, Type
from pydantic_settings import (
    BaseSettings,
    EnvSettingsSource,
    InitSettingsSource,
    PydanticBaseSettingsSource,
    SecretsSettingsSource,
)
from pydantic_ssm_settings import SsmSettingsConfigDict, SsmSettingsSource

class WebserviceSettings(BaseSettings):
    model_config = SsmSettingsConfigDict(ssm_prefix="/asdf")
    foo: str

    def settings_customise_sources(
        self,
        settings_cls: Type[BaseSettings],
        init_settings: InitSettingsSource,
        env_settings: EnvSettingsSource,
        dotenv_settings: PydanticBaseSettingsSource,
        file_secret_settings: SecretsSettingsSource,
    ) -> Tuple[PydanticBaseSettingsSource, ...]:
        return (
            init_settings,
            env_settings,
            dotenv_settings,
            file_secret_settings,
            SsmSettingsSource(settings_cls),
        )
```
cuse 0.0.1
Remote control of a computer
Requires Python: >=3.12

# ComputerUse

A Python library for controlling computers with AI agents. This package provides a simple interface for programmatic control of mouse movements, keyboard input, and screen capture.

## Installation

```bash
pip install computeruse
```

## Quick Start

```python
from computeruse import Computer

# Initialize a computer connection
computer = Computer("http://localhost:17014")

# Take a screenshot
screenshot = computer.screenshot()

# Move mouse and click
computer.move_mouse(x=100, y=100).left_click()

# Type text
computer.type("Hello, World!")
```

## Features

- Mouse control (move, click, drag)
- Keyboard input
- Screen capture
- System information
- Debug viewer

## Requirements

- Python 3.12 or higher
- Docker (for running the computer server)

## License

MIT License
defigraph 0.1.2
A package for creating a directed graphs based on DeFi protocols
Requires Python: >=3.10

# Defi Graph

![test](https://github.com/mmsaki/defigraph/actions/workflows/test.yml/badge.svg)
![GitHub repo size](https://img.shields.io/github/repo-size/mmsaki/defigraph)
![GitHub last commit](https://img.shields.io/github/last-commit/mmsaki/defigraph)
![PyPI - Version](https://img.shields.io/pypi/v/defigraph)
![PyPI - Downloads](https://img.shields.io/pypi/dm/defigraph)
![GitHub top language](https://img.shields.io/github/languages/top/mmsaki/defigraph)

![X (formerly Twitter) Follow](https://img.shields.io/twitter/follow/msakiart)

This is package for creating and visualizing graphs in DeFi protocols.

![Token Graph](./docs/imgs/output.png)

## Install

Install using pip or uv

```sh
pip install defigraph

# or using uv

uv add defigraph
```

## Modules

- [x] [Edge](#edge-type) - describes a path between tokens
- [x] [Vertex](#vertex-type) - describes a token
- [x] [Graph](#graph-type) - describes a defi market
- [x] [Pool](#pool-type) - describes trading token pairs

## Edge type

Edges store two main state:

1. `self.weight` - a weight between two tokens
   - typeof `float`
   - `{0,1}` Depends on direction of edge
   - Calculated as `-Math.log(self.pool.token_price_{0,1})`
1. `self.pool` - an instance of a token pool
   - typeof `Pool`
1. `self._tuple` - Allows indexing/iteration of the edge object
   - typeof `iter`
   - Array of `[Vertex1, Vertex2, (self.weight, Pool)]`

## Pool type

A pool object describing tokens:

1. `self.address` - the address of the pool
   - typeof `Hex` checksum address
1. `self.token0` - a token described as a vertex
   - typeof `Vertex`
1. `self.token1` - a token described as a vertex
   - typeof `Vertex`
1. `self.token0_price` - the price of token0
   - typeof `float`
1. `self.token1_price` - the price of token1
   - typeof `float
1. `self.fee` - describes the pool fee e.g Uniswap (100 | 500 | 1000 | 3000)
   - typeof `int`

## Graph type

An adjacency list graph object desribing a defi market

1. `self.vertices` - contains a list of all vertices
   - typeof `List[Vertex]`
1. `self.adjascency_list` - a mapping describing edges in the graph
   - typeof `Dict[Vertex, List[Edge]]`
   - example: {Vertex: [Edge1, Edge2, Edge3, Edge4]}

## Vertex type

A node on the graph describing a token

1. `self.name` - name of the token
   - typeof `string`
1. `self.decimals` - number of decimals for token
   - typeof `int`
1. `self.address` - address of token
   - typeof `Hex` checksum address

## Tests

Run tests:

```sh
pytest
```

## Usage

See example in [docs/notebooks/graph.ipynb](./docs/notebooks/graph.ipynb)