semvec/pypi-packages huggingface dataset:
kliptypek 0.0.2
Clipboard typer. Insert text from clipboard using simulated typing.
Requires Python: >=3.7

# kliptypek

Clipboard typer. Insert text from clipboard using simulated typing.

# Start

Just copy needed text in clipboard and run:

```bash
kliptypek
```

Then focus needed window. There are 3 seconds for this by default, change it with flag `--delay_before` if needed.

# Installation

For `GNU/Linux` some package needed for `pyautogui`:

```bash
sudo pacman -S tk scrot
sudo apt install python3-tk scrot
```

```bash
pip3 install --upgrade pip
pip3 install kliptypek
```

There are flags to configure program behaviour. Type "--help" to see them. For example, you can use text not from clipboard with another timings:

```bash
kliptypek --help
kliptypek  --print_unicode_special
kliptypek --clip_text "c⌫kliptyper=←⌫k→)↵" --delay_between_up_down 1 --delay_between 100 --delay_before 2000
```
django-quik 0.0.8
Powering up your Django experience.

# Django Quik (Livereload + Tailwindcss)

This project aims to provide extra power while developing Django applications such as livereload and tailwindcss support
while you modify template, static files .etc

It is a wrapper around Django CLI, and you don't need to modify your existing code or add it in installed apps
like other livereload packages.

## Installation

```bash
pip install django-quik
```

Make sure to install this package inside the same virtual environment if your project is using.
Now open url: [http://127.0.0.1:8000](http://127.0.0.1:8000)

## Usage

The main motivation for Django Quik is to provide features without modifying your any code.

```bash
django-quik runserver
```

You can use all the Django commands with django quik.

## Setting up tailwindcss

Make sure you have installed npm in your system.

```bash
django-quik init tailwindcss
```

It will create two files: `tailwind.config.js` and `tailwind.mapping` after going through your
project `INSTALLED_APPS` and `TEMPLATES`.

MODIFY `tailwind.mapping` file based on your needs.

When you run `django-quik runserver`, it will run with tailwind livereload support.

## Does it support WebSocket?

Yes, Django Quik supports HTTP/1.0, HTTP/1.1, and WebSocket protocol. The HTTP/1.1 is overridden to HTTP/1.0.

## How Django Quik works?

Django Quik creates the proxy server then starts Django development server internally. It acts as the middleman between
the client and the Django server. If the content type is `text/html` being served, it injects script to reload page
which will be triggered from `Server Side Event(SSE)`.
churn_prediction 0.1.0
Pacote para previsão de churn
Requires Python: <4.0,>=3.12

# churn_prediction

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

A short description of the project.

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience 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 mkdocs project; see www.mkdocs.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`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         src and configuration for tools like black
│
├── 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.cfg          <- Configuration file for flake8
│
└── src   <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes src a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
upnlp 0.0.12
A package designed to support NLP teaching at graduate level
Requires Python: >=3.10

# UP-NLP

The Université Paris NLP package (upnlp) is meant to provide support for teaching Natural Language Processing
(NLP) at graduate level. It targets computational linguists, cognitive scientists
and computer scientists.  It aims to help students to get a smooth introduction to modern 
libraries and tools used nowadays in NLP without getting lost into the gory details
and without requiring insanely heavy computational resources.

Thus the library provides:

* Convenient access to small scale data sets relevant for in-class exercises
* Convenient access to small scale language models relevant for in-class exercises.
* A programming interface designed to be easily comparable to real-world full-scale libraries like Huggingface or OpenAI:
  key notions learned with the interface are easy to transfer to real world use cases.


The best way to discover the library is through its documentation.
adc64format 0.1.2
A python library to parse ADC64-formatted files
Requires Python: >=3.8

adc64format
-----------

This is a script and library to help interfact with the ADC64 format.

To install::

    pip install adc64format

## mpd format (new)
To use interactively or within another python codebase::

    from adc64format import mpd_parse_chunk, mpd_parse_run_start, MPDReader

    input_file = adc64format.MPDReader(input_filename,n_adcs)
    input_file.open()

    # Read run info
    _, nbytes_runinfo, runinfo = adc64format.mpd_parse_run_start(input_file.stream)
    # use the first file for the event reference
    _, chunk_size, test_event = adc64format.mpd_parse_chunk(input_file.stream)
    
    events = input_file.next(batch_size)
    print(events.keys())
    

## adc64 format (old)

To dump the contents of a single ADC64 file to an HDF5 format::

    adc64_to_hdf5.py <input ADC64 file>.data <output HDF5 file>.h5

To use interactively or within another python codebase::

    from adc64format import dtypes, skip_chunks, parse_chunk, ADC64Reader

    # Option 1: Parse a single event from an ordinary file object
    with open('<ADC64 file>.data', 'rb') as f:

        # Load the first event
        chunk = parse_chunk(f)

        # Look at chunk data (as numpy arrays)
        for key in dtypes:
            print(chunk[key])

        # Skip N events
        n = 100
        skip_chunks(f, n)
        chunk = parse_chunk(f)


    # Option 2: Parse events from multiple files and align by timestamp
    with ADC64Reader('<ADC 64 file from ADC 0>.data', '<ADC 64 file from ADC 1>.data', ...) as reader:
        batch_size = 10 # how many events to load on each iteration
        events = reader.next(batch_size)
       
        # get matched events between multiple files
        events_file0, events_file1, ... = events

        # Look at data
        for key in dtypes:
            print(events_file0[key])
ethernal 0.1.0
Ethernal - Enterprise AI Agent Cloud Platform
Requires Python: >=3.1

# Ethernal - Enterprise AI Agent Cloud Platform

## Overview
Ethernal is an enterprise-grade cloud platform enabling organizations to create, deploy, and manage AI agents integrated with Solana blockchain technology. The platform provides seamless token creation, custom domain integration, and scalable infrastructure for AI-powered conversational agents.

## Key Features
- Custom AI agent creation with configurable personalities and knowledge bases
- Automated Solana token generation and management for each agent
- Kubernetes-based cloud deployment with auto-scaling
- Custom domain integration with SSL/TLS support
- Enterprise-grade security and authentication
- RESTful API for seamless integration

## Technical Architecture
- Backend: Python/FastAPI
- Database: MongoDB
- Blockchain: Solana
- Infrastructure: Kubernetes
- Authentication: JWT
- AI: OpenAI GPT Models

## Quick Start
```bash
# Clone repository
git clone https://github.com/your-org/ethernal.git

# Environment setup
cp .env.example .env
# Configure your environment variables

# Deploy with Docker
docker-compose up -d
```

### Authentication
```bash
curl -X POST \
  https://api.ethernal.ai/v1/auth/token \
  -H 'Content-Type: application/json' \
  -d '{"email":"user@example.com","password":"password"}'
```

### Create AI Agent
```bash
curl -X POST \
  https://api.ethernal.ai/v1/agents \
  -H 'Authorization: Bearer {token}' \
  -d '{
    "name": "Assistant",
    "description": "Enterprise AI Assistant",
    "model_configuration": {
      "model": "gpt-4",
      "personality": "professional"
    }
  }'
```

## Deployment
The platform leverages Kubernetes for container orchestration:
```bash
kubectl apply -f k8s/
```

## Security Features
- End-to-end encryption
- Role-based access control
- Regular security audits
- Multi-factor authentication
- Rate limiting

## Monitoring & Analytics
- Prometheus integration
- Grafana dashboards
- Request tracking
- Performance metrics
- Cost analytics


## License
Enterprise Edition - Contact sales for licensing information