semvec/pypi-packages huggingface dataset:
PreProcessingGEP 1.0.2
Preprocessing Python package

## Usage of PreProcessingService 

You can access following functions:


The provided package is a collection of functions for text preprocessing and cleaning. Here is a brief explanation of each function:

_en_stopwords: Returns a list of English stopwords.

strip_numeric: Removes numbers from a string.

strip_punctuation: Removes all punctuation marks from a string.

remove_stopwords: Removes stopwords from a string.

strip_multiple_whitespaces: Removes excess whitespace from a string.

strip_short: Removes words with a length less than a specified size from a string.

remove_alpha_num: Removes alphanumeric characters from a string.

lemmatize: Lemmatizes a list of tokens.

nltk_pos: Performs Part-of-Speech (POS) tagging using NLTK.

stanford_pos: Performs POS tagging using Stanford POS Tagger.

filter_pos: Filters words based on specific POS tags.

clean_text: Cleans the text by applying various cleaning functions.

preprocess_string: Preprocesses a string by applying a list of cleaning functions.

preprocess_postags: Applies a list of filtering functions to a list of strings.

guided_buy_preprocess: Preprocesses a list of strings for guided buying purposes.

dump_interim_steps: Creates a DataFrame with the intermediate steps of preprocessing.

lemmatization: Performs lemmatization on a string.

cold_start_preprocess: Preprocesses a list of words for cold start purposes.

unique_value_col: Splits words based on '|'.

convert_synonyms:A collection of synonym mappings

clean_description: Includes all above cleaning steps


Example usage:
PreProcessingService.clean_description(inputText)
pin3x-jnrh2023 2.9.2
A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives - TEMPORARY PACKAGE
Requires Python: >=3.7

# pin3x-jnrh

