usbpdpy 0.1.0__tar.gz

usbpdpy-0.1.0/.gitignore

@@ -0,0 +1,60 @@
+# Rust
+target/
+Cargo.lock
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.coverage
+.pytest_cache/
+.tox/
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# macOS
+.DS_Store
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini

usbpdpy-0.1.0/Cargo.lock

@@ -0,0 +1,171 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "indoc"
+version = "2.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
+
+[[package]]
+name = "libc"
+version = "0.2.175"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ba0117f4212101ee6544044dae45abe1083d30ce7b29c4b5cbdfa2354e07383"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fc6ddaf24947d12a9aa31ac65431fb1b851b8f4365426e182901eabfb87df5f"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "025474d3928738efb38ac36d4744a74a400c901c7596199e20e45d98eb194105"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e64eb489f22fe1c95911b77c44cc41e7c19f3082fc81cce90f657cdc42ffded"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "100246c0ecf400b475341b8455a9213344569af29a3c841d29270e53102e0fcf"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "usbpdpy"
+version = "0.1.0"
+dependencies = [
+ "hex",
+ "pyo3",
+ "pyo3-build-config",
+]

usbpdpy-0.1.0/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "usbpdpy"
+version = "0.1.0"
+edition = "2021"
+authors = ["Danila Gornushko <me@okhsunrog.dev>"]
+license = "MIT"
+description = "Python bindings for the usbpd Rust crate - fast USB Power Delivery message parsing"
+repository = "https://github.com/okhsunrog/usbpdpy"
+homepage = "https://github.com/okhsunrog/usbpdpy"
+keywords = ["usb", "usb-pd", "power-delivery", "protocol", "parsing"]
+categories = ["api-bindings", "parsing", "hardware-support"]
+readme = "README.md"
+
+[workspace]
+# This is an independent workspace
+
+[lib]
+name = "usbpdpy"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.26.0", features = ["extension-module"] }
+hex = "0.4"
+
+[build-dependencies]
+pyo3-build-config = "0.26.0"

usbpdpy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Danila Gornushko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

