pykeramics 0.0.0__tar.gz

pykeramics-0.0.0/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+authors.workspace = true
+description = "Keramics Python bindings"
+edition.workspace = true
+license.workspace = true
+name = "keramics-python"
+repository.workspace = true
+version.workspace = true
+
+[lib]
+name = "pykeramics"
+crate-type = ["cdylib"]
+
+[dependencies]
+keramics-datetime = { version = "0.0.0", path = "../keramics-datetime" }
+keramics-vfs = { version = "0.0.0", path = "../keramics-vfs" }
+pyo3 = { version = "0.26.0", features = ["extension-module"] }

pykeramics-0.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include Cargo.toml pyproject.toml
+recursive-include src *

pykeramics-0.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pykeramics
+Version: 0.0.0
+License: "Apache-2.0"
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Rust
+Requires-Python: >=3.8

pykeramics-0.0.0/pyproject.toml

@@ -0,0 +1,2 @@
+[build-system]
+requires = ["setuptools>=41.0.0", "wheel", "setuptools_rust>=1.0.0"]

pykeramics-0.0.0/setup.cfg

@@ -0,0 +1,16 @@
+[metadata]
+name = pykeramics
+version = 0.0.0
+license = "Apache-2.0"
+classifiers = 
+	Development Status :: 2 - Pre-Alpha
+	Programming Language :: Python
+	Programming Language :: Rust
+
+[options]
+python_requires = >=3.8
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pykeramics-0.0.0/setup.py

@@ -0,0 +1,25 @@
+# Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+#
+# 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 https://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.
+
+import os
+
+from setuptools import setup
+from setuptools_rust import RustExtension
+
+setup(
+    rust_extensions=[
+        RustExtension(
+            "pykeramics",
+            debug=os.environ.get("BUILD_DEBUG") == "1",
+        )
+    ],
+)

pykeramics-0.0.0/src/datetime.rs

@@ -0,0 +1,113 @@
+/* Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+ *
+ * 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 https://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.
+ */
+
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyNone};
+
+use keramics_datetime::{DateTime, Filetime, PosixTime32, PosixTime64Ns};
+
+pub struct PyDateTime {}
+
+impl PyDateTime {
+    pub fn new(date_time: &DateTime) -> PyResult<Py<PyAny>> {
+        Python::attach(|py| -> PyResult<_> {
+            match date_time {
+                DateTime::Filetime(filetime) => {
+                    let py_filetime: PyFiletime = PyFiletime {
+                        filetime: filetime.clone(),
+                    };
+                    Ok(Py::new(py, py_filetime)?.into_any())
+                }
+                DateTime::NotSet => {
+                    let py_none: Borrowed<'_, '_, PyNone> = PyNone::get(py);
+                    Ok(py_none.to_owned().unbind().into_any())
+                }
+                DateTime::PosixTime32(posix_time) => {
+                    let py_posix_time: PyPosixTime32 = PyPosixTime32 {
+                        posix_time: posix_time.clone(),
+                    };
+                    Ok(Py::new(py, py_posix_time)?.into_any())
+                }
+                DateTime::PosixTime64Ns(posix_time) => {
+                    let py_posix_time: PyPosixTime64Ns = PyPosixTime64Ns {
+                        posix_time: posix_time.clone(),
+                    };
+                    Ok(Py::new(py, py_posix_time)?.into_any())
+                }
+                _ => {
+                    todo!();
+                }
+            }
+        })
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "Filetime")]
+#[derive(Clone)]
+struct PyFiletime {
+    filetime: Filetime,
+}
+
+#[pymethods]
+impl PyFiletime {
+    #[getter]
+    pub fn timestamp(&self) -> PyResult<u64> {
+        Ok(self.filetime.timestamp)
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "PosixTime32")]
+#[derive(Clone)]
+struct PyPosixTime32 {
+    posix_time: PosixTime32,
+}
+
+#[pymethods]
+impl PyPosixTime32 {
+    #[getter]
+    pub fn timestamp(&self) -> PyResult<i32> {
+        Ok(self.posix_time.timestamp)
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "PosixTime64Ns")]
+#[derive(Clone)]
+struct PyPosixTime64Ns {
+    posix_time: PosixTime64Ns,
+}
+
+#[pymethods]
+impl PyPosixTime64Ns {
+    #[getter]
+    pub fn fraction(&self) -> PyResult<u32> {
+        Ok(self.posix_time.fraction)
+    }
+
+    #[getter]
+    pub fn timestamp(&self) -> PyResult<i64> {
+        Ok(self.posix_time.timestamp)
+    }
+}
+
+#[pymodule]
+pub fn datetime(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<PyFiletime>()?;
+    module.add_class::<PyPosixTime32>()?;
+    module.add_class::<PyPosixTime64Ns>()?;
+
+    Ok(())
+}

