semvec/pypi-packages huggingface dataset:
barc4beams 2025.11.26
A Python project for: standardization, statistics, and plotting ray-traced photon beams (PyOptiX, SHADOW3/4).
Requires Python: >=3.10
Keywords: ray-tracing, beamline design, x-ray optics, optics

# barc4beams

**barc4beams** is a Python package providing tools for standardization, statistical analysis,
 and visualization of (photon) beams from simulation codes such as **SHADOW3/4** and **PyOptiX**.
 **barc4beams** also converts intensity maps from wave-optics codes such as **SRW** and **WOFRY**.

It offers a data class called `Beam`, which offers import/export utilities, statistical
moment-based analysis, and a consistent plotting API for beam profile, divergence,
phase space, and caustic visualization.

---

## Features

- Import beams from **SHADOW3/4**, **PyOptiX**, or intensity maps from **SRW** / **WOFRY**  
- Convert to a standard `Beam` format  
- Compute beam moments, FWHM, skewness, kurtosis, and focal distances  
- Merge and analyze ensembles of beams across runs  
- Propagate beams in free space and build caustics  
- Save and reload beams in HDF5 and JSON formats (stats)
- Plotting using Matplotlib

See **examples/README.md** for detailed descriptions of the  
three reference notebooks:

1. Beam import from ray-tracing codes  
2. Beam sampling from intensity maps  
3. Beam collections and statistical aggregation

---

## Installation

From PyPI:

```bash
pip install barc4beams
```

---

