semvec/pypi-packages huggingface dataset:
gkbus-test 0.2.7
High-level KWP over K-line/CANbus library

# GKBus

High-level KWP over K-Line/CANbus library powering the [GKFlasher](https://github.com/dante383/GKFlasher)

**WARNING: This library is in highly experimental stage, it was decoupled from GKFlasher's code to make development easier.**
You shouldn't use it yet. The code will be cleaned up and API documentation will be created after reaching MVP stage of GKFlasher
hekaido-test-repo 0.1.0
my solution of second hw in MLOps course

second_hw
==============================

my solution of second hw in MLOps course =)

Project Organization
------------

    ├── LICENSE
    ├── Makefile           <- Makefile with commands like `make data` or `make train`
    ├── README.md          <- The top-level README for developers using this project.
    ├── data
    │   ├── external       <- Data from third party sources.
    │   ├── interim        <- Intermediate data that has been transformed.
    │   ├── processed      <- The final, canonical data sets for modeling.
    │   └── raw            <- The original, immutable data dump.
    │
    ├── docs               <- A default Sphinx project; see sphinx-doc.org for details
    │
    ├── models             <- Trained and serialized models, model predictions, or model summaries
    │
    ├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
    │                         the creator's initials, and a short `-` delimited description, e.g.
    │                         `1.0-jqp-initial-data-exploration`.
    │
    ├── references         <- Data dictionaries, manuals, and all other explanatory materials.
    │
    ├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
    │   └── figures        <- Generated graphics and figures to be used in reporting
    │
    ├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
    │                         generated with `pip freeze > requirements.txt`
    │
    ├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
    ├── src                <- Source code for use in this project.
    │   ├── __init__.py    <- Makes src a Python module
    │   │
    │   ├── data           <- Scripts to download or generate data
    │   │   └── make_dataset.py
    │   │
    │   ├── features       <- Scripts to turn raw data into features for modeling
    │   │   └── build_features.py
    │   │
    │   ├── models         <- Scripts to train models and then use trained models to make
    │   │   │                 predictions
    │   │   ├── predict_model.py
    │   │   └── train_model.py
    │   │
    │   └── visualization  <- Scripts to create exploratory and results oriented visualizations
    │       └── visualize.py
    │
    └── tox.ini            <- tox file with settings for running tox; see tox.readthedocs.io


--------

<p><small>Project based on the <a target="_blank" href="https://drivendata.github.io/cookiecutter-data-science/">cookiecutter data science project template</a>. #cookiecutterdatascience</small></p>
stoch 1.0.0
Stochastic Process

stoch: a package for stochastic calculations
====


## Generators of stochastic process

- `gaussian_process(mean=0, std=1, dt=1, size=None)`

- `ornstein_uhlenbeck_process(x0=0, mu=0, theta=1, sigma=1, dt=1, size=None)`

Note: The parameter `size` follows the convention in `numpy`. When it is `None`, it generates `float`; When it is `int`(s), it generates `np.array` of shape `size`.


### Usage Examples

```
from stoch import gaussian_process, ornstein_uhlenbeck_process
gen = gaussian_process(mean=0, std=0.1, dt=0.01)  # generate scaler
gen = gaussian_process(mean=0, std=0.1, dt=0.01, size=(2, 4))  # generate np.array of shape (2, 4)
gen = ornstein_uhlenbeck_process(x0=0., mu=0.1, theta=0.5, sigma=0.3, dt=0.01)  # generate scaler
gen = ornstein_uhlenbeck_process(x0=0., mu=0.1, theta=0.5, sigma=0.3, dt=0.01, size=3)  # generate np.array of shape (3,)
for i in range(10):
    print(next(gen))
```
adjidev-cbs 1.0.1
Cyber brebes system advanced hacking tools
Requires Python: >=3.11

# C.B.S

CBS adalah alat hacking untuk menjalankan tools apapun ( mendukung semua bahasa program )


# CARA MENGGUNAKANNYA
1. Pertama tama install atau clone reposity ini
   ```bash
   git clone https://github/adjidev/cbs
   ```

   ```bash
   pip install adjidev-cbs
   ```

2. Setelah itu jalankan tools nya
   ```bash
   cbs --help
   ```
   - Untuk melihat versinya
   ```bash
   cbs --version
   ```
   - Untuk wizard ui
   ```bash
   cbs --wizard
   ```



# CARA MENAMBAHKAN PAYLOAD ATAU FITUR BARU

Untuk menambahkan tools atau fitur baru sangatlah gampang anda tinggal menambahkan `cbs_config.xml` seperti ini dibawah ini:

