semvec/pypi-packages huggingface dataset:
dogesec-commons 1.3.4
A package containing views we reuse between various dogesec products
Requires Python: >=3.10

# dogesec_commons

[![codecov](https://codecov.io/gh/muchdogesec/dogesec_commons/graph/badge.svg?token=AV1IGB1GNW)](https://codecov.io/gh/muchdogesec/dogesec_commons)

## Overview

A package containing views we reuse between various DOGESEC products

User must set `STIXIFIER_NAMESPACE` in `settings.py`

To use Objects views, `dogesec_commons.objects.app.ArangoObjectsViewApp` must be added in `settings.INSTALLED_APPS`

You can see an example of it in use here:

https://github.com/muchdogesec/obstracts/blob/main/requirements.txt

## Support

[Minimal support provided via the DOGESEC community](https://community.dogesec.com/).

## License

[Apache 2.0](/LICENSE).
hexa-sdk 0.1.1
A short description of your project
Requires Python: >=3.9

# Hexa SDK

A small SDK that exposes the `hexapackage` entry point and provides a `ContextVar`-backed global context store for AI endpoints.

## Requirements

The incoming request JSON must include the following keys so the SDK can seed the global context:

- `prompt`: the instruction template for your LLM.
- `context`: the data or background you want to feed into the prompt.
- `schema`: the JSON schema describing how to interpret the model output.

## 🚀 Usage

`hexa-sdk` lets you standardize how inputs are received and outputs are reported by relying on a global context instead of threading variables through every helper.

### 1. Basic setup

Install the package:

```bash
pip install hexa-sdk
```

### 2. Integration in your endpoint

Load the incoming request into the context store and then treat `prompt`, `context`, and `schema` as globally accessible values.

```python
from hexa import hexapackage
from hexa.main import set_value, get_value


def my_ai_endpoint(request):
    payload = request.json()

    # 1. Push the incoming data into the global context.
    set_value("prompt", payload["prompt"])
    set_value("context", payload["context"])
    set_value("schema", payload["schema"])

    # 2. Consume the values anywhere in your flow without passing them through every call.
    final_input = f"Instructions: {get_value('prompt')}\n\nData: {get_value('context')}"

    # 3. Call your LLM (OpenAI, Anthropic, etc.)
    ai_output = "The result from your model"

    # 4. Pack and return — you can reuse the store to compile whatever payload the Hexa dashboard expects.
    set_value("result", ai_output)
    return {
        "prompt": get_value("prompt"),
        "context": get_value("context"),
        "schema": get_value("schema"),
        "output": get_value("result"),
    }
```

### 3. Key properties

Once the values are stored, they are available everywhere in the current execution context:

* `hexapackage()` returns the full store so the SDK can inspect or serialize every tracked value.
* `get_value("prompt")`, `get_value("context")`, and `get_value("schema")` read the global context without threading arguments through helpers.
* `set_value` is the simplest way to seed or update any piece of shared data.

This usage flow emphasizes how `hexa-sdk` removes the boilerplate of passing `prompt`/`context`/`schema` through many helper layers and keeps your AI wiring clean and focused on the model call.
eltako14bus 0.0.79
Library for participating in the Eltako Series 14 RS485 bus

Eltako14Bus Python library
==========================

This repository contains a library and some tools for interacting with the Eltako Series 14 bus system,
which is an extension to the EnOcean Serial Protocol ESP2.

This is part of the reverse engineering approach that allows using Eltako
Series 14 devices without a FAM.

It can work both on a direct RS485 serial connection to the bus,
with or without a FAM14 present on the bus,
through a FAM14's serial connection,
or through a bespoke CoAP interface to the ESP2 protocol.

Tools
-----

The eltakotool program shipped with it can
do various raw interactions with the bus
(replacing some FAM14 functionality, locking and unlocking the bus, sending arbitrary messages)
as well as reading and writing the bus participants' memory
(including verification and annotation of the memory contents).

Protocol description
--------------------

(This is a short version.
The long is partially available in the EnOcean and Eltako documentations,
and the rest is in the reverse engineered code).

The EnOcean serial protocol is a point-to-point serial protocol between a computer and a radio transceiver;
it contains synchronization bytes, some structured data bytes, and checksumming.
The most common message formats are RPS and 4BS,
which have equivalent messages (with short and long (4 byte) data, respectively) on the radio side.
These messages contain some addressing information both when receiving (indicating which device sent it)
and when sending through the transceiver (in which case the addresses need to match the address range of the transceiver, giving about 128 possible sending addresses).

The Eltako protocol is loosely built on the ESP2 protocol,
but is used on an RS485 bus (with up to 127 participants),
and uses several message types that are not defined in ESP2.

Part of the Eltako bus protocol is enumeration:
Devices on the bus can be put into an addressing mode,
and the bus master (a FAM14 or the library user) can assign one of the 127 available address to the device.

Commands are also known to visually identify devices on the bus,
and to read and write their configuration (eg. in a relay, setting which buttons it should react to).

License
-------

This was developed by Christian Amsüss <c.amsuess@energyharvesting.at> and Energy Harvesting Solutions 2016-2020.

It is published under the terms of GNU LGPL version 3 or later.
weld-cli 0.13.0
Human-in-the-loop coding harness: plan, review, iterate, commit with transcript provenance
Requires Python: >=3.11

<p align="center">
  <img src=".github/weld-logo.png" alt="Weld Logo" width="400">
</p>

**Human-in-the-loop coding harness with transcript provenance**

Weld generates structured prompts for AI-assisted development workflows. Instead of ad-hoc prompting, weld provides templates for: research → plan → implement → review → commit.

## Why Weld?

- **Structured Prompts**: Generate focused prompts for research, planning, and review
- **Full Auditability**: Every AI interaction linked via transcript gists in commits
- **Codebase Discovery**: Analyze existing codebases before making changes
- **Spec Refinement**: Interview-style Q&A to improve specifications

```
Spec Doc  -->  Research Prompt  -->  Plan Prompt  -->  Review  -->  Commit
                                                                  + transcript
```

## Install

```bash
uv tool install weld-cli          # or: pipx install weld-cli
uv tool upgrade weld-cli          # upgrade to latest
```

## Quick Start

```bash
weld init                              # Initialize in your project
weld doctor                            # Check environment
weld plan specs/feature.md -o plan.md  # Generate implementation plan
weld implement plan.md                 # Execute plan interactively
weld commit --all                      # Commit with transcript
```

## Documentation

| | |
|---|---|
| **[Installation](docs/installation.md)** | Prerequisites and setup |
| **[Quickstart](docs/quickstart.md)** | Get running in 5 minutes |
| **[Workflow](docs/workflow.md)** | Full development workflow |
| **[Commands](docs/commands/index.md)** | Command reference |
| **[Configuration](docs/configuration.md)** | Config options |
| **[Troubleshooting](docs/troubleshooting.md)** | Common issues |
| **[Development](docs/development/index.md)** | Contributing guide |

## License

See [LICENSE](LICENSE) for details.
cpan123 0.2.9
123云盘的python接口文档(非官方)
Requires Python: >=3.10


## cpan123

这是一个非官方的123云盘开放平台调用库，可以轻松的在Python中调用123云盘开放平台而不需要多次编写重复的代码

文档: [cpan123.readthedocs.io](https://cpan123.readthedocs.io/)
bw2calc 2.3.2
The calculation engine for the Brightway life cycle assessment framework.
Requires Python: >=3.9

---
title: Brightway2 Calculations
---

[![pypi version](https://img.shields.io/pypi/v/bw2calc.svg)](https://pypi.org/project/bw2calc/)

[![conda-forge version](https://img.shields.io/conda/vn/conda-forge/bw2calc.svg)](https://anaconda.org/conda-forge/bw2calc)

[![bw2calc appveyor build status](https://ci.appveyor.com/api/projects/status/uqixaochulbu6vjv?svg=true)](https://ci.appveyor.com/project/cmutel/brightway2-calc)

[![Test coverage report](https://coveralls.io/repos/bitbucket/cmutel/brightway2-calc/badge.svg?branch=master)](https://coveralls.io/bitbucket/cmutel/brightway2-calc?branch=default)

This package provides the calculation engine for the [Brightway2 life
cycle assessment framework](https://brightway.dev). [Online
documentation](https://docs.brightway.dev) is available, and the source
code is hosted on
[Github](https://github.com/brightway-lca/brightway2-calc).

The emphasis here has been on speed of solving the linear systems, for
normal LCA calculations, graph traversal, or Monte Carlo uncertainty
analysis.

Relies on [bw_processing](https://github.com/brightway-lca/bw_processing)
for input array formatting.
fastabx 0.7.0
A library for efficient computation of ABX discriminability
Requires Python: >=3.12
Keywords: machine learning, speech

# Fast ABX evaluation

**fastabx** is a Python package for efficient computation of ABX discriminability.

The ABX discriminability measures how well categories of interest are separated in the representation space by
determining whether tokens from the same category are closer to each other than to those from a different category.
While ABX has been mostly used to evaluate speech representations, it is a generic framework that can be applied
to other domains of representation learning.

This package provides a simple interface that can be adapted to any ABX conditions, and to any input modality.

Check out the documentation for more information: https://docs.cognitive-ml.fr/fastabx

## Install

Install the pre-built package in your environment:

```bash
pip install fastabx
```

It requires Python 3.12 or later, and depends on PyTorch 2.10.0 or later, NumPy, Polars, tqdm, and [torchdtw](https://github.com/bootphon/torchdtw).

## Citation

A preprint is available on arXiv: https://arxiv.org/abs/2505.02692 \
If you use fastabx in your work, please cite it:

```bibtex
@misc{fastabx,
  title={fastabx: A library for efficient computation of ABX discriminability},
  author={Maxime Poli and Emmanuel Chemla and Emmanuel Dupoux},
  year={2025},
  eprint={2505.02692},
  archivePrefix={arXiv},
  primaryClass={cs.CL},
  url={https://arxiv.org/abs/2505.02692},
}
```
sumit-sdk 1.2.6
SDK to communicate with sumit API
Requires Python: >=3.8

# Sumit-sdk



## Getting started

## Description

Sumit SDK is a Python package that allows users to interact with Sumit-AI API. This document describes how to install the SDK from a zip file and how to use its main features.

## Installation

install from pip: `pip install sumit-sdk`  
or uv: `uv pip install sumit_sdk`  

### Step 1: Download the SDK

1. Navigate to the "Tags" section of the GitLab repository.
2. Find the desired version of the SDK and click on it.
3. Click on the "Download" button and select "ZIP" to download a zip file of the SDK.

### Step 2: Extract the ZIP File

Extract the downloaded zip file to a location of your choice. You can do this by right-clicking the zip file and selecting "Extract All..." (the exact option might vary depending on your operating system).

### Step 3: Install the SDK

Open a terminal and navigate to the directory where the zip file was extracted. The SDK can be installed using _pip_ by running the following command:

```sh
cd path/to/extracted/folder
pip install .
```

_depracted:   
using `setup.py` installation with: `python setup.py install` is depracted and not supported in new python versions_

#### Install on Windows  
installation of: PyAudio, pyalsaaudio may failed in Windows. In this case the installation of all required library will failed. So in this case please install the required packages via pip: 
```pip install -r requirements.txt```
ctd-processing 1.11.7
Custom CTD processing tools and a runner to use these interchangeable with the standard seabird modules.
Requires Python: >=3.12
Keywords: CTD, processing, seabird, data, Oceanography

# Intro

This is a custom software suite to process Sea-Bird CTD data. It fully supports running Sea-Birds original processing modules, but also custom ones, written in python or independent executables, that adhere to the command line interface of the original Sea-Bird modules. They can interchangeably be used as part of 'processing procedures', workflows of multiple processing steps in sequence on one or more data file. These procedures are defined by .toml configuration files.

# Current development goals

- Developing new custom processing modules

  - Improving AlignCTD

  - A module to retrieve start and end of a cast (cast_borders)

  - A new bottle handling module, that creates btl files after all processing steps

- Writing an entry point to the different functionalities

- The replacement of Sea-Birds executables by their python packages