semvec/pypi-packages huggingface dataset:
joe-lab 0.0.6
A package for solving 1+1-dimensional PDEs quickly and accurately with Fourier spectral discretization in space and high-order time-stepping.
Requires Python: >=3.8

# joe
A library for solving partial differential equations for real or complex scalar functions $u(x,t)$ that depend on one spatial variable and one temporal variable. *joe* uses Fourier spectral discretization in space and high-order exponential time-stepping to rapidly and precisely solve initial-value problems. 

FEATURES

-Fast, accurate numerical solutions of partial differential equations (PDEs) of the form 
$$
\partial_{t}^m u +L\left(\frac{1}{i}\partial_{x}\right)u + f(x,t,u,u_{x}, u_{xx},...) = 0,
$$
where $m=1$ or $m=2$, $u(x,t)$ is a real- or complex-valued scalar field defined on an interval, and $L(k)$ , $f$ are some nice functions supplied by the user.

-Supports periodic boundary conditions as well as absorbing boundaries/sponge layers (to simulate waves going off to spatial infinity)

-Users can either call the PDE they want to simulate from a catalogue of built-in options, or define their own custom PDE.

-Easily customizable initial conditions.

-Clean, object-oriented approach to handling simulations makes post-processing (accuracy assesment) very straightforward.      

-Producing publication-quality visuals is quick and easy with *joe*'s built-in functions: simply call the right plotting function on your simulation, tweak a few options, and you've got a plot or movie ready to go. Almost all the required matplotlib stuff is under the hood.  

DEPENDENCIES

