archive-r-python 0.1.2__tar.gz → 0.1.6__tar.gz

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/LICENSE.txt

@@ -1,5 +1,5 @@
 archive_r License
-Version: 0.1.2 (2025-12-02)
+Version: 0.1.6 (2025-12-10)
 
 ----------------------------------------
 Primary License
@@ -66,12 +66,32 @@ The following components are redistributed only because libarchive (bundled with
    - Purpose: libarchive dependency providing Zstandard compression; shipped within archive_r binaries.
    - License: BSD License (https://github.com/facebook/zstd)
 
-8. OpenSSL 3
-   - Purpose: libarchive dependency providing cryptographic support for encrypted archives; included with archive_r packages.
-   - License: Apache License 2.0 with OpenSSL exception (https://www.openssl.org/source/license.html)
+8. Nettle
+   - Purpose: libarchive dependency providing cryptographic support (macOS/Linux); bundled with archive_r binaries.
+   - License: GNU LGPLv3+ or GNU GPLv2+ (https://www.lysator.liu.se/~nisse/nettle/)
 
-9. libiconv / libcharset
-   - Purpose: libxml2/libarchive dependency for character set conversion; redistributed with archive_r artifacts.
-   - License: GNU LGPLv2.1+ (https://www.gnu.org/software/libiconv/)
+9. mini-gmp
+   - Purpose: Nettle dependency for arithmetic operations (macOS/Linux); bundled with archive_r binaries.
+   - License: GNU LGPLv3+ or GNU GPLv2+ (https://gmplib.org/)
+
+10. OpenSSL 3
+    - Purpose: libarchive dependency providing cryptographic support (Windows); bundled with archive_r binaries.
+    - License: Apache License 2.0 with OpenSSL exception (https://www.openssl.org/source/license.html)
+
+11. lz4
+   - Purpose: libarchive dependency providing LZ4 compression; shipped with archive_r artifacts when required.
+   - License: BSD 2-Clause (https://github.com/lz4/lz4)
+
+12. libb2 (BLAKE2)
+   - Purpose: libarchive dependency providing BLAKE2 hashing; bundled when archive formats require it.
+   - License: CC0 1.0 Universal (https://github.com/BLAKE2/libb2)
+
+13. libattr
+   - Purpose: libarchive dependency providing extended attribute support on POSIX platforms; included in POSIX builds only.
+   - License: LGPL-2.1-or-later for the library (https://savannah.nongnu.org/projects/attr)
+
+14. libacl
+   - Purpose: libarchive dependency providing POSIX ACL support; included in POSIX builds only.
+   - License: LGPL-2.1-or-later for the library (https://savannah.nongnu.org/projects/acl)
 Users of archive_r should review the linked third-party licenses to ensure
 compliance with their terms when redistributing this software.

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/MANIFEST.in

@@ -9,3 +9,5 @@ recursive-include examples *.py
 recursive-include test *.py
 recursive-include _vendor/archive_r/include *
 recursive-include _vendor/archive_r/src *
+include tools/build-deps-manylinux.sh
+include tools/build-deps-macos.sh

{archive_r_python-0.1.2/archive_r_python.egg-info → archive_r_python-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: archive_r_python
-Version: 0.1.2
+Version: 0.1.6
 Summary: Python bindings for archive_r that recursively traverse nested archives without creating temporary extraction files
 Home-page: https://github.com/Raizo-TCS/archive_r
 Author: archive_r Team
@@ -17,6 +17,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Development Status :: 4 - Beta
 Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Software Development :: Libraries
@@ -484,7 +486,7 @@ Or use the project-wide test runner:
 
 ```bash
 cd archive_r
-./run_tests.sh
+./bindings/python/run_binding_tests.sh
 ```
 
 ---
@@ -609,4 +611,5 @@ The Python bindings are distributed under the MIT License, consistent with the a
 
 ---
 
-**Note**: This document describes archive_r Python bindings version 0.1.2.
+**Note**: This document describes archive_r Python bindings version 0.1.6.
+

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/README.md

@@ -455,7 +455,7 @@ Or use the project-wide test runner:
 
 ```bash
 cd archive_r
-./run_tests.sh
+./bindings/python/run_binding_tests.sh
 ```
 
 ---
@@ -580,4 +580,5 @@ The Python bindings are distributed under the MIT License, consistent with the a
 
 ---
 
-**Note**: This document describes archive_r Python bindings version 0.1.2.
+**Note**: This document describes archive_r Python bindings version 0.1.6.
+

archive_r_python-0.1.6/VERSION

@@ -0,0 +1 @@
+0.1.6

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/include/archive_r/data_stream.h

@@ -8,6 +8,17 @@
 #include <functional>
 #include <memory>
 #include <sys/types.h>
+#include <cstdint>
+
+#ifdef _WIN32
+#include <basetsd.h>
+using ssize_t = SSIZE_T;
+#endif
+
+// Avoid conflict with potential 'read' macro on Windows
+#ifdef read
+#undef read
+#endif
 
 namespace archive_r {
 

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/include/archive_r/entry.h

@@ -10,6 +10,11 @@
 #include <sys/types.h>
 #include <vector>
 
+#ifdef _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
 #include "archive_r/entry_fault.h"
 #include "archive_r/entry_metadata.h"
 #include "archive_r/path_hierarchy.h"

archive_r_python-0.1.6/_vendor/archive_r/include/archive_r/platform_compat.h

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#pragma once
+
+#include <sys/types.h>
+
+#if defined(_WIN32)
+#  include <sys/stat.h>
+#  if !defined(_SSIZE_T_DEFINED)
+#    include <BaseTsd.h>
+using ssize_t = SSIZE_T;
+#    define _SSIZE_T_DEFINED
+#  endif
+#  if !defined(_MODE_T_DEFINED)
+using mode_t = unsigned short; // MSVC does not expose POSIX mode_t by default
+#    define _MODE_T_DEFINED
+#  endif
+#endif

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/archive_stack_cursor.cc

@@ -60,6 +60,11 @@ void StreamArchive::rewind() {
 
 PathHierarchy StreamArchive::source_hierarchy() const { return _stream->source_hierarchy(); }
 
+std::shared_ptr<StreamArchive> StreamArchive::parent_archive() const {
+  auto entry_stream = std::dynamic_pointer_cast<EntryPayloadStream>(_stream);
+  return entry_stream ? entry_stream->parent_archive() : nullptr;
+}
+
 la_ssize_t StreamArchive::read_callback_bridge(struct archive *a, void *client_data, const void **buff) {
   auto *archive = static_cast<StreamArchive *>(client_data);
 
@@ -120,7 +125,9 @@ EntryPayloadStream::EntryPayloadStream(std::shared_ptr<StreamArchive> parent_arc
   }
 }
 
-EntryPayloadStream::~EntryPayloadStream() = default;
+EntryPayloadStream::~EntryPayloadStream() {
+  deactivate_active_part();
+}
 
 std::shared_ptr<StreamArchive> EntryPayloadStream::parent_archive() const { return _parent_archive; }
 
@@ -143,11 +150,8 @@ void EntryPayloadStream::open_single_part(const PathHierarchy &single_part) {
 }
 
 void EntryPayloadStream::close_single_part() {
-  if (_parent_archive->current_entryname.empty()) {
-    return;
-  }
-
-  _parent_archive->skip_data();
+  // libarchive automatically skips unread data when reading the next header,
+  // so explicit skipping here is unnecessary and avoids potential exceptions in destructor.
 }
 
 ssize_t EntryPayloadStream::read_from_single_part(void *buffer, size_t size) {
@@ -170,7 +174,8 @@ int64_t EntryPayloadStream::size_of_single_part(const PathHierarchy &single_part
 
 ArchiveStackCursor::ArchiveStackCursor()
     : options_snapshot()
-    , stream_stack() {}
+    , _current_stream(nullptr)
+    , _current_archive(nullptr) {}
 
 void ArchiveStackCursor::configure(const ArchiveOption &options) {
   options_snapshot = options;
@@ -178,16 +183,16 @@ void ArchiveStackCursor::configure(const ArchiveOption &options) {
 
 void ArchiveStackCursor::reset() {
   options_snapshot = ArchiveOption{};
-  stream_stack.clear();
+  _current_stream = nullptr;
+  _current_archive = nullptr;
 }
 
 bool ArchiveStackCursor::descend() {
-  if (stream_stack.empty()) {
-    throw std::logic_error("stream stack is empty");
+  if (!_current_stream) {
+    throw std::logic_error("current stream is empty");
   }
 
-  auto stream = stream_stack.back();
-
+  auto stream = _current_stream;
   if (auto *archive = current_archive()) {
     if (stream && !archive->current_entry_content_ready()) {
       stream->rewind();
@@ -196,17 +201,22 @@ bool ArchiveStackCursor::descend() {
 
   PathHierarchy dummy_hierarchy = stream->source_hierarchy();
   auto archive_ptr = std::make_shared<StreamArchive>(std::move(stream), options_snapshot);
-  append_single(dummy_hierarchy, std::string{});
-  stream_stack.emplace_back(std::make_shared<EntryPayloadStream>(archive_ptr, std::move(dummy_hierarchy)));
+  _current_archive = archive_ptr;
+  _current_stream = nullptr;
   return true;
 }
 
 bool ArchiveStackCursor::ascend() {
-  if (stream_stack.size() <= 0) {
+  if (depth() <= 0) {
     return false;
   }
 
-  stream_stack.pop_back();
+  if (_current_archive) {
+    _current_stream = _current_archive->get_stream();
+    _current_archive = _current_archive->parent_archive();
+  } else {
+    _current_stream = nullptr;
+  }
 
   return true;
 }
@@ -217,6 +227,8 @@ bool ArchiveStackCursor::next() {
     return false;
   }
 
+  _current_stream = nullptr;
+
   while (true) {
     if (!archive->skip_to_next_header()) {
       return false;
@@ -225,7 +237,8 @@ bool ArchiveStackCursor::next() {
       break;
     }
   }
-  stream_stack.back() = create_stream(current_entry_hierarchy());
+
+  _current_stream = create_stream(current_entry_hierarchy());
   return true;
 }
 
@@ -233,33 +246,32 @@ bool ArchiveStackCursor::synchronize_to_hierarchy(const PathHierarchy &target_hi
   if (target_hierarchy.empty()) {
     throw_entry_fault("target hierarchy cannot be empty", {});
   }
- 
-  const size_t last_depth = target_hierarchy.size() - 1;
-  if (stream_stack.size() < target_hierarchy.size()) {
-    stream_stack.resize(target_hierarchy.size());
+
+  // 1. Ascend until we find a common ancestor
+  while (depth() > 0) {
+    auto current_h = _current_archive->source_hierarchy();
+    if (current_h.size() <= target_hierarchy.size() &&
+        hierarchies_equal(current_h, pathhierarchy_prefix_until(target_hierarchy, current_h.size() - 1))) {
+      break;
+    }
+    ascend();
   }
-  for (size_t depth = 0; depth < target_hierarchy.size(); ++depth) {
-    auto prefix = pathhierarchy_prefix_until(target_hierarchy, depth);
-    auto stream = stream_stack[depth];
 
-    // Reuse the existing stream when it already matches this prefix.
-    if (stream && hierarchies_equal(stream->source_hierarchy(), prefix)) {
-      continue;
+  // 2. Descend to target
+  for (size_t d = depth(); d < target_hierarchy.size(); ++d) {
+    auto prefix = pathhierarchy_prefix_until(target_hierarchy, d);
+
+    if (!_current_stream || !hierarchies_equal(_current_stream->source_hierarchy(), prefix)) {
+      _current_stream = create_stream(prefix);
+      _current_stream->rewind();
     }
-    // Shrink the stack to the current depth before creating a fresh stream.
-    stream_stack.resize(depth+1);
-    stream = create_stream(prefix);
-    stream_stack.back() = stream;
-    stream->rewind();
- 
-    if (depth == last_depth) {
-      return true;
+
+    if (d < target_hierarchy.size() - 1) {
+      descend();
     }
-    // Descend into the archive for the next level of the hierarchy.
-    descend();
   }
-  
-   return true;
+
+  return true;
 }
 
 ssize_t ArchiveStackCursor::read(void *buff, size_t len) {
@@ -267,38 +279,22 @@ ssize_t ArchiveStackCursor::read(void *buff, size_t len) {
     return 0;
   }
 
-  if (stream_stack.empty()) {
-    throw_entry_fault("Stream stack is empty", {});
+  if (StreamArchive *archive = current_archive()) {
+    return archive->read_current(buff, len);
   }
 
-  auto stream = stream_stack.back();
-  ssize_t bytes = 0;
-  bytes = stream->read(buff, len);
-
-  if (bytes < 0) {
-    const std::string message = "Failed to read from active stream";
-    throw_entry_fault(message, current_entry_hierarchy());
+  if (_current_stream) {
+    return _current_stream->read(buff, len);
   }
-
-  return bytes;
+  return 0;
 }
 
 StreamArchive *ArchiveStackCursor::current_archive() {
-  if (stream_stack.size() <= 0) {
-    return nullptr;
-  }
-
-  const auto stream = std::dynamic_pointer_cast<EntryPayloadStream>(stream_stack.back());
-  if (!stream) {
-    return nullptr;
-  }
-
-  auto parent_archive = stream->parent_archive();
-  return parent_archive ? parent_archive.get() : nullptr;
+  return _current_archive.get();
 }
 
 PathHierarchy ArchiveStackCursor::current_entry_hierarchy() {
-  if (stream_stack.empty() || !stream_stack.front()) {
+  if (depth() == 0 || (!_current_stream && !_current_archive)) {
     return {};
   }
 
@@ -310,7 +306,7 @@ PathHierarchy ArchiveStackCursor::current_entry_hierarchy() {
     return path;
   }
 
-  return stream_stack.front()->source_hierarchy();
+  return _current_stream->source_hierarchy();
 }
 
 std::shared_ptr<IDataStream> ArchiveStackCursor::create_stream(const PathHierarchy &hierarchy) {
@@ -322,9 +318,7 @@ std::shared_ptr<IDataStream> ArchiveStackCursor::create_stream(const PathHierarc
     }
     return std::make_shared<SystemFileStream>(hierarchy);
   }
-  auto stream = std::dynamic_pointer_cast<EntryPayloadStream>(stream_stack.back());
-
-  return std::make_shared<EntryPayloadStream>(stream->parent_archive(), hierarchy);
+  return std::make_shared<EntryPayloadStream>(_current_archive, hierarchy);
 }
 
 } // namespace archive_r

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/archive_stack_cursor.h

@@ -13,7 +13,6 @@
 #include <exception>
 #include <memory>
 #include <string>
-#include <sys/types.h>
 #include <vector>
 
 namespace archive_r {
@@ -32,6 +31,9 @@ public:
   void rewind() override;
 
   PathHierarchy source_hierarchy() const;
+  std::shared_ptr<StreamArchive> parent_archive() const;
+
+  std::shared_ptr<IDataStream> get_stream() const { return _stream; }
 
 private:
   static la_ssize_t read_callback_bridge(struct archive *a, void *client_data, const void **buff);
@@ -76,7 +78,7 @@ struct ArchiveStackCursor {
 
   void configure(const ArchiveOption &options);
   void reset();
-  bool has_stream() const { return !stream_stack.empty(); }
+  bool has_stream() const { return _current_stream != nullptr; }
 
   bool descend();
   bool ascend();
@@ -84,7 +86,16 @@ struct ArchiveStackCursor {
   bool synchronize_to_hierarchy(const PathHierarchy &hierarchy);
   ssize_t read(void *buffer, size_t len);
 
-  size_t depth() const { return stream_stack.size(); }
+  size_t depth() const {
+    size_t d = 0;
+    auto a = _current_archive;
+    while (a) {
+      d++;
+      a = a->parent_archive();
+    }
+    return d;
+  }
+
   StreamArchive *current_archive();
 
   PathHierarchy current_entry_hierarchy();
@@ -92,7 +103,10 @@ struct ArchiveStackCursor {
   std::shared_ptr<IDataStream> create_stream(const PathHierarchy &hierarchy);
 
   ArchiveOption options_snapshot;
-  std::vector<std::shared_ptr<IDataStream>> stream_stack;
+
+private:
+  std::shared_ptr<IDataStream> _current_stream;
+  std::shared_ptr<StreamArchive> _current_archive;
 };
 
 } // namespace archive_r

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/archive_stack_orchestrator.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "archive_r/path_hierarchy.h"
+#include "archive_r/platform_compat.h"
 #include "archive_type.h"
 #include "archive_stack_cursor.h"
 #include "entry_fault_error.h"
@@ -11,7 +12,6 @@
 #include <limits>
 #include <memory>
 #include <string>
-#include <sys/types.h>
 #include <unordered_set>
 
 namespace archive_r {

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/archive_type.h

@@ -11,10 +11,11 @@
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <sys/types.h>
 #include <unordered_set>
 #include <vector>
 
+#include "archive_r/platform_compat.h"
+
 namespace archive_r {
 
 struct archive_deleter {

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/entry_impl.h

@@ -8,7 +8,6 @@
 #include <filesystem>
 #include <memory>
 #include <optional>
-#include <sys/types.h> // for mode_t
 #include <unordered_set>
 
 namespace archive_r {

{archive_r_python-0.1.2 → archive_r_python-0.1.6}/_vendor/archive_r/src/multi_volume_stream_base.cc

@@ -20,6 +20,7 @@ struct MultiVolumeStreamBase::Impl {
   std::vector<int64_t> part_offsets;
   std::size_t total_parts = 0;
   std::size_t active_part_index = 0;
+  std::size_t open_part_index = 0;
   bool part_open = false;
   int64_t logical_offset = 0;
   int64_t total_size = -1;
@@ -84,7 +85,7 @@ void MultiVolumeStreamBase::rewind() {
 }
 
 bool MultiVolumeStreamBase::at_end() const {
-  return (_impl->active_part_index >= _impl->total_parts) && !_impl->part_open;
+  return _impl->active_part_index >= _impl->total_parts;
 }
 
 int64_t MultiVolumeStreamBase::seek(int64_t offset, int whence) {
@@ -122,14 +123,14 @@ int64_t MultiVolumeStreamBase::seek(int64_t offset, int whence) {
 int64_t MultiVolumeStreamBase::tell() const { return _impl->logical_offset; }
 
 void MultiVolumeStreamBase::Impl::ensure_part_active(std::size_t part_index) {
-  if (part_open && active_part_index == part_index) {
+  if (part_open && open_part_index == part_index) {
     return;
   }
 
   self.deactivate_active_part();
   PathHierarchy single_part = pathhierarchy_select_single_part(self._logical_path, part_index);
   self.open_single_part(single_part);
-  active_part_index = part_index;
+  open_part_index = part_index;
   part_open = true;
 }
 
@@ -144,7 +145,6 @@ bool MultiVolumeStreamBase::Impl::advance_to_next_part() {
   if (active_part_index >= total_parts) {
     return false;
   }
-  self.deactivate_active_part();
   ++active_part_index;
   return active_part_index < total_parts;
 }