semvec/pypi-packages huggingface dataset:
opsicos 1.1.2
A professional Python SDK for the Opsicos AI Gateway.
Requires Python: >=3.6

# Opsicos Python SDK

Install this private SDK using pip and Git:

```bash
pip install "git+https://YOUR_GITHUB_USERNAME:YOUR_PERSONAL_ACCESS_TOKEN@github.com/1-Tawsif-1/opsicos-api.git#subdirectory=sdks/python"
repo2md 0.2.0
Python module to convert GitHub repositories to markdown files.
Requires Python: >=3.10
Keywords: repo2md

# repo2md

`repo2md` is a python module to convert GitHub repositories into Markdown files.

![Python][label-pyversion]

**Platform Supported**

![Platform][label-platform]

**Deployments**

[![pypi][label-actions-pypi]][gha_pypi]

[![Pypi][label-pypi]][pypi]
[![Pypi-format][label-pypi-format]][pypi-files]
[![Pypi-status][label-pypi-status]][pypi]

## Installation

```shell
pip install repo2md
```

## Usage

```python
import os
import dotenv

import repo2md

repo2md.IGNORE_DIRECTORIES.append("docs_gen")
repo2md.IGNORE_LIST.append("docs_gen")

dotenv.load_dotenv(".env", override=True)

repo2md.convert_repo_to_md(
    repo_name="Jarvis",
    git_owner="thevickypedia",
    git_token=os.getenv("GIT_TOKEN"),
)
```

#### CLI

```shell
repo2md --help
```
> _The CLI exposes fewer options than using the module directly in code._

## Coding Standards
Docstring format: [`Google`][google-docs] <br>
Styling conventions: [`PEP 8`][pep8] and [`isort`][isort]

## [Release Notes][release-notes]
**Requirement**
```shell
python -m pip install gitverse
```

**Usage**
```shell
gitverse-release reverse -f release_notes.rst -t 'Release Notes'
```

## Linting

**Requirement**
```shell
python -m pip install pre-commit
```

**Usage**
```shell
pre-commit run --all-files
```

## Pypi Package
[![pypi-module][label-pypi-package]][pypi-repo]

[https://pypi.org/project/repo2md/][pypi]

## License & copyright

&copy; Vignesh Rao

Licensed under the [MIT License][license]

[//]: # (Labels)

[3.11]: https://docs.python.org/3/whatsnew/3.11.html
[license]: https://github.com/thevickypedia/repo2md/blob/main/LICENSE
[google-docs]: https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings
[pep8]: https://www.python.org/dev/peps/pep-0008/
[isort]: https://pycqa.github.io/isort/
[samples]: https://github.com/thevickypedia/repo2md/tree/main/samples

[label-actions-pypi]: https://github.com/thevickypedia/repo2md/actions/workflows/python-publish.yaml/badge.svg
[label-pypi]: https://img.shields.io/pypi/v/repo2md
[label-pypi-format]: https://img.shields.io/pypi/format/repo2md
[label-pypi-status]: https://img.shields.io/pypi/status/repo2md
[label-pypi-package]: https://img.shields.io/badge/Pypi%20Package-repo2md-blue?style=for-the-badge&logo=Python
[label-pyversion]: https://img.shields.io/badge/python-3.11%20%7C%203.12-blue
[label-platform]: https://img.shields.io/badge/Platform-Linux|macOS|Windows-1f425f.svg
[release-notes]: https://github.com/thevickypedia/repo2md/blob/main/release_notes.rst

[gha_pypi]: https://github.com/thevickypedia/repo2md/actions/workflows/python-publish.yml

[pypi]: https://pypi.org/project/repo2md
[pypi-files]: https://pypi.org/project/repo2md/#files
[pypi-repo]: https://packaging.python.org/tutorials/packaging-projects/
aes-bridge 2.0.4
AesBridge is a modern, secure and cross-language AES encryption library
Requires Python: >=3.10

# AesBridge Python

![PyPI Version](https://img.shields.io/pypi/v/aes-bridge.svg)
![CI Status](https://github.com/mervick/aes-bridge-python/actions/workflows/python-tests.yml/badge.svg)
![CI Status](https://github.com/mervick/aes-bridge-python/actions/workflows/test-published-pypi.yml/badge.svg)

**AesBridge** is a modern, secure, and cross-language **AES** encryption library. It offers a unified interface for encrypting and decrypting data across multiple programming languages. Supports **GCM**, **CBC**, and **legacy AES Everywhere** modes.


This is the **Python implementation** of the core project.  
👉 Main repository: https://github.com/mervick/aes-bridge

## Features

- 🔐 AES-256 encryption in GCM (recommended) and CBC modes
- 🌍 Unified cross-language design
- 📦 Compact binary format or base64 output
- 🐍 Pure Python with zero dependencies (except `cryptography`)
- ✅ HMAC Integrity: CBC mode includes HMAC verification
- 🔄 Backward Compatible: Supports legacy AES Everywhere format

## Quick Start

### Installation

```
pip install aes-bridge
```

### Usage

```python
from aes_bridge import encrypt, decrypt

