semvec/pypi-packages huggingface dataset:
clipthread-server 0.0.2
A clipboard synchronization tool that work on every platform
Requires Python: >=3.09
Keywords: clipboard, clipthread, server, sync, synchronization

# ClipThread Server

ClipThread is a multi-platform clipboard synchronization tool that enables real-time sharing of clipboard content across different devices. It uses a client-server architecture to maintain clipboard history and ensure secure synchronization between multiple devices.

## Purpose
The ClipThread server acts as the central hub for all clipboard operations. It:
- Manages clipboard content synchronization between connected clients 
- Maintains a clipboard history journal
- Handles secure data transmission between devices
- Provides REST API endpoints for clipboard operations

## Running the Server

### Using Docker Compose
```bash
# Clone the repository
git clone https://github.com/clipthread/clipthread-server.git

# Navigate to docker directory
cd clipthread-server/docker

# Start the server
docker-compose up -d
```

### Using Systemd
1. Install the package:
```bash
pip install clipthread-server
```

2. Copy the systemd service file:
```bash
sudo cp systemd/clipthread-server.service /etc/systemd/system/
```

3. Start the service:
```bash
sudo systemctl enable clipthread-server
sudo systemctl start clipthread-server
```

## License
This project is licensed under the MIT License - see the LICENSE file for details.

## Todo
- [ ] Add authentication system
- [ ] Implement encryption for clipboard content
- [ ] Create API documentation
- [ ] Add rate limiting
- [ ] Implement clipboard content filtering

