semvec/pypi-packages huggingface dataset:
iotanalyzer 0.0.1
IoTAnalyzer is an open-source IoT device management toolkit that can help smart home owner, Internet Service Providers (ISPs), and researchers to automatically monitor smart home IoT devices, and analyze potential security and privacy vulnerabilities.

# IoTAnalyzer

IoTAnalyzer is an open-source IoT device management toolkit that can help smart home owner, Internet Service Providers (ISPs), and researchers to automatically monitor smart home IoT devices, and analyze potential security and privacy vulnerabilities.

## Installation

Run the following to install:

```python
pip install iotanalyzer
```

## Usage

### Machine Learning Classifier

```python
from iotanalyzer import classifier

c = classifier
```
xt-FlaskAPIDocs 0.1.0
Interface automation document based on flash.
Requires Python: >=3.6

# flask-api-docs
Interface automation document based on flash


# Installation

It is possible to install the tool with pip:

```
pip install xt-FlaskAPIDocs
```

# Usage

Sample usage:

```python
from flask import Flask

from flask_api_demo.test.HelloWorld import HelloWorld
from flask_docs import BluePrint, Docs

app = Flask(__name__)

a = BluePrint('hello', __name__)

a.add_url_rule('/hello', 'hello', HelloWorld().hello_world, methods=['GET'], args={"test1": 'str', "test2": 'int'})
a.add_url_rule('/bye', 'bye', HelloWorld().bye_world, methods=['GET'], args={"test1": 'str', "test2": 'int'})
app.register_blueprint(a)
Docs(app, hide_docs=True)
```
helasentilex 0.1.1
Python API for Sinhala Sentiment Lexicon
Requires Python: >=3.6

# HelaSentiLex (Hela Sentiment Lexicon)
Python API for Sinhala Sentiment Lexicon with 14000+ sentiment tagged Sinhala words

