semvec/pypi-packages huggingface dataset:
DSPutility 0.0.21
DSP utility collection
Requires Python: >=3.8

DSP utility packages  
===
Common utilities developed by DSP inc.

# packages  
1. log  
2. dbintf  

## log
A loggin decorator keeps logging functions' error messeages  

* features  
    1. Crete logger using different log file  
    2. Identical log file shared by multiple `log` instances (in same module scope) won't create multiple file handler for multiple write  
* import package
```python
from dsputility import log
instance = log()
```
```python
from dsputility.log import log
instance = log()
```
```python
import dsputility as du
instance = du.log()
```
* usseage  

```python
from dsputility import log

logName = os.path.basename(__file__)
myLog = log(logPath=logName) 
myLog2 = log(logPath=logName)

@myLog.errlog(logName)
def func1(x):
    return x/0

@myLog.errlog(logName)
async def afunc1():
    open('not exist', 'r')
		
@myLog2.errlog(logName)
def func2(x):
    "won't cause multiple handler problem"
    return x/0
```
ngenux-text-cleaner 1.0
This package extracts meaningful information from cluttered text.
Requires Python: >=3.6

<h1 align='center'> Text Cleaner </h1>

This is a simple Python package that removes the
noisy data and extracts the meaningful information
from the given cluttered input data.

The package includes a pipeline for performing all the
steps in one go along with multiple methods that can
be used for specific needs.
ringo-scanner 0.1.8
a framework for scanning the web for vulnerabilities

# RingoScanner


## What is it?
RingoScanner is a framework for scanning the web for vulnerabilities.

## Usage
```python
from ringo_scanner import Scanner
Scanner(func, items).execute() # It's like a map(func, items)
```

