semvec/pypi-packages huggingface dataset:
kimino 1.0.0
Easy-to-use Linux desktop app entry creator TUI app.
Requires Python: >=3.14

# Kimino

Kimino is a TUI app. Which helps to create, custom app desktop entry in Linux.

# Preview

# Features

**1. Supports online web app (suppose : Youtube web app)**
**2. Bash file app (it runs the bash file)**
**3. TUI or GUI app (it aks for the command for ruining the app, like : `Kimino`)**
**4. Supports all Linux distro, all terminal apps**
**_much more!_**


# Installation (Windows, Linux, Mac OS)

**Installation or update with `uv`:**

```
uv tool install -U git+https://github.com/TheAhumMaitra/Kimino.git
```

**_Done , now launch with just ``Kimino` command_**

**Manual installation:**

**Pre-requirements : `python` installed**
**\*Note : It can work on older Python version but it is not recommended.**

**_Steps :_**

1. Clone this repo

```
git clone https://github.com/TheAhumMaitra/Kimino.git
```

2. Go to the `Kimino` folder

It's saved where you cloned this repo

```
cd Kimino
```

3. Install it

```
pip install .
```

**_Done , now launch with just `Kimino` command_**


# License

[`GPL-3.0-or-later`](LICENSE)
pun-nlp 0.0.9
A robust NLP pipeline for stemming, lemmatization, and vectorization
Requires Python: >=3.7

# pun_nlp
[![PyPI Downloads](https://static.pepy.tech/badge/pun-nlp)](https://pepy.tech/projects/pun-nlp)

## Overview
pun_nlp is a robust NLP abstraction layer designed to simplify text processing and vectorization. It handles dependency management, resource downloading, and text preprocessing automatically, so you don't have to write boilerplate code.

It solves common issues with NLTK downloads and path errors by implementing a robust, lazy-loading resource manager that works in restricted environments like Kaggle and corporate servers.

## Features
-   **Robust Resource Management**: Automatically handles NLTK/Spacy downloads and SSL errors.
-   **Lazy Loading**: Resources are only loaded into memory when needed.
-   **Type Safety**: Prevents invalid combinations of operations (like vectorizing POS tuples).
-   **Unified API**: Process single strings, lists, or 2D arrays of text with one method.
-   **Seamless Vectorization**: Integrates directly with Scikit-Learn's TF-IDF and Count vectorizers.

## Installation
```bash
pip install pun_nlp
```

## Usage

### Basic Pipeline
```python
from pun_nlp import NLPProcessor

# Initialize with desired flags
p = NLPProcessor(
    tokenize=True, 
    stem=True, 
    remove_stopwords=True,
    normalize=True
)

text = "The QUICK brown foxes are running fast!"

# Automatically handles downloads and processing
print(p.process(text))
# Output: ['quick', 'brown', 'fox', 'run', 'fast']
```

### NER & POS Tagging
```python
# NER (Case sensitive checking happens before normalization)
p_ner = NLPProcessor(ner=True)
print(p_ner.process("Apple Inc. is hiring in California."))
# Output: [('Apple Inc.', 'ORG'), ('California', 'GPE')]

# POS Tagging (Tags tokens correctly before stemming)
p_pos = NLPProcessor(pos_tagging=True, stem=True)
print(p_pos.process("The boys are likely running."))
# Output: [('the', 'DT'), ('boy', 'NNS'), ('are', 'VBP'), ('like', 'RB'), ('run', 'VBG')]
```

### Vectorization
```python
p_vec = NLPProcessor(vectorize="tfidf", stop_words=True)
corpus = [
    "Machine learning is fascinating.",
    "Natural language processing is a subset of AI."
]

p_vec.fit_vectorizer(corpus)
vectors = p_vec.transform_texts(corpus)
print(vectors.shape)
```

## Configuration
| Parameter | Description |
|-----------|-------------|
| `stem` | Enable stemming (PorterStemmer). |
| `lemmatize` | Enable lemmatization (WordNet). |
| `vectorize` | "tfidf", "count", or None. |
| `tokenize` | Force return of token list. |
| `remove_stopwords` | Remove English stopwords (Case-insensitive). |
| `pos_tagging` | Return (Word, Tag) tuples. |
| `ner` | Return Entity tuples (Uses Spacy). |
| `normalize` | Lowercase & remove punctuation. |
| `backend` | "nltk" (default) or "spacy". |

## License
MIT License. See [LICENSE](LICENSE) for details.
postgres-wire 1.0.2
Add your description here
Requires Python: >=3.13

# postgres-wire

This module provides a [postgres wire compatible](https://www.yugabyte.com/key-concepts/postgresql-compatibility/) server for Python that leverages [Pydantic models](https://docs.pydantic.dev/latest/) for brevity.

```bash
$ # The example below is being run in a separate terminal
$ psql postgresql://user:password@localhost:5432/db
psql (14.19 (Homebrew), server 0.0.0)
Type "help" for help.

db=> SELECT t;
  foo   | bar
--------+-----
 'wow'  |  12
 'woah' |  21
(2 rows)

db=>
```

## Installing

You should be able to use your preferred package manager to fetch the latest version from [PyPi](https://pypi.org/project/postgres-wire/).

```bash
$ uv add postgres-wire
$ # or pip install postgres-wire
```

## Usage

```python
from postgres_wire import create_server, Handler
from pydantic import BaseModel


class YourObject(BaseModel):
  foo: str
  bar: int

class YourHandler(Handler):
  # If you'd like to listen on a different port
  # port = 55432

  def query(self, sql):
    print(f"Handling the query <{sql}>")
    return [YourObject(foo="wow", bar=12), YourObject(foo="woah", bar=21)]

serve = create_server(YourHandler)
serve() # You can now connect with `psql postgresql://user:pass@localhost:5432`
```

## Usage with auth

If you're interested in adding auth (ie API keys), then implement a `check_auth` method for the handler object which accepts a username and password as arguments.

```python
from postgres_wire import create_server, Handler
from pydantic import BaseModel


class YourObject(BaseModel):
  foo: str
  bar: int

class YourHandler(Handler):
  # If you'd like to listen on a different port
  # port = 55432

  def query(self, sql):
    print(f"Handling the query <{sql}>")
    return [YourObject(foo="wow", bar=12), YourObject(foo="woah", bar=21)]

  def check_auth(self, user, password):
    if password == "pass":
      # Raising an exception will cause the authentication to fail
      raise ValueError

serve = create_server(YourHandler)
serve() # You can now connect with `psql postgresql://user:password@localhost:5432`
```

## Background

The initial code is taken from [this gist](https://gist.github.com/ddurham2/b2449a565c0e95e94627a7f28bcbe531) which was an improvement atop [this gist](https://gist.github.com/eatonphil/079f8654174b9b9c1953b76008d024ae).