semvec/pypi-packages huggingface dataset:
pulse-broker 1.0.14
Python SDK for Pulse Broker
Requires Python: >=3.7

# Pulse Python SDK

Official Python client for [Pulse Broker](https://github.com/marcosrosa/pulse).

## Installation

```bash
pip install pulse-broker
```

## Configuration

The SDK looks for a `pulse.yaml` (or `pulse.yml`) file in your project root. If not found, it defaults to `localhost:5555` (HTTP) and `localhost:5556` (gRPC).

### Example `pulse.yaml`

```yaml
# Connection Settings
broker:
  host: "localhost"
  http_port: 5555
  grpc_port: 5556
  timeout_ms: 5000

# Client Defaults
client:
  id: "my-python-app"
  auto_commit: true       # Automatically commit offsets after successful processing
  max_retries: 3

# Topic Configuration
topics:
  - name: "events"
    create_if_missing: true
    config:
      fifo: false
      retention_bytes: 1073741824  # 1GB
    consume:
      auto_commit: true

  - name: "transactions"
    create_if_missing: true
    config:
      fifo: true
    consume:
      auto_commit: false  # Manual commit required

  - name: "logs"
    create_if_missing: true
    config:
      fifo: false
    consume:
      auto_commit: true
```

## Usage

### Producer

You can send dictionaries (automatically serialized to JSON) or raw bytes.

```python
from pulse import Producer

# Initialize (uses pulse.yaml or defaults)
# You can override settings: Producer(host="10.0.0.1", port=9090)
producer = Producer()

# Send JSON
producer.send("events", {"type": "user_created", "id": 123})

# Send Bytes
producer.send("logs", b"raw log line")

producer.close()
```

### Consumer

Use the `@consumer` decorator to register message handlers.

```python
from pulse import consumer, commit, run

# Simple Consumer (uses auto_commit from config)
@consumer("events")
def handle_event(msg):
    print(f"Received event: {msg.payload}")
    # msg.payload is a dict if JSON, else bytes

# Manual Commit Consumer
# Override config params directly in the decorator if needed
@consumer("transactions", auto_commit=False)
def handle_transaction(msg):
    try:
        process_payment(msg.payload)
        commit()  # Manually commit offset
        print(f"Processed transaction {msg.offset}")
    except Exception as e:
        print(f"Failed to process: {e}")
        # Do not commit, message will be redelivered on restart/rebalance

if __name__ == "__main__":
    print("Starting consumers...")
    run()  # Blocks and runs all registered consumers
```
stripe-kit 0.3.0
Streamlined training for robots in plausible environments 
Requires Python: >=3.10

# STRIPE-kit

[![Documentation](https://img.shields.io/badge/github-Documentation-magenta?logo=github)](https://grafczterech.github.io/STRIPE-kit)
[![PyPi](https://img.shields.io/badge/PyPI-stripe_kit-blue?logo=python)](https://pypi.org/project/stripe_kit/)

**S**treamlined **T**raining for **R**obots **I**n **P**lausible **E**nvironments

STRIPE-kit is a collection of tools and resources designed to help developers
build environments and tasks for use in Isaac Lab. The core idea is that you
use the utilities provided by STRIPE-kit to define everything you need, and
then you need not integrate anything else.

With STRIPE-kit, you can easily create and manage your Isaac Lab environments
coupled with tasks. You define the assets, terrain and STRIPE-kit will handle
the rest, alongside registering within gymnasium,

For more information, please visit the
[documentation](https://grafczterech.github.io/STRIPE-kit/index.html)
which goes into further detail regarding installation, usage and features.
ACID-code-v2 1.3.0
Returns line profiles from input spectra by fitting the stellar continuum and performing LSD
Requires Python: >=3.8
Keywords: lsd, least squares deconvolution, fitting, ACID

A.C.I.D v2 (Accurate Continuum fItting and Deconvolution)
==============================================================

ACID_v2 (https://github.com/Benjamin-Cadell/ACID_v2) is a fork of ACID (https://github.com/ldolan05/ACID) from the work of Lucy Dolan for her PhD. ACID_v2 improves on ACID by:

    - Updating packages and code to work with newer and stable versions of python.

    - Improving memory management so that ACID can be run on MacOS without crashes (ie extending compatibility to all POSIX systems)

    - Adding additional kwargs to ACID to tailor output, including verbosity settings, MCMC number of steps, multiprocessing switch, and more.
    
    - Utilising classes for both ACID and the result of ACID, allowing for analysis methods that can be found in the doccumentation.

The mathematical functions and method remain the same as ACID and are outlined in Dolan et al. 2024 (https://academic.oup.com/mnras/article/529/3/2071/7624678).

The documentation will be kept up to date with the latest function descriptions until at least 2029. Please note that this install is incompatible with Windows systems.

ACID is a technique that builds on traditional Least-Squares Deconvolution (LSD) by simultaneously fitting the stellar continuum and stellar line profile and performing LSD in effective optical depth. 

In a basic sense, ACID simulatenously fits the stellar continuum and profile using a combination of LSD and MCMC techniques. The spectra are then continuum corrected using this continuum fit. LSD is then run on the continuum corrected spectra to return high-resolution line profiles for each spectrum.
pita-z 0.0.1
This package is the implementation of PITA, which is a semi-supervised image-based photo-z algorithm
Requires Python: >=3.9

This repo contains code for my project on deep learning photometric redshifts with space-based images.

# Photometric Redshifts for High-Redshift Galaxies
Predicting redshifts of galaxies from their images (photo-z) is a crucial step in analyzing astronomical datasets. This is because obtaining accurate redshifts with spectroscopy (spec-z) is expensive, and as a result most imaged galaxies, especially in next-generation surveys (such as [Roman](https://roman.gsfc.nasa.gov])), will not have spec-z's. 

Empirical machine learning techniques offer a promising way to predict photo-z's, and state-of-the-art methods use convolutional neural networks on the images directly to leverage pixel-level information. However, these methods have been limited to low-redshift galaxies with ground-based imaging due to the lack of high-quality training sets for higher-redshift galaxies. 

In this work, we test the feasibility of these methods on higher-redshift galaxies with space-based imaging, using data from the Hubble Space Telescope [CANDELS survey](https://www.ipac.caltech.edu/project/candels). We find that a semi-supervised approach that leverages all available images (even ones which don't have redshift labels) performs best.

# Semi-Supervised Photo-z Algorithm
Our approach combines contrastive learning ([MoCo](https://github.com/facebookresearch/moco) implementation), color prediction, and redshift prediction, to learn a low-dimensional representation (latent space) of galaxy images that is ideal for redshift prediction across a wide range of redshifts (from 0 to ~3).

<img width="1578" height="869" alt="semi_supervised_architecture" src="https://github.com/user-attachments/assets/df847c21-aad5-4e2d-8e2d-6bd1bcd13a02" />