semvec/pypi-packages huggingface dataset:
tfluna-driver 0.1.0
Code to read measurements from a Tf-Luna LiDAR sensor.
Requires Python: >=3.6

# TF-Luna LiDAR Python Driver

The [TF-Luna sensor](https://www.dfrobot.com/product-1995.html) is a LiDAR sensor, which can be read either with I2C or Serial.

This repository contains the code permitting to use the TF-Luna sensor with the serial interface.

This repository is a fork of [tfluna-python](https://github.com/makerportal/tfluna-python), and is a rewrite of the driver to a class-based structure.
The new code is also more careful when it comes to handling the serial interface: this driver is indeed intended to be used (only) as a Python resource, i.e. as follows (more details in the `example` folder):

```
import tfluna
import timeout_decorator

with tfluna.TfLuna(baud_speed=115200, serial_name="/dev/serial0") as tfluna:
    tfluna.get_version()
    tfluna.set_samp_rate(10)
    #tfluna.set_baudrate(57600) # can be used to change the baud_speed
    distance,strength,temperature = tfluna.read_tfluna_data() 
```

### - TF-Luna + Raspberry Pi Wiring - 

The TF-Luna can be wired to the Raspberry Pi via the mini UART port:

![TF-Luna RPi Wiring](https://static1.squarespace.com/static/59b037304c0dbfb092fbe894/t/6009f277b8566661c36dfa67/1611264637375/TF_luna_RPi_wiring.png?format=1500w)
tfluna-clementnuss 0.1.0
Code to read measurements from a Tf-Luna LiDAR sensor.
Requires Python: >=3.6

# TF-Luna LiDAR with Raspberry Pi
Python codes for configuring and reading the TF-Luna Light Detection And Ranging (LiDAR) module interfaced with a Raspberry Pi computer.

Tutorial: https://makersportal.com/blog/distance-detection-with-the-tf-luna-lidar-and-raspberry-pi

Buy a TF-Luna from our Store: https://makersportal.com/shop/tf-luna-lidar-module

#

### - TF-Luna + Raspberry Pi Wiring - 

The TF-Luna can be wired to the Raspberry Pi via the mini UART port:

![TF-Luna RPi Wiring](https://static1.squarespace.com/static/59b037304c0dbfb092fbe894/t/6009f277b8566661c36dfa67/1611264637375/TF_luna_RPi_wiring.png?format=1500w)

---
### - TF-Luna Ranging Test - 

The script entitled 'tfluna_test_plot.py' outputs a plot similar to the following:

![TF-Luna Ranging Test](./images/tfluna_test_plot_white.png)

---
### - Real-Time Ranging Visualization - 

The script entitled 'tfluna_test_realtime.py' outputs a real-time output of distance and signal strength, similar to the following:

![TF-Luna Real-Time Ranging](./images/tfluna_realtime_plot_white.png)
fasmga 1.0.11
Python Fasm.ga API wrapper
Requires Python: >=3.6

# fasmga - Fasm.ga Python API wrapper
This is the official PyPI module for the [Fasm.ga Python API wrapper](https://www.fasm.ga/developer/wrappers/python).

### Terms and Conditions
You can use this code without paying anything, but you have to add [this](https://github.com/fasm-ga/fasmga-python-wrapper/blob/main/LICENSE) license.

### Documentation and Examples
You can find the documentation and the examples [here](https://github.com/fasm-ga/fasmga-python-wrapper/wiki).

### We respect licenses. See packages' licenses [here](https://github.com/fasm-ga/fasmga-python-wrapper/blob/main/other-licenses).
VirtualKey 0.0.5
VirtualKey with ctypes. 更新避免lol的屏蔽
Requires Python: >=3.6

# Driver level key simulation.
## Implementation based on CTypes.
# 驱动级按键模拟。
## 基于ctypes实现。

[案例【example】](https://github.com/bode135/VirtualKey_with_Ctypes/blob/master/example.py)

> Compared to the [`Pydamo`](https://github.com/bode135/pydamo "jump to the pydamo project") scheme(I don't know how to do this with ctypes), the CTypes scheme does not support background emulation, but supports 64-bit Python.

> ctypes方案对比[`pydamo`](https://github.com/bode135/pydamo "jump to the pydamo project")方案(我不知道怎么用ctypes做后台)，不支持后台模拟，但支持64位python。
tridu33ml 0.0.1
tridu33 Learn Write ML Frame
Requires Python: >=3.6

tridu33 Learn Write a Machine learning framework:.

it is a Coursework in kaikeba .

after ` pip install tridu33ml`,then `pip list`this is a test about Boston price: 

```python
#boston.py
import numpy as np
from sklearn.datasets import load_boston
from sklearn.utils import shuffle, resample
#from miniflow import *

# Load data
data = load_boston()
X_ = data['data']
y_ = data['target']

# Normalize data
X_ = (X_ - np.mean(X_, axis=0)) / np.std(X_, axis=0)

n_features = X_.shape[1]
n_hidden = 10
W1_ = np.random.randn(n_features, n_hidden)
b1_ = np.zeros(n_hidden)
W2_ = np.random.randn(n_hidden, 1)
b2_ = np.zeros(1)


from tridu33ml.nn import core
from tridu33ml.utils import utilities
# Neural network
X, y = core.Placeholder(), core.Placeholder()
W1, b1 = core.Placeholder(), core.Placeholder()
W2, b2 = core.Placeholder(), core.Placeholder()

l1 = core.Linear(X, W1, b1)
s1 = core.Sigmoid(l1)
l2 = core.Linear(s1, W2, b2)
cost = core.MSE(y, l2)

feed_dict = {
    X: X_,
    y: y_,
    W1: W1_,
    b1: b1_,
    W2: W2_,
    b2: b2_
}

epochs = 5000
# Total number of examples
m = X_.shape[0]
batch_size = 16
steps_per_epoch = m // batch_size

graph = utilities.topological_sort_feed_dict(feed_dict)
trainables = [W1, b1, W2, b2]

print("Total number of examples = {}".format(m))



losses = []

for i in range(epochs):
    loss = 0
    for j in range(steps_per_epoch):
        # Step 1
        # Randomly sample a batch of examples
        X_batch, y_batch = resample(X_, y_, n_samples=batch_size)

        # Reset value of X and y Inputs
        X.value = X_batch
        y.value = y_batch

        # Step 2
        _ = None
        utilities.forward_and_backward(graph) # set output node not important.

        # Step 3
        rate = 1e-2
    
        utilities.optimize(trainables, rate)

        loss += graph[-1].value
    
    if i % 100 == 0: 
        print("Epoch: {}, Loss: {:.3f}".format(i+1, loss/steps_per_epoch))
        losses.append(loss/steps_per_epoch)



```

 run the test :

```
python boston.py
```

then you will see the training result.
metaloader 0.4.0
A configurable pipeline for loading data files
Requires Python: >=3.7

# Metaloader: A Configuration File Loader and Preprocessor

This package offers a highly configurable pipeline for loading complex configuration file hierarchies.

It provides abstractions for several stages in the configuration loading pipeline:

 - Filesystems: Files could be stored on any kind of filesystem - Local, Amazon S3, FTP etc.
 - Serialisations: Files could be in any number of formats - JSON, YAML etc.
 - Directives: Files can contain special "preprocessor directives" - Imports, Macros etc.
 - Stanza Handlers: Different top-level stanzas in the files may need to be handled and merged in a special way, or validated.
convbnmerge 0.1.6
One-clicked merge convolution and batchnorm to one unified convolution

# Convolution Batchnorm Merge

Only one line of code and we can accelerate your model up to 50% faster! 

## Installation
```
$ pip install convbnmerge
```

## Usage
`conv-bn-merge` is <b>ONLY</b> used in inference time!
```python
from convbnmerge import merge

model = ...
"""
training...
"""
merge(model)
```

## Update
* 2021.18.04: support ConvTranspose2d and ConvTranspose3d
* 2021.02.04: also support Conv3d


## How much fast
You usually reach 30++% inferece time reduce. In some cases, the number is more than 50%! 
```python
from time import time

import torch
from torchvision.models.resnet import resnet34

from convbnmerge import merge

if __name__ == '__main__':
    model = resnet34(pretrained=True)
    x = torch.Tensor(2, 3, 32, 32)

    with torch.no_grad():
        start = time()
        for i in range(100):
            model(x)
        stop = time()
        print(stop - start)             # Before merge: about 7.9s
    
    merge(model)

    with torch.no_grad():
        start = time()
        for i in range(100):
            model(x)
        stop = time()
        print(stop - start)             # After merge: about 4.8s
```

## How we do
Coming soon

## Are outputs the same before and after merge?
A small difference caused by round-off error. In almost cases, it doesn't harm the model's result.
```python
import torch
from torchvision.models.resnet import resnet34

from convbnmerge import merge

if __name__ == '__main__':
    model = resnet34(pretrained=True)
    model.eval()
    x = torch.Tensor(1, 3, 32, 32)
    out_old = model(x)
    merge(model)
    out_new = model(x)
    print(((out_old-out_new)**2).sum())         #less than 1e-10 
```

## License
`conv-bn-merge` is MIT-licensed.
Elite 1.1.1
A lightweight module for elliptic-curve security schemes.
Requires Python: >=3

# Elite v1.1.1

A lightweight module for elliptic-curve security schemes.

*Repository: https://github.com/origamizyt/Elite*

---

## 1. Installation

This module is available on PyPI, which you can install by running the command below:
```
pip install Elite
```

The source code is also available on Github.

## 2. Usage

### 2.1 Concepts

There are a few concepts you need to know before coping with this module. Otherwise you may get lost in the usage and description. You'll need to you what is a:

- **Scheme**. A security scheme is an object which encapsulates the standard procedures in its methods and provides simple interfaces to operate with.
- **Cryptography Provider**. A crypto provider is an instance which manages the symmetric algorithm part of the scheme.

### 2.2 Basic usage

For top-level functionalities, you can instantiate an instance of a scheme either by calling `getscheme` or directly create an instance. However, it's recommended that beginners use the `getscheme` method:
```py
import elite
# server side
s = elite.getscheme()
# client side
c = elite.getscheme()
```

After instantiating a scheme, you can export your local public key or import remote key by calling the following methods:
```py
# binary version
c.importBinaryKey(s.exportBinaryKey())
# hex version
s.importHexKey(c.exportHexKey())
```

After loading the keys, a shared secret should now be established. Call the `secret` method to generate a shared secret. The two secrets should be the same.
```py
# should be the same
print(s.secret())
print(c.secret())
```

Sign / Verify data via the `sign` / `verify` method:
```py
signature = s.sign(b'data')
assert c.verify(b'data', signature)
```

Encrypt / Decrypt data via the `encrypt` / `decrypt` method:
```py
data = s.encrypt(b'data')
assert b'data' == c.decrypt(data)
```

> *NOTE*: a scheme can only verify / decrypt data from the other side. Don't try to verify / decrypt data generated by yourself.

### 2.3 Advanced usage

For mid-level programmers, you could try instantiating the schemes directly. They are in the `scheme` submodule.
```py
from elite.scheme import P384r1AesGcmScheme
# secp384r1 with AES_GCM
s = P384r1AesGcmScheme()
c = P384r1AesGcmScheme()
```

For high-level programmers, you can instantiate the `ECCScheme` class to create your own schemes:
```py
from elite.scheme import ECCScheme
from elite.cipher import getprovider
from elite.secret import CurveKind

s = ECCScheme(CurveKind.CK_SECP256K1, getprovider())
```

You can test the module using unittest:
```
$ python -m unittest elite.test --verbose
```

For deeper usage, please view the source code.