semvec/pypi-packages huggingface dataset:
hammit 1.0.2
Package to compute hamming distance between two strings.
Requires Python: >=3.7

# Hammit

Have you ever wanted to calculate the hamming distance between two strings? Well here's a library for that.

## Usage

```
>>> from hammit.distance import distance
>>> distance('123','122')
1 
```

A return value of -1 indicates the hamming distance could not be computed.
package-test-python-estevam 0.0.1
My short description
Requires Python: >=3.8

# package_name

Description. 
The package package_test_python_estevam is used to:
	- 
	-

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_test_python_estevam
```

## Usage

```python
from package_name import file1_name
file1_name.my_function()
```

## Author
Estevam

## License
[MIT](https://choosealicense.com/licenses/mit/)
cronbach 0.6.0
Compute Cronbach's alpha statistic
Requires Python: >=3.7

========
cronbach
========


.. image:: https://img.shields.io/pypi/v/cronbach.svg
        :target: https://pypi.python.org/pypi/cronbach

.. image:: https://img.shields.io/travis/datagazing/cronbach.svg
        :target: https://travis-ci.com/datagazing/cronbach

.. image:: https://readthedocs.org/projects/cronbach/badge/?version=latest
        :target: https://cronbach.readthedocs.io/en/latest/?version=latest
        :alt: Documentation Status



Compute Cronbach's alpha statistic

* Fork of cronbach_alpha from pingouin
* Avoids some later dependencies (such as newer scipy)
* Credit to pingouin for all the initial code

Features
--------

* Works on pandas.DataFrame objects
* Supports pairwise deletion for missing values
* Computes confidence intervals

Examples
--------

.. code-block:: python

  >>> from cronbach import alpha
  >>> alpha(df)
  (0.9503375120540019, array([0.79 , 0.992]))

License
-------

* Free software: GPL-3.0

Documentation
-------------

* https://cronbach.readthedocs.io/

Credits
-------

This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template.

.. _Cookiecutter: https://github.com/audreyr/cookiecutter
.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage
lino-shop 22.11.0
A Lino for managing a webshop


Lino Shop is a customizable management system for web shops.

- Project homepage: https://gitlab.com/lino-framework/shop

- Documentation:
  https://lino-framework.gitlab.io/shop/

- For *introductions* and *commercial information* 
  please see `www.saffre-rumma.net
  <https://www.saffre-rumma.net>`__.
json-to-models 0.0.4
extracts python models from json files
Requires Python: >=3.7

# json to models
 
extracts python models from json files

## usage