## Client Applications
- Desktop UI (Tkinter): [ui-tkinter](https://github.com/clipthread/ui-tkinter)
- Core Library: [clipthread-core](https://github.com/clipthread/core)
- Android App: [clipthread-android](https://github.com/clipthread/android)
gemba 0.1.3
GEMBA — GPT Estimation Metric Based Assessment
Requires Python: >=3.8

# GEMBA-MQM and GEMBA-DA

## Setup

Install required packages with python >= 3.8 (tested with 3.12.7)

```
pip install -r requirements.txt
```

Set up secrets either for Azure API or OpenAI API: 

```
export OPENAI_AZURE_ENDPOINT=
export OPENAI_AZURE_KEY=
```

or

```
export OPENAI_API_KEY=
```

## Scoring with GEMBA

Install the gemba package with `pip install gemba` and use the following code:

```python
from gemba import get_gemba_scores

source = ["Hello, how are you?", "I am fine, thank you.", "I am not fine, thank you."]
hypothesis = ["Hallo, wie geht es dir?", "Ich bin gut, danke.", "Ich bin Joel, wer bist du?"]
source_lang = "en"
target_lang = "de"

answers, errors = get_gemba_scores(source, hypothesis, source_lang, target_lang, method="GEMBA-MQM_norm", model="gpt-4o")

for answer, error in zip(answers, errors):
    print(answer, error)

```

Alternatively, you can run the main file on two text files. It assumes two files with the same number of lines. It prints the score for each line pair:

```bash
python main.py --source=source.txt --hypothesis=hypothesis.txt --source_lang=English --target_lang=Czech --method="GEMBA-MQM" --model="gpt-4"
```

The main recommended methods: `GEMBA-MQM` and `GEMBA-DA` with the model `gpt-4`.

## Collecting and evaluating experiments for GEMBA-DA

Get mt-metric-eval and download resources:

```
git clone https://github.com/google-research/mt-metrics-eval.git
cd mt-metrics-eval
pip install .
alias mtme='python3 -m mt_metrics_eval.mtme'
mtme --download
cd ..
mv ~/.mt-metrics-eval/mt-metrics-eval-v2 mt-metrics-eval-v2
```

Collect data and run the scorer

```
python gemba_da.py 

export PYTHONPATH=mt-metrics-eval:$PYTHONPATH
python evaluate.py
```

## License
GEMBA code and data are released under the [CC BY-SA 4.0 license](https://github.com/MicrosoftTranslator/GEMBA/blob/main/LICENSE.md).

## Paper
You can read more about GEMBA-DA [in our arXiv paper](https://arxiv.org/pdf/2302.14520.pdf) 
or GEMBA-MQM [in our arXiv paper](https://arxiv.org/pdf/2310.13988.pdf).

## How to Cite


### GEMBA-MQM 

    @inproceedings{kocmi-federmann-2023-gemba-mqm,
        title = {GEMBA-MQM: Detecting Translation Quality Error Spans with GPT-4},
        author = {Kocmi, Tom  and Federmann, Christian},
        booktitle = "Proceedings of the Eighth Conference on Machine Translation",
        month = dec,
        year = "2023",
        address = "Singapore",
        publisher = "Association for Computational Linguistics",
    }

### GEMBA-DA

    @inproceedings{kocmi-federmann-2023-large,
        title = "Large Language Models Are State-of-the-Art Evaluators of Translation Quality",
        author = "Kocmi, Tom and Federmann, Christian",
        booktitle = "Proceedings of the 24th Annual Conference of the European Association for Machine Translation",
        month = jun,
        year = "2023",
        address = "Tampere, Finland",
        publisher = "European Association for Machine Translation",
        url = "https://aclanthology.org/2023.eamt-1.19",
        pages = "193--203",
    }
cloudera-assist 0.1.0
A CLI tool for managing credentials and executing playbooks for Cloudera demonstrations, workshops, and tutorials.
Requires Python: >=3.9
Keywords: ansible-navigator, cdp, cloudera

# cloudera-assist

A CLI application for managing credentials and executing playbooks for Cloudera demonstrations, workshops, and tutorials.

Built with [![Hatch](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)

# Install

Install the CLI tool (in your preferred `venv` manager):

```bash
pip install git+https://github.com/cloudera-labs/cloudera-assist.git
```

And then run `cldr-assist` in any `ansible-navigator`-enabled Cloudera project!

# Usage

tk tk

# Develop

`cloudera-assist` uses [uv](https://github.com/astral-sh/uv) and [hatch](https://hatch.pypa.io/latest/) to manage the build process and environments and [pytest](https://docs.pytest.org/en/stable/) for testing.

Install the two management tools to your system, e.g. `brew install uv hatch`.

To work with a CLI development shell, run `hatch shell` to spin up a `venv` with the project's dependencies and some additional libraries for `pytest`.

You can then run tests using `hatch run test`.

Versioning can be handled by `hatch version` and its permutations; the tool is set to manage the `VERSION` variable in `src/cloudera_assist/__version__.py`.

To add a new Python dependency, run `uv add <the library>`. This will update the `pyproject.toml` file and the general `venv` for the project.

# License and Copyright

Copyright 2025, Cloudera, Inc.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
miniperscache 0.1.3
miniperscache is a small Python library for persistent caching of function results.
Requires Python: >=3.10

![pypi](https://img.shields.io/pypi/v/miniperscache)

A small python package for persistent caching of function results. Main features:
- Supports both sync and async functions.
- Properly typed, so your decorated functions will have the same type hints as the original function.
- Customizable serializers and storage backends.

Unsupported, todo:
- TTL/expiry
- Class/instance methods

## Examples

### Sync
```python
from miniperscache import cached

@cached(tag="expensive_calculation")
def expensive_calculation(x: int, y: int) -> float:
    return x * y
```

### Async
```python
from miniperscache import cached_async

@cached_async(tag="expensive_calculation")
async def expensive_calculation(x: int, y: int) -> float:
    result = await fetch_expensive_data(x, y)
    return result
```

### Custom serializers and storage
```python
from miniperscache import cached, FileStorage, JsonSerializer

@cached(tag="expensive_calculation", storage=FileStorage(), value_serializer=JsonSerializer())
def expensive_calculation(x: int, y: int) -> float:
    ...
```

### Skipping unhashable arguments
The cache works by hashing the arguments of the function call. If some of the arguments, e.g. random Python objects, are unhashable, you can skip them by passing a custom arg hasher set to `DefaultArgHasher(skip_args=["arg_names", ...])`:
```python
from miniperscache import cached_async, DefaultArgHasher

@cached_async(tag="expensive_calculation", arg_hasher=DefaultArgHasher(skip_args=["client"]))
async def model_call(client: ClientObject, prompt: str) -> float:
    res = await client.messages.create(
        prompt=prompt
    )
    return res.content
```

Or, you can provide your own arg hasher
```python
from miniperscache import cached_async, default_raw_arg_hasher

def model_call_arg_hasher(client: ClientObject, prompt: str) -> bytes:
    return default_raw_arg_hasher(client.model, prompt)

@cached_async(tag="expensive_calculation", arg_hasher=model_call_arg_hasher)
async def model_call(client: ClientObject, prompt: str) -> float:
    res = await client.messages.create(
        ...
        prompt=prompt
    )
    return res.content
```

### Deletion
TTL / more systematic expiration isn't supported yet, but what you can do is:
```python
from miniperscache import SqliteStorage
SqliteStorage().delete_tag("expensive_calculation")
```

## Customization
### Serializers
Currently:
- DillSerializer (default)
- PickleSerializer
- JsonSerializer

### Storage
- SqliteStorage (default)
-- Note: serializing to/from disk should be very fast so we don't even provide AsyncSqliteStorage - if writing to disk becomes a bottleneck for you, you can implement it using aiosqlite.
- FileStorage
- AsyncFileStorage
manishSMS 0.1.4
A School Management System
Requires Python: >=3.6

# [Basic School Management System Python Package](https://pypi.org/project/manishSMS/)

   A simple School Management System implemented in Python. This system allows for the management of Students, Staffs, and Courses using a command-line interface (CLI) and stores data in an Excel file.

## Features

The system provides basic CRUD (Create, Read, Update, Delete) functionalities for three main fields:

1. **Students**
   - Add new students
   - Display all students
   - Search for a student by ID
   - Update student details by ID
   - Delete a student by ID

2. **Staff**
   - Add new staff members
   - Display all staff members
   - Search for staff by ID
   - Update staff details by ID
   - Delete staff by ID

3. **Courses**
   - Add new courses
   - Display all courses
   - Search for a course by ID
   - Update course details by ID
   - Delete a course by ID
  
## Screenshots

### CLI Interface
![CLI Interface](https://raw.githubusercontent.com/Manish-Let-It-Be/manishSMS/refs/heads/main/SMS.jpg?token=GHSAT0AAAAAAC4QFT7PGNXIA4XPJM3OTM6KZ4ICQAA)

### Excel File
![Excel File](https://raw.githubusercontent.com/Manish-Let-It-Be/manishSMS/refs/heads/main/SMSexcel.jpg?token=GHSAT0AAAAAAC4QFT7OWO5HJ6ZP7ZVTONMYZ4ICQKA)

## Technologies Used

- **Python**: The programming language used for the implementation.
- **tabulate**: A library used to display data in a tabular format in the CLI.
- **openpyxl**: A library used for reading and writing Excel files, which serves as the database for the system.

## Installation

### Package Installation
1. You can install the School management System package using pip:
    ```bash
    pip install manishSMS
    ```
2. Run the program:
    ```bash
    startsms
    ```

### Clone & Run
1. Clone the repository:
   ```bash
   git clone https://github.com/Manish-Let-It-Be/manishSMS.git
   cd school-management-system
   ```

2. Install the required libraries:
   ```bash
   pip install tabulate openpyxl
   ```

3. Run the program:
   ```bash
   python sms.py
   ```

## Usage

Once the program is running, you will be presented with a menu to choose between managing students, staff, or courses. Follow the prompts to perform the desired operations.

---

<p align="center">
  <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&pause=1000&color=39FF14&center=true&width=435&lines=Thank+You+For+Checking+!">
</p>