Source de la version de pinocchio utilisée aux [JNRH'2023](https://jnrh2023.sciencesconf.org/)
Ceci dépend d’une version pour l’instant privée de pinocchio-3x.

C’est un paquet ayant volontairement une durée de vie très limitée: ne pas utiliser en dehors des JNRH'2023.
unreal-qt 0.0.1
A Qt manager for Unreal that enables the use of PyQt & PySide in Unreal Engine
Requires Python: >=3.4
Keywords: application,unreal,pyside,pyqt,qt,engine,unrealengine

# unreal qt
QT PySide2 support for unreal engine 5 (likely works in unreal 4)
- prevent widget from instantly dissapearing due to garbage collection
- automatically style all Qt widgets using Xingyu Lei's [unreal_stylesheet](https://github.com/leixingyu/UnrealStylesheet)
- dark window bar for a better visual match with Unreal
- parent widget to Unreal's main window to stay on top
        

## Quickstart

this guide assumes you have PySide2 installed already!
1. Add the unreal_qt folder in your python path. See [unreal docs](https://docs.unrealengine.com/4.27/en-US/ProductionPipelines/ScriptingAndAutomation/Python/#pythonpathsintheunrealeditor)
2. Use the following code snippet to create `sample.py` and add it to unreal python path.
```python
# 1. SETUP - this step can automatically run on editor startup when added to your init_unreal.py
import unreal_qt
unreal_qt.setup()  

# 2. CREATE WIDGET - create your qt widget
# every widget you make after setup won't block the editor & have unreal styling
from PySide2.QtWidgets import QLabel, QWidget, QVBoxLayout
w = QWidget()
layout = QVBoxLayout()
w.setLayout(layout)
layout.addWidget(QLabel("Hello World!"))

# 3. WRAP WIDGET - (optional) manage garbage collection, add darkbar, stay on top
unreal_qt.wrap(w)

# 4. SHOW WIDGET - if using stay on top this needs to run after the wrap stage
w.show()
```
3. import script in unreal with the Python terminal to run it.
```python
import sample
```

![image](https://user-images.githubusercontent.com/3758308/191580757-f3993797-da80-449e-b9d4-ad311b2f37c5.png)

## Dark title bar
The windows bar is by default white on Windows, and QT can't change the bar color.

With unreal_qt you can add a custom bar.

- default window bar & frame

![image](https://user-images.githubusercontent.com/3758308/191618705-45914a58-893b-4680-995e-976571b7c7eb.png)

- custom bar, no frame (no resize support!)

![image](https://user-images.githubusercontent.com/3758308/191618309-13e7329f-4310-407a-9eef-383a113e1ac1.png)

- custom bar, frame, no title bar (supports resize)

![image](https://user-images.githubusercontent.com/3758308/191618151-319b8530-addb-4b9a-a51f-5da0a90a4fd3.png)


## community
- tech-artists.org [PySide and Unreal5](https://discourse.techart.online/t/pyside-and-unreal5/15475/6) thread 
- [ ]  TODO unreal forums thread

## similar to
- https://github.com/FXTD-ODYSSEY/Unreal-PyToolkit
colab-xterm 0.2.0
Open a terminal in colab, including the free tier.
Requires Python: >=3.6

# colab-xterm
Colab-xterm allows you to open a terminal in a cell.

# Usage

1. Install package and load the extension
    ```
    !pip install colab-xterm
    %load_ext colabxterm
    ```
2. Open a terminal
    ```
    %xterm
    ```
3. Enjoy!

Try it out in the demo notebook. 

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/infuseai/colab-xterm/blob/main/demo.ipynb)

# Features
- TTY support
- Does not block your kernel

# Options

```
%xterm height=1000 port=10001
```

option | description
-------|-----------
height | The height of the terminal panel
port | The server port

# Screenshots
![](assets/colab-xterm.png)
pyngleton 0.0.6
A small example package
Requires Python: >=3.7

Thread-safe and process-safe singleton class.
The singleton is shared between all threads.
For every process, a new instance is initialized and shared between all threads of the process.

## Examples
### Basic usage:
```python
from pyngleton import singleton

@singleton
class MyClass:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

if __name__ == '__main__':
    a = MyClass(1, 2, 3)
    b = MyClass(4, 5, 6)
    
    assert a is b
    
    assert b.x == 1 and b.y == 2 and b.z == 3
```

### Multithreading:
```python
from concurrent.futures import ThreadPoolExecutor
from pyngleton import singleton
   
@singleton
class MyClass:
    pass

if __name__ == '__main__':
    n = 2
    with ThreadPoolExecutor(max_workers=n) as exc:
        tasks = [exc.submit(MyClass) for _ in range(n)]
        results = set(task.result() for task in tasks)
    assert len(results) == 1  # all threads share the same instance
```

### Multiprocessing:
```python
import multiprocessing
from concurrent.futures import ProcessPoolExecutor
from pyngleton import singleton

@singleton
class MyClass:
    def __init__(self, x: int, y: int, z: int, queue: multiprocessing.Queue):
        self.x = x
        self.y = y
        self.z = z
        queue.put((x, y, z))
        
def worker(x: int, y: int, z: int, queue: multiprocessing.Queue):
    MyClass(x, y, z, queue)

if __name__ == '__main__':
    n = 2
    queue = multiprocessing.Manager().Queue()
    with ProcessPoolExecutor(max_workers=n) as exc:
        tasks = [exc.submit(worker, i, i, i, queue) for i in range(n)]
        for task in tasks:
            task.result()
    results = []
    while not queue.empty():
        results.append(queue.get())
    assert results == [(0, 0, 0), (1, 1, 1)]  # each process has its own instance
```
The classes decorated with `@singleton` can't be pickled. If you want to be able to do that, 
you can inherit from `Singleton` or `SingletonMeta` instead of using the decorator.

### Inherting:
```python
from pyngleton import Singleton, SingletonMeta

class MyClassA(metaclass=SingletonMeta):
    pass

class MyClassB(Singleton):
    pass
    
if __name__ == '__main__':
    assert MyClassA() is MyClassA()
    assert MyClassB() is MyClassB()
    assert MyClassA() is not MyClassB()
```
slice-guard 0.0.3
A library for detecting critical data segments in structured and unstructured data based on features, metadata and model predictions.
Requires Python: >=3.7

# slice-guard
A library for detecting critical data slices in structured and unstructured data based on features, metadata and model predictions.

## For building the library
Follow this description: [Packaging Projects](https://packaging.python.org/en/latest/tutorials/packaging-projects/)