- input: [./json_data](https://github.com/tesla-cat/json-to-models/tree/main/json_data)

```cmd
pip install json-to-models
```

```python
from json_to_models import JsonToModels
import glob, json

jtm = JsonToModels(root_name='Root')

for path in glob.glob(f'./json_data/*.json'):
    print(path)
    with open(path) as f:
        data = json.load(f)
    jtm.extract_models(data)   

jtm.write_models()
```

- output: [models.py](https://github.com/tesla-cat/json-to-models/blob/main/models.py)
validir 0.1.0
Directory structure template-based validation.
Requires Python: >=3.7

# validir

A command line Python tool / package for directory validation: making sure a directory structure matches an expected template.

---

## Example Usage

`validir` checks a local directory structure against a YAML template like the following:

```yaml
# contents of template.yaml
flags:                    # top-level flags used during the verification process
  allow_extra: false      # whether or not to consider the presence of extra files and directories an error
  check_hidden: false     # whether or not to check hidden files (i.e. files starting with '.')
root:                     # beginning of expected directory structure
- optional: ["*"]         # we expect a directory called 'optional' which can have anything in it
- whoops: []              # the whoops folder must be present and completely empty
- required:               # the required directory is, well, required
  - metadata:             # the metadata directory is required
    - "*.ext"             # metadata must have the extension .ext ...
    - "sample*"           # ... or start with the keyword "sample"
  - textfiles:            # textfiles is another required directory
    - "text*.txt"         # textfiles must be named text and end with the .txt extension
    - "text*.yaml"        # people can also store corresponding yaml files
  - required.txt          # the required file is required, naturally
```

To verify a local directory against this template, run the following:

```bash
validir validate {DIRECTORY} template.yaml
```

Validir also provides an API to generate templates from a given directory. This is intended as a bootstrapping process which allows users to refine a pre-existing directory structure instead of starting from scratch:

```bash
validir generate {DIRECTORY}
```

For more information about any command line options, call `validir --help`.

---

## Installation

**Via Package Manager**

```bash
python3 -m pip install validir
```

**Via Source**

To install locally, clone this repository and run the following:

```bash
git clone https://github.com/danielmohansahu/validir.git
python3 -m pip install ./validir
```

Installation verification is done via [tox](https://tox.wiki/en/latest/). To run the test suite:

```bash
# from within validir directory
tox
```

## Errata

PEP8 checks:

```bash
pycodestyle --ignore=E201,E202,E203,E266 --max-line-length=100 --indent-size=2 .
```
hissw 2.3
Seamlessly integrate SSWIDL code into your Python workflow
Requires Python: >=3.6
Keywords: solar,sun,ssw,solar-physics,idl,sswidl,solarsoft

# :snake: :sunny: hiss(w)

[![GHA](https://github.com/wtbarnes/hissw/workflows/Deploy%20Docs/badge.svg)](https://github.com/wtbarnes/hissw/actions)
[![PyPI](https://img.shields.io/pypi/v/hissw.svg)](https://pypi.python.org/pypi)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4039915.svg)](https://doi.org/10.5281/zenodo.5519495)


Easily integrate SSWIDL into your Python workflows.
See the [docs](https://wtbarnes.github.io/hissw/) for more info.

## Install

To install hissw,

```shell
$ pip install hissw
```

which will automatically install the package and its dependencies.
hissw depends on the [Jinja2](http://jinja.pocoo.org/docs/dev/) and [scipy](https://docs.scipy.org/doc/) libraries. 
You can also install these manually with [conda](https://www.anaconda.com/download/) or from PyPI, i.e. `pip install <package-name>`.
Additionally, you'll need a local install of IDL and the [Solarsoft library](http://www.lmsal.com/solarsoft/).

Alternatively, you can install hissw from GitHub,

```shell
$ git clone https://github.com/wtbarnes/hissw.git
$ cd hissw && python -m pip install -e[all,test]
```

and then run the tests to make sure everything is working alright. Note that you must specify paths to SSW and IDL appropriately.

```shell
$ pytest --ssw-home=<path to top of SSW tree> --idl-home=<path to top level dir of IDL install>
```

**Note: hissw relies on executing several shell commands. This has not been tested on Windows.**

## Citing `hissw`

If you use `hissw` in your work, please use the following citation,

```bibtex
@software{will_barnes_2022_6640421,
  author       = {Will Barnes and
                  Bin Chen},
  title        = {wtbarnes/hissw: v2.0},
  month        = jun,
  year         = 2022,
  publisher    = {Zenodo},
  version      = {v2.0},
  doi          = {10.5281/zenodo.6640421},
  url          = {https://doi.org/10.5281/zenodo.6640421}
}
```

## Reporting Issues and Contributing

Open an [issue on GitHub](https://github.com/wtbarnes/hissw/issues) to report a problem.
[Pull requests](https://github.com/wtbarnes/hissw/pulls) welcome.
pt-staycool 1.0.2
Tugas kelompok 9 dashprog
Requires Python: >=3.6

<div style="text-align: center;">
    <h1>Tugas Dasprog kelompok 9</h1>
</div> <br>
<h2>Membuat program hitung honor karyawan PT.STAY COOL</h2>
<h3>Anggota kelompok :</h3>
<ul>
    <li>Muhamad Dafa Prasetya <sup>12220563</sup></li>
    <li>Devi Alvandi <sup>12220453</sup> </li>
    <li>Dimas Ajie <sup>12220563</sup> </li>
    <li>Chairil Fajri <sup>12220563</sup> </li>
    <li>Arie Sutiawan <sup>12221429</sup> </li>
</ul>
<h1>Jangan lupa followw!!!</h1>
reactive-uart2ip 0.2.1
TCP server that mediates UART serial communication
Requires Python: >=3.6

# reactive-uart2ip

Application that works as a "bridge" between the Sancus FPGA (through UART) and an external client using TCP/IP. This is implemented with the specific purpose to handle Authentic Execution messages, hence this application is not "general purpose", but strongly dependent to the Sancus application running inside the FPGA.

## Installation

```bash
# Install reactive-uart2ip - you must be in the root of this repository
pip install .

# run reactive-uart2ip
### <loglevel>: log level, e.g., "debug". Default "info"
### <device>: UART device. Default "/dev/ttyUSB1"
### <port>: port used by the app to listen for TCP connections
reactive-uart2ip -l <loglevel> -d <device> -p <port>
```

## Run reactive-uart2ip with Docker

```bash
# Run the reactive-uart2ip Docker image
### <loglevel>, <device> and <port> are the same as above
make run LOG=<loglevel> DEVICE=<device> PORT=<port>
```

## How it works

The application is implemented using `asyncio` tasks.

### Serial task

A first task reads for messages from the **serial** communication. 

- The messages can either be commands or results (see [reactive-net](https://github.com/gianlu33/reactive-net))
- A `Command` received from the device is immediately sent to the destination (ip and port are received as well), and there is **no response**.
  - Sancus only sends `RemoteOutput` commands
- A `Result` of a command previously sent to the device is added to a queue, where the task of the TCP connection that has sent the command will retrieve and send back to the client.

### TCP/IP tasks

For each new TCP connection, an asynchronous task is created, but **only one task at a time** uses the UART (by means of a lock).

- Each TCP connection has the purpose to send a command to the device. If the command expects a result, the task will wait until it is received (without releasing the lock). A timeout is set to avoid endless wait of other tasks, but this should never happen in a normal situation.
- Before starting the transmission of the data, a *handshake* is performed. This is necessary to "wake up" the device, in order not to lose bytes during the transmission. The handshake consists on the exchange of one single dummy byte between the application and the FPGA.
- Since the FPGA has a RX buffer limited to 127 bytes, we need to split large packets in several chunks. In order not to lose any bytes, the FPGA sends an *ACK* byte after each chunk received. The application, after sending the chunk, waits for the ACK, and after that continues the transmission.