semvec/pypi-packages huggingface dataset:
scionpathml 1.0.8
Advanced CLI tool for SCION network measurement management and data analysis
Requires Python: >=3.8
Keywords: scion networking measurement cli data-analysis network-monitoring


SCIONPATHML CLI - Advanced SCION Network Measurement Management

A comprehensive command-line interface for managing SCION network measurements,
including AS/Server configuration, pipeline command control, data transformation,
automated scheduling, and log analysis.

Features:
• Complete AS (Autonomous System) and server management
• Pipeline command control with category-based operations  
• Automatic JSON to CSV data transformation
• Advanced log management and viewing
• Data organization and backup operations
• Cron-based scheduling for automated measurements
• Colored CLI output with comprehensive help system

System Requirements:
• SCION network infrastructure access
• SCION bandwidth tester: sudo apt install scion-apps-bwtester
• Python 3.8+ (tested with 3.10.12)


For detailed documentation and examples, run: scionpathml help
knowlify-ai 0.1.1
Turn your Python code into an explanatory video by calling knowlify.create('fast'|'detailed').
Requires Python: >=3.8

# Knowlify Python SDK

Turn your Python code into explanatory videos with a simple function call.

## Installation

```bash
pip install knowlify-ai
```

## Quick Start

```python
import knowlify

# Initialize with your API key
knowlify.init(api_key="your-api-key-here")

# Create a video from code above this call
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Generate video
knowlify.create()  # defaults to "fast" mode
```

## API Reference

### `knowlify.init(api_key: str)`

Initialize Knowlify with your API key.

**Parameters:**
- `api_key` (str): Your Knowlify API key

**Example:**
```python
knowlify.init(api_key="your-secret-key")
```

### `knowlify.create(mode="fast", wait=False, *, function=None, task=None)`

Create a video from your code.

**Parameters:**
- `mode` (str): Video generation mode - `"fast"` or `"detailed"` (default: `"fast"`)
- `wait` (bool): Whether to wait for completion (default: `False`)
- `function` (str, optional): Specific function name to capture (e.g., `"my_func"` or `"MyClass.method"`)
- `task` (str, optional): Custom task description (overrides code capture)

**Returns:**
- `str`: Video URL if `wait=True`, empty string if `wait=False`

**Examples:**

```python
# Capture code above the call
knowlify.create()

# Capture specific function
knowlify.create(function="fibonacci")

# Capture class method
knowlify.create(function="MyClass.calculate")

# Custom task
knowlify.create(task="explain this sorting algorithm")

# Detailed mode with wait
url = knowlify.create(mode="detailed", wait=True)
print(f"Video URL: {url}")
```

### `knowlify.start()` and `knowlify.end(mode="fast", wait=False)`

Capture code between start and end markers.

**Example:**
```python
knowlify.start()

# Your code here
def complex_algorithm():
    # ... complex logic ...
    return result

knowlify.end()  # Generates video of code between start() and end()
```

## Modes

- **`"fast"`**: Quick generation, good for simple explanations
- **`"detailed"`**: More comprehensive, better for complex topics

## Error Handling

```python
import knowlify

try:
    knowlify.create()
except knowlify.InvalidAPIKeyError:
    print("Invalid API key")
except knowlify.OutOfMinutesError:
    print("Out of minutes")
except knowlify.KnowlifyAPIError as e:
    print(f"API error: {e}")
```

## Output

- **Non-blocking mode** (`wait=False`): Videos save to `./knowlify_videos/` in background
- **Blocking mode** (`wait=True`): Returns video URL and saves locally

## Requirements

- Python 3.8+
- Valid Knowlify API key
## License

MIT License - see LICENSE file for details.

## Support

