semvec/pypi-packages huggingface dataset:
EURUSD-package 0.1.0
A package for analyzing and visualizing EUR/USD forex data
Requires Python: >=3.8

# EUR/USD Exchange Rate Analyzer
Course: Introduction to Python

This repository contains a Python package for analyzing and forecasting EUR/USD historical exchange rate data. It includes tools for data loading, preprocessing, exploratory data analysis, visualization, and time series forecasting using Facebook's Prophet library.

The package is built to support:
 - Time series forecasting
 - Exchange rate trend and volatility analysis

## Dataset Overview
Source: [Historical EUR/USD exchange rate data (2000–2025)](https://www.kaggle.com/datasets/saifansariai/euro-usd-price-2001-to-2025)

Frequency: Daily

Rows: 11,284

Columns: 7

Format: CSV

Columns:
 - Date – Date of recorded exchange rate (Format: DD-MM-YYYY)
 - Price – Closing price of EUR/USD
 - Open – Opening price
 - High – Highest price of the day
 - Low – Lowest price of the day
 - Vol. – Volume (all values are NaN)
 - Change % – Percent change from previous day (as string with % sign)

## Installation
To install the package locally, clone this repository and install the required dependencies:

```
git clone https://github.com/nisher07/EURUSD_Analysis.git
```
Make sure you have Prophet, pandas, matplotlib, seaborn, and scikit-learn installed. If not, add them via:

```
pip install prophet pandas matplotlib seaborn scikit-learn
```

## Usage Example
Here’s how to use the package after importing:

```
from EURUSD_package import DataLoader, DataAnalyzer, DataVisualizer,
AnalyzeForecast

# 1. Load and preprocess the dataset
loader = DataLoader("EURUSD_data.csv")
loader.load_data()
loader.preprocess_data()

# 2. Analyze the dataset
analyzer = DataAnalyzer(loader.data)
print(analyzer.describe_data())

# 3. Forecast future values
forecast = AnalyzeForecast(loader.data)
forecast.perform_forecasting()
```

For a full walkthrough, check the [TUTORIAL.ipynb](https://github.com/nisher07/EURUSD_Analysis/blob/main/TUTORIAL.ipynb) notebook in this repo.

## License
This project is licensed under the MIT License – see the [LICENSE](https://github.com/nisher07/EURUSD_Analysis/blob/main/LICENSE) file for details.
py-epic 0.1.19
HTTP wrapper for the Epic/Fortnite APIs.
Requires Python: >=3.10

[![Python Version: >=3.10](https://img.shields.io/pypi/pyversions/py-epic.svg)](https://pypi.python.org/pypi/py-epic)
[![Code Style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://img.shields.io/badge/imports-isort-ef8336.svg)](https://github.com/PyCQA/isort)

**Still in early development.**

# PyEpic
An asynchronous, object-oriented API wrapper for the Epic/Fortnite HTTP services, written in Python.

# Key Features
- Use of the `asyncio` framework to handle many IO-bound tasks concurrently.
- Automatic, configurable rate limit handling and caching.
- Optimised for a balance of speed and memory.

# Installing
**Python 3.10 or higher is required. For project dependencies, see [requirements.txt](https://github.com/delliott0000/PyEpic/blob/master/requirements.txt).**

It is recommended to install the library within a virtual environment instead of the global Python installation.

```sh
# Windows
py -m pip install py-epic

# Linux/MacOS
python3 -m pip install py-epic
```

# Basic Example

```py
import asyncio
import pyepic


async def main():
    async with pyepic.HTTPClient() as client:
        auth_code = input(f'Enter authorization code from {client.user_auth_path} here: ')

        async with client.create_auth_session(auth_code) as auth_session:
            account = await auth_session.account()

            print(f'Logged in as: {account}')


asyncio.run(main())
```

# Disclaimers
- The APIs that PyEpic interacts with are not officially documented, nor are they intended to be used outside the official clients.
  - The package could experience major breaking changes (or stop working!) at any moment.
  - The developer can not take responsibility for any damages that result from using the package.
EnvBider 0.1.0a1
A Python library for simplified environment variable management
Requires Python: >=3.6
Keywords: environment, configuration, env, dotenv, settings

# EnvBider

A Python library for simplified environment variable management with type conversion and nested configuration support.

## Features

- Simple environment variable access with type conversion
- Nested configuration support
- Automatic environment file (.env) loading
- Validation and default values

## Installation

```bash
pip install EnvBider
```

## Basic Usage

```python
import envbider

# Load environment variables from .env file
envbider.load_dotenv()

# Get environment variable with type conversion
port = envbider.get('PORT', default=8000, type=int)
debug = envbider.get('DEBUG', default=False, type=bool)

# Nested configuration
config = envbider.get_nested('APP_CONFIG')
print(config['database']['host'])
```

## Advanced Usage

### Type Conversion

```python
# Automatic type conversion
value = envbider.get('SOME_NUMBER', type=float)
```

### Nested Configuration

```python
# JSON string in environment variable
config = envbider.get_nested('APP_CONFIG')

# Access nested values
print(config['logging']['level'])
```

### Custom Prefixes

```python
from envbider.core import env_binder

# Define nested configuration classes with custom prefixes
@env_binder(prefix="DB")
class DatabaseConfig:
    host: str
    port: int = 5432
    username: str
    password: str

@env_binder
class AppConfig:
    app_name: str
    database: DatabaseConfig = None

# Environment variables would be:
# APP_NAME=MyApp
# DB_HOST=localhost
# DB_PORT=5432
# DB_USERNAME=admin
# DB_PASSWORD=secret
```

### Validation

```python
# Validate required variables
envbider.validate_required(['DB_HOST', 'DB_PORT'])
```

## Demonstration

1. Create a `.env` file:
```
PORT=8080
DEBUG=true
APP_CONFIG={"database": {"host": "localhost", "port": 5432}, "logging": {"level": "info"}}
```

2. Run the example:
```python
import envbider

envbider.load_dotenv()

port = envbider.get('PORT', type=int)
debug = envbider.get('DEBUG', type=bool)
config = envbider.get_nested('APP_CONFIG')

print(f"Port: {port}")
print(f"Debug mode: {debug}")
print(f"Database host: {config['database']['host']}")
```

## License

MIT
muzzy 0.1.3
A python function library
Requires Python: >=3.9

# Muzzy
A python function library.

## Installation
use pip
```shell
pip install muzzy
```
use poetry
```
poetry add muzzy
```
> Please confirm that you have properly set up the Python interpreter and can correctly recognize the packages installed by Poetry.

## Usage
```python
from muzzy import is_base16, is_base64, is_url, to_base64, base32_encode, base32_decode

message = base32_encode(b"f", "Crockford")
print(base32_decode(message, "Crockford").decode("utf-8"))
```

## API Reference
### def base32_encode(s: bytes, variants: Variant, option:  Options = None) -> str
### def base32_decode(s: str, variants: Variant) -> bytes
### def to_base16(b: bytes) -> str
### def to_base64(b: bytes) -> str
### def to_urlsafe_base64(b: bytes) -> str
### def from_base16(s: str) -> bytes
### def from_base64(s: str) -> bytes
### def from_urlsafe_base64(s: str) -> bytes
### def base64_to_base16(s: str) -> str
### def is_base64(s: str) -> bool
### def is_base16(s: str) -> bool
### def is_url(s: str) -> bool
aa-routing 0.3.0a0
AllianceAuth Routing and Pathfinding
Requires Python: >=3.10
Keywords: allianceauth, eveonline

# Routing for Alliance Auth

Routing is a pathfinding plugin for [Alliance Auth](https://gitlab.com/allianceauth/allianceauth/).

## Features

- def route_path(source: int, destination: int, mode="p_shortest",  algorithm="astar", edges: list = [], static_cache: bool = False) -> List[int]:
- def route_length(source: int, destination: int, mode="p_shortest",  algorithm="astar", edges: List = [], static_cache: bool = False ) -> int:
- def systems_range(source: int, range: int, mode="p_shortest", edges: list = [], static_cache: bool = False) -> List:

- A pregenerated optional Graph dict, to reduce DB load and processing for mass use, cannot guarantee accuracy without shipping new versions.

## Implementations

### Planned

AA Drifters
AA Incursions

## Installation

Routing is an App for [Alliance Auth](https://gitlab.com/allianceauth/allianceauth/), Please make sure you have this installed. Routing is not a standalone Django Application

### Step 1 - Install app

```shell
pip install aa-routing
```

### Step 2 - Configure Auth settings

Configure your Auth settings (`local.py`) as follows:

- Add `'routing'` to `INSTALLED_APPS`
- Add below lines to your settings file:

### Step 3 - Maintain Alliance Auth

- Run migrations `python manage.py migrate`
- Gather your staticfiles `python manage.py collectstatic`
- Restart your project `supervisorctl restart myauth:`

### Step 4 - Pull Required Data

```bash
python manage.py shell
```

```python
from routing.tasks import pull_data_solarsystems, pull_data_connections, import_trig_data

pull_data_solarsystems()
pull_data_connections()
import_trig_data()
```

## Settings

| Name | Description | Default |
| --- | --- | --- |

## Contributing

Make sure you have signed the [License Agreement](https://developers.eveonline.com/resource/license-agreement) by logging in at <https://developers.eveonline.com> before submitting any pull requests. All bug fixes or features must not include extra superfluous formatting changes.
voidbox 1.0.0
Free cloud file storage, built on `Voidbox.alhasubji.store` API's

#VoidBox: Free cloud files storage.
[VoidBox WEB](https://voidbox.alhasubji.store)
___

![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white) &nbsp;
___ 

## Free Cloud Storage Module:

[![PyPI version](https://badge.fury.io/py/voidbox.svg)](https://badge.fury.io/py/voidbox)

VoidBox is a free cloud storage library based on the API of `voidbox.alhasubji.store`. It operates on a box system, where each box can store up to 1.9 GB of data. The library allows you to interact with the API for creating boxes, uploading files, and more.
```bash
pip install VoidBox
```
### Try it now!
## An e.g
***You must have the `API_KEY` or `BearerTOKEN` to use:***
```python
from voidbox import VoidBoxAPI
from voidbox import Create
create = Create()
# Create Object 
api = VoidBoxAPI(token="API or Bearer Token")

# Signup
signup_response = create.signup("username", "password")
print(signup_response)

# Login 
login_response = create.login("username", "password")
print(login_response)

# Get my Info
me_response = api.get_me()
print(me_response)
# Create a box.
create_box_response = api.create_box("My New Box", "A description of my new box")
print(create_box_response)
#Upload a file to a box
upload_file_response = api.upload_file("boxid", "path/to/file.txt")
print(upload_file_response)
```
## It also has `signup` and `signin` functions only using the Create Integrated class .
______
______
______

[!!] *** Powered By `voidbox.alhasubji.store` website.