## Authors
- [Harukawa Sayaka](https://github.com/BBleae)
fsleyes-plugin-roitools 0.0.6
FSLeyes plugin to work with ROIs

# fsleyes-plugin-roitool

A plugin which provides a easy way to find rois from Masks/Label-Images and get a fast information

## Usage

To pen the Plugin go to Settings->Ortho View->RoiTools. 

* all Overlays which are marked as ` mask image` or ` Label image` are listed in the Roi-Tools-Widget.
* You can drop down all Overlays to see the containing labels of each overlay
* DoubleClick on any label to jump to the center of mass of the label.

## Issues


## TODO
	
	* Mean/Std of each label in all overlays as table

## Changes
  0.0.6: Make Window visible with current fsleyes version
	0.0.5: Labelizing-Button adds labeled image to RoiList
kivy-garden.ebs.gallery 1.0
Image Gallery widget for Kivy
Keywords: Kivy kivy-garden

Gallery Widget for Kivy
=======================

[![Github Build Status](https://github.com/ebs-universe/kivy_garden.ebs.gallery/workflows/Garden%20flower/badge.svg)](https://github.com/ebs-universe/kivy_garden.ebs.gallery/actions)

This package provides half of a simple Image Gallery / Carousel widget for 
Kivy. The other half is provided by the EBS linuxnode GalleryManager class. 

Most non-EBS applications would not benefit from this widget. The functionality 
provided here can just as easily be obtained by use of the Kivy ScreenManager 
widget, which also considerably more flexible. The reason ScreenManager was not
used here is primarily because I hadn't seen ScreenManager yet when the Image Gallery 
was first written. This widget may not be used in the future by the EBS Image Gallery, 
and if it is not, it will no longer be maintained.

This package is part of the EBS widget collection for Kivy. It is written in 
mostly Python and depends on the EBS core widgets and widget infrastructure package. 
For more information, see [kivy_garden.ebs.core](https://github.com/ebs-universe/kivy_garden.ebs.core)

See https://kivy-garden.github.io/ebs.flower/ for the rendered flower docs.

Please see the garden [instructions](https://kivy-garden.github.io) for 
how to use kivy garden flowers.


CI
--

Every push or pull request run the [GitHub Action](https://github.com/kivy-garden/flower/actions) CI.
It tests the code on various OS and also generates wheels that can be released on PyPI upon a
tag. Docs are also generated and uploaded to the repo as well as artifacts of the CI.


TODO
-------

* add your code

Contributing
--------------

Check out our [contribution guide](CONTRIBUTING.md) and feel free to improve the flower.

License
---------

This software is released under the terms of the MIT License.
Please see the [LICENSE.txt](LICENSE.txt) file.

How to release
===============

See the garden [instructions](https://kivy-garden.github.io/#makingareleaseforyourflower) for how to make a new release.
th-eventhub-models 0.0.3
Models For TH Event Hub
Requires Python: >=3.6

# th-eventhub-models

This Repo Contains The Object Models For The Transform Health Event Hub Operations.

### To Publish Changes

1. Make changes to the models
2. Update the version number in `setup.py`
3. Install dist tools by using
   `python -m pip install --user --upgrade setuptools wheel`
4. Run `python setup.py sdist bdist_wheel`
5. Test locally by running `pip install -e .`
6. Install twine by `python -m pip install --user --upgrade twine`
7. After creating an account in testPy upload it in testPy by `python -m twine upload - repository testpypi dist/*`
8. Test if it works as expected by uninstalling the local version and installing the testPy version by <br> 
   `pip uninstall th-eventhub-models --yes-i-know-what-i-am-doing` <br> 
    and then <br>
   `pip install -i https://test.pypi.org/th-eventhub-models/th-eventhub-models==<version-number>`
9. Upload to PyPI Repository by running
   ` python -m twine upload dist/*`
10. Install in any repository of your choice by using `pip install th-eventhub-models` and import by using
    `from transformHealthEventHubModels.insertOne import DSEventHubInsertOneObject`
coveragepy-lcov 0.1.2
A simple .coverage to LCOV converter
Requires Python: >=3.6.3,<4.0.0
Keywords: coverage

# coveragepy-lcov

`coveragepy-lcov` is a simple CLI for converting `.coverage` files generated by [Coverage.py](https://github.com/nedbat/coveragepy) to the `LCOV` format.

## Credits

This tools is based on code from [Coverage.py](https://github.com/nedbat/coveragepy/blob/master/coverage/report.py).

## Installation

Using pip:

```bash
pip install coveragepy-lcov
```

## Usage

```bash
# If the .coverage file is in your current working directory
coveragepy-lcov

# Point to a different .coverage file path
coveragepy-lcov --data_file_path example/.coverage

# Write the output to a different file path
coveragepy-lcov --output_file_path build/lcov.info

# Use relative paths in the LCOV output
coveragepy-lcov --relative_path
```

## Options

```text
Usage: coveragepy-lcov [OPTIONS]

Options:
  --data_file_path TEXT    Path to .coverage file
  --output_file_path TEXT  lcov.info output file path
  --config_file TEXT       Path to .coveragerc file
  --relative_path          Use relative path in LCOV output
  --preview                Preview LCOV output
  --help                   Show this message and exit.
```

## Further reading

- [LCOV format](http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php)
- https://github.com/nedbat/coveragepy/issues/587
deltax 0.0.1.6
Python library to control an DeltaX robot
Requires Python: >=3.6

# Python library to control a robot from 'Delta X Robot'

## exemple

### DeltaX S
```Python
robot = DeltaX(port = "COM4", model=DeltaX.DeltaX_S)
if robot.connect() == True:
    print("connected")
robot.syncPosition()
robot.wait_for_robot_response()
print(robot.position())
robot.syncInput(I=[0, 1], A=[0])
robot.wait_for_robot_response()
print(robot.getDigitalInput(I=[0, 1]))
print(robot.getAnalogInput(A=[0]))
robot.setDO(D=[0,1], value=DeltaX.ON)
robot.wait_for_robot_response()
while 1:
    robot.moveL([20,0,-800])
    robot.moveL([-20,0,-800])
    robot.moveC(offset=[-30,-30], point=[-20, 0])
    robot.wait_for_robot_response()
```

### DeltaX V2
```Python
robot = DeltaX(port = "COM4", model=DeltaX.DeltaX_V2)
if robot.connect() == True:
    print("connected")
robot.syncPosition()
robot.wait_for_robot_response()
print(robot.position())
robot.setEndEffector(name=DeltaX.Vacuum)
robot.wait_for_robot_response()
robot.controlEndEffector(value=DeltaX.ON)
robot.wait_for_robot_response()
while 1:
    robot.moveL([20,0,-270])
    robot.moveL([-20,0,-270])
    robot.moveC(offset=[-30,-30], point=[-20, 0])
    robot.wait_for_robot_response()
```

## list func
    - connect
    - disconnect
    - is_connected
    - sendGcode
    - wait_for_robot_response
    - robot_response
    - isResponded
    - lastGcodeState
    - syncMotionParameters
    - motionParameters
    - sleep
    - position
    - angle
    - homing
    - syncPosition
    - syncAngle
    - syncInput
    - getDigitalInput
    - getAnalogInput
    - setDO
    - controlEndEffector
    - setEndEffector
    - disableSteppers
    - setAcceleration
    - setStartingAndEndingSpeeds
    - setXYZOffset
    - moveL
    - moveC

![DeltaX S](https://raw.githubusercontent.com/VanThanBK/python-deltax/master/image.png)