Visit [knowlify.com](https://knowlify.com) for more information.
spyctl 0.24.1
A command line tool for viewing and managing Spyderbat Resources
Requires Python: >=3.10
Keywords: spyctl, spyderbat, kubectl, kubernetes

<p align="center">
  <a href="" rel="noopener">
 <img width=200px height=200px src="https://i.imgur.com/nkMr2fl.png" alt="Project logo"></a>
</p>

<h1 align="center">Spyctl</h1>

Spyctl, is a command-line utility for viewing and managing Spyderbat Resources. It provides basic
mechanisms for retrieving and uploading data via the [Spyderbat API](https://api.spyderbat.com/openapi.pdf).

Spyctl is the answer for those wanting a command-line solution to interact with Spyderbat.

---

<p align="center"> 
    <br> 
</p>

## Getting Started <a name = "getting_started"></a>

Follow the [Installation Guide](https://docs.spyderbat.com/installation/spyctl)

Or if you already have Spyctl installed explore the [Tutorials](https://docs.spyderbat.com/tutorials) section of the Spyderbat Docs

## Support <a name = "support"></a>

If you need support, you can reach out to us at dev@spyderbat.com or on our [community Slack workspace](https://join.slack.com/t/spyderbatcommunity/shared_invite/zt-1ncqumr1c-WVVRwJTNfTQSW2Y8_maGOw)


## ✍️ Authors <a name = "authors"></a>

- [@brent-spyder](https://github.com/brent-spyder) - Developer/Admin
- [@spyder-kyle](https://github.com/spyder-kyle) - Developer
- [@spyder-guy](https://github.com/spyder-guy) - Developer
- [@spyder-ruhika](https://github.com/spyder-ruhika) - Developer
almasru 3.0.3
This python module is a tool to use Alma SRU. it manages the logs and the backup of the records.
Requires Python: >=3

*********************
Alma SRU helper |doc|
*********************

This python module is a tool to use Alma SRU. It manages the logs and the
backup of the records.

* Author: Raphaël Rey (raphael.rey@slsp.ch)
* Year: 2025
* Version: 3.0.3
* License: GNU General Public License v3.0
* `Documentation <https://almasru.readthedocs.io/en/latest/>`_

.. |doc| image:: https://readthedocs.org/projects/almapi-wrapper/badge/?version=latest
    :target: https://almasru.readthedocs.io/en/latest/
    :alt: Documentation Status
gmsh-interop 2025.1
A parser for GMSH's .msh format
Requires Python: >=3.10

Interoperability between Python and Gmsh
========================================

.. image:: https://gitlab.tiker.net/inducer/gmsh_interop/badges/main/pipeline.svg
    :alt: Gitlab Build Status
    :target: https://gitlab.tiker.net/inducer/gmsh_interop/commits/main
.. image:: https://github.com/inducer/gmsh_interop/actions/workflows/ci.yml/badge.svg
    :alt: Github Build Status
    :target: https://github.com/inducer/gmsh_interop/actions/workflows/ci.yml
.. image:: https://badge.fury.io/py/gmsh_interop.svg
    :alt: Python Package Index Release Page
    :target: https://pypi.org/project/gmsh_interop/
.. image:: https://zenodo.org/badge/113488057.svg
   :alt: Zenodo DOI for latest release
   :target: https://zenodo.org/doi/10.5281/zenodo.11075135

This package allows Python to interoperate with the `gmsh <http://gmsh.info/>`__
mesh generator.

This package contains:

* ``gmsh_interop.reader`` to read gmsh's ``.msh`` file format.
* ``gmsh_interop.runner`` to run gmsh under program control and process its output.

Its contents was extracted from `meshpy <https://github.com/inducer/meshpy>`__
to escape its obnoxious licensing.

Links:

* `Github <https://github.com/inducer/gmsh_interop>`__
* `Python Package Index <https://pypi.org/project/gmsh_interop/>`__
* `Documentation <https://documen.tician.de/gmsh_interop>`__
hexaboost 1.0.1
Hexaboost - CLI para generar proyectos en Python con plantillas listas
Requires Python: >=3.8
Keywords: cli, scaffolding, python, boost, templates

# ⚡ Hexaboost

[![PyPI version](https://badge.fury.io/py/hexaboost.svg)](https://pypi.org/project/hexaboost/)
[![CI](https://github.com/hexaboost/hexaboost/actions/workflows/ci.yml/badge.svg)](https://github.com/hexaboost/hexaboost/actions)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

Generador de proyectos escalables con arquitectura Hexagonal, pensado para acelerar el desarrollo de aplicaciones modernas en **Python**.

---

## 🚀 Características
- 🏗️ CLI intuitiva para crear y gestionar proyectos.
- 📦 Plantillas listas (ejemplo: FastAPI) para arrancar rápido.
- 🌐 Documentación multi-idioma incluida.
- ✅ Tests preconfigurados con `pytest`.
- 🔧 Preparado para integrarse con CI/CD.

---

## 📦 Instalación

Desde PyPI:

```bash
pip install hexaboost
Verifica la instalación:

bash
Copiar código
hexaboost --help
⚡ Uso básico
Inicializar un proyecto vacío:

bash
Copiar código
hexaboost init myproject
Crear un proyecto desde plantilla (ejemplo FastAPI):

bash
Copiar código
hexaboost new python-fastapi myproject
Sincronizar la documentación (multi-idioma):

bash
Copiar código
hexaboost sync-readme
🧪 Tests
Ejecutar los tests de un proyecto generado:

bash
Copiar código
pytest -v myproject/tests
📂 Estructura del proyecto generado
arduino
Copiar código
myproject/
├── app/              # código principal
├── tests/            # pruebas con pytest
├── requirements.txt
├── pyproject.toml
└── README.md
🤝 Contribuciones
¡Las contribuciones son bienvenidas! 🎉

Haz un fork del repositorio.

Crea una rama:

bash
Copiar código
git checkout -b feature/nueva-feature
Haz commit de tus cambios:

bash
Copiar código
git commit -m "Añadida nueva feature"
Sube tu rama y abre un PR.

📜 Licencia
Este proyecto está bajo la licencia MIT.
fastapi-oidc-simple 0.2.0
Simple OIDC integration for FastAPI using Authlib
Requires Python: >=3.9

# fastapi-oidc

A lightweight **OpenID Connect (OIDC)** integration for **FastAPI**, built on top of [Authlib](https://docs.authlib.org/).  
It provides simple routes for OIDC login, callback, and user info, along with dependency helpers to protect endpoints and enforce group-based access.

---

## ✨ Features

- 🔑 Easy OIDC integration with FastAPI  
- 🔗 Built-in routes for `/auth/login`, `/auth/callback`, and `/auth/userinfo`  
- 🛡️ Dependency helpers:
  - `require_oidc` → protect endpoints with authentication  
  - `require_oidc_group("group")` → enforce group-based authorization  
- 🧩 Uses Authlib’s discovery-based OIDC client  
- ⚡ Minimal setup: just plug it into your FastAPI app  

---
PubChemPy 1.0.5
A simple Python wrapper around the PubChem PUG REST API.
Requires Python: >=3.10
Keywords: pubchem, python, rest, api, chemistry, cheminformatics

# PubChemPy

[![PyPI Version](https://img.shields.io/pypi/v/PubChemPy?logo=python&logoColor=%23ffffff)](https://pypi.python.org/pypi/PubChemPy)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/pubchempy?logo=anaconda&logoColor=%23ffffff)](https://anaconda.org/conda-forge/pubchempy)
[![License](https://img.shields.io/pypi/l/PubChemPy)](https://github.com/mcs07/PubChemPy/blob/main/LICENSE)
[![DOI](https://zenodo.org/badge/7462957.svg)](https://zenodo.org/badge/latestdoi/7462957)
[![Tests](https://img.shields.io/github/actions/workflow/status/mcs07/pubchempy/test.yml?logo=github&logoColor=%23ffffff&label=tests)](https://github.com/mcs07/PubChemPy/actions/workflows/test.yml)
[![Docs](https://img.shields.io/readthedocs/pubchempy?logo=readthedocs&logoColor=%23ffffff)](https://docs.pubchempy.org)

PubChemPy provides a way to interact with PubChem in Python. It allows chemical searches by name, substructure and similarity, chemical standardization, conversion between chemical file formats, depiction and retrieval of chemical properties.

## Installation

Install PubChemPy with pip:

```shell
pip install pubchempy
```

Or with conda:

```shell
conda install -c conda-forge pubchempy
```

For detailed instructions, see the [installation guide](https://docs.pubchempy.org/en/latest/guide/install.html).

## Example usage

Retrieve a compound by its PubChem Compound Identifier (CID) and print its SMILES and IUPAC name:

```pycon
>>> import pubchempy as pcp
>>> comp = pcp.Compound.from_cid(1423)
>>> print(comp.smiles)
CCCCCCCNC1CCCC1CCCCCCC(=O)O
>>> print(comp.iupac_name)
7-[2-(heptylamino)cyclopentyl]heptanoic acid
```

Search compounds by name and print the SMILES and molecular weight of the first result:

```pycon
>>> results = pcp.get_compounds("Aspirin", "name")
>>> print(results[0].smiles)
CC(=O)OC1=CC=CC=C1C(=O)O
>>> print(results[0].molecular_weight)
180.16
```

## Documentation

Full documentation is available at <https://docs.pubchempy.org>.

This includes a [step-by-step guide on how to use PubChemPy](https://docs.pubchempy.org/en/latest/guide/gettingstarted.html), as well as a [complete API reference](https://docs.pubchempy.org/en/latest/api.html).

## Contributing

- Feature ideas and bug reports are welcome on the [Issue Tracker](https://github.com/mcs07/PubChemPy/issues).
- Fork the [source code](https://github.com/mcs07/PubChemPy) on GitHub, make changes and file a pull request.

## License

PubChemPy is licensed under the [MIT license](https://github.com/mcs07/PubChemPy/blob/main/LICENSE).
llama-index-readers-string-iterable 0.4.1
llama-index readers string iterable integration
Requires Python: <4.0,>=3.9

# LlamaIndex Readers Integration: StringIterable

## Overview

The StringIterable Reader converts an iterable of strings into a list of documents. It's a simple utility to quickly create documents from a list of text strings.

### Installation

You can install String Iterable Reader via pip:

```bash
pip install llama-index-readers-string-iterable
```

## Usage

```python
from llama_index.readers.string_iterable import StringIterableReader

# Initialize StringIterableReader
reader = StringIterableReader()

# Load data from an iterable of strings
documents = reader.load_data(
    texts=["I went to the store", "I bought an apple"]
)
```

This loader is designed to be used as a way to load data into
[LlamaIndex](https://github.com/run-llama/llama_index/tree/main/llama_index) and/or subsequently
used as a Tool in a [LangChain](https://github.com/hwchase17/langchain) Agent.
llama-index-readers-wordlift 0.4.1
llama-index readers wordlift integration
Requires Python: <4.0,>=3.9
Keywords: graphql, knowledge graph, seo, structured data, wordlift

# WordLift Reader

```bash
pip install llama-index-readers-wordlift
```

The WordLift GraphQL Reader is a connector to fetch and transform data from a WordLift Knowledge Graph using your the WordLift Key. The connector provides a convenient way to load data from WordLift using a GraphQL query and transform it into a list of documents for further processing.

## Usage

To use the WordLift GraphQL Reader, follow the steps below:

1. Set up the necessary configuration options, such as the API endpoint, headers, query, fields, and configuration options (make sure you have with you the [Wordlift Key](https://docs.wordlift.io/pages/key-concepts/#wordlift-key)).
2. Create an instance of the `WordLiftLoader` class, passing in the configuration options.
3. Use the `load_data` method to fetch and transform the data.
4. Process the loaded documents as needed.

Here's an example of how to use the WordLift GraphQL Reader:

```python
import json
from llama_index.core import VectorStoreIndex
from llama_index.core import Document
from langchain.llms import OpenAI
from llama_index.readers.wordlift import WordLiftLoader

# Set up the necessary configuration options
endpoint = "https://api.wordlift.io/graphql"
headers = {
    "Authorization": "<YOUR_WORDLIFT_KEY>",
    "Content-Type": "application/json",
}

query = """
# Your GraphQL query here
"""
fields = "<YOUR_FIELDS>"
config_options = {
    "text_fields": ["<YOUR_TEXT_FIELDS>"],
    "metadata_fields": ["<YOUR_METADATA_FIELDS>"],
}
# Create an instance of the WordLiftLoader
reader = WordLiftLoader(endpoint, headers, query, fields, config_options)

# Load the data
documents = reader.load_data()

# Convert the documents
converted_doc = []
for doc in documents:
    converted_doc_id = json.dumps(doc.doc_id)
    converted_doc.append(
        Document(
            text=doc.text,
            doc_id=converted_doc_id,
            embedding=doc.embedding,
            doc_hash=doc.doc_hash,
            extra_info=doc.extra_info,
        )
    )

# Create the index and query engine
index = VectorStoreIndex.from_documents(converted_doc)
query_engine = index.as_query_engine()

# Perform a query
result = query_engine.query("<YOUR_QUERY>")

# Process the result as needed
logging.info("Result: %s", result)
```
llama-index-tools-duckduckgo 0.4.1
llama-index tools integrating DuckDuckGo search
Requires Python: <4.0,>=3.9
Keywords: research

# DuckDuckGo Search Tool

This tool enables agents to search and retrieve results from the DuckDuckGo search engine. It utilizes the duckduckgo_search package, which either fetches instant query answers from DuckDuckGo or conducts a full search and parses the results.

## Usage

This tool has a more extensive example usage documented in a Jupyter notebook [here](./examples/duckduckgo_search.ipynb)

Here's an example usage of the DuckDuckGoSearchToolSpec.

```python
from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

tool_spec = DuckDuckGoSearchToolSpec()

agent = FunctionAgent(
    tools=DuckDuckGoSearchToolSpec.to_tool_list(),
    llm=OpenAI(model="gpt-4.1"),
)

print(await agent.run("What's going on with the superconductor lk-99"))
print(await agent.run("what are the latest developments in machine learning"))
```

## Available tool functions:

- `duckduckgo_instant_search`: Make a query to DuckDuckGo api to receive an instant answer.

- `duckduckgo_full_search`: Make a query to DuckDuckGo search to receive a full search results.
llama-index-readers-intercom 0.4.1
llama-index readers intercom integration
Requires Python: <4.0,>=3.9
Keywords: help center, intercom, knowledge base

# Intercom Loader

```bash
pip install llama-index-readers-intercom
```

This loader fetches the text from Intercom help articles using the Intercom API. It also uses the BeautifulSoup library to parse the HTML and extract the text from the articles.

## Usage

To use this loader, you need to pass in an Intercom account access token.

```python
from llama_index.readers.intercom import IntercomReader

loader = IntercomReader(intercom_access_token="my_access_token")
documents = loader.load_data()
```

This loader is designed to be used as a way to load data into [LlamaIndex](https://github.com/run-llama/llama_index/).
llama-index-embeddings-vertex 0.4.1
llama-index embeddings vertex integration
Requires Python: <4.0,>=3.9

# LlamaIndex Embeddings Integration: Vertex

Implements Vertex AI Embeddings Models:

| Model                                | Release Date      |
| ------------------------------------ | ----------------- |
| textembedding-gecko@003              | December 12, 2023 |
| textembedding-gecko@002              | November 2, 2023  |
| textembedding-gecko-multilingual@001 | November 2, 2023  |
| textembedding-gecko@001              | June 7, 2023      |
| multimodalembedding                  |                   |

**Note**: Currently Vertex AI does not support async on `multimodalembedding`.
Otherwise, `VertexTextEmbedding` supports async interface.

---

### New Features

- **Flexible Credential Handling:**

  - Credential Management: Supports both direct credentials and service account info for secure API access.

- **Model Name Handling in Embedding Requests:**
  - The `_get_embedding_request` function now accepts the `model_name` parameter, allowing it to manage models that do not support the `task_type` parameter, like `textembedding-gecko@001`.

### Example Usage

```python
from google.oauth2 import service_account
from llama_index.embeddings.vertex import VertexTextEmbedding

credentials = service_account.Credentials.from_service_account_file(
    "path/to/your/service-account.json"
)

embedding = VertexTextEmbedding(
    model_name="textembedding-gecko@003",
    project="your-project-id",
    location="your-region",
    credentials=credentials,
)
```

Alternatively, you can directly pass the required service account parameters:

```python
from llama_index.embeddings.vertex import VertexTextEmbedding

embedding = VertexTextEmbedding(
    model_name="textembedding-gecko@003",
    project="your-project-id",
    location="your-region",
    client_email="your-service-account-email",
    token_uri="your-token-uri",
    private_key_id="your-private-key-id",
    private_key="your-private-key",
)
```
llama-index-retrievers-vertexai-search 0.3.1
llama-index retrievers vertex ai search integration
Requires Python: <4.0,>=3.9

# LlamaIndex Retrievers Integration: Vertex AI Search

## Vertex AI Search

> [Vertex AI Search](https://cloud.google.com/enterprise-search?e=48754805&hl=en) helps developers build secure, Google-quality search experiences for websites, intranet and RAG systems for generative AI agents and apps. Vertex AI Search is a part of Vertex AI Agent Builder.

> [Vertex AI Agent Builder](https://cloud.google.com/products/agent-builder?e=48754805&hl=en#build-and-deploy-enterprise-ready-generative-ai-experiences): Create AI agents and applications using natural language or a code-first approach. Easily ground your agents or apps in enterprise data with a range of options. Vertex AI Agent Builder gathers all the surfaces and tools that developers need to build their AI agents and applications..

## Installation

```
pip install llama-index-retrievers-vertexai-search
```

## Usage

```
from llama_index.retrievers.vertexai_search import VertexAISearchRetriever

retriever = VertexAISearchRetriever(
        project_id=PROJECT_ID,
        data_store_id=DATA_STORE_ID,
        location_id=LOCATION_ID,
        engine_data_type=1
    )

query = "harry potter"
retrieved_results = retriever.retrieve(query)

# Prints the first retrieved result
print(retrieved_results[0].get_content())
```

## Notebook

Explore the retriever using Notebook present at:
<a href="https://colab.research.google.com/github/run-llama/llama_index/blob/main/docs/docs/examples/retrievers/vertex_ai_search_retriever.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
llama-index-vector-stores-astra-db 0.5.1
llama-index vector_stores astra integration
Requires Python: <4.0,>=3.9

# Astra DB Vector Store

A LlamaIndex vector store using Astra DB as the backend.

## Usage

Pre-requisite:

```bash
pip install llama-index-vector-stores-astra-db
```

A minimal example:

```python
from llama_index.vector_stores.astra_db import AstraDBVectorStore

vector_store = AstraDBVectorStore(
    token="AstraCS:xY3b...",  # Your Astra DB token
    api_endpoint="https://012...abc-us-east1.apps.astra.datastax.com",  # Your Astra DB API endpoint
    collection_name="astra_v_table",  # Table name of your choice
    embedding_dimension=1536,  # Embedding dimension of the embeddings model used
)
```

## More examples and references

A more detailed usage guide can be found
[at this demo notebook](https://docs.llamaindex.ai/en/stable/examples/vector_stores/AstraDBIndexDemo.html)
in the LlamaIndex docs.

> **Note**: Please see the AstraDB documentation [here](https://docs.datastax.com/en/astra/astra-db-vector/clients/python.html).
llama-index-indices-managed-dashscope 0.4.1
llama-index indices managed-dashscope integration
Requires Python: <4.0,>=3.9

# LlamaIndex Indices Integration: Managed-Dashscope

## Installation

```shell
pip install llama-index-indices-managed-dashscope
```

## Usage

```python
import os
from llama_index.core.schema import QueryBundle
from llama_index.readers.dashscope.base import DashScopeParse
from llama_index.readers.dashscope.utils import ResultType

os.environ["DASHSCOPE_API_KEY"] = "your_api_key_here"
os.environ["DASHSCOPE_WORKSPACE_ID"] = "your_workspace_here"

# init retriever from scratch
from llama_index.indices.managed.dashscope.retriever import (
    DashScopeCloudRetriever,
)


file_list = [
    # your files (accept doc, docx, pdf)
]

parse = DashScopeParse(result_type=ResultType.DASHCOPE_DOCMIND)
documents = parse.load_data(file_path=file_list)

# create a new index
index = DashScopeCloudIndex.from_documents(
    documents,
    "my_first_index",
    verbose=True,
)

# # connect to an existing index
# index = DashScopeCloudIndex("my_first_index")

retriever = index.as_retriever()
nodes = retriever.retrieve("test query")
print(nodes)
```