semvec/pypi-packages huggingface dataset:
hacs-autogen 0.2.2
AutoGen UI adapter for HACS (Healthcare Agent Communication Standard)
Requires Python: >=3.10

# HACS AutoGen Integration

AutoGen integration for Healthcare Agent Communication Standard (HACS).

## Features

- AutoGen multi-agent framework integration
- Healthcare-specific agent workflows
- FHIR-compliant data exchange between agents
- Clinical decision support workflows

## Installation

```bash
pip install hacs-autogen
```

## Quick Start

```python
from hacs_autogen import create_healthcare_agents
from hacs_models import Patient

# Create healthcare agent team
agents = create_healthcare_agents()

# Process patient data
patient = Patient(display_name="John Doe", age_years=65)
result = agents.process_patient(patient)

print(f"Clinical assessment: {result}")
```

## Documentation

For full documentation, see the [main HACS documentation](https://github.com/solanovisitor/hacs/blob/main/docs/README.md).

## License

Apache-2.0
pyNNMF 0.1.4
Library for computing Non-Negative Matrix Factorisation with missing values imputation.
Requires Python: >=3.8

# pyNNMF - Non-Negative Matrix Factorization (NNMF)

Library for computing Non-Negative Matrix Factorisation with missing values imputation.

## Authors

* **Mário Antunes** - [mariolpantunes](https://github.com/mariolpantunes)

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

## Status

![Python CI](https://github.com/mariolpantunes/pyNNMF/workflows/Python%20CI/badge.svg)

MIT License

Copyright (c) 2022 Mário Antunes

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
coolstring 0.1.2
A fun implementation of a string that can perform several operators and more
Requires Python: >=3.10

# CoolString
## A string, but COOL :)

### Description

This is a fun project that implements a type of string in python that supports as many operators and dunder-methods in python as possible.
This must not necessarily be useful in every case.


### Links
* Look into the [Documentation](https://coolstring.readthedocs.io/en/latest/) for further information.
* The module is available on PyPI: [coolstring](https://pypi.org/project/coolstring).
* The source code on GitHub: [GitHub](https://github.com/playlix42/coolstring).

### License

* _coolstring_ is [![gpl-3.0](https://img.shields.io/badge/license-gpl__3__0-blue.svg)](LICENSE)
troy-playground 0.1.0
Execute functions and extract their local variables for debugging and testing
Requires Python: >=3.10

# Troy Playground

A Python debugging tool that executes functions and extracts their local variables for inspection. Originally designed for analyzing test functions, it allows you to turn any function into a playground where you can access and examine internal variables after execution.

## Installation

```bash
pip install troy-playground
```

## Usage

### Basic Example

```python
from troy_playground import extract_locals, run_function_playground

# Example with a test function
from tests.test_module import TestClass

test_obj = TestClass()
vars_dict = extract_locals(
    test_obj.test_method,
    ['result', 'data', 'processed'],  # variables to extract
    test_obj  # instance for bound methods
)

# Access the extracted variables
print(vars_dict['result'])
print(vars_dict['data'])
```

### Using with Module Path

```python
# Extract variables from a test method
vars_dict = run_function_playground(
    'tests.test_module',
    'TestClass',
    'test_method', 
    ['result', 'response', 'mock_data']
)

# Also works with regular functions
vars_dict = run_function_playground(
    'my_module',
    None,  # No class for module-level functions
    'process_data',
    ['output', 'transformed']
)
```

### Passing Arguments

```python
# You can pass arguments to the function
vars_dict = extract_locals(
    obj.method_with_params,
    ['result'],
    obj,  # instance
    'arg1', 'arg2',  # positional args
    param1='value1',  # keyword args
    param2='value2'
)
```

## API Reference

### `extract_locals(func, var_names, instance=None, *args, **kwargs)`

Execute a function and extract specified local variables.

- `func`: The function to execute
- `var_names`: List of variable names to extract
- `instance`: Optional instance for bound methods
- `*args`, `**kwargs`: Arguments to pass to the function

Returns a dictionary with extracted variables. If an error occurs, the dict will contain an `__error__` key.

### `run_function_playground(module_path, class_name, func_name, var_names, *args, **kwargs)`

Import and run a function by module path.

- `module_path`: Import path to module
- `class_name`: Class name (None for module-level functions)  
- `func_name`: Function/method name
- `var_names`: List of variable names to extract
- `*args`, `**kwargs`: Arguments to pass to the function

## Use Cases

- **Test Debugging**: Extract intermediate values from test functions to understand failures
- **Function Analysis**: Inspect internal state without modifying source code
- **Interactive Development**: Turn any function into a REPL-like playground

## License

MIT