numpy, scipy, matplotlib, jupyter (for accessing tutorials), cmocean (https://matplotlib.org/cmocean/), alive-progress (https://pypi.org/project/alive-progress/1.0/). You may also want to download FFmpeg support for creating movies: I recommend using the PyAV package (https://pypi.org/project/av).

GETTING STARTED
 
Open up the Jupyter tutorials (https://github.com/ageorgemorgan/joe/blob/main/demos/tutorials/) to see joe in action!

Currently getting FFmpeg support is a bit of a tough one and it *does not auto-install when you install joe*. I recommend using conda, installing *joe* in a conda environment, and then using conda to install PyAV via 

```
conda install av
```

or 

```
conda install av -c conda-forge
```

FUTURE DIRECTIONS

-Get support for movies on install without installing further packages!

-Add functionality for fields defined on 2D domains 

-Allow for higher-order-derivatives in time (ie. Timoshenko beam equations)
br-lottery-simulation 0.0.10
brazilian lottery game simulation
Requires Python: >=3.10

# br-lottery-simulation

Description.

The package is for simulations and educational purposes only. The package br-lottery-simulation is used to simulate Brazilian lottery games like:

- Duplasena
- Lotofacil
- Megasena
- Quina

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install br-lottery-simulation
```

## Usage

```python
from br_lottery_simulation.play import prize_draw
prize_draw.generate_numbers_duplasena()
```

## Author

Richard Paula

## License

[MIT](https://choosealicense.com/licenses/mit/)
linux-vm 1.0
A package to manage a Docker-based Linux VM and start a web server.

# Linux_VM

The My Package provides utilities to manage a Docker-based Linux VM and start a basic HTTP server.

## Installation

Install the package using pip:

```sh
pip install -e .
```

## Usage

1. **Create the Linux VM:**

    ```sh
    create-linux-vm
    ```

2. **Start the Linux VM:**

    ```sh
    start-linux-vm
    ```

3. **Stop the Linux VM:**

    ```sh
    stop-linux-vm
    ```

4. **Start the Web Server:**

    ```sh
    start-webserver
    ```

5. Open a web browser and navigate to [http://127.0.0.1:8000](http://127.0.0.1:8000).

## Notes

- Ensure Docker is installed and running on your system.
- Adjust Docker and server settings as needed for your environment.

## License

This project is licensed under the MIT License.
iran-kish-payment 1.0.4
Iran Kish payment portal


# Payment Gateway for Iran Kish

This Python package allows users to easily integrate with the [Iran Kish](https://www.irankish.com) payment gateway for sending payment requests and processing transactions. The package also includes encryption functionality using AES, RSA, and SHA-256 for secure communication with the bank.


## Features

- Sending payment requests to Iran Kish gateway.
- Encryption using AES, RSA, and SHA-256 for secure communication.


## Installation

Install the package via pip

```bash
  pip install iran-kish-payment
```
Make sure you also have `pycryptodome` installed for encryption:

```bash
  pip install pycryptodome
```
    
## Usage
Sending request to bank
```python
from iran_kish_payment import request_payment

pub_key_pem = """GIVEN PUB KEY FROM BANK"""

BANK_RESPONSE = request_payment(
                    terminal_id="PAYANE",
                    acceptor_id="PAZIRANDE",
                    password="PASSWORD",
                    amount=1000,  # IRR
                    pub_key_pem=pub_key_pem,
                    request_id="12334",  # length 20
                    revert_uri="https://example.com"  # callback url
                )

print(BANK_RESPONSE)

```


## License

This project is licensed under the MIT License - see the LICENSE file for details.


## Author

- [@parsbytes](https://www.github.com/parsbytes)
fincept-investments 0.1.2
A Terminal for Financial Market Analysis and Fetching all kinds of Data.
Requires Python: >=3.6

# Fincept Investments ✨

[![License: MIT](https://img.shields.io/badge/license-MIT-C06524)](https://github.com/yourusername/fincept-investments/blob/main/LICENSE.txt)
[![PyPI - Version](https://img.shields.io/pypi/v/fincept-investments.svg)](https://pypi.org/project/fincept-investments/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fincept-investments.svg)](https://pypi.org/project/fincept-investments/)
[![Downloads](https://static.pepy.tech/badge/fincept-investments/month)](https://pypi.org/project/fincept-investments/)

**Fincept Investments** is a comprehensive CLI tool that provides financial insights, market analysis, and a host of other financial services such as technical analysis, fundamental analysis, sentiment analysis, quantitative analysis, and economic data services. It's designed to help investors and financial professionals navigate the complex world of investments with ease and precision.

(Currently, it has more India-specific data. We are constantly updating it to present world data, and new updates are released every day. If you are from another country and can help me with the data source of your country, please reach out to me.)

## Features 🧐

- **Market Tracker**: Track FII/DII data, Nifty 50 list, and more.
- **Economics**: Get economic indicators and analysis (Feature under development).
- **News**: Stay updated with top financial news across the globe.
- **Technical Analysis**: Perform technical analysis on stocks and market indices.
- **Fundamental Analysis**: Dive deep into the fundamentals of companies.
- **Sentiment Analysis**: Gauge market sentiment with real-time data.
- **Quantitative Analysis**: Analyze financial data using quantitative methods.
- **Economic Data**: Access key economic indicators to inform your investment decisions.

## Installation 🚀

Install the latest version of Fincept Investments from PyPI: pip install fincept-investments 

## USAGE

1 -> Stock Tracker -> fiidii Data , stock query
2 -> Economics (InDevelopment)
3 -> News -> 10 Country News Available

```toml
fincept start
```

## UPCOMING FEATURS

- **World Mariane Trade Data**
- **India Bond Data**
- **India Mutual Fund Data**
- **Company Finaical Statements Data**

## Star History

![GitHub repo stats](https://github-readme-stats.vercel.app/api/pin/?username=Fincept-Corporation&repo=FinceptTerminal&show_icons=true&theme=radical)
[![Star History Chart](https://api.star-history.com/svg?repos=Fincept-Corporation/fincept-investments&type=Date)](https://star-history.com/#Fincept-Corporation/fincept-investments&Date)


## PLEASE LEAVE AN STAR ON THE REPO AND FOR ANY QUERY OR UPDATE REACH OUT TO ME ON dev@fincept.in
hackforall77 0.0.1
Una biblioteca para consultar cursos de hack4u.

# Hack4u Academy Courses Library

Una biblioteca Python para consultar cursos de la academia Hack4u.

## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación 
Instala el paquete usando `pip3`:

```python3
pip3 install hackforall77
```

## Uso básico

## Listar todos los cursos

```python
from hackforall77 import list_courses

for course in list_courses():
    print(course)
```
### Obtener un curso por nombre

```python
from hackforall7 import get_course_by_name

course = get_course_by_name("Introducción a Linux")
print(course)
```
## Calcular duración total de los cursos

```python3
from hackforall77.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```
siemensfile 0.1.30
Paquete para leer archivos .dat de Siemens y realizar reconstrucciones de imágenes.
Requires Python: >=3.12.4

# SIEMENSFile

**SIEMENSFile** es un paquete para previsualizar, leer y procesar archivos `.dat` de Siemens y realizar reconstrucciones de imagenes de resonancia magnetica (MRI). Este paquete facilita la extraccion de datos del `rawdata` y el `metadata` y su reconstruccion preliminar en imagenes utilizando transformadas rapidas de Fourier (FFT). La unica reconstruccion implementada es la cartesiana; proximamente se implementara la reconstruccion no cartesiana.

## Instalacion

Puedes instalar el paquete directamente desde PyPI con el siguiente comando:

```bash
pip install siemensfile
```

# Importar la funcion siemensfile desde el paquete

```bash
from siemensfile import siemensfile
```

# Usar la funcion siemensfile para procesar un archivo .dat

```bash
[metadata, rawdata] = siemensfile(r'test/siemens_file_test_cartesian_sample.dat', reconstruccion="Cartesiana")


```
# Resultados
Los resultados se guardaran en la misma ubicacion donde se encuentra el archivo .dat, dentro de una carpeta llamada `output`. En esta carpeta, encontraras un archivo DICOM (.dcm), el Metada en formato `.Json`, junto con las imagenes reconstruidas y el espacio K en formato .png.

# Usar la funcion para mostrar la estructura de rawdata

```bash
rawdata.shape

```

# Usar la funcion para guardar la metadata en un archivo .json

```bash
import json
import os

def guardar_metadata_en_json(metadata, nombre_archivo):
    """
    Funcion para guardar el contenido de metadata en un archivo .json.

    Parameters:
    - metadata: Lista de diccionarios que contiene los metadatos.
    - nombre_archivo: Nombre del archivo .json donde se guardara la informacion.
    """
    # Asegurarse de que el archivo tiene la extension .json
    if not nombre_archivo.endswith('.json'):
        nombre_archivo += '.json'

    # Guardar metadata en un archivo .json
    try:
        with open(nombre_archivo, 'w') as file:
            json.dump(metadata, file, indent=4)
        print(f"Metadata guardada exitosamente en {nombre_archivo}")
    except Exception as e:
        print(f"Error al guardar metadata en el archivo .json: {str(e)}")


guardar_metadata_en_json(metadata, "metadatos_scan")
```

# Creditos y Reconocimientos

Este proyecto utiliza como base el paquete twixtools, desarrollado por Philipp Ehses. twixtools proporciona la funcionalidad central para la lectura de archivos .dat de Siemens, y este proyecto expande sus capacidades para incluir reconstrucciones de imagenes.

Agradecemos enormemente a los autores y colaboradores de twixtools por su trabajo, que ha permitido el desarrollo de este paquete.

Si estas buscando una solucion mas completa para leer y escribir archivos .dat de Siemens, te recomendamos que tambien consultes twixtools directamente.
https://github.com/pehses/twixtools
package-processamento-imagem 0.0.5
biblioteca de processamento de imagens em Python que oferece uma ampla gama de ferramentas para a análise e manipulação de imagens
Requires Python: >=3.8

# package_processamento_imagem

Descripton:
O pacote package_processamento_imagem Ã© usado para:
    Processing
        - Histogram matching
        - Structural similary
        - Resize image
    utils
        - Read image
        - Save image
        - Plot image
        - Plot result
        - Plot histogram


## Installation 

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_processamento_imagem

```bash
pip install package_processamento_imagem
```

## Author
Fernando Flavio

## License
[MIT](https://choosealicense.com/licenses/mit/)
cv-timeseries 0.0.2
My short description
Requires Python: >=3.8

# cv_timeseries

Description.\
The package cv_timeseries is used to:\
	- Calculate the variation coefficient (VC) of a time series;\
	- Plot the VC.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install cv_timeseries

```bash
pip install cv_timeseries
```

## Usage

```python
from cv_timeseries.statistics.calculate_cv import VC
from cv_timeseries.plots.plot_cv import Plot


cv = VC(time_series).calculate_vc()
Plot(cv).plot_cv()
```

## Author
Ana Sofia

## License
[MIT](https://choosealicense.com/licenses/mit/)