semvec/pypi-packages huggingface dataset:
bse 3.1.0
Unofficial Python Api for BSE India stock exchange
Requires Python: >=3.8
Keywords: bse, bse-stock-data, stock-market-api, stock-news-api

# BseIndiaApi

An Unofficial Python Api for BSE India stock exchange.

Python version: >= 3.8

## Install with PIP

```
pip install -U bse
```

## Documentation

[https://bennythadikaran.github.io/BseIndiaApi/](https://bennythadikaran.github.io/BseIndiaApi/)

You might like [stock-news](https://github.com/BennyThadikaran/stock-news) built using `BseIndiaApi`. It helps to keep track of corporate announcements and actions on your portfolio.

## Usage

Using with statement

```python
from bse import BSE

with BSE(download_folder='./') as bse:
    scripCode = bse.getScripCode('tcs')  # 532540 bse scrip code

    data = bse.actions(scripcode=scripCode)

    ohlc = bse.quote(scripCode)  # Open, High, Low, LTP
```

or

```python
from bse import BSE
from bse.constants import INDEX

bse = BSE(download_folder='./')

code = bse.getScripCode('tcs')  # 532540 bse scrip code

gainers = bse.gainers(by='index', name=INDEX.BSE500)

bse.exit()  # close the request session
```

## Sample Responses

`src/samples` contain the sample responses from the various methods in JSON format.

The files are named after the corresponding method in `src/BSE.py`. Use it to understand the API response structure.

## Example Folder

`src/examples` contains scripts that use the `BSE.py`.

To use the scripts download or clone the repo.

- [get_all_announcements.py](https://github.com/BennyThadikaran/BseIndiaApi/blob/main/src/examples/get_all_announcements.py): This file demonstrates how to paginate and get all announcements using `BSE.announcements`. It has step by step explanation of code.
- [actions.py](https://github.com/BennyThadikaran/BseIndiaApi/blob/main/src/examples/actions.py): `py actions.py infy` to print the recent corporate actions. Nothing more.
- [advances.py](https://github.com/BennyThadikaran/BseIndiaApi/blob/main/src/examples/advances.py): `py advances.py` to print the advance decline ratios for various bse Indexes.

You may also like my other repo: [Stock-News](https://github.com/BennyThadikaran/stock-news) - It uses BseIndiaApi and displays stock announcements, dividend, bonus/splits and upcoming results etc for your portfolio or watchlist stocks.
VisioCrypt 0.1
Package to encrypt short messages

# VisioCrypt

**Visual cryptography** package designed to hide text messages inside a QR
code, generating two transparencies that reveal the content when overlaid.

## Installation

1. Clone this repository and enter it:

   ```bash
   git clone https://github.com/<user>/VisioCrypt.git
   cd VisioCrypt
   ```

2. Install the package with `pip`:

   ```bash
   python -m pip install .
   ```

   For an editable installation for development you can use:

   ```bash
   python -m pip install -e .
   ```

## Usage

The `VisioCrypt.main` module provides high-level functions for encrypting and
decrypting messages. The basic workflow consists of two steps: generating the
transparencies from the text and recovering the message from them.

### Encryption

```python
from VisioCrypt.main import apply_encryption

trans_A, trans_B = apply_encryption(
    "secret message",
    save_ims_gen_trans=True,
    path_im_A="trans_A.png",
    path_im_B="trans_B.png",
)
```

The example above generates a QR code with the specified text and produces two
transparencies (`trans_A.png` and `trans_B.png`). When they are overlaid, the
original message can be recovered.

### Decryption

```python
from VisioCrypt.main import apply_decryption

message = apply_decryption(trans_A=trans_A, trans_B=trans_B)
print(message)  # prints: "secret message"
```

It is also possible to load the transparencies from files:

```python
message = apply_decryption(
    load_from_files=True,
    path_im_A="trans_A.png",
    path_im_B="trans_B.png",
)
```

## Package structure

```
VisioCrypt/
├── encryptor.py  # Generates the QR and the transparencies
├── decryptor.py  # Recovers the message from the transparencies
└── main.py       # High-level functions (apply_encryption, apply_decryption)
```
pyargman 0.0.4
A Python module like argumentparser for managing comandline  arguments,
Requires Python: >=3.6
Keywords: cli, arguments, manager, alternative

# pyargman

**pyargman** is a lightweight Python module for managing command-line arguments,


## Features

- **Simple API** for building command-line arguments
- **Supports duplicate and boolean arguments**
- **Easy conversion to CLI list or string format**

## Installation

Install pyargman using pip:

```bash
pip install pyargman
```
install from github

```
git clone https://github.com/its-me-abi/pyargman.git
cd pyargman
```

## Quick Start

Below is an example demonstrating how to use pyargman to manage and convert CLI arguments:

```python
from pyargman import ArgManager

# Initialize argument manager for a CLI command (e.g., "java")
a = ArgManager("java")

# Add arguments
a.set_arg("--helo_duplicate", 1)
a.set_arg("--helo_duplicate", 2)  # Supports duplicate arguments
a.set_arg("--helo_duplicate", 2 , delete = True)  # if there is already a value 2 then it willbe deleted                             
a.set_arg("--helo_boolean_value", True)  # Argument without a value
a.set_arg("script_path_like", True)

# Convert arguments to list and string formats
print("Converted to CLI list:", a.tolist())
print("Converted to CLI string:", a.toString())

responce would looks like
   converted to cli list  ['java', '--helo_duplicate', '1', '--helo_boolean_value', 'script_path_like']
   converted to cli string  java --helo_duplicate 1 --helo_boolean_value script_path_like
#
```
### License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Author

Developed and maintained by [its-me-abi](https://github.com/its-me-abi).
bpl-next 0.4.0
Bayesian models for football match prediction, based on Dixon and Coles (1997).
Requires Python: >=3.9

# bpl-next
![tests](https://github.com/anguswilliams91/bpl-next/actions/workflows/tests.yml/badge.svg)

new version of [bpl](https://github.com/anguswilliams91/bpl/tree/master), implemented in numpyro

## Statistical model

The statistical model behind `bpl` is a slight variation on the Dixon & Coles approach.
The likelihood is:

![equation](https://latex.codecogs.com/gif.latex?p(y_h%2C%20y_a)%20%3D%20\tau(y_h%2C%20y_a)\times%20\mathrm{Poisson}(y_h%20\%2C%20|%20\%2C%20a_h%20b_a%20\gamma_h)%20\times%20\mathrm{Poisson}(y_a%20\%2C%20|%20\%2C%20a_a%20b_h))

where y_h and y_a are the number of goals scored by the home team and the away team, respectively.
a_i is the *attacking aptitude* of team i and b_i is the *defending aptitude* of team j.
gamma_i represents the home advantage for team i, and tau is a correlation term that was introduced by Dixon and Coles to produce more realistic scorelines in low-scoring matches.
The model uses the following bivariate, hierarchical prior for a and b

![equation](https://latex.codecogs.com/gif.latex?%5Cbegin%7Bbmatrix%7D%20%5Clog%20a_i%20%5C%5C%20%5Clog%20b_i%20%5Cend%7Bbmatrix%7D%20%5C%2C%20%5Cbig%20%7C%20%5C%2C%20X_i%5Csim%20%5Cmathcal%7BN%7D%20%5Cleft%28%20%5Cbegin%7Bbmatrix%7D%20X_i%20.%20%5Cbeta_a%20%5C%5C%20%5Cmu_b%20&plus;%20X_i%20.%20%5Cbeta_b%20%5Cend%7Bbmatrix%7D%2C%5Cquad%20%5Cbegin%7Bbmatrix%7D%20%5Csigma_a%5E2%2C%20%5Cquad%20%5Crho%20%5Csigma_a%20%5Csigma_b%20%5C%5C%20%5Crho%20%5Csigma_a%20%5Csigma_b%2C%20%5Cquad%20%5Csigma_b%5E2%20%5Cend%7Bbmatrix%7D%20%5Cright%29.)

X_i are a set of (optional) team-level covariates (these could be, for example, the attack and defence ratings of team i on Fifa).
beta are coefficient vectors, and mu_b is an offset for the defence parameter.
rho encodes the correlation between a and b, since teams that are strong at attacking also tend to be strong at defending as well.
The home advantage has a log-normal prior

![equation](https://latex.codecogs.com/gif.latex?\gamma_i%20\sim%20\mathrm{LogNormal}(\mu_\gamma%2C%20\sigma_\gamma)%2C)


Finally, the hyper-priors are

![equation](https://latex.codecogs.com/gif.latex?\begin{align}%20\mu_b%2C%20\beta_a%2C%20\beta_b%2C\mu_\gamma%20%26\sim%20\mathcal{N}(0%2C%201)%2C%20\nonumber%20\\%20\sigma_a%2C%20\sigma_b%20%2C%20\sigma_\gamma%20%26\sim%20\mathcal{N}^&plus;(0%2C%201)%2C%20\nonumber%20\\%20u%20%3D%20(\rho%20&plus;%201)%20/%202%20%26\sim%20\mathrm{Beta}(2%2C%204).%20\nonumber%20\end{align})
sketch-image 0.1.1
Convert images into sketches
Requires Python: >=3.12

# Sketch Image

> [!WARNING]
> This package is just a playground to learn packages and fun experiments.

Convert Images to Sketches

# Installation

```bash
pip install sketch-image
```

# Get Started

```bash
sketch-image --image <image_path> --output <output_path>
```

Note: The `--image` and `--output` flags are optional.

- The CLI will prompt for input image path until supplied.
- The output will be placed in the Pictures directory within the user's home directory by default.

For help, run:

```bash
sketch-image --help
```
fseconomy-python 0.1.2
Python Bindings for FSEconomy
Requires Python: >=3.9

# FSEconomy Python Bindings

This package provides Python bindings for various [FSEconomy](https://www.fseconomy.net) APIs.

[![Documentation Status](https://readthedocs.org/projects/fseconomy-python/badge/?version=latest)](https://fseconomy-python.readthedocs.io/en/latest/?badge=latest)

**Important Links**

* Documentation: https://fseconomy-python.readthedocs.io/
* GitHub: https://github.com/fseconomy/fseconomy-python
* Bug Tracker: https://github.com/fseconomy/fseconomy-python/issues

## Usage

### Initialization

In order to use any of FSEconomy's APIs, you will need to initialize 
the corresponding API keys:

```python
import fseconomy

fseconomy.set_access_key('0123456789ABCDEF')
fseconomy.set_service_key('0123456789ABCDEF')
fseconomy.set_user_key('0123456789ABCDEF')
```

Please refer to the corresponding section of the
[FSEconomy Operations Guide](https://sites.google.com/site/fseoperationsguide/data-feeds)
for an explanation of the different keys and their purpose.

### FSEconomy Data Feeds

Retrieve data from FSEconomy's data feed API. For most feeds, you must set a valid key first.

```python
import fseconomy
import fseconomy.data

fseconomy.set_access_key('0123456789ABCDEF')
fseconomy.set_service_key('0123456789ABCDEF')
fseconomy.set_user_key('0123456789ABCDEF')

data_feed = fseconomy.data.aircraft_configs()
print(data_feed.status) # HTTP response status code
print(data_feed.data)   # parsed into native python data types
print(data_feed.binary) # true if raw data is binary data
print(data_feed.raw)    # raw data as received from the server
```

A comprehensive list of all data feeds can be found in the
[official documentation](https://fseconomy-python.readthedocs.io/en/latest/)

### FSEconomy REST API

### FSEconomy Auth API
GALINDA 1.0.3
GALINDA is a Galaxy Image N-Body Data Animator. Galinda is designed to provide you with 2D Histogram images of particles in your simulations and produce an animation of these histograms. This function is useful for obtaining a quick overall view of your simulated astronomical object and its evolution over time-steps.

# GALINDA
Group 11's PyPI Package, CodeAstro 2025

GALINDA is a Galaxy Image N-Body Data Animator. Galinda is designed to provide you with 2D Histogram images of particles in your simulations and produce an animation of these histograms. This function is useful for obtaining a quick overall view of your simulated astronomical object and its evolution over time-steps.

Inputs: A folder containing HDF5 files of particle position data for a given snapshot or time-step. 

Package Requirements: numpy, matplotlib, h5py, ffmpeg

Any comments, questions, or concerns, please reach out to the developers: edavis43@ur.rochester.edu, pfofie@uci.edu, edward.skrabacz@u.northwestern.edu