usbpdpy-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: usbpdpy
+Version: 0.1.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: System :: Hardware :: Universal Serial Bus (USB)
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+License-File: LICENSE
+Summary: Python bindings for the usbpd Rust crate - fast USB Power Delivery message parsing
+Keywords: usb,usb-pd,power-delivery,protocol,parsing,hardware
+Home-Page: https://github.com/okhsunrog/usbpdpy
+Author-email: Danila Gornushko <me@okhsunrog.dev>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/okhsunrog/usbpdpy
+Project-URL: Repository, https://github.com/okhsunrog/usbpdpy
+Project-URL: Issues, https://github.com/okhsunrog/usbpdpy/issues
+Project-URL: Documentation, https://github.com/okhsunrog/usbpdpy#readme
+
+# usbpdpy
+
+Python bindings for the [`usbpd`](https://crates.io/crates/usbpd) Rust crate.
+
+## Installation
+
+```bash
+pip install usbpdpy
+```
+
+## Usage
+
+```python
+import usbpdpy
+
+# Parse message from bytes
+message = usbpdpy.parse_pd_message(b'\x61\x11')
+print(f"Type: {message.header.message_type}")
+print(f"Name: {usbpdpy.get_message_type_name(message.header.message_type)}")
+
+# Convert hex to bytes
+data = usbpdpy.hex_to_bytes("1161")
+message = usbpdpy.parse_pd_message(data)
+```
+
+## API
+
+### Functions
+
+- `parse_pd_message(data: bytes) -> PyPdMessage`
+- `parse_pd_messages(messages: List[bytes]) -> List[PyPdMessage]`
+- `get_message_type_name(msg_type: int) -> str`
+- `hex_to_bytes(hex_str: str) -> bytes`
+- `bytes_to_hex(data: bytes) -> str`
+
+### Classes
+
+**PyPdMessage**
+- `header: PyPdHeader`
+- `data_objects: List[PyPdDataObject]` 
+- `raw_bytes: List[int]`
+- `get_hex() -> str`
+
+**PyPdHeader**
+- `message_type: int`
+- `port_data_role: str` ("UFP"/"DFP")
+- `port_power_role: str` ("Sink"/"Source")
+- `message_id: int`
+- `number_of_data_objects: int`
+- `extended: bool`
+
+**PyPdDataObject**
+- `raw: int`
+- `object_type: str`
+- `parsed_data: Optional[str]`
+
+## Requirements
+
+- Python 3.8+
+- No runtime dependencies
+
+## License
+
+MIT

usbpdpy-0.1.0/README.md

@@ -0,0 +1,64 @@
+# usbpdpy
+
+Python bindings for the [`usbpd`](https://crates.io/crates/usbpd) Rust crate.
+
+## Installation
+
+```bash
+pip install usbpdpy
+```
+
+## Usage
+
+```python
+import usbpdpy
+
+# Parse message from bytes
+message = usbpdpy.parse_pd_message(b'\x61\x11')
+print(f"Type: {message.header.message_type}")
+print(f"Name: {usbpdpy.get_message_type_name(message.header.message_type)}")
+
+# Convert hex to bytes
+data = usbpdpy.hex_to_bytes("1161")
+message = usbpdpy.parse_pd_message(data)
+```
+
+## API
+
+### Functions
+
+- `parse_pd_message(data: bytes) -> PyPdMessage`
+- `parse_pd_messages(messages: List[bytes]) -> List[PyPdMessage]`
+- `get_message_type_name(msg_type: int) -> str`
+- `hex_to_bytes(hex_str: str) -> bytes`
+- `bytes_to_hex(data: bytes) -> str`
+
+### Classes
+
+**PyPdMessage**
+- `header: PyPdHeader`
+- `data_objects: List[PyPdDataObject]` 
+- `raw_bytes: List[int]`
+- `get_hex() -> str`
+
+**PyPdHeader**
+- `message_type: int`
+- `port_data_role: str` ("UFP"/"DFP")
+- `port_power_role: str` ("Sink"/"Source")
+- `message_id: int`
+- `number_of_data_objects: int`
+- `extended: bool`
+
+**PyPdDataObject**
+- `raw: int`
+- `object_type: str`
+- `parsed_data: Optional[str]`
+
+## Requirements
+
+- Python 3.8+
+- No runtime dependencies
+
+## License
+
+MIT

usbpdpy-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "usbpdpy"
+description = "Python bindings for the usbpd Rust crate - fast USB Power Delivery message parsing"
+version = "0.1.0"
+authors = [
+    {name = "Danila Gornushko", email = "me@okhsunrog.dev"},
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research", 
+    "Topic :: System :: Hardware :: Universal Serial Bus (USB)",
+    "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9", 
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+]
+keywords = ["usb", "usb-pd", "power-delivery", "protocol", "parsing", "hardware"]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/okhsunrog/usbpdpy"
+Repository = "https://github.com/okhsunrog/usbpdpy"
+Issues = "https://github.com/okhsunrog/usbpdpy/issues"
+Documentation = "https://github.com/okhsunrog/usbpdpy#readme"
+
+[tool.maturin]
+module-name = "usbpdpy"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=7.0.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0.0",
+]

usbpdpy-0.1.0/src/lib.rs

@@ -0,0 +1,229 @@
+use pyo3::prelude::*;
+use pyo3::types::{PyBytesMethods, PyListMethods};
+
+/// Python wrapper for USB PD Header
+#[pyclass]
+#[derive(Clone, Debug)]
+pub struct PyPdHeader {
+    #[pyo3(get)]
+    pub message_type: u8,
+    #[pyo3(get)]
+    pub port_data_role: String,
+    #[pyo3(get)]
+    pub specification_revision: u8,
+    #[pyo3(get)]
+    pub port_power_role: String,
+    #[pyo3(get)]
+    pub message_id: u8,
+    #[pyo3(get)]
+    pub number_of_data_objects: u8,
+    #[pyo3(get)]
+    pub extended: bool,
+}
+
+#[pymethods]
+impl PyPdHeader {
+    fn __repr__(&self) -> String {
+        format!(
+            "PyPdHeader(type={}, data_role={}, power_role={}, msg_id={}, num_objects={})",
+            self.message_type,
+            self.port_data_role,
+            self.port_power_role,
+            self.message_id,
+            self.number_of_data_objects
+        )
+    }
+
+    fn to_dict(&self, py: Python) -> PyResult<Py<pyo3::PyAny>> {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("message_type", self.message_type)?;
+        dict.set_item("port_data_role", &self.port_data_role)?;
+        dict.set_item("specification_revision", self.specification_revision)?;
+        dict.set_item("port_power_role", &self.port_power_role)?;
+        dict.set_item("message_id", self.message_id)?;
+        dict.set_item("number_of_data_objects", self.number_of_data_objects)?;
+        dict.set_item("extended", self.extended)?;
+        Ok(dict.into())
+    }
+}
+
+/// Python wrapper for USB PD Data Object
+#[pyclass]
+#[derive(Clone, Debug)]
+pub struct PyPdDataObject {
+    #[pyo3(get)]
+    pub raw: u32,
+    #[pyo3(get)]
+    pub object_type: String,
+    #[pyo3(get)]
+    pub parsed_data: Option<String>, // JSON string of parsed data
+}
+
+#[pymethods]
+impl PyPdDataObject {
+    fn __repr__(&self) -> String {
+        format!("PyPdDataObject(type={}, raw=0x{:08x})", self.object_type, self.raw)
+    }
+
+    fn to_dict(&self, py: Python) -> PyResult<Py<pyo3::PyAny>> {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("raw", self.raw)?;
+        dict.set_item("object_type", &self.object_type)?;
+        dict.set_item("parsed_data", &self.parsed_data)?;
+        Ok(dict.into())
+    }
+}
+
+/// Python wrapper for complete USB PD Message
+#[pyclass]
+#[derive(Clone, Debug)]
+pub struct PyPdMessage {
+    #[pyo3(get)]
+    pub header: PyPdHeader,
+    #[pyo3(get)]
+    pub data_objects: Vec<PyPdDataObject>,
+    #[pyo3(get)]
+    pub raw_bytes: Vec<u8>,
+}
+
+#[pymethods]
+impl PyPdMessage {
+    fn __repr__(&self) -> String {
+        format!(
+            "PyPdMessage(type={}, objects={}, raw_len={})",
+            self.header.message_type,
+            self.data_objects.len(),
+            self.raw_bytes.len()
+        )
+    }
+
+    fn to_dict(&self, py: Python) -> PyResult<Py<pyo3::PyAny>> {
+        let dict = pyo3::types::PyDict::new(py);
+        dict.set_item("header", self.header.to_dict(py)?)?;
+        
+        let objects = pyo3::types::PyList::empty(py);
+        for obj in &self.data_objects {
+            objects.append(obj.to_dict(py)?)?;
+        }
+        dict.set_item("data_objects", &objects)?;
+        dict.set_item("raw_bytes", &self.raw_bytes)?;
+        Ok(dict.into())
+    }
+
+    fn get_hex(&self) -> String {
+        hex::encode(&self.raw_bytes)
+    }
+}
+
+/// Parse a USB PD message from raw bytes (simplified version without usbpd crate for now)
+#[pyfunction]
+pub fn parse_pd_message(data: &Bound<'_, pyo3::types::PyBytes>) -> PyResult<PyPdMessage> {
+    let bytes = data.as_bytes();
+    
+    if bytes.len() < 2 {
+        return Err(pyo3::exceptions::PyValueError::new_err("Message too short"));
+    }
+    
+    // Simple parsing - this is a placeholder until we fix the usbpd crate integration
+    let header_word = u16::from_le_bytes([bytes[0], bytes[1]]);
+    
+    let header = PyPdHeader {
+        message_type: (header_word & 0x1F) as u8,
+        port_data_role: if (header_word & 0x20) != 0 { "DFP".to_string() } else { "UFP".to_string() },
+        specification_revision: ((header_word >> 6) & 0x3) as u8,
+        port_power_role: if (header_word & 0x100) != 0 { "Source".to_string() } else { "Sink".to_string() },
+        message_id: ((header_word >> 9) & 0x7) as u8,
+        number_of_data_objects: ((header_word >> 12) & 0x7) as u8,
+        extended: (header_word & 0x8000) != 0,
+    };
+
+    let data_objects = Vec::new(); // Simplified - no data object parsing yet
+    
+    Ok(PyPdMessage {
+        header,
+        data_objects,
+        raw_bytes: bytes.to_vec(),
+    })
+}
+
+/// Parse multiple USB PD messages from a list of byte arrays
+#[pyfunction]
+pub fn parse_pd_messages(messages: &Bound<'_, pyo3::types::PyList>) -> PyResult<Vec<PyPdMessage>> {
+    let mut parsed_messages = Vec::new();
+    
+    for item in messages.iter() {
+        if let Ok(bytes) = item.downcast::<pyo3::types::PyBytes>() {
+            match parse_pd_message(&bytes) {
+                Ok(msg) => parsed_messages.push(msg),
+                Err(e) => {
+                    // Log error but continue with other messages
+                    eprintln!("Warning: Failed to parse message: {}", e);
+                }
+            }
+        }
+    }
+    
+    Ok(parsed_messages)
+}
+
+/// Get message type name from message type number
+#[pyfunction]
+pub fn get_message_type_name(msg_type: u8) -> String {
+    match msg_type {
+        0 => "Reserved".to_string(),
+        1 => "GoodCRC".to_string(),
+        2 => "GotoMin".to_string(),
+        3 => "Accept".to_string(),
+        4 => "Reject".to_string(),
+        5 => "Ping".to_string(),
+        6 => "PS_RDY".to_string(),
+        7 => "Get_Source_Cap".to_string(),
+        8 => "Get_Sink_Cap".to_string(),
+        9 => "DR_Swap".to_string(),
+        10 => "PR_Swap".to_string(),
+        11 => "VCONN_Swap".to_string(),
+        12 => "Wait".to_string(),
+        13 => "Soft_Reset".to_string(),
+        14 => "Data_Reset".to_string(),
+        15 => "Data_Reset_Complete".to_string(),
+        16 => "Not_Supported".to_string(),
+        17 => "Get_Source_Cap_Extended".to_string(),
+        18 => "Get_Status".to_string(),
+        19 => "FR_Swap".to_string(),
+        20 => "Get_PPS_Status".to_string(),
+        21 => "Get_Country_Codes".to_string(),
+        22 => "Get_Sink_Cap_Extended".to_string(),
+        23 => "Get_Source_Info".to_string(),
+        24 => "Get_Revision".to_string(),
+        _ => format!("Unknown({})", msg_type),
+    }
+}
+
+/// Utility function to convert hex string to bytes
+#[pyfunction]
+pub fn hex_to_bytes(hex_str: &str) -> PyResult<Vec<u8>> {
+    hex::decode(hex_str.trim())
+        .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("Invalid hex string: {}", e)))
+}
+
+/// Utility function to convert bytes to hex string
+#[pyfunction]
+pub fn bytes_to_hex(data: &Bound<'_, pyo3::types::PyBytes>) -> String {
+    hex::encode(data.as_bytes())
+}
+
+/// A Python module implemented in Rust for USB PD message parsing
+#[pymodule]
+fn usbpdpy(m: &Bound<'_, pyo3::types::PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(parse_pd_message, m)?)?;
+    m.add_function(wrap_pyfunction!(parse_pd_messages, m)?)?;
+    m.add_function(wrap_pyfunction!(get_message_type_name, m)?)?;
+    m.add_function(wrap_pyfunction!(hex_to_bytes, m)?)?;
+    m.add_function(wrap_pyfunction!(bytes_to_hex, m)?)?;
+    
+    m.add_class::<PyPdMessage>()?;
+    m.add_class::<PyPdHeader>()?;
+    m.add_class::<PyPdDataObject>()?;
+    
+    Ok(())
+}

