semvec/pypi-packages huggingface dataset:
terraweave 0.1.6
A Python wrapper for Terraform
License: MIT
Requires Python: >=3.7

# TerraWeave: A Python Wrapper for Terraform

TerraWeave is a Python library that provides a simple interface for interacting with Terraform. It wraps common Terraform commands such as `init`, `plan`, `apply`, `destroy`, and workspace management, making it easier to integrate Terraform into Python-based workflows.

## Features

- Initialize a Terraform working directory (`terraform init`).
- Generate and show execution plans (`terraform plan`).
- Apply changes to reach the desired state (`terraform apply`).
- Destroy Terraform-managed infrastructure (`terraform destroy`).
- Retrieve Terraform output variables (`terraform output`).
- Manage Terraform workspaces:
  - List workspaces (`terraform workspace list`).
  - Show the current workspace (`terraform workspace show`).
  - Create a new workspace (`terraform workspace new`).
  - Select a workspace (`terraform workspace select`).
  - Delete a workspace (`terraform workspace delete`).

## Installation

#### Pip
``` pip install TerraWeave ```

#### From source
Clone the repository to your local machine:

```bash
git clone https://github.com/brains93/TerraWeave.git
cd TerraWeave
```
Ensure you have Python 3.7+ installed, along with Terraform installed and available in your system's PATH.

Usage
Example: Basic Usage

NOTE: the class uses python logging to print the output to stdout, this can be redirectedto a file using the same logging library 

```
from TerraWeave import TerraformWrapper

# Path to the directory containing Terraform configuration files
working_dir = "/path/to/terraform/config"

# Initialize the TerraformWrapper
tf = TerraformWrapper(working_dir)

# Initialize Terraform
print("Initializing Terraform...")
tf.init()

# Generate a plan
print("Generating Terraform plan...")
tf.plan()

# Apply the changes
print("Applying Terraform changes...")
tf.apply()

# Destroy the infrastructure
print("Destroying Terraform-managed infrastructure...")
tf.destroy()
```
codekite 0.1.7
A modular toolkit for LLM powered codebase understanding.
License: MIT
Requires Python: >=3.10

# CodeKite Code Intelligence Toolkit

[![CI](https://github.com/shaneholloman/codekite/actions/workflows/ci.yml/badge.svg)](https://github.com/shaneholloman/codekite/actions/workflows/ci.yml)

`codekite` is a modular, production-grade Python toolkit for codebase mapping, symbol extraction, code search, and building LLM-powered developer tools, agents, and workflows.

Use `codekite` to build things like code reviewers, code generators, even IDEs, all enriched with the right code context.

## Quick Installation

### Install from PyPI

```sh
# Installation (includes all features)
uv tool install codekite
```

### Install from Source

```sh
git clone https://github.com/shaneholloman/codekite.git
cd codekite
uv sync
uv pip install -e .
```

## Basic Usage

```python
from codekite import Repository

# Load a local repository
repo = Repository("/path/to/your/local/codebase")

# Load a remote public GitHub repo
# repo = Repository("https://github.com/owner/repo")

# Explore the repo
print(repo.get_file_tree())
# Output: [{"path": "src/main.py", "is_dir": False, ...}, ...]

print(repo.extract_symbols('src/main.py'))
# Output: [{"name": "main", "type": "function", "file": "src/main.py", ...}, ...]
```

## Key Features & Capabilities

`codekite` helps your apps and agents deeply understand and interact with codebases, providing the core components to build your own AI-powered developer tools. Here are just a few of the things you can do:

- **Explore Code Structure:**

  - Get a bird's-eye view with `repo.get_file_tree()` to list all files and directories.
  - Dive into specifics with `repo.extract_symbols()` to identify all functions, classes, and other code constructs, either across the entire repository or within a single file.

- **Pinpoint Information:**

  - Perform precise textual or regular expression searches across your codebase using `repo.search_text()`.
  - Track down every definition and reference of a specific symbol (like a function or class) with `repo.find_symbol_usages()`.

- **Prepare Code for LLMs & Analysis:**

  - Break down large files into manageable pieces for LLM context windows using `repo.chunk_file_by_lines()` or `repo.chunk_file_by_symbols()`.
  - Instantly grab the full definition of a function or class just by knowing a line number within it using `repo.extract_context_around_line()`.

- **Generate Code Summaries (Alpha):**

  - Leverage LLMs to create natural language summaries for files, functions, or classes using the `Summarizer` (e.g., `summarizer.summarize_file()`, `summarizer.summarize_function()`).
  - Build a searchable semantic index of these AI-generated docstrings with `DocstringIndexer` and query it with `SummarySearcher` to find code based on intent and meaning.

- **And much more...** `codekite` also offers capabilities for semantic search on raw code, building custom context for LLMs, and more.

## License

MIT License