pykeramics-0.0.0/src/lib.rs

@@ -0,0 +1,34 @@
+/* Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+ *
+ * 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 https://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.
+ */
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use pyo3::wrap_pymodule;
+
+mod datetime;
+mod vfs;
+
+/// Keramics Python module.
+#[pymodule]
+fn pykeramics(python: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add("__version__", env!("CARGO_PKG_VERSION"))?;
+    module.add_wrapped(wrap_pymodule!(datetime::datetime))?;
+    module.add_wrapped(wrap_pymodule!(vfs::vfs))?;
+
+    let sys = PyModule::import(python, "sys")?;
+    let sys_modules: Bound<'_, PyDict> = sys.getattr("modules")?.downcast_into()?;
+    sys_modules.set_item("pykeramics.datetime", module.getattr("datetime")?)?;
+    sys_modules.set_item("pykeramics.vfs", module.getattr("vfs")?)?;
+
+    Ok(())
+}

pykeramics-0.0.0/src/pykeramics.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pykeramics
+Version: 0.0.0
+License: "Apache-2.0"
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Rust
+Requires-Python: >=3.8

pykeramics-0.0.0/src/pykeramics.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+Cargo.toml
+MANIFEST.in
+pyproject.toml
+setup.cfg
+setup.py
+src/datetime.rs
+src/lib.rs
+src/vfs.rs
+src/pykeramics.egg-info/PKG-INFO
+src/pykeramics.egg-info/SOURCES.txt
+src/pykeramics.egg-info/dependency_links.txt
+src/pykeramics.egg-info/top_level.txt
+tests/test_module.py
+tests/test_vfs.py

pykeramics-0.0.0/src/pykeramics.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pykeramics-0.0.0/src/pykeramics.egg-info/top_level.txt

@@ -0,0 +1 @@
+

pykeramics-0.0.0/src/vfs.rs

