semvec/pypi-packages huggingface dataset:
EBRPIH1118 0.1.4
A Python package to interface with the board, and control relays, digital inputs/outputs, and analog inputs on Raspberry Pi.
Requires Python: >=3.6

# EBRPIH1118

![EBRPIH1118](https://raw.githubusercontent.com/electronbits/Py_EBRPIH1118/main/ebrpih1118.jpg)

`EBRPIH1118` is a Python package designed to facilitate the control of hardware resources such as relays, digital inputs (DI), digital outputs (DO), analog inputs (AI), and temperature sensors on a Raspberry Pi. This package provides a convenient API to interact with GPIO pins and SPI devices, making it easy to develop automation applications on the Raspberry Pi.

## Features

- **Relay Control**: Easily manage relays connected to the Raspberry Pi GPIO pins.
- **Digital Input/Output**: Read from and write to digital input/output pins.
- **Analog Input**: Read analog sensor data using SPI interface.
- **Temperature Sensor Integration**: Read data from 1-wire temperature sensors.
- **Flexible Hardware Management**: Abstract hardware interaction with a clean, easy-to-use API.

## Installation

You can install `EBRPIH1118` using pip. Ensure you have the necessary Python libraries for GPIO and SPI communication.

### Prerequisites

Before installing `EBRPIH1118`, ensure that your Raspberry Pi is set up with the following libraries:

```bash
sudo apt-get update
sudo apt-get install python3-pip python3-rpi.gpio python3-spidev
```

# Installing the Package
```bash
pip install EBRPIH1118
```

# Usage
## Importing the Package
from EBRPIH1118_intf import ebrpih1118

# Example usage
```python
from EBRPIH1118_intf import ebrpih1118

# Initialize GPIO and SPI
hardware_manager = ebrpih1118.EBRPIH1118()

# Example: Turn on relay #1
hardware_manager.energize_relay(relay_number=1)

# Example: Read an analog input from channel 1 to 4 (SPI)
analog_value = hardware_manager.read_ai_channels(channels="1,2,3,4")
print(f"Analog Input Values: {analog_value}")

# Cleanup after operations
hardware_manager.cleanup()
```



# Steps to Contribute
Fork the repository.
Create a new branch for your feature or bug fix.
Make your changes.
Submit a pull request to the main repository.

# License
This project is licensed under the MIT License - see the LICENSE file for details.

# Acknowledgments
 - This package uses the RPi.GPIO library for GPIO control.
 - It also uses the spidev library for SPI communication.

# More Information

For more details, visit our website: [www.electronbits.com](https://www.electronbits.com)
ahsoka 0.0.2
A pipeline for JWST near-IR transiting exoplanet data
Requires Python: >=3.9

<img src="ahsoka_logo.png">

# Ahsoka

Developing a pipeline for JWST near-IR transiting exoplanet data


## Installation

The latest version of Ahsoka can be installed directly with pip:

`pip install ahsoka`

To install a development version:

    Clone the repository:  
    `git clone https://github.com/Witchblade101/ahsoka`
        or
    `git@github.com:Witchblade101/ahsoka.git`

    Install ahsoka:  
    `cd ahsoka`  
    `pip install .`

    Install in Develop Mode
    `pip install -e .`
anms-ace 1.0.1
ADM CODEC Engine
Requires Python: >=3.7

<!--
Copyright (c) 2023 The Johns Hopkins University Applied Physics
Laboratory LLC.

This file is part of the Asynchronous Network Managment System (ANMS).

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

This work was performed for the Jet Propulsion Laboratory, California
Institute of Technology, sponsored by the United States Government under
the prime contract 80NM0018D0004 between the Caltech and NASA under
subcontract 1658085.
-->
# ACE Tools
This is the AMM CODEC Engine (ACE) for the DTN Management Architecture (DTNMA).
It is part of the larger Asynchronous Network Managment System (ANMS) managed for [NASA AMMOS](https://ammos.nasa.gov/).

It is a library to manage the information in DTNMA Application Data Models (ADMs) and use that information to encode and decode DTNMA Application Resource Identifiers (ARIs) in:
 * Text form based on [URI encoding](https://www.rfc-editor.org/rfc/rfc3986.html)
 * Binary form based on [CBOR encoding](https://www.rfc-editor.org/rfc/rfc9052.html)

It also includes an `ace_ari` command line interface (CLI) for translating between the two ARI forms.

## Development

To install development and test dependencies for this project, run from the root directory (possibly under sudo if installing to the system path):
```sh
pip3 install -r <(python3 -m piptools compile --extra test pyproject.toml 2>&1)
```

To install the project itself from source run:
```
pip3 install .
```

An example of using the ARI transcoder, from the source tree, to convert from text to binary form is:
```
echo 'ari:/IANA:ion_admin/CTRL.node_contact_add(UVAST.1685728970,UVAST.1685729269,UINT.2,UINT.2,UVAST.25000,UVAST.1)' | PYTHONPATH=./src ADM_PATH=./tests/adms python3 -m ace.tools.ace_ari --inform=text --outform=cborhex
```
which will produce a hexadecimal output:
```
0xC1188D410605061616141416161A647A2ECA1A647A2FF502041961A801
```

## Contributing

To contribute to this project, through issue reporting or change requests, see the [CONTRIBUTING](CONTRIBUTING.md) document.
sniperpy 1.0.1
A Python package to analyze SMB2 packets from pcap files
Requires Python: >=3.6

# Sniperpy: SMB2 Packet Analyzer
`sniperpy` is a Python package designed to extract and analyze SMB2 packets from PCAP files. It helps security engineers quickly retrieve relevant SMB2 data like Create and Close requests/responses from packet captures.

# Features
- Extract SMB2 Create and Close requests/responses from PCAP files.
- Parse and analyze metadata (source/destination IPs, ports).
- Save extracted metadata as a JSON file.

# Installation
You can install `sniperpy` using `pip`:
```
pip install sniperpy
```

# Usage
After installing the package, you can import it and use the functions provided to work with SMB2 packets in your PCAP files.

### Example Code
```
from sniperpy import extract_smb_packets, parse_smb_packets, save_extracted_files, SMBExtractorError

# Specify the path to your pcap file
pcap_file = "path_to_your_pcap_file.pcap"

try:
    # Extract SMB packets from the PCAP
    smb_packets = extract_smb_packets(pcap_file)

    # Parse SMB packet metadata
    metadata = parse_smb_packets(smb_packets)

    # Optionally, save the metadata to a JSON file
    save_extracted_files(metadata, output_dir="output_directory")

    # Print metadata to the console
    for entry in metadata:
        print(entry)

except SMBExtractorError as e:
    print(f"An error occurred: {e}")
```

### Example output
```
{
    "Packet Type": "SMB2 Create Request",
    "Source IP": "192.168.1.100",
    "Source Port": 445,
    "Destination IP": "192.168.1.101",
    "Destination Port": 139
}
```
# Functions Overview
- `extract_smb_packets(pcap_file)`: Extracts SMB2 packets from the provided pcap file.
- `parse_smb_packets(smb_packets)`: Parses SMB2 packets to extract metadata (IP addresses, ports, etc.).
- `save_extracted_files(metadata, output_dir)`: Saves the parsed metadata as a JSON file in the specified output directory.
- `SMBExtractorError`: Custom exception to handle errors related to SMB packet extraction and parsing.
pohlednice 0.2.1
Pythonic implementation of the 'postcard' wire format
Requires Python: <4.0,>=3.12

# Pohlednice

Pohlednice is a pythonic implementation of the [postcard](https://postcard.jamesmunns.com/) wire format.

## Usage

Variable integer:
```python
from pohlednice import I16, I32

I16.to_bytes(400) // a byte iterator
bytes(I16.to_bytes(400)) // transform into bytes

// or chain multiple
chain(I16.to_bytes(3600), I32.to_bytes(55))

// read from a byte iterable
number I16.from_bytes([1])
```

De/Serialize Structure:
```python
from pohlednice import Struct, U16, String, Option, ByteArray

class ABC(Struct):
    a: U16
    b: String
    c: Option[ByteArray]


payload = bytes(ABC.to_bytes(ABC(40, 'Trollě', None)))

abc = ABC.from_bytes(payload)
```

De/Serialize Enum:
```python
class Color(Enum):
    Red: None
    Blue: None
    Green: None
    Custom: Tuple[U8, U8, U8]

payload = Color.to_bytes(Color.Custom((0xff, 0xf0, 0x0f)))
color = Color.from_bytes(payload)
```
slowstack-plus 1.0.0
Epic's Slowstack lib but with python 3.8+ support.
Requires Python: >=3.8

> [!NOTE]
> A fork of Epic's [Slowstack](https://github.com/TAG-Epic/slowstack) lib but with python 3.8+ support *and it's probably unstable*. 
> Create an issue if you find any bugs but that aren't present in the official.

# Slowstack
Fuck it, overkill all the way.

A rate limiting library for stacking multiple rate limiters on top of each other in an efficient way.