semvec/pypi-packages huggingface dataset:
basebot22-basebot-JustinGuese 0.3.43
A python package to interact with the tradingbot22 backend. used in tradingbot22-tradingbots
Requires Python: >=3.8

[![Upload Python Package](https://github.com/JustinGuese/tradingbot22-basebot/actions/workflows/main.yaml/badge.svg)](https://github.com/JustinGuese/tradingbot22-basebot/actions/workflows/main.yaml)

Published on: https://pypi.org/project/basebot22-basebot-JustinGuese/

# tradingbot22-basebot

python package to interact with the [tradingbot22-backend](https://github.com/JustinGuese/tradingbot22-backend), used in [tradingbot22-tradingbots](https://github.com/JustinGuese/tradingbot22-tradingbots)

`pip install basebot22-basebot-JustinGuese`

or

`pip install -U git+https://github.com/JustinGuese/tradingbot22-basebot/`

Import with

`from basebot22.basebot import BaseBot`

## usage

```
bot = BaseBot("testbot")
print(bot.getPortfolio())
bot.buy("AAPL", 2000, amountInUSD=True)
print("portfolio after buy")
print(bot.getPortfolio())
print("portfolio after sell")
bot.sell("AAPL", 1500, amountInUSD=True)
print(bot.getPortfolio())
print("portfolio worth is: %.2f dollars" % bot.getPortfolioWorth())
print("next earnings calendar events:")
print(bot.getEarnings(only_now=True))
```
chbpm 0.1.3
A Python library for BPM adjustment in audio files

# Chbpm: BPM Adjustment Tool

## Overview
Chbpm is a Python-based tool designed for analyzing and adjusting the tempo of music tracks. This tool is ideal for fitness enthusiasts, dancers, and anyone who needs music to maintain a consistent BPM for their activities. The primary goal is to adjust the BPM of songs to fit within a target BPM range, facilitating a consistent pace during workouts or dance routines.

## Features
- **BPM Analysis**: Automatically analyzes the BPM of music files.
- **BPM Adjustment**: Adjusts the tempo of music tracks to a target BPM suitable for exercise or dance routines.
- **Dual BPM Handling**: For songs within a specified range, it uses the target BPM directly. For songs where double the BPM falls within the range, it adjusts to half the target BPM.
- **File Format Support**: Compatible with various audio file formats (e.g., MP3, M4A).
- **Error Logging**: Detailed logging for troubleshooting, including optional suppression of verbose `ffmpeg` metadata output.

## Installation
Ensure `ffmpeg` is installed on your system. [Installation inctructions.](https://ffmpeg.org/download.html)
### For Users
```bash
pip install chbpm
```

### For Developers
1. Install Pipenv:
```bash
pip install pipenv
```
2. Clone this repository.
```bash
git clone https://github.com/dariakriukova/rhythm-is-a-runner.git
```
3. Navigate to the Project Directory
4. Install Dependencies:
```bash
pipenv install
```
5. Activate the Virtual Environment:
```bash
pipenv shell
```

## Usage
Run the tool from the command line, specifying the input folder and other optional parameters:

```bash
python -m chbpm path_to_music_folder
```

### Command-Line Options
- `input_path`: Path to the input music folder. 

- `-o`, `--output_path`: Path to the output folder where adjusted music files will be saved. Defaults to `adjusted`.  

- `-t`, `--target_bpm`: Optional target BPM for tempo adjustment. Defaults to `180`.  

- `-r`, `--range_percentage`: Percentage for BPM range adjustment. Defaults to `15%`. This setting determines the 
flexibility in BPM adjustment.  

- `--log`: Set log level. INFO by default.

- `--format`: Convert output audio files to given format. By default keeps the original format.

`--ffmpeg_options`: Control over the audio processing, enabling adjustments to codec, bitrate, and more.

### Important Note
The arguments passed through `--ffmpeg_options` are directly supplied to FFmpeg, so it's essential to ensure they are valid and compatible with the input and output file formats being used. Refer to the [FFmpeg documentation](https://ffmpeg.org/ffmpeg.html) for a comprehensive list of available options.
procesadortext 1.0
This is my text processor that will process text using 9 NLP processing tehcniques and two display
Requires Python: >=3.11

# TextPreprocessor

## Overview
The TextPreprocessor is a Python class designed for comprehensive text preprocessing.
This library can perform the following tasks:
```
1. Text lematization    --> text_lematizacion()
2. Text stemming        --> text_stemming()
3. Remove links         --> remove_links()
4. Remove hastags       --> remove_hastags()
5. Remove characters    --> remove_characters()
6. Convert to lowercase --> convert_to_lowercase()
7. Remove emojis        --> remove_emojis()
8. Remove numbers       --> remove_numbers()
9. Remove stopwords     --> remove_stopwords()
10. Cloud words         --> cloudwords()
11. Frequency words     --> frecwords()
```

## Installation
Ensure you have NLTK installed. You can install NLTK via pip:

pip install nltk




## Usage
```python
### Import the TextPreprocessor class
from text_preprocessor import TextPreprocessor
# Initialize the preprocessor with default settings
preprocessor = TextPreprocessor()

# Customize the preprocessor by setting flags
preprocessor = TextPreprocessor(
    text_lematizacion_flag =True, 
    text_stemming_flag=True, 
    remove_links=True, 
    remove_hastags=True,
    remove_characters=True,
    convert_to_lowercase=True, 
    remove_emojis=True, 
    remove_numbers=True,
    remove_stopwords_flag= True, 
    cloudwords =True,
    frecwords = True
)


text = "Your text goes here..."
processed_text = preprocessor.preprocess_text(text)

```
## Available Methods
1. preprocess_text(text): Preprocesses the input text based on the initialized flags.
2. Other methods in the class can be used individually for specific preprocessing steps (e.g., remove_links, remove_stopwords, etc.).
# Examples
```python

text = "Hello! This is an example text with #hashtags and links: https://example.com"
# Initialize preprocessor
preprocessor = TextPreprocessor(remove_links=True, remove_hashtags=True)

# Preprocess text
processed_text = preprocessor.preprocess_text(text)
print(processed_text)
Output: "Hello This is an example text with and links"

```
```python

texto = "If you need to tokenize the text before removing stopwords, you might want to incorporate a tokenization function such as word_tokenize from NLTK."
# lematizacion
p1 = pt.TextPreprocessor()
doc = p1.lematizacion_text(texto)
Output: "if you need to tokenize the text before remove stopword , you might want to incorporate a tokenization function such as word_tokenize from NLTK ."

```
```python

texto = "If you need to tokenize the text before removing stopwords, you might want to incorporate a tokenization function such as word_tokenize from NLTK."
# stemming
p1 = pt.TextPreprocessor()
doc = p1.stemming_text(texto)
Output: "if you need to token the text befor remov stopword , you might want to incorpor a token function such as word_token from nltk ."
```
# License

This project is licensed under the MIT License - see the LICENSE file for details.
bbdl 2.0.5
BBDL
Requires Python: >=3.9

# Download Borneo Bulletin :newspaper:
![Preview of BB-DL.py](preview-bb-dl.PNG)

## Usage

This only works on **Python3** :snake:

`python3 bbdl.py` if you have Python2 and Python3 installed or;

`python bbdl.py` if you only have Python3 installed.

:whale:

If you have Docker/podman installed, this can be done easily with a single command line where `${pwd}` will be the host directory that it will copy its files from the container to:

`docker run -it --rm -v ${pwd}:/usr/src/app/news docker.pkg.github.com/Anak-IT-Brunei/bb-dl/bbdl:2.0.3`

## Download

For the Python Script, find it on the release page [here](https://github.com/Anak-IT-Brunei/bb-dl/releases)

For the Docker Image, find it on Github Packages [here](https://github.com/Anak-IT-Brunei/bb-dl/packages/)

## Documentation

Source code for the documenation are in the `/docs` folder. Be sure to install the dependencies (at least, mkdocs and mkdocs-custommill via pip) to be able to run `mkdocs serve` to contribute to the documentations.

## Credits

Decided to make a Borneo Bulletin download script thanks to Tim's Telegram News Bot for exposing the URL.

Feel free to fork and contribute
alien-onslaught 3.3.2
Alien Onslaught: An action-packed arcade space shooter game.


## Alien-Onslaught
- Alien Onslaught is an action-packed game that will test your shooting skills and reflexes. The game is set in outer space, where you must shoot fleets of aliens to reach higher levels and increase your high score. With each level, the game becomes more challenging as the aliens become stronger and faster, bosses are starting to appear, and more asteroids rain down from above.

- The game offers a range of game modes (e.g.: Boss Rush, Endless Onslaught, Cosmic Conflict (PVP)), including single-player and multiplayer modes, where you can choose to battle it out with friends or take on the aliens alone. In game you can also get a variety of ship power-ups, including increased ship speed, bullet speed, and fire power, as well as shields that protect you from enemy fire. It also includes a high score system where players can compete with others for the top spot on the leaderboard, boss fights, different weapons, different player ship types, and more other features.

### Requirements:
- Python 3.7 or later
- Pygame 2.0 or later

### Game Launch:
* pip install alien-onslaught
* python -m src.alien_onslaught

## Controls:
#### Gameplay:
#### Player 1 (Thunderbird):
* Move: W, A, S, D
* Fire: Space
* Laser: C
* Launch Missiles: X

#### Player 2 (Phoenix):
* Move: Arrow Keys
* Fire: Enter
* Laser: R-Shift
* Launch Missiles: R-Ctrl

#### UI Controls:
* Toggle Fullscreen: F
* Pause: P
* - While Paused:
*  Save Game: S
*  Restart: R
*  Return to Game Menu: ESC
*  Return to Main Menu: M
*  Quit: Q

### Game images can be found [here](https://github.com/KhadaAke/Alien-Onslaught/tree/main/game_assets/images/game_images)
procesador-de-texto 1.0.0.0
This is my text processor that will process text using 9 NLP processing tehcniques and two display
Requires Python: >=3.11

# TextPreprocessor

## Overview
The TextPreprocessor is a Python class designed for comprehensive text preprocessing.
This library can perform the following tasks:
```
1. Text lematization    --> text_lematizacion()
2. Text stemming        --> text_stemming()
3. Remove links         --> remove_links()
4. Remove hastags       --> remove_hastags()
5. Remove characters    --> remove_characters()
6. Convert to lowercase --> convert_to_lowercase()
7. Remove emojis        --> remove_emojis()
8. Remove numbers       --> remove_numbers()
9. Remove stopwords     --> remove_stopwords()
10. Cloud words         --> cloudwords()
11. Frequency words     --> frecwords()
```

## Installation
Ensure you have NLTK installed. You can install NLTK via pip:

pip install nltk




## Usage
```python
### Import the TextPreprocessor class
from text_preprocessor import TextPreprocessor
# Initialize the preprocessor with default settings
preprocessor = TextPreprocessor()

# Customize the preprocessor by setting flags
preprocessor = TextPreprocessor(
    text_lematizacion_flag =True, 
    text_stemming_flag=True, 
    remove_links=True, 
    remove_hastags=True,
    remove_characters=True,
    convert_to_lowercase=True, 
    remove_emojis=True, 
    remove_numbers=True,
    remove_stopwords_flag= True, 
    cloudwords =True,
    frecwords = True
)


text = "Your text goes here..."
processed_text = preprocessor.preprocess_text(text)

```
## Available Methods
1. preprocess_text(text): Preprocesses the input text based on the initialized flags.
2. Other methods in the class can be used individually for specific preprocessing steps (e.g., remove_links, remove_stopwords, etc.).
# Examples
```python

text = "Hello! This is an example text with #hashtags and links: https://example.com"
# Initialize preprocessor
preprocessor = TextPreprocessor(remove_links=True, remove_hashtags=True)

# Preprocess text
processed_text = preprocessor.preprocess_text(text)
print(processed_text)
Output: "Hello This is an example text with and links"

```
```python

texto = "If you need to tokenize the text before removing stopwords, you might want to incorporate a tokenization function such as word_tokenize from NLTK."
# lematizacion
p1 = pt.TextPreprocessor()
doc = p1.lematizacion_text(texto)
Output: "if you need to tokenize the text before remove stopword , you might want to incorporate a tokenization function such as word_tokenize from NLTK ."

```
```python

texto = "If you need to tokenize the text before removing stopwords, you might want to incorporate a tokenization function such as word_tokenize from NLTK."
# stemming
p1 = pt.TextPreprocessor()
doc = p1.stemming_text(texto)
Output: "if you need to token the text befor remov stopword , you might want to incorpor a token function such as word_token from nltk ."
```
# License

This project is licensed under the MIT License - see the LICENSE file for details.
as4012-sstr 1.0.0
Computational Assignment for AS4012
Requires Python: >=3.9

# README

This is the source repository for the AS4012: Nebulae And Stars 2 Stellar Structure Computational Project
* University of St Andrews, Spring 2024
* Instructor: Dr. Ian Czekala

See the project website: https://iancze.github.io/AS4012-MESA/index.html
criminalip 0.0.1
Simple Python wrapper around the CriminalIP.io API
Requires Python: >=3.7

# pyCriminalIP
---
Simple Python wrapper around the [CriminalIP](https://www.criminalip.io) API

## Sample usage

``` python
from criminalip.client import Client

API_KEY = <ADD YOUR UNIQUE KEY HERE>

crimip = Client(API_KEY)
print(crimip.banner_search("ssh"))
```
no-action 0.7.0
no_action is an incremental automation library to eliminate toil in processes.
Requires Python: >=3.11,<4.0

# no_action

An incremental automation library to eliminate toil in processes.

## Description

Ideologically based on Dan Slimmon's [Do-nothing scripting][dns] article from 2019. `no_action`
provides a `Step` class that can be sub-classed and customized as well as a `Prodecure` class that
wraps a series of ordered steps.

First, one writes a series of Steps with the manual details in their docstring and the procedure
prints the docstrings, a glorified checklist. Over time though, with each Step encapsulated in
a discrete class, Steps of a procedure can be automated by writing code that actually does what is
described in the docstring (override the `Step.execute()` method). Soon, your procedures are fully
automated and can be hooked into an Internal Developer Platform (IDP), a runner, or other automation
orchestration system.

[dns]: https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-the-key-to-gradual-automation/#

## Installation

This library can be found on PyPI. Run the following command to install the library into your
project.

`python3 -m pip install no-action`

<!--
## Usage

Use examples liberally, and show the expected output if you can. It's helpful to have inline the
smallest example of usage that you can demonstrate, while providing links to more sophisticated
examples if they are too long to reasonably include in the README.

## Support

Tell people where they can go to for help. It can be any combination of an issue tracker, a chat
room, an email address, etc.

## Contributing

State if you are open to contributions and what your requirements are for accepting them.

For people who want to make changes to your project, it's helpful to have some documentation on how
to get started. Perhaps there is a script that they should run or some environment variables that
they need to set. Make these steps explicit. These instructions could also be useful to your future
self.

You can also document commands to lint the code or run tests. These steps help to ensure high code
quality and reduce the likelihood that the changes inadvertently break something. Having
instructions for running tests is especially helpful if it requires external setup, such as starting
a Selenium server for testing in a browser.

## Authors and acknowledgment

Show your appreciation to those who have contributed to the project.
-->

## License

This project is licensed under the GNU GPL 3. See;

- [LICENSE](.LICENSE) for the preamble.
- [COPYING](./COPYING) for the full text.
simple-iptables 1.0.2
Simple Python client library for Iptables

# iptables


### Introduction

Native iptables is not friendly enough for most users.
This module is trying to make Linux/Iptables working like security groups in cloud environments.

### Scenarios
 - Service must be public facing, but still wants to block random bad ipaddress easily.
 - Scripting interface talking to iptables, be convenient like same thing in cloud.

### Examples
##### To protect your personal web server
```python

from simple_iptables import securitygroup as sg

# Create a security group based on tcp/port, naming associated to your to-be-protected service.
sg.create_security_group(security_group_name='httpd', dst_port='80')

# Create, append/insert, rules based on source address, with action accept/reject/drop.
sg.create_security_group_rule(security_group_name='httpd', 
                              src_addr='1.2.3.0/24',
                              rule_action='insert',
                              packet_action='DROP')
sg.create_security_group_rule(security_group_name='httpd',
                              src_addr='2.3.4.0/24',
                              rule_action='insert',
                              packet_action='DROP')

# List current rules for a given security group.
sg.list_security_group_rules(security_group_name='httpd')

# Delete a given rule for a security group.
sg.delete_security_group_rule(security_group_name='httpd', rule_id='HTTPD_kfnsznwvb0mzn3uh')

# Delete a given security group and its rules completely.
sg.delete_security_group(security_group_name='httpd')

```