ciphertext = encrypt("My secret message", "MyStrongPass")
plaintext = decrypt(ciphertext, "MyStrongPass")
```

## API Reference

### Main Functions (GCM by default)

- `encrypt(data, passphrase)`  
  Encrypts a string using AES-GCM (default).  
  **Returns:** base64-encoded string.
  
- `decrypt(data, passphrase)`  
  Decrypts a base64-encoded string encrypted with AES-GCM.

### GCM Mode (recommended)

- `encrypt_gcm(data, passphrase)`  
  Encrypts a string using AES-GCM.
  **Returns:** base64-encoded string.

- `decrypt_gcm(data, passphrase)`  
  Decrypts a base64-encoded string encrypted with `encrypt_gcm`.

- `encrypt_gcm_bin(data, passphrase)`  
  Returns encrypted binary data using AES-GCM.

- `decrypt_gcm_bin(data, passphrase)`  
  Decrypts binary data encrypted with `encrypt_gcm_bin`.

### CBC Mode

- `encrypt_cbc(data, passphrase)`  
  Encrypts a string using AES-CBC. 
  HMAC is used for integrity verification.  
  **Returns:** base64-encoded string.  

- `decrypt_cbc(data, passphrase)`  
  Decrypts a base64-encoded string encrypted with `encrypt_cbc` and verifies HMAC.

- `encrypt_cbc_bin(data, passphrase)`  
  Returns encrypted binary data using AES-CBC with HMAC.

- `decrypt_cbc_bin(data, passphrase)`  
  Decrypts binary data encrypted with `encrypt_cbc_bin` and verifies HMAC.

### Legacy Compatibility

⚠️ These functions are kept for backward compatibility only.
Their usage is strongly discouraged in new applications.

- `encrypt_legacy(data, passphrase)`  
  Encrypts a string in the legacy AES Everywhere format.  

- `decrypt_legacy(data, passphrase)`  
  Decrypts a string encrypted in the legacy AES Everywhere format.
pyonvista 0.8.4
A tiny python API wrapper for onvista.de financial website.
Requires Python: >=3.10

# pyonvista
A tiny python wrapper to the non-public onvista.de REST-Api.

As the API is not public user shall assume that the usage of this package harms the
website user agreements. However, this version now avoids any web scrapping for metadata.

You can search for an instrument and get its quote data. 
The quote data can be limit by resolution and date.

The wrapper now also works with instruments other than stocks. Also for example data from ETF
can be requested. 

Im not planing to add other API Endpoints at the moment as long as nobody gives me a good reason for this.

Additionally the wrapper now is asynchronous. User should be aware of asyncio or async programming.


## Installation
    pip install pyonvista

## Usage
```python
import asyncio
import aiohttp
import pprint

from pyonvista import PyOnVista

async def main():
    client = aiohttp.ClientSession()
    api = PyOnVista()
    await api.install_client(client)
    async with client:
        instruments = await api.search_instrument("VW")
        instrument = await api.request_instrument(instruments[0])
        quotes = await api.request_quotes(instrument, )
        pprint.pprint(instrument)
        pprint.pprint(quotes[:3])
        # prints a lot of information of VW Stonk
        # try a etf
        instruments = await api.search_instrument(key="IE00B42NKQ00")
        quotes = await api.request_quotes(instruments[0])
    pprint.pprint(quotes[0].instrument)

    await client.close()
    await asyncio.sleep(.1)

if __name__ == '__main__':
    asyncio.run(main())
```
pytest-excel 1.8.1
pytest plugin for generating excel reports
Requires Python: >=3.11
Keywords: excel, pytest, report

pytest-excel
================


pytest-excel is a plugin for `py.test <http://pytest.org>`_ that allows to 
to create excel report for test results.


Requirements
------------


You will need the following prerequisites in order to use pytest-excel:

- Python 3.11 and above
- pytest
- pandas
- openpyxl


Installation
------------


To install pytest-excel and required dependencies::

    $ pip install pytest-excel openpyxl

Then run your tests with::

    $ py.test --excelreport=report.xls

If you would like more detailed output (one test per line), then you may use the verbose option::

    $ py.test --verbose

If you would like to run tests without execution to collect test doc string::

    $ py.test --excelreport=report.xls --collect-only


If you would like to get timestamp in the as filename::

    $ py.test --excelreport=report%Y-%M-dT%H%.xls
pyvaulter 0.3.2
Encrypt sensitive data. Emulates much of the functionality of Ansible Vaults but for Python.
Requires Python: >=3.10

# pyvaulter

A very simple Python module that can be used to encrypt sensitive data. Emulates much of the functionality of Ansible Vaults but for Python.

## Requires Linux: Uses `vim` for editing, and `less` for viewing

## Basic Usage (Creating/Editing Encrypted Files)

All encrypted files are placed in the current working directory.

`pyvaulter [--help] <edit|create|view|encrypt> <file_name>`

`pyvaulter create <file_name>`: Create and encrypt a new file

`pyvaulter edit <file_name>`: Edit an encrypted file that has been encrypted by pyvaulter

`pyvaulter view <file_name>`: View an encrypted file a file that has been encrypted by pyvaulter

`pyvaulter encrypt <file_name>`: Encrypt an existing, unencrypted file (path). This is intended to encrypt a copy of an
already-existing file on your system. It will not encrypt the original file, but rather create a copy of it.

## Basic Usage (In a script)

You can use `pyvaulter` in your script or application to decrypt the contents of files at runtime. So, in practice the
workflow looks like this:

1. Encrypt an existing file, or create a new encrypted file with pyvaulter
2. In your script or application, decrypt the file like so:

```python
from pyvaulter import decrypt
from getpass import getpass

# You could also just pass in the decryption password using an environment variable, that way you're not prompted to
# type it each time, but for the sake of simplicity, you can also do it this way.
secure_password = getpass('Enter decryption password')

# Decrypt the file, returning the contents as a string
my_secret_file_content = decrypt(file_path='/path/to/encrypted/file', decryption_password=secure_password)
```