@@ -0,0 +1,296 @@
+/* Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+ *
+ * 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 https://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.
+ */
+
+use std::sync::Arc;
+
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+
+use keramics_vfs::{
+    VfsFileEntry, VfsFileSystemReference, VfsFileType, VfsLocation, VfsPath, VfsResolver,
+    VfsResolverReference, VfsString, VfsType,
+};
+
+use super::datetime::PyDateTime;
+
+#[pyclass]
+#[pyo3(name = "VfsFileEntry")]
+#[derive(Clone)]
+struct PyVfsFileEntry {
+    file_entry: Arc<VfsFileEntry>,
+}
+
+#[pymethods]
+impl PyVfsFileEntry {
+    #[getter]
+    pub fn access_time(&self) -> PyResult<Option<Py<PyAny>>> {
+        match self.file_entry.get_access_time() {
+            Some(date_time) => Ok(Some(PyDateTime::new(date_time)?)),
+            None => Ok(None),
+        }
+    }
+
+    #[getter]
+    pub fn change_time(&self) -> PyResult<Option<Py<PyAny>>> {
+        match self.file_entry.get_change_time() {
+            Some(date_time) => Ok(Some(PyDateTime::new(date_time)?)),
+            None => Ok(None),
+        }
+    }
+
+    #[getter]
+    pub fn creation_time(&self) -> PyResult<Option<Py<PyAny>>> {
+        match self.file_entry.get_creation_time() {
+            Some(date_time) => Ok(Some(PyDateTime::new(date_time)?)),
+            None => Ok(None),
+        }
+    }
+
+    #[getter]
+    pub fn name(&self) -> PyResult<Option<PyVfsString>> {
+        match self.file_entry.get_name() {
+            Some(name) => Ok(Some(PyVfsString {
+                string: Arc::new(name),
+            })),
+            None => Ok(None),
+        }
+    }
+
+    #[getter]
+    pub fn modification_time(&self) -> PyResult<Option<Py<PyAny>>> {
+        match self.file_entry.get_modification_time() {
+            Some(date_time) => Ok(Some(PyDateTime::new(date_time)?)),
+            None => Ok(None),
+        }
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "VfsFileSystem")]
+#[derive(Clone)]
+struct PyVfsFileSystem {
+    file_system: VfsFileSystemReference,
+}
+
+#[pymethods]
+impl PyVfsFileSystem {}
+
+#[pyclass(eq)]
+#[pyo3(name = "VfsFileType")]
+#[derive(Clone, PartialEq)]
+pub enum PyVfsFileType {
+    #[pyo3(name = "BLOCK_DEVICE")]
+    BlockDevice,
+    #[pyo3(name = "CHARACTER_DEVICE")]
+    CharacterDevice,
+    #[pyo3(name = "DEVICE")]
+    Device,
+    #[pyo3(name = "DIRECTORY")]
+    Directory,
+    #[pyo3(name = "FILE")]
+    File,
+    #[pyo3(name = "NAMED_PIPE")]
+    NamedPipe,
+    #[pyo3(name = "SOCKET")]
+    Socket,
+    #[pyo3(name = "SYMBOLIC_LINK")]
+    SymbolicLink,
+    #[pyo3(name = "WHITEOUT")]
+    Whiteout,
+}
+
+#[pyclass]
+#[pyo3(name = "VfsLocation")]
+#[derive(Clone)]
+struct PyVfsLocation {
+    location: Arc<VfsLocation>,
+}
+
+#[pymethods]
+impl PyVfsLocation {
+    #[new]
+    #[pyo3(signature = (path_type, path))]
+    pub fn new(path_type: PyVfsType, path: PyVfsPath) -> PyResult<Self> {
+        let vfs_type: VfsType = match &path_type {
+            PyVfsType::Apm => VfsType::Apm,
+            PyVfsType::Ext => VfsType::Ext,
+            PyVfsType::Ewf => VfsType::Ewf,
+            PyVfsType::Fake => VfsType::Fake,
+            PyVfsType::Gpt => VfsType::Gpt,
+            PyVfsType::Mbr => VfsType::Mbr,
+            PyVfsType::Os => VfsType::Os,
+            PyVfsType::Qcow => VfsType::Qcow,
+            PyVfsType::Vhd => VfsType::Vhd,
+            PyVfsType::Vhdx => VfsType::Vhdx,
+        };
+        let vfs_path: &VfsPath = path.path.as_ref();
+        Ok(Self {
+            location: Arc::new(VfsLocation::new_base(&vfs_type, vfs_path.clone())),
+        })
+    }
+
+    pub fn new_with_layer(&self, path_type: PyVfsType, path: PyVfsPath) -> PyResult<Self> {
+        let vfs_type: VfsType = match &path_type {
+            PyVfsType::Apm => VfsType::Apm,
+            PyVfsType::Ext => VfsType::Ext,
+            PyVfsType::Ewf => VfsType::Ewf,
+            PyVfsType::Fake => VfsType::Fake,
+            PyVfsType::Gpt => VfsType::Gpt,
+            PyVfsType::Mbr => VfsType::Mbr,
+            PyVfsType::Os => VfsType::Os,
+            PyVfsType::Qcow => VfsType::Qcow,
+            PyVfsType::Vhd => VfsType::Vhd,
+            PyVfsType::Vhdx => VfsType::Vhdx,
+        };
+        let vfs_path: &VfsPath = path.path.as_ref();
+        Ok(Self {
+            location: Arc::new(self.location.new_with_layer(&vfs_type, vfs_path.clone())),
+        })
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "VfsResolver")]
+#[derive(Clone)]
+struct PyVfsResolver {
+    resolver: VfsResolverReference,
+}
+
+#[pymethods]
+impl PyVfsResolver {
+    #[new]
+    pub fn new() -> PyResult<Self> {
+        Ok(Self {
+            resolver: VfsResolver::current(),
+        })
+    }
+
+    pub fn get_file_entry_by_location(
+        &self,
+        location: PyVfsLocation,
+    ) -> PyResult<Option<PyVfsFileEntry>> {
+        match self.resolver.get_file_entry_by_location(&location.location) {
+            Ok(result) => match result {
+                Some(file_entry) => Ok(Some(PyVfsFileEntry {
+                    file_entry: Arc::new(file_entry),
+                })),
+                None => {
+                    return Ok(None);
+                }
+            },
+            Err(error) => {
+                return Err(PyErr::new::<PyRuntimeError, String>(format!(
+                    "Unable to retrieve file entry with error: {}",
+                    error.to_string()
+                )));
+            }
+        }
+    }
+
+    pub fn open_file_system(&self, location: PyVfsLocation) -> PyResult<PyVfsFileSystem> {
+        match self.resolver.open_file_system(&location.location) {
+            Ok(file_system) => Ok(PyVfsFileSystem {
+                file_system: file_system,
+            }),
+            Err(error) => {
+                return Err(PyErr::new::<PyRuntimeError, String>(format!(
+                    "Unable to open file system with error: {}",
+                    error.to_string()
+                )));
+            }
+        }
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "VfsString")]
+#[derive(Clone)]
+struct PyVfsString {
+    string: Arc<VfsString>,
+}
+
+#[pymethods]
+impl PyVfsString {
+    pub fn to_string(&self) -> String {
+        self.string.to_string()
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "VfsPath")]
+#[derive(Clone)]
+struct PyVfsPath {
+    path: Arc<VfsPath>,
+}
+
+#[pymethods]
+impl PyVfsPath {
+    #[new]
+    #[pyo3(signature = (path_type, path))]
+    pub fn new(path_type: PyVfsType, path: &str) -> PyResult<Self> {
+        let vfs_type: VfsType = match &path_type {
+            PyVfsType::Apm => VfsType::Apm,
+            PyVfsType::Ext => VfsType::Ext,
+            PyVfsType::Ewf => VfsType::Ewf,
+            PyVfsType::Fake => VfsType::Fake,
+            PyVfsType::Gpt => VfsType::Gpt,
+            PyVfsType::Mbr => VfsType::Mbr,
+            PyVfsType::Os => VfsType::Os,
+            PyVfsType::Qcow => VfsType::Qcow,
+            PyVfsType::Vhd => VfsType::Vhd,
+            PyVfsType::Vhdx => VfsType::Vhdx,
+        };
+        Ok(Self {
+            path: Arc::new(VfsPath::from_path(&vfs_type, path)),
+        })
+    }
+}
+
+#[pyclass(eq)]
+#[pyo3(name = "VfsType")]
+#[derive(Clone, PartialEq)]
+pub enum PyVfsType {
+    #[pyo3(name = "APM")]
+    Apm,
+    #[pyo3(name = "EXT")]
+    Ext,
+    #[pyo3(name = "EWF")]
+    Ewf,
+    #[pyo3(name = "FAKE")]
+    Fake,
+    #[pyo3(name = "GPT")]
+    Gpt,
+    #[pyo3(name = "MBR")]
+    Mbr,
+    #[pyo3(name = "OS")]
+    Os,
+    #[pyo3(name = "QCOW")]
+    Qcow,
+    #[pyo3(name = "VHD")]
+    Vhd,
+    #[pyo3(name = "VHDX")]
+    Vhdx,
+}
+
+#[pymodule]
+pub fn vfs(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<PyVfsFileEntry>()?;
+    module.add_class::<PyVfsFileSystem>()?;
+    module.add_class::<PyVfsLocation>()?;
+    module.add_class::<PyVfsPath>()?;
+    module.add_class::<PyVfsResolver>()?;
+    module.add_class::<PyVfsString>()?;
+    module.add_class::<PyVfsType>()?;
+
+    Ok(())
+}

