semvec/pypi-packages huggingface dataset:
looker_powerpoint 0.6.0
Add your description here
Requires Python: >=3.12

![PyPI - Version](https://img.shields.io/pypi/v/looker-powerpoint) ![PyPI - Downloads](https://img.shields.io/pypi/dd/looker-powerpoint)




# Looker Powerpoint CLI (lppt)
## integrate looker looks with microsoft powerpoint presentations
QETpy 1.8.4
TES Detector Calibration and Analysis Python Tools

# QETpy Package

[![Python package](https://github.com/spice-herald/QETpy/actions/workflows/python-package.yml/badge.svg)](https://github.com/spice-herald/QETpy/actions/workflows/python-package.yml)
[![Documentation Status](https://readthedocs.org/projects/qetpy/badge/?version=latest)](https://qetpy.readthedocs.io/en/latest/?badge=latest)
[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Python 3.6](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/release/python-360/)
[![PyPI](https://img.shields.io/pypi/v/qetpy)](https://pypi.org/project/QETpy/)
[![Conda (channel only)](https://img.shields.io/conda/vn/conda-forge/qetpy)](https://anaconda.org/conda-forge/qetpy)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5104855.svg)](https://doi.org/10.5281/zenodo.5104855)

QETpy (Quasiparticle-trap-assisted Electrothermal-feedback Transition-edge sensors) provides a general set of tools for TES-based detector calibration and analysis. It contains submodules for noise modeling, IV analysis, complex impedance fitting, nonlinear optimum filter pulse fitting, and many other useful detector R&D analysis tools. This package is _NOT_ intended to contain any tools specific to a particular analysis. It is also meant to be DAQ independent, meaning it contains no IO functionality. It is assumed that the user is able to load their data as NumPy arrays separate from QETpy. 

* Documentation: [Docs](https://qetpy.readthedocs.io/en/latest/)
* Contributing: [CONTRIBUTING.md](CONTRIBUTING.md)
* Demos: [Examples](https://qetpy.readthedocs.io/en/latest/examples.html)

### Installation

To install the current stable version of QETpy, from the command line type

`pip install --upgrade qetpy`

If you prefer conda for package management, QETpy is also available on the conda-forge channel and can be installed via

`conda install -c conda-forge qetpy`

To install the most recent (stable) development version of QETpy, clone this repo, then from the top-level directory of the repo, type the following into your command line

`pip install .`

You may need to add the `--user` flag if using a shared Python installation.

This package requires python 3.6 or greater. A current version of Anaconda3 should be sufficient, however a conda environment file as well as a list of dependencies is provided (condaenv.yml and requirements.txt)
    
Examples of how to use the package can be found in the `demos/` directory. This directory contains Jupyter notebooks with example code and testing data
latencyzero 0.1.1
Cut API latency by 50-90% with Adaptive Anticipatory Approximation
Requires Python: >=3.8

# LatencyZero (A³) — Adaptive Anticipatory Approximation

**LatencyZero reduces API, database, and ML inference latency by 50–90% using safe, confidence-based approximation.**

LatencyZero is a lightweight Python SDK that acts as a smart middleware in front of expensive functions. It learns from previous executions and returns near-instant responses when it is confident the result is correct — otherwise it safely falls back to the exact computation.

---

## ✨ Key Features

- ⚡ **50–90% latency reduction** for repeated or similar requests
- 🎯 **Correctness guaranteed** via confidence-based fallback
- 🔧 **Drop-in decorator** — no refactoring required
- 🔄 **Progressive refinement** in the background
- 📊 **Built-in metrics & observability**
- 🧠 Designed for APIs, databases, and ML inference

---

## 📦 Installation

```bash
pip install latencyzero

🚀 Quick Start
from latencyzero import a3

@a3(tolerance=0.02)
def expensive_function(x):
    return model.run(x)

# First call: exact computation
expensive_function("query")

# Subsequent calls: ~10ms approximate response ⚡
expensive_function("query")


LatencyZero automatically decides when approximation is safe and falls back to exact execution if confidence is low.

⚙️ Configuration
from latencyzero import configure

configure(
    gateway_url="http://localhost:8080",
    timeout=0.1,
    enable_metrics=True
)
e-chem 1.0.1
echemkit is a lightweight Python library designed for seamless electrochemical data analysis.
Requires Python: >=3.1
Keywords: todo

# EC-python Lib

echemkit is a lightweight Python library designed for seamless electrochemical data analysis directly within Jupyter notebooks. It provides intuitive tools for loading, processing, and visualising data from standard potentiostat systems such as BioLogic, PalmSens, and Squidstat. The package supports cyclic voltammetry (CV), chrono-potentiometry (CP), electrochemically active surface area (ECSA) analysis, and Tafel slope evaluation through a consistent, object-oriented API. Researchers can quickly import raw measurement files, extract key parameters, apply smoothing or compensation routines, and generate publication-ready plots—all in an interactive environment. With clear syntax and modular design, echemkit enables reproducible, open electrochemical analysis suitable for education, prototyping, and advanced research workflows.

## License

MIT license.

##citetation

If you use echemkit for scientific research or publication, please cite it as DOI: 10.48436/4exfe-yx784
qualia-flow 0.1.1
MLflow experiment exploration and notebook generation toolkit
Requires Python: >=3.12

# Qualia Flow

MLflow / Zenml experiment exploration and notebook generation toolkit.

## Overview

Qualia Flow provides tools for discovering, exploring, and documenting Machine Learning experiments through automatically generated Jupyter notebooks.

## Features

- 🔍 **Automatic Discovery** - Scans MLflow tracking server for experiments and runs
- 🎯 **Interactive Selection** - User-friendly CLI for choosing what to explore
- 📓 **Notebook Generation** - Creates ready-to-use Jupyter notebooks
- 📊 **Comparison Tools** - Built-in parameter and metric comparison
- 💻 **Programmatic API** - Use in your own scripts

## Installation

From the main project:

```bash
pip install -e .
```

Or install qualia_flow as a standalone package:

```bash
cd packages/qualia_flow
pip install -e .
```

## Quick Start

### Interactive CLI

```bash
# Generate an observational notebook
qualia-flow create

# Or with demo data
qualia-flow demo 3  # Create 3 demo runs
qualia-flow create
```

### Programmatic Usage

```python
from qualia_flow import ArtifactExplorer, NotebookGenerator

# Explore artifacts
explorer = ArtifactExplorer(tracking_uri="./mlruns")
experiments = explorer.list_experiments()
runs = explorer.list_runs([exp['id'] for exp in experiments])

# Generate notebook
generator = NotebookGenerator(tracking_uri="./mlruns")
generator.generate_notebook(
    selected_runs=runs,
    output_path="my_analysis.ipynb",
    title="My Analysis"
)
```

## Documentation

- [Quick Start Guide](docs/quick_start_observational_notebooks.md)
- [Full Documentation](docs/observational_notebooks.md)
- [API Reference](docs/QUICK_REFERENCE.md)
- [Architecture](docs/ARCHITECTURE_DIAGRAM.md)

## Examples

See [examples/](examples/) for usage patterns:
- Basic notebook generation
- Filtering runs by criteria
- Comparing best runs by metric
- Getting run details
- Custom notebook structures

## Project Structure

```
qualia_flow/
├── __init__.py           # Package exports
├── cli.py                # Command-line interface
├── explorer.py           # MLflow artifact exploration
├── generator.py          # Notebook generation
├── scripts/              # Standalone scripts
├── examples/             # Usage examples
└── docs/                 # Documentation
```

## Commands

- `qualia-flow create` - Interactive notebook generator
- `qualia-flow demo [N]` - Create N demo MLflow runs

## License

Part of the Qualia Lab project.