semvec/pypi-packages huggingface dataset:
nodejs-eval 0.0.5
Evaluate arbitrary JavaScript from Python using a NodeJS sidecar
Requires Python: >=3.8

# NodeJS Eval

Evaluate arbitrary JavaScript from Python, using a NodeJS sidecar process.

This combines:

- The Python [`nodejs-bin`](https://pypi.org/project/nodejs-bin/) project, which
  bundles NodeJS (with `npm` and `npx`) into a PyPI package, and
- The JavaScript/TypeScript
  [`http-eval`](https://www.npmjs.com/package/http-eval) project, which runs a
  JavaScript evaluation server on a Unix domain socket.

[![PyPI - Version](https://img.shields.io/pypi/v/nodejs-eval.svg)](https://pypi.org/project/nodejs-eval)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/nodejs-eval.svg)](https://pypi.org/project/nodejs-eval)

______________________________________________________________________

**Table of Contents**

- [Installation](#installation)
- [License](#license)
- [Usage instructions](#usage-instructions)

## Installation

```console
pip install nodejs-eval
```

## License

`nodejs-eval` is distributed under the terms of the
[MIT](https://spdx.org/licenses/MIT.html) license.

## Usage instructions

### Basic synchronous call

JavaScript code is evaluated as a function body within a synchronous or
asynchronous JavaScript function, within an ECMAScript module.

Note that the NodeJS evaluator always only supports `async` mode on the Python
side. However, the supplied JavaScript code can be either sync or async.

```python
    from nodejs_eval import evaluator

    async with evaluator() as e:
        result = await e.run("return 6*7;")
        assert result == 42
```

### Basic asynchronous call

```python
    from nodejs_eval import evaluator

    async with evaluator() as e:
        result = await e.run_async(
            """
await new Promise(r => setTimeout(r, 2000));
return 6*7;
""")
        assert result == 42
```

### Storing state on `this`

Evaluations run with a consistent JavaScript `this` context, so state can be
stored on it:

```python
    from nodejs_eval import evaluator

    async with evaluator() as e:
        await e.run("this.x = 6*7;")
        result = await e.run("return this.x;")
        assert result == 42
```

### Import using dynamic `await import()`

Because code is executed within an ECMAScript module, you can use
[the dynamic async `import()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import)
to import other modules.

This is easiest done in `async` mode:

```python
    from nodejs_eval import evaluator

    async with evaluator() as e:
        result = await e.run_async(
            """
const os = await import("os");
return os.cpus();
"""
        )
        assert len(result) > 0
```
pyMSO4 1.0
Tektronix MSO4 VISA library
Requires Python: >=3.10

# pyMSO4
A python library for interfacing with the Tektronix MSO4 oscilloscopes (tested
with MSO44).

## Installation
```bash
pip install pyMSO4
```

## Usage
Connect the probe on channel 1 to the calibration square wave output, and press
the Autoset button, the following code will capture a trace of the signal as
seen on the oscilloscope screen:

```python
import pyMSO4
mso44 = pyMSO4.MSO4(trig_type=pyMSO4.MSO4EdgeTrigger)
mso44.con(ip="128.181.240.130") # Using p2p ethernet connection
mso44.ch_a_enable([True, False, False, False]) # Enable channel 1
mso44.acq.wfm_src = ['ch1'] # Set waveform source to channel 1
mso44.acq.wfm_start = 0
mso44.acq.wfm_stop = mso44.acq.horiz_record_length # Get all data points
wfm = mso44.sc.query_binary_values('CURVE?', datatype=mso44.acq.get_datatype(), is_big_endian=mso44.acq.is_big_endian)
mso44.dis()
```

Additional examples can be found in the [documentation][1].

## Documentation
Sphinx documentation is available [here][1].

## Got root?
If you're here because you think it's fun to get root on an oscilloscope, see
Appendix C of the
[report](https://github.com/ceres-c/pyMSO4/blob/master/report/report.pdf)
for the details.

[1]: https://ceres-c.it/pyMSO4/
bitheap-gateway-client 0.1.0
A Bitcoin gateway client for generating QR codes for payments in shops

# BitHeap Gateway Python Client

The `bitheap_gateway_client` is a Python package designed for e-commerce and retail platforms to facilitate Bitcoin payments. It simplifies the process of integrating Bitcoin payment functionality, including generating QR codes for Bitcoin transactions.

## Features

- Request Bitcoin payments with QR code generation.
- Check the status of Bitcoin payments.
- Execute payouts in Bitcoin.
- Retrieve a seller's Bitcoin balance.

## Installation

To install `bitheap_gateway_client`, simply use pip:

```bash
pip install bitheap_gateway_client
```

## Usage
Here's how to use the bitheap_gateway_client in your Python project:

### Importing the Client

```python
from bitheap_gateway_client.client import BitHeapGatewayClient
```

### Requesting a Payment


```python
response = BitHeapGatewayClient.request_payment('expect', 'currency', 'message', 'seller', 'customer', 'callback_url', 'account_id')
print(response.json())
```

### Checking Payment Status

```python
response = BitHeapGatewayClient.check_payment('address')
print(response.json())
```

### Processing a Payout

```python
response = BitHeapGatewayClient.payout('seller', 'amount', 'currency', 'address', 'account_id')
print(response.json())
```

### Getting Seller's Balance

```python
response = BitHeapGatewayClient.get_seller_balance('seller')
print(response.json())
```

## Contributions
Contributions are welcome! Please feel free to submit pull requests or open issues to improve the functionality or efficiency of this package.

## License
This project is licensed under the MIT License - see the LICENSE file for details.
rsa-crypto-python 2.0.4
A package that implements assymetric encryption and description using rsa
Requires Python: >=3.8

# RSA Encryption Python Package

A Python package for asymmetric encryption using RSA.

## Installation

```bash
pip install rsa-crypto-python
```

## Usage

```python
from rsa_crypto_python.rsa_crypto_python import RSAEncryption

# Create an instance of the RSAEncryption class

rsa = RSAEncryption()
# rsa = RSAEncryption(env_file_path=None)


# crypt private_to_public
original_text = 'Hello, this is a secret message!'
encrypted_text = rsa.encrypt_with_private_key(original_text)
print('Encrypted Text:', encrypted_text)


decrypted_text = rsa.decrypt_with_public_key(encrypted_text)
print('Decrypted Text:', decrypted_text)

# crypt public_to_private
original_text = 'Hello, this is a secret message!'
encrypted_text = rsa.encrypt_with_public_key(original_text)
print('Encrypted Text:', encrypted_text)


decrypted_text = rsa.decrypt_with_private_key(encrypted_text)
print('Decrypted Text:', decrypted_text)
```

## Configuration
Set your public and private key paths in a .env file:
```bash
PUBLIC_KEY_PATH=/path/to/your/keys/public_key.pem
PRIVATE_KEY_PATH=/path/to/your/keys/private_key.pem
```

### To generate keys
Generate Private Key
```bash
openssl genpkey -algorithm RSA -out keys/private_key.pem
```

Generate Public Key
```bash
openssl rsa -pubout -in keys/private_key.pem -out keys/public_key.pem
```


## Contributing

1. Fork the repository
2. Create a new branch (`git checkout -b feature/awesome-feature`)
3. Commit your changes (`git commit -am 'Add awesome feature'`)
4. Push to the branch (`git push origin feature/awesome-feature`)
5. Create a new Pull Request

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

- Thanks to the cryptography library for providing the tools for secure communication.

## Author

Ukweh Everest

## Contact

For any inquiries, please contact [exrelativity@gmail.com].