semvec/pypi-packages huggingface dataset:
request-tea-ok 1.0.3
This function is designed to make HTTP requests to the website app.tea.xyz
Requires Python: >=3.6

<h1 align="center">Welcome to request-tea-ok! 👋 </h1>

<p align="center">This function is designed to make HTTP requests to the website app.tea.xyz. 💖 </p>
        
## 🎯 How does it work

The project utilizes the `requests` library in Python to send HTTP requests. Its purpose is to simplify user interactions with the website and retrieve responses.
        
## Installation : `pip install true-random`
        
## 📝 License
        
* Copyright © 2024 Ahda
oandadata 0.1.4
A Python library for retrieving financial data.

# Financial Data Retrieval Library


# oandadata

`oandadata` is a Python library designed to retrieve financial data from the OANDA API. It provides a simple and efficient way to access candle data for a specified currency pair.

## Features

- **Easy-to-use API**: With just a few lines of code, you can retrieve candle data for any currency pair available on the OANDA platform.
- **Flexible Parameters**: You can specify the number of candles to retrieve, the timeframe for each candle, the type of price data to retrieve, and the currency pair.
- **Pandas Integration**: The retrieved data is returned as a pandas DataFrame, making it easy to analyze and manipulate the data.

## Example

Here's an example of how you can use `oandadata` to retrieve candle data:

```python
import oandadata

# Define your parameters
token = 'your_api_token'
count = 100
timeframe = 'H1'
price_type = 'MBA'
currency_pair = 'XAU_CAD'

# Retrieve the candle data
df = oandadata.get_candles(token, count, timeframe, price_type, currency_pair)

# Now 'df' is a DataFrame containing the candle data
mltu 1.2.5
Machine Learning Training Utilities (MLTU) for TensorFlow and PyTorch
Requires Python: >=3

# MLTU - Machine Learning Training Utilities
Machine Learning Training Utilities for <b>TensorFlow 2.*</b> and <b>PyTorch</b> with Python 3
<p align="center">
  <img src="https://pylessons.com/media/Tutorials/mltu/machine-learning-training-utilities.png">
</p>

# Installation:
To use MLTU in your own project, you can install it from PyPI:
```bash
pip install mltu
```
When running tutorials, it's necessary to install mltu for a specific tutorial, for example:
```bash
pip install mltu==0.1.3
```
Each tutorial has its own requirements.txt file for a specific mltu version. As this project progress, the newest versions may have breaking changes, so it's recommended to use the same version as in the tutorial.

# Tutorials and Examples can be found on [PyLessons.com](https://pylessons.com/mltu)
1. [Text Recognition With TensorFlow and CTC network](https://pylessons.com/ctc-text-recognition), code in ```Tutorials\01_image_to_word``` folder;
2. [TensorFlow OCR model for reading Captchas](https://pylessons.com/tensorflow-ocr-captcha), code in ```Tutorials\02_captcha_to_text``` folder;
3. [Handwriting words recognition with TensorFlow](https://pylessons.com/handwriting-recognition), code in ```Tutorials\03_handwriting_recognition``` folder;
4. [Handwritten sentence recognition with TensorFlow](https://pylessons.com/handwritten-sentence-recognition), code in ```Tutorials\04_sentence_recognition``` folder;
5. [Introduction to speech recognition with TensorFlow](https://pylessons.com/speech-recognition), code in ```Tutorials\05_speech_recognition``` folder;
6. [Introduction to PyTorch in a practical way](https://pylessons.com/pytorch-introduction), code in ```Tutorials\06_pytorch_introduction``` folder;
7. [Using custom wrapper to simplify PyTorch models training pipeline](https://pylessons.com/pytorch-introduction), code in ```Tutorials\07_pytorch_wrapper``` folder;
8. [Handwriting words recognition with PyTorch](https://pylessons.com/handwriting-recognition-pytorch), code in ```Tutorials\08_handwriting_recognition_torch``` folder;
9. [Transformer training with TensorFlow for Translation task](https://pylessons.com/transformers-training), code in ```Tutorials\09_translation_transformer``` folder;
10. [Speech Recognition in Python | finetune wav2vec2 model for a custom ASR model](https://youtu.be/h6ooEGzjkj0), code in ```Tutorials\10_wav2vec2_torch``` folder;
11. [YOLOv8: Real-Time Object Detection Simplified](https://youtu.be/vegL__weCxY), code in ```Tutorials\11_Yolov8``` folder;
12. [YOLOv8: Customizing Object Detector training](https://youtu.be/ysYiV1CbCyY), code in ```Tutorials\11_Yolov8\train_yolov8.py``` folder;
phasors 0.0.1
Phasor - A means to measure complex values with magnitude and angle.




# Phasors

*A means to measure complex values with magnitude and angle.*

The `phasor` package provides a means to work with complex numbers in their
polar coordinate form (with a magnitude and angle) allowing simple computation
for advanced electrical engineering or other phasor-based work.

## Installation

Installing is as simple as:

    pip install phasors

## Usage

```python
from phasor import Phasor