[![Documentation Status](https://readthedocs.org/projects/barc4beams/badge/?version=latest)](https://barc4beams.readthedocs.io/en/latest/?badge=latest)
[![PyPI](https://img.shields.io/pypi/v/barc4beams.svg)](https://pypi.org/project/barc4beams/)
[![License: CeCILL-2.1](https://img.shields.io/badge/license-CeCILL--2.1-blue.svg)](https://opensource.org/licenses/CECILL-2.1)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17588927.svg)](https://doi.org/10.5281/zenodo.17588927)
pyPhasesRecordloaderSHHS 0.8.0
Adds a record loaders to the pyPhases package
Requires Python: >=3.5

# Extension for pyPhasesRecordloader

Extension to load records from the Sleep Heart Health Study (SHHS) database. Includes both parts (shhs1 and shhs2).

The extension requires a downloaded version of the shhs dataset. The location can be set using the `shhs-path' configuration value.

## Usage

In a phase you can access the data through the `RecordLoader`:

Add the plugins and config values to your project.yaml::

```yaml
name: SHHSProject
plugins:
  - pyPhasesML
  - pyPhasesRecordloaderSHHS
  - pyPhasesRecordloader

phases:
  - name: MyPhase

config:
  shhs-path: C:/datasets/shhs

```

In a phase (`phases/MyPhase.py`) you can access the records using the `RecordLoader`:

```python
from pyPhasesRecordloader import RecordLoader
from pyPhases import Phase

class MyPhase(Phase):
    def run(self):
      recordIds = recordLoader.getRecordList()
      for recordId in recordIds:
        record = recordLoader.getRecord(recordId)
```

Run your project with `python -m phases run MyPhase`.
hyperparse 0.0.9
Parse shell env variables to python dict
Keywords: Shell env

# Hyperparse

A simple and powerful parser for shell environment variables and command line arguments.

## Installation

```bash
pip install hyperparse
```

## Quick Start

```python
from hyperparse import parse_string

config = parse_string('lr=1e-4,batch=32,model={name:bert,layers:12}')

print(config.lr)           # 0.0001
print(config.batch)        # 32
print(config.model.name)   # 'bert'
```

## Supported Types

| Type | Example | Result |
|------|---------|--------|
| Integer | `a=1` | `1` |
| Negative | `a=-1` | `-1` |
| Float | `a=3.14` | `3.14` |
| Scientific | `a=1e-5` | `0.00001` |
| Boolean | `a=True` | `True` |
| None | `a=None` or `a` | `None` |
| String | `a=hello` | `'hello'` |
| List | `a=[1,2,3]` | `[1, 2, 3]` |
| Nested List | `a=[[1,2],[3,4]]` | `[[1, 2], [3, 4]]` |
| Dict | `a={x:1,y:2}` | `{'x': 1, 'y': 2}` |
| Nested | `a={x:[1,2],y:{z:3}}` | `{'x': [1, 2], 'y': {'z': 3}}` |

## Attribute Access

Parse results support both dict-style and attribute-style access:

```python
config = parse_string('a=1,b={x:2,y:3}')

# Dict style
config['a']      # 1
config['b']['x'] # 2

# Attribute style
config.a         # 1
config.b.x       # 2
```

## Check Key Existence

```python
config = parse_string('a=1,b=2,c=3')

# Check if all keys exist
config.hasall('a', 'b')      # True
config.hasall('a', 'x')      # False

# Check if any key exists
config.hasany('a', 'x')      # True
config.hasany('x', 'y')      # False
```

## Environment Variables

```bash
export usermode="lr=1e-4,batch=32,epochs=10"
python main.py
```

```python
from hyperparse import parse, reset_hyper

usermode, _ = parse("usermode")
print(usermode.lr)     # 0.0001
print(usermode.batch)  # 32
```

## Argparse Integration

```python
from hyperparse import parse, reset_hyper
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--lr', type=float, default=0.01)
parser.add_argument('--batch', type=int, default=16)
args = parser.parse_args()

usermode, _ = parse("usermode")
reset_hyper(usermode, args)

print(args.lr)     # 0.0001 (overridden by env)
print(args.batch)  # 32 (overridden by env)
```

## Local Variables

```python
from hyperparse import parse, reset_hyper

lr = 0.01
batch = 16

usermode, _ = parse("usermode")
reset_hyper(usermode)

print(lr)     # 0.0001
print(batch)  # 32
```

## API Reference

### `parse_string(s)`
Parse a string into an AttrDict.

### `parse(name)`
Parse from environment variable or command line argument.

### `reset_hyper(hyper, pargs=None)`
Update argparse namespace or local variables with parsed values.

### `AttrDict`
Dict subclass with attribute access and helper methods:
- `.hasall(*keys)` - True if all keys exist
- `.hasany(*keys)` - True if any key exists

## License

MIT
qe-api-client 3.1.0
Python client for the Qlik Engine JSON API
Requires Python: >=3.6

# Qlik Engine API Client

Python client for the [Qlik Engine JSON API](https://help.qlik.com/en-US/sense-developer/November2024/Subsystems/EngineAPI/Content/Sense_EngineAPI/introducing-engine-API.htm)

Forked from [jhettler/pyqlikengine](https://github.com/jhettler/pyqlikengine)

## Requirements
* Python 3.6+
* websocket-client>=0.47.0

## Installation
```bash
pip install qe-api-client
```

## Connecting to Qlik Sense Enterprise Server
You need to export the Qlik Sense certificates in PEM format from the Qlik Sense Enterprise server to a local folder in 
order to authenticate on the server.

```python
from qe_api_client.engine import QixEngine

url = 'qlik-1.ad.xxx.xxx'
user_directory = 'UserDomainToQlikLogin'
user_id = 'sense'
ca_certs = 'qlik_certs/qlik-1_root.pem'
certfile = 'qlik_certs/qlik-1_client.pem'
keyfile = 'qlik_certs/qlik-1_client_key.pem'
qixe = QixEngine(url=url, user_directory=user_directory, user_id=user_id, ca_certs=ca_certs, certfile=certfile, 
                 keyfile=keyfile)

# print all apps in Qlik Server
print(qixe.ega.get_doc_list())
```

## Connecting to Qlik Sense Desktop
You need to start your Qlik Sense Desktop client on your local PC.

```python
from qe_api_client.engine import QixEngine

url = 'ws://localhost:4848/app'
qixe = QixEngine(url=url)

# print all apps in Qlik Server
print(qixe.ega.get_doc_list())
```

## Examples of usage
Please click on this [link](https://github.com/lr-bicc/qe-api-client/tree/master/examples) to find examples of usage of this client.

## API reference
Please click on this [link](https://lr-bicc.github.io/qe-api-client) for full API reference documentation .