semvec/pypi-packages huggingface dataset:
straxen 3.2.7
Streaming analysis for XENON
Requires Python: <3.13,>=3.10

# straxen
Streaming analysis for XENON(nT)

[![Test package](https://github.com/XENONnT/straxen/actions/workflows/pytest.yml/badge.svg?branch=master)](https://github.com/XENONnT/straxen/actions/workflows/pytest.yml)
[![Coverage Status](https://coveralls.io/repos/github/XENONnT/straxen/badge.svg)](https://coveralls.io/github/XENONnT/straxen)
[![PyPI version shields.io](https://img.shields.io/pypi/v/straxen.svg)](https://pypi.python.org/pypi/straxen/)
[![Readthedocs Badge](https://readthedocs.org/projects/straxen/badge/?version=latest)](https://straxen.readthedocs.io/en/latest/?badge=latest)
[![CodeFactor](https://www.codefactor.io/repository/github/xenonnt/straxen/badge)](https://www.codefactor.io/repository/github/xenonnt/straxen)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/XENONnT/straxen/master.svg)](https://results.pre-commit.ci/latest/github/XENONnT/straxen/master)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5576262.svg)](https://doi.org/10.5281/zenodo.5576262)

[Straxen](https://straxen.readthedocs.io) is the analysis framework for XENONnT, built on top of the generic [strax framework](https://github.com/AxFoundation/strax). Currently it is configured for analyzing XENONnT and XENON1T data.

For installation instructions and usage information, please see the [straxen documentation](https://straxen.readthedocs.io/en/latest/setup.html).


## Further status
[![Python Versions](https://img.shields.io/pypi/pyversions/straxen.svg)](https://pypi.python.org/pypi/straxen)
[![PyPI downloads](https://img.shields.io/pypi/dm/straxen.svg)](https://pypistats.org/packages/straxen)
secparse 0.1.1
SecParse API SDK for Python (secparse.com)
Requires Python: >=3.8
Keywords: secparse, graphql, sdk, client, subscriptions, websocket

# SecParse SDK

Python SDK for SecParse - Query and subscribe to SEC EDGAR filing data via GraphQL.

## Installation

```bash
pip install secparse
```

## API Key

Get your API key at https://secparse.com

## Quick Start

### Basic Query

```python
import asyncio
from secparse import SecParseClient

async def main():
    async with SecParseClient(api_key="your-api-key") as client:
        result = await client.query("""
            query {
              Fact(
                where: {
                  Concept: {name: {_eq: "Assets"}, namespace: {_eq: "us-gaap"}}
                  Submission: {filerCik: {_eq: "63908"}}
                }
                limit: 5
              ) {
                effectiveDate
                valueNumber
                Submission {
                  Filer { name }
                }
              }
            }
        """)
        print(result)

asyncio.run(main())
```

### Real-time Subscriptions

```python
import asyncio
from secparse import SecParseClient

async def main():
    client = SecParseClient(api_key="your-api-key")

    try:
        async for data in client.subscribe("""
            subscription {
              Submission(where: {Filer: {cik: {_eq: "63908"}}}) {
                accessionNumber
                acceptedDate
              }
            }
        """):
            print(f"New submission: {data}")
    finally:
        await client.close()

asyncio.run(main())
```

## License

MIT
a2a-agentspeak 0.0.12
AgentSpeak agents on A2A/ACL protocol.
Requires Python: >=3.12

# A2A Agentspeak
AgentSpeak agents on A2A/ACL protocol. (Work in progress).

# Features
 * Run AgentSpeak agents on an A2A server.
 * Describe agent card and skills in an interface file in a dedicated format.
 * Targets that are not declared in the interface are private and ignored from incoming messages.
 * Extension of the A2A protocol that supports _tell_, _achieve_, and _ask_ performatives.
 * Synchronous answers for _ask_ messages (to consult a belief).
 * Asynchronous answers for _achieve_ messages (to request some actions and optionally answer later).
 * Two repositories : one to keep track of running agents (hot repository for hot agents) and one to keep track of agents that can be run locally on demand (cold repository for cold agents). 
 * Hot agent repositories can be accessed by requested interface (formatted, see `samples/llm_req_manager_with_orchestrator_and_hot_repository`) 
   or by natural language (interpreted by a LLM, see `samples/llm_req_manager_with_orchestrator_and_repository_and_nl_selection`).
 * Cold agent repositories can be accessed by interface (see `tests/ping_agent_on_cold_repo`, `tests/cold_agent_on_repo_with_holes`, and `tests/spawn`).
 * Hot agent repositories can receive failure reports and degrade the reputation of failing agents. 
   That reputation is taken into account when selecting agents (see `samples/llm_req_manager_with_orchestrator_and_hot_repository` and `samples/llm_req_manager_with_orchestrator_and_repository_and_nl_selection`).
 * Configuration of agents with customized actions at init time (see `tests/customizable_robot`, `tests/action`, and `tests/cold_agent_on_repo_with_holes`).
 * Different codecs can be used to encode/decode the content of the messages (AgentSpeak agents can encode the content of the message differently than Python agents or Java agents).


# Examples and Documentation

Some examples are given in the `samples` and `tests` directories. This is the only source of documentation currently.

To run the simple example from `samples/ping`, first run `run_receiver_agent.py` , then run `run_sender_agent.py` .
That example does not require access to an LLM.


# Requirements
This module relies on the A2A Protocol (package `a2a-sdk`), the A2A-ACL package (`acl-a2a`),
and [python-agentspeak](https://github.com/niklasf/python-agentspeak) (package `agentspeak`). 

## Optional Requirements

 To run the examples that use an LLM, you need: 
  * the package `mistralai`
and set your MISTRAL_API_KEY in the environment,
  * the package `openai`
and set your OPENAI_API_KEY in the environment.

## General architecture

![class diagram](doc/A2A-ACL-class-diagram-full.drawio.svg)
a2a-acl 0.0.12
ACL agents on A2A protocol.
Requires Python: >=3.12
Keywords: A2A, ACL

# A2A ACL
ACL agents on A2A protocol (work in progress).

# Features
 * Agents that send and receive messages with an illocution/performative on top of A2A.
 * Simply describe A2A agent cards and skills in an interface file in a dedicated format.
 * Targets that are not declared in the interface are private and ignored from incoming messages.
 * Extension of the A2A protocol that supports _tell_, _achieve_, and _ask_ performatives.
 * Asynchronous answers for _achieve_ messages (to request some actions and optionally answer later).
 * Different codecs can be used to encode/decode the content of the messages.


# Examples and Documentation

Some examples are given in the `sample_agents` and `tests` directories. This is the only source of documentation currently.


# Requirements
This module relies on the A2A Protocol (package `a2a-sdk`).
clinbin 0.2.1
Use cut-off points from medical guidelines to classify clinical variables.
Requires Python: >=3.12

# Clinbin
[**Quickstart**](#quickstart) | [**Reference docs**](https://hylkedonker.gitlab.io/clinbin) | [![coverage report](https://gitlab.com/hylkedonker/clinbin/badges/main/coverage.svg)](https://gitlab.com/hylkedonker/clinbin/-/commits/main) | [![pipeline status](https://gitlab.com/hylkedonker/clinbin/badges/main/pipeline.svg)](https://gitlab.com/hylkedonker/clinbin/-/commits/main)



Discretize clinical variables according to clinical guidelines in Python.

For example, classify blood pressures according to the European Society of Cardiology guidelines or classify body-mass index according to the World Health Organization.


## Installation
```
pip3 install git+https://gitlab.com/hylkedonker/clinbin.git
```

## Quickstart
Here is an example for blood pressure. See the [clinbin docs](https://hylkedonker.gitlab.io/clinbin) for more.
```python
In [1]: from clinbin import classify_blood_pressure
   ...: import pandas as pd
   ...:
   ...: systolic = pd.Series([80, 120,   50], index=['alice', 'bob', 'charlie'])
   ...: diastolic = pd.Series([60, 60, 100], index=['alice', 'bob', 'charlie'])
   ...: classify_blood_pressure(systolic, diastolic)
Out[1]:
alice            normal
bob            elevated
charlie    hypertension
dtype: category
Categories (3, object): ['normal' < 'elevated' < 'hypertension']
```

## Support
Open a [New issue](https://gitlab.com/hylkedonker/clinbin/-/issues/new) in the issue tracker.

## Contributing
We welcome updates and new contributions. New contributions must preferably be de facto
standards in the field, e.g., coming from professional societies or authoritative
organizations in the field. Code must be black formatted and new contributions are to be
accompanied by a unit test.

## Authors and acknowledgment
H. C. Donker

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
mcp-haystack 1.2.0
Haystack integration for Model Context Protocol (MCP)
Requires Python: >=3.10
Keywords: Haystack, MCP, Model Context Protocol

# mcp-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/mcp-haystack.svg)](https://pypi.org/project/mcp-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mcp-haystack.svg)](https://pypi.org/project/mcp-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/mcp)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/mcp/CHANGELOG.md)

---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

To run integration tests locally, you need to export the `OPENAI_API_KEY` environment variable.