voltage = Phasor(67, 120)

print(voltage)
# 67 ∠ 120°
```
exper 0.2.0
This is a python package for running deep learning experiments. Users can rapidly run their experiments by importing this module.

# exper

`exper` is a very lightweight Python package designed for personal use to speed up the execution of PyTorch-based deep learning experiments. This framework is specifically crafted to support Distributed Data Parallel (DDP) training, mix precision training and provides a convenient mechanism for saving experiment logs.

## Features:

- **PyTorch Integration:** Built on top of PyTorch, `exper` allows seamless integration with the PyTorch deep learning ecosystem.
  
- **DDP Training Support:** `exper` supports Distributed Data Parallel training, enabling efficient and scalable model training across multiple GPUs.

- **Experiment Logging:** Easily log and save experiment details, parameters, and results for better reproducibility and analysis.

- **Based on TorchDrug:** `exper` is derived from the open-source library [TorchDrug](https://github.com/DeepGraphLearning/torchdrug/tree/master) developed by MILA, providing a foundation for reliable and robust deep learning experiments.

## Installation:
```bash
pip install exper
```

## License
`exper` is released under [Apache-2.0 License](https://github.com/DeepGraphLearning/torchdrug/blob/master/LICENSE).

## Contributing
Feel free to contribute your codes to make this package easy to use.
try-pub-pypi 0.0.3
A small example package
Requires Python: >=3.6

[![Publish Python 🐍 distribution 📦 to PyPI and TestPyPI](https://github.com/seralekseenko/try_pub_pypi/actions/workflows/pub_on_pypi_org.yml/badge.svg)](https://github.com/seralekseenko/try_pub_pypi/actions/workflows/pub_on_pypi_org.yml)

[![Lint & Tests](https://github.com/seralekseenko/try_pub_pypi/actions/workflows/lint_test.yml/badge.svg)](https://github.com/seralekseenko/try_pub_pypi/actions/workflows/lint_test.yml)

# try_pub_pypi

Only test to automate publishing to pypi.org

### virtual python3 ENV

1. Create virtual ENV → `python3 -m venv .venv` # смотри conda (Anaconda)
2. Activate → `source .venv/bin/activate`
3. Check virt env → `echo $VIRTUAL_ENV` → should be non empty output
4. Deactivate → `deactivate` or reopen terminal session

### Requirements

- instal `pip install -r requirements.txt`
- save `pip freeze > requirements.txt`
- check to old requirements `pip list --outdated`
- upgrade some package `pip install -U package_name`

### Run tests

A simple way: `python3 -m unittest discover -s ./tests` or `pytest`

### Publish on pypi.org

- manual mod: just run Actions → Publish Python 🐍 distribution 📦 to PyPI
- pub by special commit tag to only 'main' branch:
    1. `git commit -m "your important message"` & `git push`
    2. `git tag vx.x.x`; `x` is the numbers! Follow the pattern: 'v[0-9]+.[0-9]+.[0-9]+'
    3. `git push origin vx.x.x`
habitat-suitability 0.0.7
A Python package to run habitat suitability modeling, custom/boostrap habitat binning, and binning analysis.
Requires Python: >=3.8

# Habitat Suitability Modeling 


***

# Documentation
requires the installation of GDAL
# Documentation
https://github.com/HenningNiklas/Habitat-Suitability-Modeling-Docs
-----------------------------------------------------------
formulations 1.2
A basic moduel that contains many formulas.

# formulations
A package that allows you to use many formulas quickly. These formulas span from science to geometry.

# Basic
Contains basic formulas like exponents.

**import formulations as fm<br><br>fm.Basic.Round(5.5)**

# Science
Contains formulas used in science like MC2.

**import formulations as fm<br><br>fm.Science.MC2(5)**

# Algebra
Contains formulas and functions used in algebra, like absolute value, floor, and ceiling.

**import formulations as fm<br><br>fm.Algebra.abs(-4)**

# Geometry
Contains formulas for geometry, like area of a circle, pathatgeryon, and area of a square.

**import formulations as fm<br><br>fm.Geometry.Distance2D(2, 6, 3, 4)**
fastapi-debug-toolbar 0.6.3
A debug toolbar for FastAPI.
Requires Python: >=3.8
Keywords: debug, fastapi, profiling

# ![FastAPI](https://raw.githubusercontent.com/mongkok/fastapi-debug-toolbar/main/debug_toolbar/statics/img/icon-green.svg) Debug Toolbar

<p align="center">
    <a href="https://fastapi-debug-toolbar.domake.io">
        <img src="https://user-images.githubusercontent.com/5514990/131232994-621774a8-1662-468d-87d8-2199b93387d6.gif" alt="FastAPI Debug Toolbar">
    </a>
</p>
<p align="center">
    <em>🐞A debug toolbar for FastAPI based on the original django-debug-toolbar.🐞</em>
    <br><em><b>Swagger UI</b> & <b>GraphQL</b> are supported.</em>
</p>
<p align="center">
    <a href="https://github.com/mongkok/fastapi-debug-toolbar/actions">
        <img src="https://github.com/mongkok/fastapi-debug-toolbar/actions/workflows/test-suite.yml/badge.svg" alt="Test">
    </a>
    <a href="https://codecov.io/gh/mongkok/fastapi-debug-toolbar">
        <img src="https://img.shields.io/codecov/c/github/mongkok/fastapi-debug-toolbar?color=%2334D058" alt="Coverage">
    </a>
    <a href="https://www.codacy.com/gh/mongkok/fastapi-debug-toolbar/dashboard">
        <img src="https://app.codacy.com/project/badge/Grade/e9d8ba3973264424a3296016063b4ab5" alt="Codacy">
    </a>
    <a href="https://pypi.org/project/fastapi-debug-toolbar">
        <img src="https://img.shields.io/pypi/v/fastapi-debug-toolbar" alt="Package version">
    </a>
</p>


---

**Documentation**: [https://fastapi-debug-toolbar.domake.io](https://fastapi-debug-toolbar.domake.io)

---

## Installation

```sh
pip install fastapi-debug-toolbar
```

## Quickstart

Add `DebugToolbarMiddleware` middleware to your FastAPI application:

```py
from debug_toolbar.middleware import DebugToolbarMiddleware
from fastapi import FastAPI

