semvec/pypi-packages huggingface dataset:
qandle 0.1.12
QANDLE is a fast and simple quantum state-vector simulator for hybrid machine learning using the PyTorch library.
Requires Python: >=3.12

# QANDLE
**QANDLE** is a fast and simple quantum state-vector simulator for hybrid machine learning using the PyTorch library.
Documentation and examples can be found in the [QANDLE documentation](https://gstenzel.github.io/qandle/), the code resides on [GitHub](https://github.com/gstenzel/qandle).
The paper can be found on [arXiv](https://arxiv.org/abs/2404.09213).

## Installation
```bash
pip install qandle
```

## Usage
```python
import torch
import qandle

# Create a quantum circuit
circuit = qandle.Circuit(
    layers=[
        # embedding layer
        qandle.AngleEmbedding(num_qubits=2),
        # trainable layer, with random initialization
        qandle.RX(qubit=1),
        # trainable layer, with fixed initialization
        qandle.RY(qubit=0, theta=torch.tensor(0.2)),
        # data reuploading
        qandle.RX(qubit=0, name="data_reuploading"),
        # disable quantum weight remapping
        qandle.RY(qubit=1, remapping=None),
        qandle.CNOT(control=0, target=1),
        qandle.MeasureProbability(),
    ]
)


input_state = torch.rand(circuit.num_qubits, dtype=torch.float) # random input
data_reuploading = torch.rand(1, dtype=torch.float) # random data reuploading input

# Run the circuit
circuit(input_state, data_reuploading=data_reuploading)
```	

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Citation
If you use QANDLE in your research, please cite the following paper:
```bbl
@misc{qandle2024,
      title={Qandle: Accelerating State Vector Simulation Using Gate-Matrix Caching and Circuit Splitting}, 
      author={Gerhard Stenzel and Sebastian Zielinski and Michael Kölle and Philipp Altmann and Jonas Nüßlein and Thomas Gabor},
      year={2024},
      eprint={2404.09213},
      archivePrefix={arXiv},
      primaryClass={quant-ph}
}
```
visible-residues 0.3.0
Find residues with sidechains in a specific region
Requires Python: ~=3.10

Visible Residues
================

[![Last release](https://img.shields.io/pypi/v/visible_residues.svg)](https://pypi.python.org/pypi/visible_residues)
[![Python version](https://img.shields.io/pypi/pyversions/visible_residues.svg)](https://pypi.python.org/pypi/visible_residues)
[![Documentation](https://img.shields.io/readthedocs/visible_residues.svg)](https://visible-residues.readthedocs.io/en/latest/)
[![Test status](https://img.shields.io/github/actions/workflow/status/kalekundert/visible_residues/test.yml?branch=master)](https://github.com/kalekundert/visible_residues/actions)
[![Test coverage](https://img.shields.io/codecov/c/github/kalekundert/visible_residues)](https://app.codecov.io/github/kalekundert/visible_residues)
[![Last commit](https://img.shields.io/github/last-commit/kalekundert/visible_residues?logo=github)](https://github.com/kalekundert/visible_residues)

This is an extension module implementing one performance-critical function used 
to create a machine learning dataset of 3D images of macromolecules with 
labeled amino acid identities.  Specifically, the function accepts a dataframe 
of atoms in the image, then samples a fixed number of residues whose sidechains 
are likely to be mostly within the image.  To avoid biasing the samples based 
on the specific sidechains involved (e.g. glycine has a smaller sidechain than 
arginine, so it might be sampled more often if the actual sidechain was 
considered), this "within the image" determination is based entirely on 
backbone coordinates.
gitstarter 0.1.0
Hybrid Streamlit UI: automates Git-CLI + GitHub API workflows
Requires Python: >=3.7

# gitstarter

**Hybrid Streamlit UI** that automates Git-CLI workflows for beginners and GitHub-API tasks for power users—all from your local directory.

---

## 📄 License

This project is released under the MIT License (see [LICENSE](LICENSE)).  
© 2025 RePromptsQuest. All rights reserved.

---

## 🔗 Links

- **GitHub**: https://github.com/reprompts/gitstarter  

- **LinkedIn Group**: https://www.linkedin.com/groups/14631875/  

- **Twitter / X**: [@RepromptsQuest](https://twitter.com/RepromptsQuest)  

- **Dev.to**: https://dev.to/repromptsquest  

---

## ✨ Features

- 🚀 **Workflow-driven UI**: Choose scenarios (Init, Clone, Commit, PRs, etc.) from a sidebar  
- 🧩 **Pure Git-CLI automation**: No token needed for local Git commands (`init`, `add`, `commit`, `push`, `pull`, `branch`, `stash`, `merge`, `log`)  
- 🔐 **Optional GitHub API**: Create repos & pull-requests when you paste your PAT  
- 🌐 **Persistent Repo URL**: Enter once, use across all workflows  
- 🧠 **Educational**: Previews actual Git commands, shows output and errors  
- ⚙️ **Settings**: Edit `user.name` / `user.email`, manage PAT, reset `.git`  

---

## 🚀 Quickstart

1. **Install**  
   ```bash
   pip install gitstarter

Run:
gitstarter


Follow the UI

Paste your repo URL at the top (optional for local-only work).

Select a workflow in the sidebar (e.g. “Init / Reset Git Repo”, “Commit & Push”).

Click buttons to run Git commands—no terminal typing needed.

🛡️ Security
No telemetry: gitstarter does not phone home or collect usage data.

Token safety: Your GitHub PAT is stored only in Streamlit session state and the environment; it is never logged.

Error handling: All errors from Git CLI or GitHub API are caught and displayed in the UI.

🤝 Contributing
We welcome all contributions! See CONTRIBUTING.md for guidelines.
firevizz 0.1.1
A Python library for visualizing and analyzing fire detection data
Requires Python: >=3.6
Keywords: fire detection, visualization, mapping, sensor data

![](https://raw.githubusercontent.com/RipunjayS109/firevizz/main/bannerFV1.png)

# 🔥 FireVizz


A Python library for **visualizing** and **analyzing fire detection data** from sensor networks.  

---

## ✨ Features

- 🗺️ **Interactive map** visualization of fire sensor data  
- 🤖 **Real-time fire prediction** using machine learning models  
- 🌡️ **Heatmap** visualization for various sensor parameters  
- 📤 Export of fire prediction coordinates and sensor data  
- 🔌 Support for multiple sensor types (CO, air quality, temperature, etc.)  

---

## 📦 Installation

```bash
pip install firevizz
```

---

## 🚀 Usage

```python
from firevizz import FireVizz

# Initialize the visualizer
visualizer = FireVizz(
    data_path="sensor_data.csv",
    model_path="fire_detection_model.pkl"  # Optional
)

# Create an interactive map
visualizer.create_map("fire_map.html")

# Export fire predictions to CSV
visualizer.export_fire_predictions("fire_locations.csv")
```

---

## 🤖 Sample ML Model

A sample pretrained SVM model can be downloaded from [here](https://github.com/RipunjayS109/firevizz/blob/main/fire_detection_model_local.pkl) tarined on this [dataset](https://github.com/RipunjayS109/firevizz/blob/main/synthetic_fire_sensor_data_with_gps.csv).

## 🧾 Input Data Format

The input CSV file should contain the following columns:
- 📍 `latitude`
- 📍 `longitude`
- 🧪 `co_level`
- 🌫️ `air_quality`
- 🌡️ `temperature`
- 💧 `humidity`
- ⚖️ `pressure`
- 🧴 `voc_level`

---

## 📊 Output

1. **Interactive HTML map** showing:
   - 📍 Sensor locations  
   - 🔥 Fire predictions  
   - 🌡️ Heatmaps for various parameters  
   - 🧭 Layer controls for toggling different visualizations  

2. **CSV file** containing:
   - 🌍 GPS coordinates of predicted fire locations  
   - 📋 Associated sensor readings  

---

## 🖼️ Example

Here’s a preview of the generated interactive fire map:

![FireVizz Output Map](https://raw.githubusercontent.com/RipunjayS109/firevizz/main/Output_Map_exp.png)  
*Example fire prediction and sensor overlay map.*

> ℹ️ Don't forget to open `fire_map.html` in your browser to explore the interactive features!

---

## 📄 License

📝 MIT License
denodo-extractor 0.0.1
A package to extract metadata from a Denodo workspace
Requires Python: >=3.9

# Denodo Extractor

Denodo offers options to view the data lineage and the corresponding transformations that happen throughout it, but does not allow proper export of these transformations. This package tackles this issue by querying the meta data of this lineage from Denodo and parsing the tree in a depth-first manner to output all transformations. 

## How to make it work? 

An example script is attached below. Input that is required are:

* URL to the server
* port used for connection
* user id 
* password
* database from which you'd like to extract the meta data
* view from which you'd like to extract the meta data

The output is a dictionary that outputs the transformations per field of the view. 

```
from extractor import extractor

def main():
    ex = extractor(URL, PORT, NAME, USER, "my_password")
    print(f"Connection created to {URL}")
    transformations = ex.get_transformations("<database>", "<view>")
    
    for key, value in transformations.items():
        print(key)
        print(value)

if __name__ == "__main__":
    main()
```

Happy coding! :) Feel free to raise any issue or vulnerability that you encounter.