semvec/pypi-packages huggingface dataset:
bit-chess-python 0.1.1
Bitboard Chess implementation written entirely in Python
Requires Python: >=3.9

<h3 align="center">Bit-Chess</h3>

</div>

---

<p align="center"> Bitboard implementation for Chess in Python
    <br> 
</p>

## Table of Contents

- [About](#about)
- [Getting Started](#getting_started)
- [Usage](#usage)
- [Built Using](#built_using)
- [Acknowledgments](#acknowledgement)

## About <a name = "about"></a>

This project implements Chess bitboards using NumPy 64-bit integers and various NumPy array functions for rotated bitboard implementation. This process is used to store all possible orthogonal and diagonal moves, and their respective blocker formations calculated as a unique index. A legal move generator is created by keeping track of pinned pieces and other game conditions to reduce the need for recalculating opposing attacks.

## Getting Started <a name = "getting_started"></a>

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Installing

```
pip install bit-chess-python
```

## Usage <a name="usage"></a>

If you want to run PERFT, import the PERFT class and call the perft function:

```
from 
```

## Built Using <a name = "built_using"></a>

- NumPy
- gmpy2

## Acknowledgements <a name = "acknowledgement"></a>

- Inspired by Sebastian Logue's [Chess-Coding-Adventures](https://github.com/SebLague/Chess-Coding-Adventure)
- Rotated Bitboards [pdf](https://www.cs.cmu.edu/afs/cs/academic/class/15418-s12/www/competition/www.contrib.andrew.cmu.edu/~jvirdo/rasmussen-2004.pdf)
ImageLabelingTool 0.1
Simplify the process of labeling images or video frames with bounding boxes for object detection tasks.
Keywords: python, image labeling, object detection, bounding box annotation


# ImageLabelingTool



ImageLabelingTool is a Python package designed to facilitate the process of labeling images or video frames with bounding boxes for object detection tasks. With ImageLabelingTool, users can annotate objects with bounding boxes and save the annotations in YOLO format. The package provides a graphical user interface for interactive labeling and supports both camera input and video input.



## Installation



You can install ImageLabelingTool via pip:



```bash

pip install ImageLabelingTool

```



## Usage



To use ImageLabelingTool, follow these steps:



1. Import the `ImageLabeling` class from the package.

2. Create an instance of the `ImageLabeling` class.

3. Call the `run` method to start the labeling tool.



```python

from ImageLabelingTool import ImageLabeling



# Create an instance of the ImageLabeling class

image_labeling = ImageLabeling()



# Run the labeling tool

image_labeling.run()

```



## Features



- Annotate images or video frames with bounding boxes

- Save annotations in YOLO format

- Support for camera input and video input

- Interactive graphical user interface for labeling



## Dependencies



- OpenCV (cv2)

- Keyboard

- Time

- Random

- OS



## License



ImageLabelingTool is licensed under the MIT License. See the [LICENSE](https://github.com/Rathoreatri03/ImageLabelingTool/blob/main/LICENSE) file for details.



## Support



For support, please open an issue on our [GitHub repository](https://github.com/Rathoreatri03/ImageLabelingTool/issues).

```
easycheml 0.2.3
A simple tool for using artificial intelligence in chemistry

# EasyCheml
EasyCheml is a tensorflow-based package for deep/machine learning application in chemistry, which doesn't require any advanced knowledge of Python (or machine learning).  The intended audience is domain scientists with basic knowledge of python.


The purpose of the EasyCheml is to provide an environment that bridges the instrument specific libraries and general physical analysis by enabling the seamless deployment of deep/machine learning algorithms.

# Installation

To install EasyCheml, you can use pip:

> pip install easycheml
pacemaker-lite 0.1.3
For controlling the duration of iteration loops
Requires Python: >=3.8

# pacemaker
For controlling time per iteration loop in Python.

A carefully regulated loop comes in handy for managing rate-limited APIs,
frame refreshes in animations, and cycles in real-time simulations.
This package provides an accurate metronome for your code to keep time with,
good up to 1 MHz (one microsecond per iteration).

The pacemaker package is intentionally minimalistic and has no external dependencies.
It's a glorified snippet. The whole package's code is shorter than this README.
Works on Linux, Windows, and MacOS.

## Installation

```bash
pip install pacemaker-lite
```

## Usage

```python
from pacemaker.pacemaker import Pacemaker

iterations_per_second = 2.5
pm = Pacemaker(iterations_per_second)

for i in range(100):
    _ = pm.beat()
    print(i)
```

The repetitive import line can be better understood as
```python
from pacemaker_package.pacemaker_module import PacemakerClass
```

## What it does

The Pacemaker class keeps a loop operating at a steady rhythm,
according to a wall clock. It's useful for coordinating the activities
of several asynchronous and real-time processes.

Initialize Pacemaker(clock_frequency) with the desired number of iterations per second.
Call Pacemaker.beat() in a loop to keep it cycling
at the clock frequency.

If the pacemaker experiences a delay, it will allow faster iterations to try
to catch up. Heads up: because of this, any individual iteration might end up being much
shorter than suggested by the pacemaker's target rate.

beat() returns the amount of time that it was off from the ideal pace, counting
back from the first beat.
```python
off_by = pm.beat()
```
A return value of 0 means it
was exactly correct. If it's higher than that, it means that the
cycle came in late.
It will usually be off by a little. You can create a
set of checks on the return value if it's important to keep the cycle
time tightly controlled.
```python
a_little_late = .1  # seconds
a_lot_late = .5  # seconds
off_by = pm.beat()
if off_by > a_lot_late:
    raise RuntimeError(f"Last beat was running behind by {elapsed} seconds.")
if off_by > a_little_late:
    print(f"Last beat was running behind by {elapsed} seconds.")  # or log this
```

For a deep dive on what the pacemaker does and why, check out
[Chapter 2 of How to Train Your Robot: Keeping Time with Python](https://brandonrohrer.com/httyr2pdf).
acquiring 0.4.3
Payment Orchestration Library for Python
Requires Python: >=3.8

# Acquiring

Payment Orchestration Library for Python.

[![Common Changelog](https://common-changelog.org/badge.svg)](https://common-changelog.org)


## Overview

Acquiring aspires to be a flexible and effective toolkit for building applications that handle money.
The word "acquiring" is the industry term that means collecting and processing payments from customers.

Some reasons you might want to check it out:

- Stable interface via single PaymentSaga class.
- Flexible internals that can be customized for any payment method, existing AND non-existing.
- Platform agnostic (really!), meant to be plugged into your existing Django project easily.
- Support for all database engines under the Django umbrella.
- The creator is a very nice guy!

## Requirements

- One of the supported versions of Python
- A spirit of adventure

## Installation

Install using pip...

```sh
pip install acquiring
```

Add 'acquiring' to your INSTALLED_APPS setting.

```python
INSTALLED_APPS = [
    ...
    'acquiring',
]
```

## Local development

This project relies on Docker as the main way to test and develop. You can `docker compose build` and be ready to roll.

## Funding

This project was created by Alvaro Duran. You can support his work or give him words of encouragement
by subscribing to [Money In Transit](http://news.alvaroduran.com/), the weekly newsletter that bridges the gap
between payments strategy and technology execution.

Speaking of, a few of the ideas that inspired this project were initially installments of Money in Transit:

- [Advice I Wish I Had Known When I Built My First Payment Application](https://news.alvaroduran.com/p/advice-i-wish-i-had-known-when-i)
- [Pizza Place Payments](https://news.alvaroduran.com/p/pizza-place-payments)
- [A Taxonomy of Payment Methods](https://news.alvaroduran.com/p/a-taxonomy-of-payment-methods)
- [Nobody Gets Fired for Choosing Java](https://news.alvaroduran.com/p/nobody-gets-fired-for-choosing-java)
- [Gumroad Wallet, a $100M Opportunity](https://news.alvaroduran.com/p/gumroad-wallet-a-100m-opportunity)