app = FastAPI(debug=True)
app.add_middleware(DebugToolbarMiddleware)
```

## SQLAlchemy

Please make sure to use the *"Dependency Injection"* system as described in the [FastAPI docs](https://fastapi.tiangolo.com/tutorial/sql-databases/#create-a-dependency) and add the `SQLAlchemyPanel` to your panel list:

```py
app.add_middleware(
    DebugToolbarMiddleware,
    panels=["debug_toolbar.panels.sqlalchemy.SQLAlchemyPanel"],
)
```

## Tortoise ORM

Add the `TortoisePanel` to your panel list:

```py
app.add_middleware(
    DebugToolbarMiddleware,
    panels=["debug_toolbar.panels.tortoise.TortoisePanel"],
)
```
name-generator-nicomp 1.0.10
Generate random names from a list of nouns and adjectives as you might see in a Kahoot game. I'm not affiliated with Kahoot except as an end-user.
Requires Python: >=3.8

Description: This project generates silly names from a list of adjectives and a list of nouns
        
        Example:
        
            >>> from name_generator_nicomp.NameGenerator import NameGenerator
            >>> nameGenerator = NameGenerator()
            >>> print(nameGenerator.generate_name())
boolean-solver-gui 0.1.0
A simple boolean algebra solver with gui

# EC530_Final
Logic Synthesis Engine API

# Repo Organization
program1.py -- Contains main function as well as all sub-functions called during the main function

input_examples/ -- Contains two examples of inputs to program1.py

   input.txt shows an example boolean algebraic function input 

   BILF.txt shows an example of BILF (Berkeley Logic Interchange Format) input which 
   represents a digital combinational logic circuit

# Tool Description
This tool is an attempt to make a logic synthesis engine. It takes either a boolean algebraic
function or a digital combinational logic circuit (BILF) input from a text file and produces a 
variety of outputs:
1. The design as a canonical SOP
2. The design as a canonical POS
3. The design INVERSE as a canonical SOP
4. The design INVERSE as a canonical POS
5. A minimized number of literals representation in SOP
  a. The number of saved literals vs. the canonical version
6. A minimized number of literals representation in POS
  a. Report on the number of saved literals vs. the canonical version
7. The number of Prime Implicants
8. The number of Essential Prime Implicants
9. The number of ON-Set minterms
10. The number of ON-Set maxterms
11. The total number of transistors needed for the minimized SOP design
12. The total number of transistors needed for the minimized POS design
    
The tool also produces the inputted boolean expression, variable names, minterms, maxterms, and
recommends SOP or POS design based on required transistor numbers.

Essential prime implicants and prime implicants are found through the use of the Quine-
McCluskey method. An open source python library (shown here: https://github.com/tpircher-zz/quine-mccluskey/tree/master) 
was used to calculate the Essential Prime Implicants through the provided QM algorithm, and the 
sympy library was used for much of the boolean algebra.

# How to run the program
Some libraries may need to be downloaded, such as sympy and pyeda, to run the code properly.
Ensure that input files are located in the same directory as the program.
The program can be run with the following command on windows:

**python .\program1.py input.txt**

When prompted with: "Is the input a combinational logic circuit or a boolean algebraic function? (C/B):"
input 'C' for combinational logic circuit and 'B' for boolean algebraic function.

The input file is passed as an argument with the run command.
Input constraints can be found on the example input text files.

# Collaborators 
This program was made with the assistance of ChatGPT-3.5 as an AI coding copilot. ChatGPT was 
used mainly for debugging/syntax and recommendations on function implementations.
memmpy 0.1.11
Memory mapped of datasets
Requires Python: >=3.10

# Memmpy
Memmpy is a Python library for working with memory mapped numpy arrays. It supports
- Saving to temporary or permanent memory mapped files
- Appending and extending arrays in constant time
- Loading arrays in batches
- Train-validation-test-splits and k-fold cross validation
- Fast & lazy shuffling by shuffling in blocks and bands


## Who should use Memmpy?
Memmpy is primarly intended for use in data science and machine learning applications where the dataset is too large to fit into memory at once.
Memmpy is not intended for use in small applications where the entire dataset fits into memory and can be loaded at once. It is also not intended for use in very large applications where training is massively distributed.


## Installation
Memmpy can be installed directly from PyPI using `pip`. It requires Python 3.10 or higher.
```bash
pip install memmpy
```

## Usage
Writing to a memory mapped file.

```python
# Create a memory mapped array
file = memmpy.Vector()

for i in range(4):
    file.append(np.random.rand(100))  # O(1)


file.extend(np.random.rand(32, 100))

# access the array
assert file.array.shape == (4 + 32, 100)

# save to non-temporary file
file.save("data.npy")
```

Loading random batches from a memory mapped file.

```python
array = np.memmap(data.npy, dtype=np.float64, mode='r', shape=(36, 100))

# Load the array in batches
batch_indicies = memmpy.batch_indicies_split(
    array.shape[0],
    4,
    "train",
    valid_part=10,  # size of the validation and train set
    kfold_index=2,  # take the second out of 10 folds
)
shuffle = memmpy.shuffle_fast(array.shape[0], seed=42)  # O(1)

for indicies in batch_indicies:
    indicies = shuffle(indicies)
    batch = array[indicies]
```