semvec/pypi-packages huggingface dataset:
mk-append-to-head-marcelao-dev 0.0.1
Append some string to a MkDocs page's <head>.
Requires Python: >=3.9

# mk-append-to-head
Append some string to a MkDocs page's &lt;head>.

## Installation

```bash
pip install mk-append-to-head
```

## Configuration

In MkDocs configuration file:

```yaml title="mkdocs.yml"
plugins:
- mk-append-to-head:
    append_str: <script>console.log(1)</script>
    pages: ['Home'] # optional
```

Leaving `pages` empty will append the `append_str` to all pages.
pyprocessors-opennre 0.5.161
Processor based on Huggingface transformers zero-shot classification pipeline
Requires Python: >=3.8

# pyprocessors_opennre

[![license](https://img.shields.io/github/license/oterrier/pyprocessors_opennre)](https://github.com/oterrier/pyprocessors_opennre/blob/master/LICENSE)
[![tests](https://github.com/oterrier/pyprocessors_opennre/workflows/tests/badge.svg)](https://github.com/oterrier/pyprocessors_opennre/actions?query=workflow%3Atests)
[![codecov](https://img.shields.io/codecov/c/github/oterrier/pyprocessors_opennre)](https://codecov.io/gh/oterrier/pyprocessors_opennre)
[![docs](https://img.shields.io/readthedocs/pyprocessors_opennre)](https://pyprocessors_opennre.readthedocs.io)
[![version](https://img.shields.io/pypi/v/pyprocessors_opennre)](https://pypi.org/project/pyprocessors_opennre/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyprocessors_opennre)](https://pypi.org/project/pyprocessors_opennre/)

Processor based on Facebook's OpenNRE

## Installation

You can simply `pip install pyprocessors_opennre`.

## Developing

### Pre-requesites

You will need to install `flit` (for building the package) and `tox` (for orchestrating testing and documentation building):

```
python3 -m pip install flit tox
```

Clone the repository:

```
git clone https://github.com/oterrier/pyprocessors_opennre
```

### Running the test suite

You can run the full test suite against all supported versions of Python (3.8) with:

```
tox
```

### Building the documentation

You can build the HTML documentation with:

```
tox -e docs
```

The built documentation is available at `docs/_build/index.html.
conferencetimer 1.0.9
PyQt6 based timer and remote application for conference talks
Requires Python: >=3.7
Keywords: Conference, Timer, PyQt6

# Conference Timer

This project provides a timer and a remote PyQt6 application for a conference timer.
The talk and questions times can be set and the timer will provide the speakers with the remaining time.

After installing the package you can run the timer via
```bash
ctimer
```
and the remote via
```bash
cremote
```

Add the *-h* flag to see the allowed command line arguments.


Alternatively, you can start the timer via python
```python
import conferencetimer
conferencetimer.start_timer()
```
and accordingly the remote via

```python
import conferencetimer
conferencetimer.start_remote()
```

If you want to use the remote from a different computer, make sure that both computers are in the same network and that your firewall is configured accordingly.

## Remote

The remote functionality is based on a small tcp server which expects a json dictionary with *command* being one of the following:

- *startpause* (toggle between running and pause)
- *reset* (resetting the timer, if *talk* and *qna* are specified the time for the talk and the questions is set respectively)
- *adjust* (adds or subtracts time specified by *delta* from the timer)
- *fullscreen* (toggles fullscreen)

### Unix systems

You can also control the timer app via the command line with netcat:

```bash
echo '{"command": "startpause"}' | nc 127.0.0.1 5555
echo '{"command": "reset", "talk": 30, "qna": 15}' | nc 127.0.0.1 5555
```

### Windows Powershell Example

A small example script to control the timer app via the powershell:

```powershell
$payload = '{"command":"start"}'
$ip = "192.168.1.50"
$port = 5555
$client = New-Object System.Net.Sockets.TcpClient($ip, $port)
$stream = $client.GetStream()
$writer = New-Object System.IO.StreamWriter($stream)
$writer.Write($payload)
$writer.Flush()
$writer.Close()
$client.Close()
```
grc-utils 0.2.0
NLP utilities for Ancient Greek

# Ancient Greek NLP utilities

A bunch of NLP tools in Python for `grc` not available elsewhere. Examples:

- standard .lower() and .upper() do *not* work for `grc`, but my `lower_grc` and `upper_grc` do.
- `no_macrons`: removes unicode vowel-length diacritics (longa and brevia) in a way that keeps all other diacritics intact.

© Albin Thörn Cleland, PhD student at Lunds universitet, Sweden.
pympi-ling 1.71
A python module for processing ELAN and Praat annotation files
Requires Python: >=3.9

pympi version 1.71
====================
### Introduction
Pympi is a package that allows you to interact with [Elan][1] files and [TextGrid][2] (regular, short and binary) files.
You can create, edit and convert both formats into each other.
It includes besides all the basic functions also functions for:
- Calculating gaps and overlaps between speakers conform [Heldner and Edlund's method][3]. (Could be used to calculate floor transfers)
- Shift annotations in both directions (Could be used when due to an error all annotations are misaligned).
- Import from CLAN's chat files.
- Merge and or filter tiers (could be used to combine hands in gesture coding)
- Move tiers between elan files.
- Etc.

### Requirements
None

### Optional requirements
- [lxml][4] is used for testing.

### Documentation and downloads
Full api documentation of the current and old versions can be found on [here][5].

Pypi repository location can be found [here][6].

### Installation
#### Automatic
- From a shell run with administrator rights:
```Shell
pip install pympi-ling
```
- Or alternatively run with administrator rights:
```Shell
easy_install pympi-ling
```

*NOTE: on windows the executable might not be in $PATH.*

#### Manual
1. Download the latest version from [pypi][5]
2. Untar the file
3. From that directory run with administrator rights
```Shell
python setup.py install
```

### How to cite
```tex
@misc{pympi-1.71,
	author={Lubbers, Mart and Torreira, Francisco},
	title={pympi-ling: a {Python} module for processing {ELAN}s {EAF} and {Praat}s {TextGrid} annotation files.},
	howpublished={\url{https://pypi.python.org/pypi/pympi-ling}},
	year={2013-2025},
	note={Version 1.71}
}
```

### Authors
Mart Lubbers (mart at martlubbers.net)
and
Francisco Torerira (francisco.torreira at mpi.nl)

and with contributions from:
JoFrhwld, sarpu, hadware, thomaskisler, mome, mimrock and xrotwang

[1]: https://tla.mpi.nl/tools/tla-tools/elan/
[2]: http://www.fon.hum.uva.nl/praat/
[3]: http://www.sciencedirect.com/science/article/pii/S0095447010000628
[4]: http://lxml.de/
[5]: http://dopefishh.github.io/pympi/
[6]: https://pypi.python.org/pypi/pympi-ling/
lbox 2.0.0
Serve files via HTTP for a set duration of time.
Requires Python: >=3.10

## Lbox - a litterbox clone-ish

This is a self-hosted server that makes you make available files for a limited amount of time.

### Installation

The best way to install this is via `pipx` which will create a virtual environment and manage the dependencies for you:

    pipx install lbox

That will work when the project is available from [Pypi](https://pypi.org), meanwhile from the .tar.gz file as created by the build command `sdist`:

    pipx install lbox-X.Y.tar.gz

Where, of course, X.Y is the version number.

### Building from repo

You should be working on a virtual environment. On your virtual environment install the `build`package:

    python3 -m pip install build

then simply run build, which will create the source distribution (i.e. the .tar.gz file) and the wheel package:

    python3 -m build

### Using Lbox

Lbox scans the directory specified in the environment variable `LBOX_ROOTDIR` for directories with names of the form *number timeunits* e.g. `5 hours`, `2days`, `20m`, etc. And the files under those directories will be deleted after the specified time elapses, being available for download in the meantime. Note that you only need to specify `d`, `m`, `h` and `s` for days, minutes, hours and seconds, respectively. Only the initial matters. Also note that whitespace between the number and the units is optional.

If the `LBOX_ROOTDIR` environment variable is not set, the default folder will be `/var/www/lbox`


#### The lbox server

The `lbox`command is the web server that _publishes_  the files. It will just provide a list of the files along with its size and the time to expiration. Every file can be downloaded from the url ending in `/file/<filename>`, with no additional directory path. No, the server doesn't allow uploading new files, but what's the need for it? Being self hosted, you can always `scp`into the right directories to share.

The lbox server runs by default on port 8080.

To run `lbox`use the command:

    LBOX_ROOTDIR=/path/to/dir lbox

It is recommended that a `systemd`is created to run `lbox` continuously. It is also recommended that `lbox`be run on http behind a reverse proxy that handles the SSL certificate and manages security etc.

### License
This project is released under the MIT license.
djangoasyncframework 0.3.8
Providing async views, ORM, and tasks for Django. 
Requires Python: >=3.6

# [Django Async Framework](https://mmasri1.github.io/django-async-framework/)

[![pypi-version]][pypi]

Django Async Framework is a lightweight class-based view framework built on top of Django.

You can find the documentation for the project [here](https://mmasri1.github.io/django-async-framework/).

## Overview
Django is a powerful web framework, but its async support is still a work in progress. Some parts play well with async, others don’t. Django Async Framework aims to fill in those gaps by giving a fully async-first way to build with Django.

### Getting Started

1. Install it with pip:

```bash
pip install djangoasyncframework
```

2. Add it to your `INSTALLED_APPS` in `settings.py`:

```python
INSTALLED_APPS = [
    # your other apps...
    'async_framework',
]
```

### Why This Matters

Django deserves a modern async-first ecosystem, not just patches around old sync components. It provides a structured foundation for writing asynchronous code in Django without relying on sync-based workarounds.


### Project Status

This is an early-stage open-source project that’s still growing. We’d love your feedback, ideas, bug reports, and contributions.

<br>

Stay tuned, Djangonauts ❤️

[pypi-version]: https://img.shields.io/pypi/v/djangoasyncframework.svg
[pypi]: https://pypi.org/project/djangoasyncframework/
dataflow-custom-extension 0.1.21
A JupyterLab extension for Dataflow customization
Requires Python: >=3.9
Keywords: dataflow, jupyter, jupyterlab, jupyterlab-extension

# Dataflow Jupyter Extension

A JupyterLab extension for dataflow customizations


## Customizations

<details>
<summary>Added custom connection lost restart command</summary>

#### `dataflow-custom:hub-restart`
-   This command has been replaced for default `hub:restart` because of it's redirection to _/hub/spawn_ , which should not be the case. So now the it redirects to _/hub/ui_ in iframe , which will be handled by UI and "App is not running" message will be shown
- Modified the connectionLost dialog to use the `dataflow-custom:hub-restart` command

</details>

### Packaging the extension

See [RELEASE](RELEASE.md)
winkerberos-typed 0.5.0
Stubs file for winkerberos package
Requires Python: >=3.10
Keywords: python3, windows, kerberos, authentication, spengo

# Winkerberos typed

This package aims to make the SSO library [`winkerberos`](https://github.com/mongodb/winkerberos) more pythonic and user friendly.

It only includes a stub file (AI generated from the help(winkerberos) command) which improves the devloper experience.

PS: This package won't do anything on its own. You need the [original](https://github.com/mongodb/winkerberos/) for the full experience.

## Table of Contents

<ul>
  <li>
    <a href="#comparison">Comparison</a>
    <ul>
      <li><a href="#before-types">Before Types</a></li>
      <li><a href="#after-types">After Types</a></li>
    </ul>
  </li>
  <li><a href="#installation">Installation</a></li>
  <li><a href="#build">Build</a></li>
  <li><a href="#license">License</a></li>
</ul>

## Comparison

### Before types:

<img src="https://raw.githubusercontent.com/DroidZed/winkerberos-typed/refs/heads/main/images/before.png"  alt="before types" title="before"/>

### After types:

<img src="https://raw.githubusercontent.com/DroidZed/winkerberos-typed/refs/heads/main/images/after.png"  alt="after types" title="after"/>

## Installation:

Simply:

```sh
pip install winkerberos-typed

```

_or_

```sh
uv add winkerberos-typed

```

_or_

```sh
poetry add winkerberos-typed

```

## Build

1. Install `uv` by following [this link](https://docs.astral.sh/uv/getting-started/installation/).

2. Clone the project:

    ```sh
    git clone https://github.com/DroidZed/winkerberos-typed && cd winkerberos-typed
    ```

4. Build with `uv`:

    ```sh
    uv build
    ```

## License:

This project is licensed under the MIT license.
ur-aj 0.1.5
Python library for controlling Universal Robots via sockets
Requires Python: >=3.7

UR-AJ
-----
By Akshay Ajit Bhawar
Linkedin: 

A lightweight Python library to control Universal Robots (UR3/UR5/UR10/UR16) via socket programming.

Installation:
    pip install ur-aj

Usage Example:
    import ur_aj as ur
    import time

    ur.configure_robot("192.168.1.11", send=30001, recv=30003)

    print("Pose:", ur.getpose())
    print("Joints:", ur.getjoints())

    ur.moveJ(-12, -503, 122, 27, 124, -120, speed=0.1)
    ur.moveLoffset(100, 0, 20, speed=0.1)

    ur.digitalout(0, True)
    time.sleep(1)
    ur.digitalout(0, False)

Features:
    - Get robot pose, joints, and speed
    - MoveL / MoveJ absolute & relative motions
    - Control digital & analog IO
    - Update single joint angle