usbpdpy-0.1.0/tests/test_basic.py

@@ -0,0 +1,136 @@
+"""
+Basic tests for usbpdpy package
+"""
+
+import pytest
+import usbpdpy
+
+
+def test_hex_to_bytes():
+    """Test hex string to bytes conversion"""
+    # Test simple hex string
+    result = usbpdpy.hex_to_bytes("1161")
+    assert result == b'\x11\x61'
+    
+    # Test with spaces (remove spaces first)
+    result = usbpdpy.hex_to_bytes("1161")
+    assert result == b'\x11\x61'
+    
+    # Test empty string
+    result = usbpdpy.hex_to_bytes("")
+    assert result == b''
+
+
+def test_bytes_to_hex():
+    """Test bytes to hex string conversion"""
+    result = usbpdpy.bytes_to_hex(b'\x11\x61')
+    assert result == "1161"
+    
+    result = usbpdpy.bytes_to_hex(b'')
+    assert result == ""
+
+
+def test_get_message_type_name():
+    """Test message type name lookup"""
+    assert usbpdpy.get_message_type_name(1) == "GoodCRC"
+    assert usbpdpy.get_message_type_name(3) == "Accept"
+    assert usbpdpy.get_message_type_name(7) == "Get_Source_Cap"
+    assert "Unknown" in usbpdpy.get_message_type_name(255)
+
+
+def test_parse_pd_message():
+    """Test USB PD message parsing"""
+    # Test GoodCRC message
+    msg_bytes = usbpdpy.hex_to_bytes("1161")
+    message = usbpdpy.parse_pd_message(msg_bytes)
+    
+    assert message.header.message_type == 17  # 0x11 & 0x1F = 17
+    assert message.header.port_data_role in ["UFP", "DFP"]
+    assert message.header.port_power_role in ["Sink", "Source"]
+    assert isinstance(message.header.message_id, int)
+    assert isinstance(message.header.number_of_data_objects, int)
+    assert isinstance(message.header.extended, bool)
+    assert len(message.raw_bytes) == 2
+    assert message.get_hex() == "1161"
+
+
+def test_parse_pd_message_error():
+    """Test error handling for invalid messages"""
+    with pytest.raises(ValueError):
+        usbpdpy.parse_pd_message(b'')  # Too short
+    
+    with pytest.raises(ValueError):
+        usbpdpy.parse_pd_message(b'\x00')  # Too short
+
+
+def test_parse_pd_messages():
+    """Test parsing multiple messages"""
+    messages = [b'\x11\x61', b'\x01\x43']
+    result = usbpdpy.parse_pd_messages(messages)
+    
+    assert len(result) == 2
+    assert all(hasattr(msg, 'header') for msg in result)
+    assert all(hasattr(msg, 'data_objects') for msg in result)
+
+
+def test_hex_to_bytes_error():
+    """Test error handling for invalid hex strings"""
+    with pytest.raises(ValueError):
+        usbpdpy.hex_to_bytes("invalid_hex")
+    
+    with pytest.raises(ValueError):
+        usbpdpy.hex_to_bytes("11G1")  # Invalid hex character
+
+
+def test_message_attributes():
+    """Test that message objects have expected attributes"""
+    msg_bytes = usbpdpy.hex_to_bytes("1161")
+    message = usbpdpy.parse_pd_message(msg_bytes)
+    
+    # Test header attributes
+    header = message.header
+    assert hasattr(header, 'message_type')
+    assert hasattr(header, 'port_data_role')
+    assert hasattr(header, 'specification_revision')
+    assert hasattr(header, 'port_power_role')
+    assert hasattr(header, 'message_id')
+    assert hasattr(header, 'number_of_data_objects')
+    assert hasattr(header, 'extended')
+    
+    # Test message attributes
+    assert hasattr(message, 'header')
+    assert hasattr(message, 'data_objects')
+    assert hasattr(message, 'raw_bytes')
+    
+    # Test methods
+    assert callable(message.get_hex)
+    assert callable(message.to_dict)
+
+
+def test_integration():
+    """Integration test with multiple operations"""
+    # Test complete workflow
+    test_messages = ["1161", "0143", "0744"]
+    
+    parsed_messages = []
+    for hex_msg in test_messages:
+        msg_bytes = usbpdpy.hex_to_bytes(hex_msg)
+        parsed_msg = usbpdpy.parse_pd_message(msg_bytes)
+        parsed_messages.append(parsed_msg)
+    
+    assert len(parsed_messages) == 3
+    
+    # Verify each message
+    for i, msg in enumerate(parsed_messages):
+        assert msg.get_hex() == test_messages[i].lower()
+        type_name = usbpdpy.get_message_type_name(msg.header.message_type)
+        assert isinstance(type_name, str)
+        assert len(type_name) > 0
+
+
+if __name__ == "__main__":
+    # Run basic smoke test
+    test_hex_to_bytes()
+    test_parse_pd_message()
+    test_integration()
+    print("✅ All basic tests passed!")