```xml
<cbs_settings>
    <cbs_setting>
        <cmd>sherlock</cmd>
        <description>Temukan username dari berbagai sosial media</description>
        <execute>python sherlock.py</execute>
        <!-- untuk <args> Opsional-->
        <args>--search {args}</args>
        <author>adjidev</author>
        <version>0.0.1</version>
    </cbs_setting>
</cbs_settings>
```

Setelah itu ikuti perintah perintah dibawah ini

```bash
cbs --load "path/ke/folder" --folder "namapayload"
```
- Untuk reposity github
```bash
cbs --load "https://github.com/adjidev/sqlforce"
```

# AKHIR
_Terima kasih sudah membaca ini_

> Disclaimer: jika anda menjual script ini tanpa izin dari saya, saya tidak akan segan segan melaporkan anda ke pihak berwenang
VedicCrypto 0.1.1
A library that creates equations from any devangiri text and the equations could be converted to graphs or sounds

# VedicCrypto
devangiri pictures

![Screenshot 2024-10-30 at 8 37 54 PM](https://github.com/user-attachments/assets/e18bdcff-6be6-416f-9d71-4b2da4733777)

Do you wanna create pictures from you name? , its now possible with Vedic crypto
Vedic crypto is a peice of code that can creates pictures from any devangiri text and its really easy to operate, you just have to enter your text and you will get the equations then you just have to use any computation tool that will convert it to a complex plane , contour plot or even Graph therory.


Upcoming updates: 

> The graph makeing ability will now be soon inbuilt in the software

> In within a few days you will be able to create sound from any text !

> The library is easy to use and you just have to install using pip and explore the functions but for some of people in us a upcomeing update will bring detailed comments and instructions to use the library


github link : https://github.com/bkpawar/VedicCrypto

bug complains here : https://github.com/bkpawar/VedicCrypto/issues

more pictures as of now generated:

![Screenshot 2024-11-06 at 11 17 18 AM](https://github.com/user-attachments/assets/d4705525-0d08-4702-8d61-8fd2ad8c7625)

![Screenshot 2024-11-11 at 6 56 46 PM](https://github.com/user-attachments/assets/00547964-6047-41c2-abc7-e97e7c561485)

![Screenshot 2024-11-15 at 5 48 44 PM](https://github.com/user-attachments/assets/2fb47017-846f-4df0-9667-757f9b39f889)
![Screenshot 2024-11-15 at 5 49 58 PM](https://github.com/user-attachments/assets/b6918e17-e9e9-444f-ba48-3850c11feb8e)

![Screenshot 2024-11-11 at 6 40 20 PM](https://github.com/user-attachments/assets/3cf7cbc6-56b6-4991-a695-b24a4faccc23)

![Screenshot 2024-11-15 at 5 57 20 PM](https://github.com/user-attachments/assets/5894a6d1-2883-40fd-ac63-6f0d631e9c56)


![Screenshot 2024-10-30 at 7 54 35 PM](https://github.com/user-attachments/assets/cbdfeed4-64b1-4360-8cdf-8712460992a5)
vixf 0.0.1
Edit X11 text fields with an external text editor
Requires Python: >=3.7

vixf
====

Allow editing X11 fields with terminal editor in $VISUAL.  Use keyboard
automation to select-all and copy text from the field, save it into a file,
edit that file with the terminal editor, and when the editor is done, read the
(presumably modified) text back from the file and paste it over the original
text.
copyclip 0.1.2
A CLI tool to copy code files from a directory to the clipboard
Requires Python: >=3.6

# CopyClip

A command-line tool that helps you copy multiple code files from a directory to your clipboard. Perfect for sharing code snippets, preparing documentation, and especially useful when working with Large Language Models (LLMs).

## Features

- Copy multiple files to clipboard with a single command
- Smart file filtering with gitignore support
- Hidden files/directories handling
- LLM-friendly output formatting with relative paths
- Verification of clipboard operations
- Fallback to file output if clipboard fails

## Why CopyClip + LLMs?

CopyClip is designed to enhance your workflow with AI coding assistants like ChatGPT, Claude, or GitHub Copilot by:
- Easily sharing entire codebases or specific directories for context
- Maintaining proper file structure and formatting
- Streamlining code reviews and discussions
- Enabling quick context switching in AI conversations
- Preserving folder structure through relative path headers

Each file is concatenated with its relative path as a header, helping AI assistants understand your project's structure:

````

--- File: src/models/user.py ---
class User:
    def __init__(self):
        pass

--- File: src/utils/helpers.py ---
def format_date():
    return "2024-01-01"

--- File: src/main.py ---
from models.user import User
from utils.helpers import format_date
````

This structured format helps AI assistants:
- Understand file relationships and imports
- Provide more contextual code suggestions
- Better grasp your project architecture
- Generate more accurate responses about your codebase

## Installation

````

pip install copyclip
````

## Usage

Basic usage:
````

copyclip /path/to/directory
````

Advanced options:
````

# Ignore specific patterns
copyclip /path/to/directory --ignore "*.js" "*.pyc" "node_modules/*"

# Respect .gitignore patterns
copyclip /path/to/directory --gitignore

# Include hidden files
copyclip /path/to/directory --include-hidden

# Print output to console
copyclip /path/to/directory --print
````

## Arguments

| Argument | Description |
|----------|-------------|
| `path` | Root path of the directory to process |
| `--ignore` | List of regex patterns to ignore files (e.g., *.js, .env, index*) |
| `--gitignore` | Also respect .gitignore patterns |
| `--include-hidden` | Include hidden files and directories (starting with .) |
| `--print` | Print the concatenated output to console |

## Example Output

When you run CopyClip on a project, it generates a formatted output like this:

````

--- File: src/main.py ---
def main():
    print("Hello, World!")

--- File: tests/test_main.py ---
def test_main():
    assert True

--- File: utils/helpers.py ---
def helper_function():
    return "I'm helping!"
````

This format ensures that:
- File paths are clearly visible
- Code structure is preserved
- AI assistants can understand the project hierarchy
- Code relationships are maintained

## Requirements

- Python 3.6+
- pyperclip

## License

MIT License
dbt-column-lineage 0.5.26
A tool for dbt column lineage
Requires Python: >=3.11

# dbt-column-lineage
This is a tool to visualize the colulmn level lineage of dbt models. It uses the `manifest.json` and `catalog.json` files generated by dbt to create a graph of the lineage of the models. It is a web application that uses a Flask backend and a Next.js frontend.

![PyPI - Version](https://img.shields.io/pypi/v/dbt-column-lineage)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dbt-column-lineage)
![PyPI - Downloads](https://img.shields.io/pypi/dw/dbt-column-lineage)
![PyPI - License](https://img.shields.io/pypi/l/dbt-column-lineage)

# quickstart
Install dbt-column-lineage using pip:
```
pip install dbt-column-lineage
```

Run the following command:
```
# go to your dbt project directory
cd your-dbt-project/

# edit your model file
vi models/test.sql

# generate the manifest.json and catalog.json files
dbt docs generate 

# set the environment variable for the dialect you are using
export SQLGLOT_DIALECT=snowflake

# Launch dbt-column-lineage with test.sql as the initial model
dbt-coloumn-lineage run-params
```

# development

To develop the application, you will need to run the backend and frontend separately.
```
git clone git@github.com:Oisix/dbt-column-lineage.git
cd dbt-column-lineage
```
## for backend

activate venv and run the following commands:
```
python3 -m venv venv
source venv/bin/activate

pip install --upgrade pip
pip install -r requirements.txt

uvicorn --app-dir src dbt_column_lineage.main:app --port=5000 --reload
```

## for frontend

run the following commands:
```
npm install
npm run dev
```
after the frontend is running,
Let's access http://localhost:3000

## for Looker integration (optional)
If you want to integrate with Looker, you can use the following commands:
```
# set the environment variables
export LOOKERSDK_CLIENT_ID=(your client id)
export LOOKERSDK_CLIENT_SECRET=(your client secret)
export LOOKERSDK_BASE_URL=(your looker base url)
export LOOKER_IGNORE_FOLDERS=(comma separated list of folders to ignore)
export LOOKER_IGNORE_ELEMENTS=(comma separated list of dashboard elements to ignore)

# it analyze the looker models, target/dashboad_analysis.json will be created
python tools/looker_analyzer.py

# rerun the backend
uvicorn --app-dir src dbt_column_lineage.main:app --port=5000 --reload
```
## for Google OAuth login test (optional)

If you want to test the OAuth login, you can use the following commands:
```
export GOOGLE_CLIENT_ID=(your client id)
export GOOGLE_CLIENT_SECRET=(your client secret)
docker build -t test .
docker run -p 5000:5000 -e USE_OAUTH=true -e GOOGLE_CLIENT_ID=$GOOGLE_CLIENT_ID -e GOOGLE_CLIENT_SECRET=$GOOGLE_CLIENT_SECRET -e DEBUG_MODE=true test
```
ChromaStyler 1.1.0
none

## Installation

To install the package, use `pip`:

```bash
pip install ChromaStyler
```
##ChromaStyler library:
 a library to get colors in python.
 use this library to make output colored!
##How to use:
 this library have three diferent parts: color, style, back
 #Color(text color):
  to use this library for text color, you can import color or use it directly:
   ```bash 
   import ChromaStyler 
   ```
   or
   ```bash
   from ChromaStyler import color
   ```
  to use color, just enter what color do you want:
   ```bash
   blue = color.blue \# Or ChromaStyler.style.bold if tou use import ChromaStyler
   print(blue + 'hello this is a blue text')
   ```
 #Style(font style):
  to use this library for font style, you can import style or use it directly:
   ```bash
   import ChromaStyler
   ```
   or
   ```bash
   from ChromaStyler import style
   ```
  to use style, just enter what style do you want:
   ```bash
   bold = style.bold \# Or ChromaStyler.style.bold if tou use import ChromaStyler
   print(bold + 'hello this is a bold text')
   ```
 #back(background color):
  to use this library for background color, you can import style or use it directly:
   ```bash
   import ChromaStyler
   ```
   or
   ```bash
   from ChromaStyler import back
   ```
  to use style, just enter what style do you want:
   ```bash
   bold = back.purple \# Or ChromaStyler.style.bold if tou use import ChromaStyler
   print(purple + 'hello this is a normal text with purple background')
   ```
translation-new 0.2.3
A python package for Multi Lingual Translation using LLM
Requires Python: <4.0,>=3.10

# **Translation Package**

**Overview**
This package provides a translation service using the facebook/mbart-large-50-many-to-many-mmt model. It supports translating text between multiple languages, including automatic language detection. This is useful for integrating translation capabilities into your applications.

**Features**                                             
Multi-language translation: Supports 50+ languages.
Automatic language detection: Detects the language of the input text.
Uses facebook/mbart-large-50-many-to-many-mmt model: State-of-the-art multilingual translation model.
Simple API: Easy integration into your Python projects.
Installation
Using Poetry
If you're using Poetry to manage dependencies, follow these steps:

**Clone this repository:**

git clone https://github.com/manojprabhakar90/translation_new.git

You can directly install the package from pypi through the below code: 

Code: pip install translation-new

# Usage

from translation_new.translator import Translator

translator = Translator()

translated_text = translator.translate("Hello, how are you?", lang="hi")

# Supported Languages

This package supports translation between the following languages (identified by their ISO codes):

Arabic (ar)
Bengali (bn)
Chinese (zh)
French (fr)
German (de)
Hindi (hi)
Spanish (es)
And many more!
For a complete list of supported languages, please check the LANGUAGE_CODES in the Translator class.

# **License**

This project is licensed under the Apache License
reop 1.0.0
Rust-style Result and Option implementation for Python
Requires Python: >=3.6

# reop

**reop** is a lightweight Python library inspired by Rust's `Result` and `Option` patterns. The name combines **"Result"** and **"Option"**, representing the two core concepts of the library.

## Why Use reop?
### The Problem
Python's try/except for error handling and the frequent use of None as a placeholder for missing values are flexible, but they often lack clarity:

**Implicit failures**: A function might fail, but this is not explicit in its return type.
Unclear intent: None values can propagate silently, making debugging harder.
Ad-hoc error handling: Handling errors consistently across large codebases is challenging.
## The Solution
With reop, you can leverage Rust-inspired patterns for safer and clearer error handling:

**Explicit Error Handling**:
Functions return Result[ValueType, ErrorType] to indicate success or failure explicitly.
No unexpected exceptions—errors are part of the function's return type.
Structured Value Management:
Use Option to represent values that may or may not exist.
No more unchecked None values—intent is always explicit.
Composable and Readable Code:
Chain operations on Result and Option objects with methods like map, and_then, and or_else.

## Installation

```bash
pip install reop
```

## Usage
Using Result for Explicit Error Handling
```python
from reop import Result, result_wrapper

@result_wrapper
def divide(a: int, b: int) -> float:
    return a / b

# Example 1: Successful division
result = divide(10, 2)
if result.is_ok:
    print(f"Success: {result.unwrap()}")  # Output: Success: 5.0

# Example 2: Division by zero
result = divide(10, 0)
if result.is_err:
    print(f"Error: {result.unwrap_err()}")  # Output: Error: division by zero

```

Using Option for Optional Values
```python
from reop import Option, option_wrapper

@option_wrapper
def find_value(key: str, data: dict) -> Optional[int]:
    return data.get(key)

# Example 1: Key exists
option = find_value("a", {"a": 42})
if option.is_some:
    print(f"Found: {option.unwrap()}")  # Output: Found: 42

# Example 2: Key does not exist
option = find_value("b", {"a": 42})
print(option.unwrap_or(0))  # Output: 0

```

## Key Benefits of reop
Improved Clarity: Make function intentions and possible failure cases explicit.
Safer Code: Avoid unexpected None values or unhandled exceptions.
Rust-inspired: Adopt proven patterns from Rust for Python programming.
Composable Methods: Chain operations for clean and concise workflows.