semvec/pypi-packages huggingface dataset:
KeGen 0.0.2
A simple key generator
Requires Python: >=3.0

KeGen it's an easy to use library that creates key 

_____________________________________________________________________________________
Installation
install it via the pip install command
"pip install kegen"
_____________________________________________________________________________________
Usage:
You need to import Kegen in your file with " import KeGen " and " from KeGen import *"
 
Then you use it  with "KeGen.generate(-lengh of the key-)" or one of the following commands:

.generateletters(-lengh of the key-)  to generate  a key with only letters

.generatenumber(-lengh of the key-) to generate a key with only numbers

.generatekey(-lengh of the key-) to generate a key with letters and numbers

.write_to_file(filename , key) to write the key in a file

______________________________________________________________________________________
Contact 
author: Mario Sperandio Marato

email: s.mario12112009@gmail.com

git: https://github.com/M-suri
OylanAPI 0.1.0
A Python client for the Oylan Assistant API
Requires Python: >=3.7

# OylanAPI

OylanAPI is a Python library for interacting with the Oylan Assistant API, available at [oylan.nu.edu.kz](https://oylan.nu.edu.kz/). Before using this library, you must register on the website and obtain an API key. The resources consumed by the library will be tied to your account.

## Features
- Create, list, retrieve, update (PUT/PATCH), or delete assistants.
- Create interactions (sending text prompts, file prompts, images, etc.).
- Upload DOCX files to update an assistant's context.
- Retrieve available models from the Oylan Assistant platform.

## Installation
Once the library is published, install it via pip:

```bash
pip install OylanAPI
```

## Usage
Here's how to use the library:

```python
from OylanAPI import Client

# Create a client with your API key
client = Client(api_key="your-api-key")

# 1) List all assistants
assistants = client.list_assistants()
print("Assistants:", assistants)

# 2) Create a new assistant
new_assistant = client.create_assistant(
    name="My Assistant",
    description="Sample description",
    temperature=0.7,
    max_tokens=512,
    model="Oylan",
    system_instructions="System instructions here",
    context="Base context here"
)
print("Created assistant:", new_assistant)

# 3) Create an interaction
interaction_response = client.create_interaction(
    assistant_id=new_assistant["id"],
    text_prompt="Hello, can you summarize the contents of this file?"
)
print("Interaction response:", interaction_response)

# 4) Upload a DOCX file
upload_result = client.upload_docx(
    assistant_id=new_assistant["id"],
    file_paths=["/path/to/document.docx"]
)
print("Upload result:", upload_result)
```

## Note
- You need to register at [oylan.nu.edu.kz](https://oylan.nu.edu.kz/) and generate an API key from the **For Developers** -> **Api Keys** tab.
- All resource usage is tied to your account, so use your key responsibly.

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
devkool 0.1.1
AI-Powered API Management CLI
Keywords: api, management, testing, ai, cli, developer tools

# Devkool: AI-Powered API Management CLI

Devkool is a command-line interface (CLI) tool designed to help developers efficiently manage, test, and interact with APIs.  It leverages AI for enhanced test case generation and provides features for tracking untracked APIs in your codebase.  Devkool aims to streamline the API development workflow and improve developer productivity.

## Features

*   Secure API Storage:  API keys and endpoints are securely stored using encryption.
*   AI-Powered Test Case Generation: Generates test case descriptions from API specifications (OpenAPI/Swagger).
*   Untracked API Detection: Scans your codebase to identify API endpoints that are being used but are not yet tracked by Devkool.
*   CLI Interface:  Easy-to-use command-line interface for all functionalities.

## Installation

1.  Clone the Repository:

    ```bash
    git clone [https://github.com/](https://github.com/)<your_username>/devkool.git  # Replace with your repo URL
    cd devkool
    ```

2.  Create a Virtual Environment (Recommended):

    ```bash
    python3 -m venv venv  # Create a virtual environment
    source venv/bin/activate  # Activate the environment (Linux/macOS)
    venv\Scripts\activate  # Activate the environment (Windows)
    ```

3.  Install Devkool:

    ```bash
    pip install -e .
    ```

## Configuration

### Encryption Key

Devkool uses encryption to secure stored API keys and endpoints.  It's crucial to set a strong encryption key.

1.  Generate a Key:

    *   Linux/macOS:

        ```bash
        export DEVKOOL_KEY=$(python3 -c "import base64; import os; print(base64.b64encode(os.urandom(32)).decode('utf-8'))")
        ```

    *   Windows (PowerShell):

        ```powershell
        $env:DEVKOOL_KEY = [Convert]::ToBase64String((New-Object System.Security.Cryptography.RNGCryptoServiceProvider).GetBytes(32))
        ```

2.  Set the Environment Variable:

    *   Linux/macOS: Add the `export DEVKOOL_KEY=...` command (the one from step 1) to your shell's configuration file (e.g., `~/.bashrc`, `~/.zshrc`, `~/.profile`).  This will make the environment variable persistent across terminal sessions. Then source the configuration file using `source ~/.zshrc` or restart your terminal.
    *   Windows:
        *   Search for "Environment Variables" in the Windows search bar.
        *   Click "Edit the system environment variables."
        *   In the System Properties window, click "Environment Variables..."
        *   Create a new system or user variable named `DEVKOOL_KEY` and paste the generated key as the value.

## Usage

### Adding an API

```bash
devkool add <api_key> <endpoint>
pytest-ignore-test-results 0.3.0
A pytest plugin to ignore test results.
Requires Python: >=3.7

# pytest-ignore-test-results

A pytest plugin that enables selective test result ignoring while maintaining test execution.

## Installation

```bash
pip install -U pytest-ignore-test-results
```

## Features

- Ignore specific test case results using exact names or patterns
- Load ignore patterns from files
- Custom exit codes for different failure scenarios
- Support for child test cases
- Option to ignore "no tests collected" errors

## Usage

### Ignore Test Results by Case Name or Pattern

When using this plugin, test cases will execute normally but their results can be selectively ignored. You have two options for specifying which test results to ignore:

1. Using exact names or patterns directly:

```bash
pytest --ignore-result-cases "test_feature_1" "test_feature_2"
```

```bash
pytest --ignore-result-cases "test_feature_*" "test_integration_*"
```

2. Specifying patterns in files:

```bash
pytest --ignore-result-files ignore_list.txt another_list.txt
```

Example ignore file content (ignore_list.txt):

```
test_feature_1  # This is a comment
test_feature_*
test_integration_suite::test_case_1
```

### Control Exit Codes

The plugin provides fine-grained control over exit codes through two options:

1. `--strict-exit-code`: When enabled, the plugin will return exit code 6 if all failed test cases are ignored. Otherwise, it maintains pytest's original exit code behavior.

```bash
pytest --ignore-result-cases "test_feature_*" --strict-exit-code
```

2. `--ignore-no-tests-collected`: When enabled, this option suppresses "no tests collected" errors and returns exit code 0.

```bash
pytest --ignore-no-tests-collected
```

### Custom Test Case Names

The plugin supports test case name customization through the `pytest_custom_test_case_name` hook:

```python
def pytest_custom_test_case_name(item):
    """
    Args:
        item: pytest item

    Returns:
        str: Custom name for the test case
    """
    return f"custom_name::{item.name}"
```
parsextract 0.1.10
A library to extract IPs, domains, and emails from text
Requires Python: >=3.6

# Parsextract

Parsextract is a Python library that extracts **IP addresses, domains, and email addresses** from raw text. It supports validation against IANA-recognized TLDs and includes additional custom TLDs sourced from OpenNIC.

## Features
- Extracts IPv4 addresses from raw text.
- Extracts domain names and validates them against IANA and OpenNIC TLDs.
- Extracts email addresses using regex-based parsing.
- Lightweight and easy to integrate.

## Installation
```sh
pip install parsextract
```

## Usage
```python
import parsextract

text = """
    Contact us at support@example.com or visit https://mywebsite.geek for more info.
    Our server IP is 192.168.1.1.
"""

# Extract IPs
ips = parsextract.extract_ips(text)
print("IPs:", ips)

# Extract Domains
domains = parsextract.extract_domains(text)
print("Domains:", domains)

# Extract Emails
emails = parsextract.extract_emails(text)
print("Emails:", emails)
```

### Example Output
```
IPs: ['192.168.1.1']
Domains: ['mywebsite.geek']
Emails: ['support@example.com']
```

## Regular Expressions Used
- **IP Address Regex**:
  ```regex
  (?i)(?<![a-zA-Z0-9:.])(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])){3}(?![a-zA-Z0-9/.])
  ```
- **Domain Regex**:
  ```regex
  (?i)(?:^|\s|["']|[,])((?:(?:[A-Z0-9_](?:[A-Z0-9_-]{0,61}[A-Z0-9_])?\.)+)(?:[A-Z0-9-]{1,63}(?<!-)))(?!(?:/[^\s/]+))(?![a-zA-Z0-9@])
  ```
- **Email Regex**:
  ```regex
  (?<!@)\b[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]{2,}\b(?!@)
  ```

## Supported TLDs
The library validates domains using **IANA-approved TLDs** and additional custom TLDs from OpenNIC.

### Custom TLDs Supported:
```
.bbs, .chan, .cyb, .dyn, .epic, .geek, .gopher, .indy, .libre, .neo, .null,
.o, .oss, .oz, .parody, .pirate
```

## License
This project is licensed under the MIT License.

## Contributing
Feel free to open an issue or submit a pull request for improvements.

## Author
Maintained by deepak.kumar@cyware.com.
lightdash-client-python 0.1471.0
A client library for accessing Lightdash API
Requires Python: <3.13,>=3.9

# lightdash-client-python

This client library provides a convenient interface for interacting with the Lightdash API.
While it aims to cover the majority of API functionalities, please note that it may not fully encapsulate all aspects of the generated code.
Users should exercise caution when utilizing this library.
Additionally, since the library is generated from the OpenAPI specification, certain API methods may exhibit unexpected behavior due to recursive references present in the spec.

## Installation

```bash
pip install lightdash-client-python
```

## Examples

[examples](./examples/) directory contains examples of how to use the client library.
langchain-kaburi 0.0.8
랭체인 편의 기능 라이브러리
Requires Python: >=3.12

# 랭체인 편의 기능 라이브러리

**Builders**
```
from langchain_kaburi.builders import ImageMessageBuilder

img_builder = ImageMessageBuilder()
message = (
    img_builder.add_text("텍스트로 변환해")
    .add_image_from_base64(image_data)
    .build()
)
```
licomp-proprietary 0.5.3
Simple command line tool to check compatibility between two licenses, given context  
Requires Python: >=3.6

# Licomp Proprietary

Licomp Proprietary provides compatibility data:

* between a Proprietary outbound license and inbound Open Source licenses
* when distributing a binary, linking to (e.g. linking to a library) Open Source components
* the Open Source components are unmodified

## Introduction 

Licomp proprietary is using the [Licomp](https://github.com/hesa/licomp) api to communicate with the Licomp resources. For a better understanding of Licomp we suggest you read:

* [Licomp basic concepts](https://github.com/hesa/licomp/#licomp-concepts)
* [Licomp reply format](https://github.com/hesa/licomp/blob/main/docs/reply-format.md)

The various licomp resources below can be accessed as a group by:
* [licomp-toolkit](https://github.com/hesa/licomp-toolkit) - (`pip install licomp-toolkit`)

Licomp is used be the following compatibility resources:
* [licomp-hermione](https://github.com/hesa/licomp-hermione) - (`pip install licomp-hermione`)
* [licomp-osadl](https://github.com/hesa/licomp-osadl) - (`pip install licomp-osadl`)
* [licomp-reclicense](https://github.com/hesa/licomp-reclicense) - (`pip install licomp-reclicense`)
* [licomp-dwheeler](https://github.com/hesa/licomp-dwheeler) - (`pip install licomp-dwheeler`)

# Using Licomp Proprietary

Since Licomp Proprietary implements [Licomp](https://github.com/hesa/licomp) we refer to the Licomp guides (both cli and python api).

## Command line interface

See [Licomp Comand Line Interface](https://github.com/hesa/licomp/blob/main/docs/cli-guide.md)

_Note: the commmad line program for Licomp Proprietary is called `licomp-proprietary`._

## Python module

See [Licomp Python API](https://github.com/hesa/licomp/blob/main/docs/python-api.md)

# Installing Licomp Proprietary

## From pypi.org

Licomp Proprietary is available via [pypi.org](https://pypi.org/) at: [https://pypi.org/project/licomp-proprietary/](https://pypi.org/project/licomp-proprietary/).


To install, simply do the following:

```
$ pip install licomp-proprietary
```

## From github

Installing from github assumes you already have `pip` installed.

```
$ git clone https://github.com/hesa/licomp-proprietary
$ pip install -r requirements.txt
$ pip install -r requirements-dev.txt
$ pip install .
```