semvec/pypi-packages huggingface dataset:
Orange3-Text 1.16.3
Orange3 TextMining add-on.
Keywords: orange3-text, data mining, orange3 add-on

Orange3 Text
============

Orange add-on for text mining. It provides access to publicly available data,
like NY Times, Twitter and PubMed. Further, it provides tools for preprocessing,
constructing vector spaces (like bag-of-words, topic modeling and word2vec) and
visualizations like word cloud end geo map. All features can be combined with
powerful data mining techniques from the Orange data mining framework.

See [documentation](http://orange3-text.readthedocs.org/).

Features
--------
#### Access to data
* Load a corpus of text documents
* Access publicly available data (The Guardian, NY Times, Twitter, Wikipedia, PubMed)

#### Text analysis
* Preprocess corpus
* Generate bag of words
* Embed documents into vector space
* Perform sentiment analysis
* Detect emotions in tweets
* Discover topics in the text
* Compute document statistics
* Visualize frequent words in the word cloud
* Find words that enrich selected documents
navas-etl 0.1.2
A flexible ELT pipeline implementation in Python
Requires Python: >=3.8

# navas-etl

![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)
![License](https://img.shields.io/badge/license-MIT-green)
[![PyPI Version](https://img.shields.io/pypi/v/pipelinex.svg)](https://pypi.org/project/pipelinex/)

A flexible ELT (Extract, Load, Transform) pipeline implementation in Python with support for multiple data sources and destinations.

## Features

- **Extract** from multiple sources:
  - REST APIs
  - CSV files
  - Databases (via SQLAlchemy)
  
- **Transform** data with:
  - Cleaning operations
  - Aggregations
  - Formatting
  
- **Load** to various targets:
  - Databases
  - CSV files
  - JSON files

## Installation

```bash
pip install navas-etl
```

## Quick Start

```python
from navas-etl import ApiExtractor, Cleaner, DbLoader

# 1. Extract data from API
extractor = ApiExtractor("https://api.example.com")
data = extractor.extract_to_dataframe("users")

# 2. Transform/Clean the data
cleaner = Cleaner(data)
cleaned_data = (cleaner
               .drop_duplicates()
               .fill_missing(strategy='mean')
               .get_data())

# 3. Load to database
loader = DbLoader("postgresql://user:password@localhost:5432/mydb")
loader.load(cleaned_data, "users_table")
```

## Documentation

### Extractors

#### API Extractor
```python
from navas-etl import ApiExtractor

extractor = ApiExtractor(base_url="https://api.example.com", auth=("user", "pass"))
data = extractor.extract("endpoint", params={"param": "value"})
```

#### CSV Extractor
```python
from navas-etl import CsvExtractor

extractor = CsvExtractor()
df = extractor.extract("data.csv")
```

#### Database Extractor
```python
from navas-etl import DbExtractor

extractor = DbExtractor("postgresql://user:pass@localhost:5432/db")
df = extractor.extract("SELECT * FROM table")
```

### Transformers

See [full documentation](https://github.com/Navashub/navas_pipeline) for more examples.

## Contributing

Contributions are welcome! Please open an issue or submit a pull request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
mqsc-pyqdmi 0.1.3
MQSC PyQDMI Library
Requires Python: >=3.9

[![PyPI](https://img.shields.io/pypi/v/mqsc.pyqdmi?logo=pypi&style=flat-square)](https://pypi.org/project/mqsc.pyqdmi/)
![OS](https://img.shields.io/badge/os-linux%20%7C%20macos-blue?style=flat-square)

<p align="center">
  <a href="https://munichquantum.software">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/munich-quantum-toolkit/.github/refs/heads/main/docs/_static/logo-mqsc-dark.svg" width="70%">
     <img src="https://raw.githubusercontent.com/munich-quantum-toolkit/.github/refs/heads/main/docs/_static/logo-mqsc-light.svg" width="70%" alt="MQSC Logo">
   </picture>
  </a>
</p>

# MQSC PyQDMI

MQSC PyQDMI is a C++17 and Python 3.9+ library built on top of the [QDMI](https://github.com/Munich-Quantum-Software-Stack/QDMI) interface.
It provides

- a fully fledged QDMI Driver implementation
- a dedicated FoMaC (_Figures of Merit and Constraints_) library that abstracts the QDMI C interface and provides a high-level C++ interface for the user.
- Python bindings for the FoMaC interface via [nanobind](https://nanobind.readthedocs.io/en/latest/) which forms the `mqsc.pyqdmi` Python package.
- basic functionality for turning QDMI devices into Qiskit backends via the `mqsc.pyqdmi_qiskit` module.

PyQDMI is compatible with QDMI version 1.1 and Qiskit version 1.0+.
nesso-cli 0.11.6
A CLI tool for managing data models.
Requires Python: >=3.10
Keywords: cli, data, dbt, dyvenia, models, nesso

# nesso-cli

![coverage](coverage/coverage-badge.svg)![docs_coverage](coverage/docstring_coverage.svg)

---
**Documentation**: 📚 [dyvenia docs (internal)][mkdocs page]

**Source Code**: 💾 [dyvenia/nesso-cli][github page]

---

<!-- body-begin -->

The [CLI](https://www.w3schools.com/whatis/whatis_cli.asp) interface of the [nesso data platform].

## Features

- [x] simplify and automate data modelling
- [x] simplify and automate metadata generation
- [x] manage nesso project configuration
- [ ] simplify and automate job scheduling (coming soon!)

## Where does nesso-cli fit in?

Currently, nesso-cli contains a single module, `models` (`nesso models`), which is used for the T in ELTC (Extract, Load, Transform, Catalog), sitting between data ingestion (`viadot`) and metadata ingestion (`luma-cli`):

![Where does nesso-cli fit](docs/_static/where_nesso_cli_fits.png)

In the future, nesso-cli will include additional modules to allow interacting with different components of the nesso data platform through a unified interface.

The next planned module is `jobs`, which will allow creating and scheduling EL and ELTC jobs via a simple CLI interface. Currently, this is done by creating jobs manually in Python and then manually scheduling them in Prefect. We hope to replace this tedious and error-prone (though repeatable) process with simple commands, such as `nesso jobs deployment create --job my_job --schedule "0 0 * * *"`, as well as interactive commands which will guide user through a set of limited choices, such as `nesso jobs job create`.

[github page]: https://github.com/dyvenia/nesso-cli
[mkdocs page]: https://nesso-cli.docs.dyvenia.com/
[nesso data platform]: https://nesso.docs.dyvenia.com/

<!-- body-end -->
sql-dhost 0.1.1
A Python package for generating SQL queries using LLMs
Requires Python: >=3.10

# sql-dhost

**sql-dhost** is a Python utility that integrates SQL database querying with powerful LLMs (like OpenAI, Claude, and Perplexity) to enable natural language to SQL query conversion. It's particularly useful for users who want to interact with databases using plain English.

## 🚀 Features

- 🔌 Easy connection to PostgreSQL databases
- 🤖 Convert natural language questions into SQL using OpenAI, Claude, or Perplexity
- 🧠 Schema-aware LLM prompts
- 🔍 Execute queries and retrieve results programmatically
- ⚙️ Modular design for easy extension

---

## 📦 Installation

Clone the repository and install dependencies:

```bash
git clone https://github.com/sujanMidatani7/sql-dhost.git
cd sql-dhost
pip install uv
uv init
uv venv
uv add -r requirements.txt
```

---

## 🛠️ Usage

### 1. **Basic Setup**

```python
from dhost import PSQLUtil

# PostgreSQL connection string
conn_str = "db_connection_string"

# Initialize PSQLUtil with API keys
psql = PSQLUtil(
    db_connection=conn_str,
    openai_api_key="your-openai-key",
    claude_api_key="your-claude-key",
    perplexity_api_key="your-perplexity-key"
)
```

---

### 2. **Set Schema**

Before generating queries, provide your database schema:

```python
schema = """
Table: users
Columns: id, name, email

Table: orders
Columns: id, user_id, amount, date
"""

psql.set_schema(schema)
```

---

### 3. **Execute Raw SQL Queries**

```python
query = "SELECT * FROM users WHERE id = %s"
results = psql.execute_query(query, params=(1,))
print(results)
```

---

### 4. **Generate SQL from Natural Language**

```python
response = psql.generate_sql_query(
    question="List all users who placed an order above $1000",
    provider="openai",
    llm="gpt-4o",
    max_tokens=500
)

print(response['sql'])
```

---

### 5. **Generate SQL and Execute It**

```python
for output in psql.generate_sql_query_and_execute(
    question="Get all users who made orders in January",
    provider="claude",
    llm="claude-3-opus"
):
    print(output)
```

---

## 🧪 Testing

To run test scripts:

```bash
python test.py
```

Ensure your `.env` or connection config is properly set up before testing.

---

## 🔧 API Reference

### `PSQLUtil.__init__(...)`
Initializes the utility with DB and optional LLM API keys.

### `set_schema(schema: str)`
Sets the database schema and updates system prompt for the LLM.

### `execute_query(query: str, params: tuple = None)`
Executes a SQL query and returns results.

### `update_system_prompt(new_prompt: str)`
Manually update the LLM system prompt.

### `get_system_prompt() -> str`
Retrieves the current system prompt.

### `generate_sql_query(question: str, provider="openai", llm=None, max_tokens=1000)`
Returns SQL and explanation generated by selected LLM.

### `generate_sql_query_and_execute(...)`
Generates SQL using LLM and streams execution results.

---

## 🤝 Contributing

Pull requests are welcome. For major changes, open an issue first to discuss.

---

## 📄 License

MIT License. See [LICENSE](LICENSE) for details.
memememe 1.0.1
A simple Python module to fetch random GIFs from Tenor.
Requires Python: >=3.6

# memememe

A simple Python module to fetch random GIFs from Tenor using a search term.

## Usage
```python
from memememe import get_random_gif

key = '' # Tenor V2 api key
gif = get_random_gif("cat", key)
print(gif)
```