semvec/pypi-packages huggingface dataset:
deepseek-reason-extractor 0.1.0
A Python package for extracting and processing reasoning patterns
Requires Python: >=3.8

# Deepseek Reason Extractor

A Python package for extracting reasoning patterns using Vaklm models.

## Installation

```bash
pip install deepseek_reason_extractor
```

## Usage

```python
from deepseek_reason_extractor import DeepseekReasonExtractor

# Initialize with default settings
extractor = DeepseekReasonExtractor(
    api_key="your-api-key"  # Optional if endpoint doesn't require auth
)

# Extract reasoning
prompt = "Explain the concept of quantum entanglement"
reasoning = extractor.extract_reasoning(prompt)

print(reasoning)
```

## Configuration

You can customize the endpoint, model, and system prompt:

```python
extractor = DeepseekReasonExtractor(
    endpoint="http://custom.endpoint/v1/chat/completions",
    model_name="custom-model",
    api_key="your-api-key",
    system_prompt="You are a helpful AI assistant"
)
```

## Development

### Building the Package

1. Install build tools:
```bash
pip install build
```

2. Build the package:
```bash
python -m build
```

3. Install locally for testing:
```bash
pip install -e .
```

### Running Tests

```bash
python -m pytest tests/
```

### Deployment

1. Update version in `pyproject.toml` and `__init__.py`
2. Build the package:
```bash
python -m build
```
3. Upload to PyPI:
```bash
python -m twine upload dist/*
```

## Error Handling

The package raises RuntimeError for API failures:

```python
try:
    reasoning = extractor.extract_reasoning(prompt)
except RuntimeError as e:
    print(f"Error: {str(e)}")
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License

[MIT](https://choosealicense.com/licenses/mit/)
number_names 0.1.2
This module provides functions for getting the English names of numbers.
Requires Python: >=3.9

# Number Names

`number_names` converts numbers to their English names.

The main useful function this package provides is called `name`. Usage
is as follows:

```python
>>> import number_names
>>> number_names.name(0)
'zero'
>>> number_names.name(1)
'one'
>>> number_names.name(2)
'two'
>>> number_names.name(123_456_789)
'one hundred and twenty three million four hundred and fifty six thousand seven hundred and eighty nine'
>>> number_names.name(3.1415)
'three point one four one five'
>>> number_names.name(-10 ** 15)
'minus one quadrillion'
>>> number_names.name(10 ** 100000)
'ten tretriginmilliatrecenduotrigintillion'
>>> number_names.name(3 + 2j)
'three plus two i'
>>> from fractions import Fraction
>>> number_names.name(Fraction(1, 2))
'one half'
>>> number_names.name(Fraction(3, 221))
'three two hundred and twenty firsts'
```
dash2html 1
Convert Plotly Dash App To Static HTML File

# Dash2HTML Library

## Overview

The `dash2html` library provides a convenient way to convert a Dash web application into a static HTML site. This library enables developers to host static versions of their Dash applications, making them accessible without requiring a running server.

---

## Features

1. **Dynamic to Static Conversion**: Converts Dash applications into static HTML sites with all necessary assets bundled.
2. **Downloadable Archive**: Automatically packages the static site into a ZIP file for easy distribution.
3. **Self-Contained Static Site**: Ensures all required assets (e.g., JavaScript, CSS) are included in the archive.

---

## How to Use

1. **Import the Library**:
   Import the `dash2html` function into your project.
   ```bash
   pip install dash2html
   ```
   ```python
   from dash import Dash
   from dash2html import dash2html
   ```

2. **Set Up Your Dash Application**:
   Create and configure your Dash app as you normally would.

3. **Call `dash2html`**:
   Pass your Dash application instance and the desired port number to the `dash2html` function:
   ```python
   from dash import Dash
   from your_library import dash2html

   app = Dash(__name__)
   # Define your app layout and callbacks here
   
   dash2html(app, port=8080)
   ```

4. **Access the Application**:
   - Start the server by running your script.
   - Visit the URL displayed in the console (e.g., `http://127.0.0.1:8080`) to load the app.

5. **Download the Static Site**:
   - After the app is loaded, navigate to `http://127.0.0.1:8080/download_zip`.
   - The static site will be packaged into a ZIP file and downloaded.

---

## Example Workflow

1. **Run the Script**:
   ```bash
   python your_script.py
   ```

2. **Visit the Dash App**:
   Open the app in your browser using the URL provided in the console (e.g., `http://127.0.0.1:8080`).

3. **Download Static Site**:
   Navigate to `http://127.0.0.1:8080/download_zip` in your browser to download the ZIP file.

---

## Notes

- Ensure that the Dash application is running and fully loaded in your browser before downloading the static site.
- The static site will be packaged as `static_site.zip` in the current working directory.

---

## Troubleshooting

- **No Content in ZIP**:
  Ensure the Dash app has been loaded in the browser before accessing the `/download_zip` endpoint.
  
- **Port Already in Use**:
  Change the `port` parameter in the `dash2html` function to an available port.

---

## Acknowledgments
Inspired by [Ref](https://gist.github.com/exzhawk/33e5dcfc8859e3b6ff4e5269b1ba0ba4) code
Created by [Sheth Jenil](https://github.com/dummyjenil/)
incertidumbres 0.0.8
Calcula incertidumbre de mediciones de laboratorio
Requires Python: >=3.11

# Incertidumbres

Paquete creado con el proposito de realizar los calculos de incertidumbres de mediciones de laboratorio. Permite calcular error absoluto, desviación estandar, agregar calculos a hojas de datos

## Instalación

Para instalar el paquete, puedes usar pip:

```
pip install incertidumbres
```

## Uso

Para usar el paquete, puedes importarlo en tu código Python:

```python
from incertidumbres import calcular_incertidumbre

# Ejemplo de uso
datos = [1, 2, 3, 4, 5]
incertidumbre = calcular_incertidumbre(datos)
print(incertidumbre)
```

Este código imprimirá el valor de la incertidumbre para los datos proporcionados.