semvec/pypi-packages huggingface dataset:
plotshell 0.1.1
AI helper for DevOps using OpenAI.


# Plot: AI Helper for DevOps

🚀 Plot is a powerful command-line tool designed to provide immediate assistance to DevOps professionals. It leverages the capabilities of OpenAI's GPT models to deliver precise command guidance tailored to various operating systems and environments.

## Features 🌟

- **Streamlined Command Assistance**: Get specific commands for your operating system without unnecessary clutter.
- **Support for Multiple GPT Models**: Choose between different GPT models like GPT-4 for tailored assistance.
- **Easy Configuration**: Simple commands to set your API key and preferred GPT model.

## Installation 🛠️

To install Plot, simply use pip. Ensure you have Python 3.6 or later installed.

```bash
pip install plotshell
```

## Configuration 🔧

Before you start using Plot, you need to configure your OpenAI API key. Optionally, you can also set your preferred GPT model if you don't want to use the default (GPT-4).

### Setting the API Key

```bash
plot --setkey
```

When prompted, enter your OpenAI API key. This key will be saved and used for future requests.

### Setting the GPT Model

If you want to use a different model than the default GPT-4, you can set it as follows:

```bash
plot --set-model gpt-3.5-turbo
```

This command will save your model choice and use it for all future inquiries.

## Usage 📝

To use Plot, simply type `plot` followed by the command or query you need help with. Here’s how it works:

```bash
plot how to setup nginx
```

### Examples

Here are a few examples of how you can use Plot to get help with common DevOps tasks:

- **Setting up nginx**:
```bash
plot setup nginx webserver
```

- **Initializing a Git repository**:
```bash
plot how to initialize git repository
```

- **Creating a Python virtual environment**:
```bash
plot create python virtual environment
```
pycrfpp 0.1.0
Python binding for CRF++
Requires Python: >=3.7

## Python binding for [CRF++](https://github.com/taku910/crfpp)

```
pip install pycrfpp
```

```python
from pycrfpp import Tagger

# -v 3: access deep information like alpha,beta,prob
# -nN: enable nbest output. N should be >= 2
tagger = Tagger("-m ../model -v 3 -n2")

# clear internal context
tagger.clear()

# add context
tagger.add("Confidence NN")
tagger.add("in IN")
tagger.add("the DT")
tagger.add("pound NN")
tagger.add("is VBZ")
tagger.add("widely RB")
tagger.add("expected VBN")
tagger.add("to TO")
tagger.add("take VB")
tagger.add("another DT")
tagger.add("sharp JJ")
tagger.add("dive NN")
tagger.add("if IN")
tagger.add("trade NN")
tagger.add("figures NNS")
tagger.add("for IN")
tagger.add("September NNP")

print(f"column size: {tagger.xsize()}")
print(f"token size: {tagger.size()}")
print(f"tag size: {tagger.ysize()}")

print("tagset information:")

ysize = tagger.ysize()

for i in range(0, ysize - 1):
  print("tag {i} {tagger.yname(i)}")

tagger.parse()

print(f"conditional prob={tagger.prob()} log(Z)={tagger.Z()}")
size = tagger.size()
xsize = tagger.xsize()
for i in range(0, (size - 1)):
  for j in range(0, (xsize-1)):
    print(tagger.x(i, j) , "\t")
  
  print(tagger.y2(i) , "\t")
  print("Details")

  for j in range(0, (ysize-1)):
    print("\t" , tagger.yname(j) , "/prob=" , tagger.prob(i,j),"/alpha=" , tagger.alpha(i, j),"/beta=" , tagger.beta(i, j))
  print("\n"),

print("nbest outputs:")
for n in range(0, 9):
  if not tagger.next():
      continue
  print("nbest n=" , n , "\tconditional prob=" , tagger.prob())
  # you can access any information using tagger.y()...
```
arithmeicops 1.0.0
A simple Python package
Requires Python: >=3.6

# Arithmetic Package
 A simple python package for basic arithmetic operations.

 ## installation

 ```sh
 pip install arithmeticops

```
## Usage

```python
from arithmeticops import add, subtract, multiply

print(add(1,2)) # prints 3
print(subtract(4,6)) # prints 10
print(multiply(2,3)) # prints 6
flatten-codebase 1.3
Flatten Codebase simplifies codebase preparation for Language Models by converting it into a single Markdown file, making it easier for the developer to provide the codebase to the LM

# Flatten Codebase

## Overview

**Flatten Codebase** is a utility tool designed to simplify the process of preparing a codebase for analysis or processing by Language Models (LMs). It achieves this by flattening the entire codebase into a single Markdown (.md) file, making it easier for the developer to provide the codebase to the LM for various tasks such as code analysis, generation, or other natural language processing (NLP) activities.

## Table of Contents

- [Purpose](#purpose)
- [Features](#features)
- [Suggested system instructions](#suggested-system-instructions)
- [Getting Started](#getting-started)
  - [Prerequisites](#prerequisites)
  - [Installation](#installation)
  - [Usage](#usage)
- [Contributing](#contributing)

## Purpose

The primary goal of this tool is to streamline the workflow involved in providing a codebase to a LM for various tasks such as code analysis, generation, or other natural language processing (NLP) activities. By converting the codebase into a flat structure within a Markdown document, it allows developers to easily provide the codebase to the LM without the need for complex file handling or processing.

## Suggested system instructions
The file `system_instructions.txt` located on the project repository contains a suggestion of system instructions to be provided to the language model when using the codebase.md file generated by this tool. The argument `--system_instructions` can also be used to display these instructions in the terminal. Feel free to modify them to better fit your needs.

## Features

- **Directory Structure Representation**: Generates a structured representation of each specified folder's contents, including all nested directories and files.
- **File Content Extraction**: Extracts and includes the content of each file within the specified folders, facilitating direct analysis or processing by LMs.
- **Output in Markdown Format**: Outputs the flattened codebase in a Markdown file, ensuring compatibility with a wide range of tools and platforms that support Markdown.

## Getting Started

### Prerequisites

Ensure you have Python installed on your system. This tool requires Python 3.x.

### Installation

Install the CLI tool with pip:
  
```bash
pip install flatten-codebase
```

### Usage

Run the CLI with the `--folders` argument followed by the paths to the base folders you wish to process. For example:
`flatten-codebase --folders /path/to/folder1 /path/to/folder2`

This will create a `codebase.md` file in the current directory containing the flattened structure and the content of the specified folders.

## Contributing

Contributions to improve the tool's functionality, performance, or documentation are welcome. Please feel free to submit pull requests or issues through the GitHub repository.