semvec/pypi-packages huggingface dataset:
subradar 1.1.5
Library for electromagnetic physics applied to subsurface radars
Requires Python: >=3.7

# `subradar`

Python library for electromagnetic physics applied to subsurface radars

## Installation

`pip install subradar`

## Keywords

Most of the modules accept the following keywords with SI units:


| Keyword | Definition |
|---------|------------|
| bmw     | Beamwidth angle |
| cl      | Correlation length |
| ep      | Dielectric permittivity |
| h       | Altitude       |
| mp      | Magnetic permeability |
| nRCS    | Normalized Radar Cross Section |
| RCS     | Radar Cross Section |
| n       | Optical index  |
| R       | Reflection coefficient |
| sigma_h, sh | Root Mean Square height |
| theta, th | angle        |
| T       | Transmission coefficient |
| wf      | Wave frequency |
| wb      | Bandwidth      |
| wk      | Wave number    |
| wl      | Wavelength     |
AstroToolkit 1.7.1
A package for the gathering, plotting and analysis of astronomical data.
Requires Python: >=3.11

AstroToolkit
============

AstroToolkit (ATK) is a set of tools for fetching, plotting, and analysing astronomical data.

<br>

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

To install AstroToolkit from PyPi, use

```
pip install AstroToolkit
```

<br>

Documentation
-------------

Full documentation for the package can be found [here](https://astrotoolkit.readthedocs.io/en/latest/).
rsr 1.0.8
Utilities for applying the Radar Statistical Reconnaissance technique
Requires Python: >=3.7

# Presentation

This is a Python package providing basic utilities for applying the Radar Statistical Reconnaissance.

# Installation

`pip install rsr`

# Example

Below, 'f' is a Statfit python Class that holds the results of the rsr processing ([description here](https://github.com/cgrima/rsr/blob/master/rsr/Classdef.py)) 

```python

import rsr
import wget
import pandas as pd
import matplotlib.pyplot as plt
%pylab

# Load data (example is non-calibrated surface echo linear amplitudes from SHARAD orbit 0887601)
data_filename = wget.download('https://raw.githubusercontent.com/cgrima/rsr/master/rsr/data.txt')
data = pd.read_csv(data_filename)
amp = data['amp'].values

# Apply RSR to a given subset of amplitude.
sample = amp[80000:85000]
f = rsr.run.processor(sample, fit_model='hk')
f.plot() # Plot results

# Apply RSR along a vector of successive amplitude.
# The RSR is applied on windows made of 1000 values. Each window is separated by
# 500 samples (can be time consuming).
a = rsr.run.along(amp, winsize=1000, sampling=250, nbcores=2)
rsr.utils.plot_along(a) # Plot results
```

# Citation

Grima, C., Schroeder, D. M., Blankenship, D. D., and Young, D. A. (2014) [Planetary landing zone reconnaissance using ice penetrating radar data: concept validation in Antarctica][1]. Planetary and Space Science 103, 191-204.

  [1]: http://www.sciencedirect.com/science/article/pii/S0032063314002244
zerodhawrapper 1.3
A Python wrapper for the Zerodha API that simplifies interaction with Zerodha's trading platform
Requires Python: >=3.6

# Zerodha Wrapper

A Python wrapper for the Zerodha API that simplifies interaction with Zerodha's trading platform.

## Features

- Easy authentication with Zerodha
- Automated login with TOTP support
- Simplified order placement and position management
- Functions for retrieving market data
- Support for futures and options trading
- Historical data retrieval
- Margin checking utilities

## Installation

```bash
pip install zerodhawrapper
```

## Configuration

1. Create a `key.json` file with your API credentials:
```json
{
    "api_key": "your_api_key",
    "api_secret": "your_api_secret"
}
```

2. Create a `credentials.json` file with your login credentials:
```json
{
    "username": "your_zerodha_username",
    "password": "your_zerodha_password",
    "totp": "your_totp_secret"
}
```

## Usage

```python
from zerodhawrapper import initialize_kite, send_order, retrieve_positions

# Initialize the Kite connection
kite = initialize_kite()

# Place an order
order_id = send_order(
    kite=kite,
    symbol="INFY",
    quantity=1,
    transaction_type="BUY",
    order_type="MARKET",
    product="CNC"
)

# Get positions
positions = retrieve_positions(kite)
```

### Available Functions

- `login()`: Authenticate with Zerodha
- `initialize_kite()`: Initialize KiteConnect client
- `get_quote(symbol)`: Get quote for a symbol
- `send_order(...)`: Place trading orders
- `retrieve_positions(kite)`: Get current positions
- `get_nifty50_futures_symbols(kite)`: Get Nifty50 futures symbols
- `get_nearest_nifty_fut_price(kite)`: Get nearest Nifty futures price
- `check_available_margin(kite)`: Check available trading margin
- `get_fno_underlyings()`: Get F&O underlying symbols
- `get_historical(...)`: Get historical data
- And many more...

## Development

To contribute to this project:

1. Clone the repository
2. Install development dependencies: `pip install -e .`
3. Make your changes
4. Submit a pull request

## License

MIT License
mmpycorex 0.3.16
Python package for unified MMCore access through pymmcore or ZMQ-MMCoreJ + associated utilities

[![License](https://img.shields.io/pypi/l/mmpycorex.svg)](https://github.com/micro-manager/mmpycorex/raw/master/LICENSE)
[![PyPI](https://img.shields.io/pypi/v/mmpycorex.svg)](https://pypi.org/project/mmpycorex)

# mmpycorex

This package contains modules for downloading and installing MM through python, and for accessing the Java core of
a running micro-manager instance, creating a headless java core object for access through python, or creating and instance of
the python wrapper of the core (pymmcore)

### Installation

`pip install mmpycorex`

## Programatically installing Micro-Manager
- Python utility functions for downloading and installing Micro-Manager
```python
from mmpycorex import download_and_install_mm, find_existing_mm_install

# this automatically installs the latest nightly build
# specify destination="your/custom/path", otherwise it will default to 'C:/Program files/Micro-Manager/'
# on windows or the home directory on mac
installed_path = download_and_install_mm()
```

## Accessing the Java core through python
```python
### Java Core example
from mmpycorex import create_core_instance, terminate_core_instances, get_default_install_location

# If micro-manager is alread running, you can get access to the core directly
# (just make sure the "run server" in the tools options dialog is checked)

# Otherwise you must create an instance of the Core in headless mode
mm_location = get_default_install_location() # 'C:/Program files/Micro-Manager/'
config_file = 'MMConfig_demo.cfg'
create_core_instance(mm_location, config_file, python_backend=False) # Create a remote MMCoreJ object

# Now that a core is running (either through the MM App or headless mode), create an object to access it
core = Core()

#### use the core

terminate_core_instances() 
```

## Accessing the python core (pymmcore)
```python
### pymmcore example
from mmpycorex import create_core_instance, terminate_core_instances

# Otherwise you must create an instance of the Core in headless mode
mm_location = get_default_install_location() # 'C:/Program files/Micro-Manager/'
config_file = 'MMConfig_demo.cfg'
create_core_instance(mm_location, config_file, python_backend=True) # Create pymmcore instance

# Now that a core is running (either through the MM App or headless mode), create an object to access it
core = Core()

#### use the core

terminate_core_instances() 
```

## Install issues on M1 Macs

https://github.com/conda-forge/miniforge/issues/165#issuecomment-860233092