pykeramics-0.0.0/tests/test_module.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+# Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+#
+# 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 https://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.
+
+import pykeramics
+
+
+def test_version() -> None:
+    assert pykeramics.__version__ == "0.0.0"

pykeramics-0.0.0/tests/test_vfs.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+# Copyright 2024-2025 Joachim Metz <joachim.metz@gmail.com>
+#
+# 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 https://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.
+
+import pytest
+
+from pykeramics import datetime
+from pykeramics import vfs
+
+
+def test_get_file_entry_by_location() -> None:
+    resolver = vfs.VfsResolver()
+
+    os_location = vfs.VfsLocation(
+        vfs.VfsType.OS, vfs.VfsPath(vfs.VfsType.OS, "../test_data/qcow/ext2.qcow2")
+    )
+    qcow_location = os_location.new_with_layer(
+        vfs.VfsType.QCOW, vfs.VfsPath(vfs.VfsType.QCOW, "/qcow1")
+    )
+    ext_location = qcow_location.new_with_layer(
+        vfs.VfsType.EXT, vfs.VfsPath(vfs.VfsType.EXT, "/testdir1/testfile1")
+    )
+    file_entry = resolver.get_file_entry_by_location(ext_location)
+
+    assert file_entry is not None
+    assert file_entry.name.to_string() == "testfile1"
+    assert file_entry.access_time.timestamp == 1735977482
+    assert file_entry.change_time.timestamp == 1735977481
+    assert file_entry.creation_time is None
+    assert file_entry.modification_time.timestamp == 1735977481
+
+    ext_location = qcow_location.new_with_layer(
+        vfs.VfsType.EXT, vfs.VfsPath(vfs.VfsType.EXT, "/bogus")
+    )
+    file_entry = resolver.get_file_entry_by_location(ext_location)
+
+    assert file_entry is None
+
+
+def test_open_file_system() -> None:
+    resolver = vfs.VfsResolver()
+
+    os_location = vfs.VfsLocation(
+        vfs.VfsType.OS, vfs.VfsPath(vfs.VfsType.OS, "../test_data/qcow/ext2.qcow2")
+    )
+    qcow_location = os_location.new_with_layer(
+        vfs.VfsType.QCOW, vfs.VfsPath(vfs.VfsType.QCOW, "/qcow1")
+    )
+    ext_location = qcow_location.new_with_layer(
+        vfs.VfsType.EXT, vfs.VfsPath(vfs.VfsType.EXT, "/testdir1/testfile1")
+    )
+    file_system = resolver.open_file_system(ext_location)
+
+    assert file_system is not None