semvec/pypi-packages huggingface dataset:
pdap-access-manager 0.4.4
Access Manager for accessing PDAP API
License: MIT
Requires Python: >=3.11

from pdap_access_manager.models.auth import AuthInfo

# Access-Manager

This is a small package that makes it easy to access the PDAP API.

It is utilized in several other PDAP repositories


## Usage

Utilizes an `aiohttp` client session, which can either be passed into the constructor, or automatically generated when using the AccessManager as a context manager.

```python
from pdap_access_manager.access_manager.async_ import AccessManagerAsync
from pdap_access_manager.models.request import RequestInfo
from pdap_access_manager.models.auth import AuthInfo
from pdap_access_manager.enums import RequestType

async def main():
    auth_info = AuthInfo(
        email="email",
        password="password"
    )
    async with AccessManagerAsync(auth_info) as am:
        url = f"{am.data_sources_url}/search/follow"
        await am.make_request(
            RequestInfo(
                url=url,
                type_=RequestType.GET,
                headers=am.jwt_header()
            )
        )

```
package-sampling 1.0.0
Python implementation of probability-based sampling algorithms inspired by the R package Sampling.
License: MIT
Requires Python: >=3.8

# Package Sampling

A Python implementation of various probability-based sampling algorithms, inspired by the R package [sampling](https://cran.r-project.org/web/packages/sampling/index.html). This package offers a variety of sampling methods like `Tillé's Method`, `Poisson Sampling`, `Systematic Sampling`, and more, designed for **unequal probability** sampling. The algorithms are implemented in a way that supports both theoretical understanding and real-world use cases.

## Installation

You can install the package directly from PyPI:

```bash
pip install package-sampling
```

## Usage Example

```python
from package_sampling.sampling import up_brewer
import numpy as np

pik = np.array([0.1, 0.2, 0.3, 0.4])

# Draw a sample using Brewer's method
samples = up_brewer(pik)
print(samples)
```

## Authors

Mohammadreza Razavian - <smrrazavian@outlook.com>
Bardia Panahbehagh - <Panahbehagh@khu.ac.ir>

## Citation

If you use this package in your work, please cite it as follows:

### APA Style

`Razavian, M., & Panahbehagh, B. (2025). Package Sampling: A Python implementation of various probability-based sampling algorithms. https://github.com/smrrazavian/package-sampling.`

### BibTex

```bibtex
@misc{razavian2025packagesampling,
  author = {Razavian, Mohammadreza and Panahbehagh, Bardia},
  title = {Package Sampling: A Python implementation of various probability-based sampling algorithms},
  year = {2025},
  url = {https://github.com/smrrazavian/package-sampling}
}
```

## Acknowledgments

This package is inspired by the R package "Sampling"
Thanks to all contributors and users

## Contributing

We welcome contributions to the package! If you have suggestions for new algorithms, improvements, or bug fixes, feel free to fork the repository and submit a pull request. Please ensure that your code adheres to the existing style and includes tests for any new functionality.
Steps to Contribute:

1. Fork the repository.
2. Clone your fork to your local machine.
3. Create a new branch for your changes.
4. Make your changes and commit them with clear messages.
5. Push your changes to your fork.
6. Open a pull request describing your changes.
investimentpylv 1.0.1
Uma biblioteca para análise de investimentos
License: MIT

# InvestPy

InvestPy é uma biblioteca Python para análise de investimentos. Ela permite obter dados de ações, calcular indicadores financeiros e visualizar gráficos de desempenho.

## Funcionalidades

- Obter dados históricos de ações usando a API do Alpha Vantage.
- Calcular retorno diário das ações.
- Visualizar gráficos de preços de fechamento das ações.

## Requisitos

- Python 3.6+
- pandas
- matplotlib
- requests
- pytest



## Configuração

Obtenha uma chave de API do [Alpha Vantage](https://www.alphavantage.co/support/#api-key) e substitua `'your_api_key'` pela sua chave de API nos exemplos abaixo.


## Uso

Depois de importar a biblioteca com o comando `pip install investimentpy==1.0.0` e já estiver com a sua KEY da *Alpha Vantage*, você pode criar um código como no exemplo a seguir:

```shell
import investpy

api_key = 'SUA_KEY'

# Obter dados de ação
df = investpy.obter_dados_acao('AAPL', api_key)

# Calcular retorno diário
df = investpy.calcular_retorno_diario(df)

# Plotar dados da ação
investpy.plotar_dados_acao(df)

```

Resultado:
![resultado calculo retorno diario](https://raw.githubusercontent.com/tadrianonet/investimentpy/main/exemplo.png)


## Contribuindo

1. Faça um fork do repositório
2. Crie uma nova branch (`git checkout -b feature/foobar`)
3. Commit suas mudanças (`git commit -am 'Add some feature'`)
4. Push para a branch (`git push origin feature/foobar`)
5. Abra um Pull Request

## Licença

Distribuído sob a licença MIT. Veja `LICENSE` para mais informações.
arycal 0.2.1
Across Run dYnamic Chromatogram ALignment - A Rust-based tool for aligning extracted ion chromatograms (EICs) across multiple runs
License: MIT
Requires Python: >=3.8
Keywords: mass-spectrometry, chromatogram, alignment, bioinformatics, proteomics

# ARYCAL Python Package

This crate contains the Python packaging for arycal, allowing you to install and use the arycal CLI from Python.

## Installation

### From PyPI (when published)

```bash
pip install arycal
```

### From source

```bash
# Clone the repository
git clone https://github.com/singjc/arycal.git
cd arycal/crates/arycal_pyo3

# Install maturin (build tool)
pip install maturin

# Build and install the package
maturin develop --bindings bin
```

## Usage

### Command Line

Once installed, you can use arycal from the command line:

```bash
arycal config.json
```

### Python API

You can also call arycal programmatically from Python:

```python
import arycal

# Run arycal with arguments
exit_code = arycal.run_arycal(["config.json"])

# Or let it use sys.argv
arycal.main()
```

## Building Wheels

To build distributable wheels for different platforms:

```bash
# From the arycal_pyo3 directory
cd crates/arycal_pyo3

# Build for the current platform
maturin build --release --bindings bin

# Build with specific features (e.g., MPI support)
maturin build --release --bindings bin --features mpi
```

The built wheels will be in the `../../dist/` directory and can be installed with:

```bash
pip install ../../dist/arycal-*.whl
```

## Requirements

- Python 3.8 or higher
- Rust toolchain 1.84 or higher (for building from source)

## Package Structure

- `python/arycal/` - Python wrapper module
- `pyproject.toml` - Python package configuration
- `examples/` - Example Python usage scripts
- `../arycal-cli/` - Rust CLI implementation

## How It Works

This package uses [maturin](https://github.com/PyO3/maturin) to build Python packages from Rust code. The `bindings = "bin"` configuration in `pyproject.toml` tells maturin to include the arycal binary in the Python wheel. The Python module provides a convenient wrapper to find and execute the binary.