### Setup environment
1. Make sure you have Python >= 3.6 by `python --version`
2. Additionally, you’ll need to make sure you have pip available by running `pip --version`
3. To install pip see [installing pip](https://pip.pypa.io/en/stable/installing/)
4. Install helasentilex package using the command `pip install helasentilex`

### Getting started
Let's begin with showing how easy it is to find sentiments of Sinhala words using helasentilex
```
>>> import helasentilex
>>> helasentilex.sentiment('යහපත්')
1
>>> helasentilex.sentiment('අමිහිරි')
-1
>>> helasentilex.sentiment('පුටුව')
0
```

If the input word does not exist in our sentiment lexicon or the input is invalid then it will return `None`
```
>>> helasentilex.sentiment(23)
None
```

You can enter a sentence as a string and get sentiment scores for available words in the sentiment lexicon
```
>>> helasentilex.sentiments('ඔබේ සැප දුක කෙසේද')
{'ඔබේ': 0, 'සැප': 1, 'දුක': -1, 'කෙසේද': None}
```

If the input is invalid then it will return an empty dictionary
```
>>> helasentilex.sentiments(23)
{}
```

### Defining labels
```
 1: POSITIVE (ධනාත්මක)
-1: NEGATIVE (ඍණාත්මක)
 0: OBJECTIVE (මධ්‍යස්ථ හෝ උදාසීන)
```


### Contributing
Want to report a bug, contribute some code, or improve documentation? Excellent! fork our repository and start 
contributing.

#### Adding new words to the sentiment lexicon
To add new words along with their sentiment scores 

1. Open `helasentilex/lexicon.csv` file
2. Append `new_word,sentiment_score`
3. Sort words in ascending order
4. Save changes to your forked repo and make a pull request

_Love helasentilex? Give our repo a **[star](https://github.com/BrainstormersLK/helasentilex)**!_
pymex-lukasz99 0.9.10
PYMEX: PSI-MI/IMEx Data Access
Requires Python: >=3.5

PYMEX package is a collection of modules providing tools for accessing interaction
data distributed by The IMEx Consortium partners as well as for parsing, transformation
and construction of PSI-MI endorsed interaction data files.

## Modules
* ``pymex.xmlrecord`` - A generic, configurable XML record serializer/deserializer. 
* ``pymex.mif`` - PSI-MI XML format support (versions 2.5.4 and 3.0.0). 
* ``pymex.pypsiq`` - PSICQUC server access.

## Quick Start
    from lxml import etree as ET
    import pymex.mif

    rec = pymex.mif.Record()
    rec.parseMif( file, 'mif254' )
    
    for interaction in rec.interactions:
       print( "Interaction type:",interaction.type.label )
       print( "Participant count:", len(interaction.participants))
       for participant in interaction.participants:   
          print(" Participant:",participant.interactor.label)
          print("   Host:", participant.interactor.host.label)
          print("   Type:", participant.interactor.type.label)
          print("   Sequence:", participant.interactor.sequence)
    
    recDom = rec.toMif( 'mif300' )
    print( ET.tostring(recDom,pretty_print=True).decode("utf-8") )

### Further details: [Pymex Wiki](https://github.com/IMExConsortium/pymex/wiki)
anglesum 0.3
A Mathematical Tool
Requires Python: >=3.6+

## Created By Pyxis
#### Copyright(c) <2021><Pyxis/Anvay Arora>

### Created as a mathematical tool to solve the common qustions of Angle Sum property that is all 3 angles of a triangle adds up to 180 degrees.

### This package Pertains to all possibilities given:
- Angle A is missing(To Use Just type in anglesum.angA())
- Angle B is missing(To Use Just type in anglesum.angB())
- Angle C is missing(To Use Just type in anglesum.angC())

### More given on https://github.com/the-protagonist-view/anglesum-package
shell-pipes 0.1.0
Extending Python syntax to implement shell commands as pipes using subprocess
Requires Python: >=2.7

# Python Shell Pipes

### A simple way to access your shell commands in Python

The `shpipes` package uses `subprocess.Popen` to run commands in a shell easily from native Python.

```python
    >>> from shpipes import Pipe
    # python --version
    >>> Pipe('python')('--version').getvalue()
    'Python 3.8.6\n'
```

## Chaining pipes together

You can chain together your commands, passing output from one to the input of another, similar to shell pipes. You can use the bitwise inclusive or operator to chain `Pipe` instances together.

```python
    # echo 1+1 | bc
    >>> (Pipe('echo')('1+1') | Pipe('bc')).getvalue()
    '2\n'
    # This also works
    >>> pipe = Pipe('echo')('1+1')
    >>> pipe |= Pipe('bc'))
    >>> pipe.getvalue()
    '2\n'
```

### Loading commands from your `PATH`

Shell Pipes can also collect all executables from your `PATH` variable and gather them into a `Commands` instance so you can use the lib just like your native shell.

```python
    >>> from shpipes import Commands
    >>> shell = Commands()
    # find . -type f | grep .py$ | wc -l
    >>> (shell.find('.', '-type', 'f') | shell.grep('.py$') | shell.wc('-l')).getvalue()
    '9\n'
    # this also works
    >>> pipe = shell.find('.', '-type', 'f')
    >>> pipe |= shell.grep('.py$')
    >>> pipe |= shell.wc('-l')
    >>> pipe.getvalue()
    '9\n'
```


### Handling pipe arguments

When a `Pipe` is called, its arguments are directly passed to `Popen` so beware that strings must be quoted properly.
You can use `getvalue()` to get the output from one pipe and then pass it as a command argument instead of input text.
Pipes are only evaluated when `getvalue()` is called

```python
    >>> license = shell.find('.', '-name', '"LICENSE"').getvalue()
    >>> shell.wc(license).getvalue()
    '  21  169 1069 ./LICENSE\n'
```

## Shell by default

Since pipes run in a shell by default, environment variables evaluate automatically

```python

    >>> pipe = shell.ps('-u $USER')
    >>> pipe |= shell.grep('python')
    >>> pipe |= shell.head('-1')
```

### Configuration options

If you need to run a different shell or disable shell entirely, then you can pass options via environment variables or kwargs to `Pipe`


### Overriding options in `Pipe`

You can override all options to `Popen` (except `stdin`/`stdout`) by passing arguments to `Pipe`
By default `Popen` is run in shell mode with your default shell.

```python
    >>> Pipe('ls', executable='/bin/zsh', cwd='/var', shell=False)
```

### Set env `SHPIPES_NO_SHELL`=true

Sets `shell=False` in the call to `Popen`

### Set env `SHPIPES_SHELL`=/bin/zsh

Changes the executable shell run by `Popen`