FastWARC 0.16.0__tar.gz → 1.0.1__tar.gz

{fastwarc-0.16.0 → fastwarc-1.0.1}/FastWARC.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: FastWARC
-Version: 0.16.0
+Version: 1.0.1
 Summary: A high-performance WARC parsing library for Python written in C++/Cython.
 Author: Janek Bevendorff
-License: Apache License 2.0
+License-Expression: Apache-2.0
 Project-URL: repository, https://github.com/chatnoir-eu/chatnoir-resiliparse
 Project-URL: homepage, https://resiliparse.chatnoir.eu
 Project-URL: documentation, https://resiliparse.chatnoir.eu
@@ -22,33 +22,51 @@ Requires-Dist: pytest>=7.2.2; extra == "test"
 Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Requires-Dist: lz4; extra == "test"
 
-# FastWARC
+# FastWARC (Python)
 
-FastWARC is a high-performance WARC parsing library for Python written in C++/Cython. The API is inspired in large parts by [WARCIO](https://github.com/webrecorder/warcio), but does not aim at being a drop-in replacement.  FastWARC supports compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are GZip and LZ4.
+FastWARC is a high-performance WARC parsing library for Python written in Rust with Python bindings. FastWARC supports
+compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are Gzip and LZ4.
 
-FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast and robust web data processing.
+This crate contains the Python bindings for FastWARC.
+
+FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast
+and robust web data processing.
 
 ## Installing FastWARC
+
 Pre-built FastWARC binaries for most Linux platforms can be installed from PyPi:
+
 ```bash
 pip install fastwarc
 ```
-**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old `manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For best performance, see the next section on how to build FastWARC yourself.
+
+**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old
+`manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For
+best performance, see the next section on how to build FastWARC yourself.
 
 ## Building FastWARC From Source
-You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
+You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you
+need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
 ```bash
 sudo apt install build-essential python3-dev zlib1g-dev liblz4-dev
 ```
+
 To build and install FastWARC from PyPi, run
+
 ```bash
 pip install --no-binary fastwarc fastwarc
 ```
+
 That's it. If you prefer to build and install directly from this repository instead, run:
+
 ```bash
 pip install -e fastwarc
 ```
+
 To build the wheels without installing them, run:
+
 ```bash
 pip wheel -e fastwarc
 
@@ -57,10 +75,14 @@ pip install build && python -m build --wheel fastwarc
 ```
 
 ## Usage Instructions
-For detailed usage instructions, please consult the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
+
+For detailed usage instructions, please consult
+the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
 
 ## Cite Us
+
 If you use FastWARC, please consider citing our [OSSYM 2021 abstract paper](https://arxiv.org/abs/2112.03103):
+
 ```bibtex
 @InProceedings{bevendorff:2021,
   author =                {Janek Bevendorff and Martin Potthast and Benno Stein},

{fastwarc-0.16.0 → fastwarc-1.0.1}/FastWARC.egg-info/SOURCES.txt

@@ -8,18 +8,23 @@ FastWARC.egg-info/dependency_links.txt
 FastWARC.egg-info/entry_points.txt
 FastWARC.egg-info/requires.txt
 FastWARC.egg-info/top_level.txt
-fastwarc/__init__.pxd
 fastwarc/__init__.py
+fastwarc/__init__.pyi
 fastwarc/cli.py
 fastwarc/py.typed
-fastwarc/stream_io.pxd
 fastwarc/stream_io.pyi
-fastwarc/stream_io.pyx
-fastwarc/tools.pyi
-fastwarc/tools.pyx
-fastwarc/warc.pxd
 fastwarc/warc.pyi
-fastwarc/warc.pyx
+fastwarc/legacy/__init__.pxd
+fastwarc/legacy/__init__.py
+fastwarc/legacy/_shims.py
+fastwarc/legacy/stream_io.pxd
+fastwarc/legacy/stream_io.pyi
+fastwarc/legacy/stream_io.pyx
+fastwarc/legacy/tools.pyi
+fastwarc/legacy/tools.pyx
+fastwarc/legacy/warc.pxd
+fastwarc/legacy/warc.pyi
+fastwarc/legacy/warc.pyx
 resiliparse_common/__init__.pxd
 resiliparse_common/string_util.pxd
 resiliparse_inc/__init__.pxd

{fastwarc-0.16.0 → fastwarc-1.0.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: FastWARC
-Version: 0.16.0
+Version: 1.0.1
 Summary: A high-performance WARC parsing library for Python written in C++/Cython.
 Author: Janek Bevendorff
-License: Apache License 2.0
+License-Expression: Apache-2.0
 Project-URL: repository, https://github.com/chatnoir-eu/chatnoir-resiliparse
 Project-URL: homepage, https://resiliparse.chatnoir.eu
 Project-URL: documentation, https://resiliparse.chatnoir.eu
@@ -22,33 +22,51 @@ Requires-Dist: pytest>=7.2.2; extra == "test"
 Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Requires-Dist: lz4; extra == "test"
 
-# FastWARC
+# FastWARC (Python)
 
-FastWARC is a high-performance WARC parsing library for Python written in C++/Cython. The API is inspired in large parts by [WARCIO](https://github.com/webrecorder/warcio), but does not aim at being a drop-in replacement.  FastWARC supports compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are GZip and LZ4.
+FastWARC is a high-performance WARC parsing library for Python written in Rust with Python bindings. FastWARC supports
+compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are Gzip and LZ4.
 
-FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast and robust web data processing.
+This crate contains the Python bindings for FastWARC.
+
+FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast
+and robust web data processing.
 
 ## Installing FastWARC
+
 Pre-built FastWARC binaries for most Linux platforms can be installed from PyPi:
+
 ```bash
 pip install fastwarc
 ```
-**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old `manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For best performance, see the next section on how to build FastWARC yourself.
+
+**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old
+`manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For
+best performance, see the next section on how to build FastWARC yourself.
 
 ## Building FastWARC From Source
-You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
+You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you
+need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
 ```bash
 sudo apt install build-essential python3-dev zlib1g-dev liblz4-dev
 ```
+
 To build and install FastWARC from PyPi, run
+
 ```bash
 pip install --no-binary fastwarc fastwarc
 ```
+
 That's it. If you prefer to build and install directly from this repository instead, run:
+
 ```bash
 pip install -e fastwarc
 ```
+
 To build the wheels without installing them, run:
+
 ```bash
 pip wheel -e fastwarc
 
@@ -57,10 +75,14 @@ pip install build && python -m build --wheel fastwarc
 ```
 
 ## Usage Instructions
-For detailed usage instructions, please consult the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
+
+For detailed usage instructions, please consult
+the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
 
 ## Cite Us
+
 If you use FastWARC, please consider citing our [OSSYM 2021 abstract paper](https://arxiv.org/abs/2112.03103):
+
 ```bibtex
 @InProceedings{bevendorff:2021,
   author =                {Janek Bevendorff and Martin Potthast and Benno Stein},

{fastwarc-0.16.0 → fastwarc-1.0.1}/README.md

@@ -1,30 +1,48 @@
-# FastWARC
+# FastWARC (Python)
 
-FastWARC is a high-performance WARC parsing library for Python written in C++/Cython. The API is inspired in large parts by [WARCIO](https://github.com/webrecorder/warcio), but does not aim at being a drop-in replacement.  FastWARC supports compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are GZip and LZ4.
+FastWARC is a high-performance WARC parsing library for Python written in Rust with Python bindings. FastWARC supports
+compressed and uncompressed WARC/1.0 and WARC/1.1 streams. Supported compression algorithms are Gzip and LZ4.
 
-FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast and robust web data processing.
+This crate contains the Python bindings for FastWARC.
+
+FastWARC belongs to the [ChatNoir Resiliparse toolkit](https://github.com/chatnoir-eu/chatnoir-resiliparse/) for fast
+and robust web data processing.
 
 ## Installing FastWARC
+
 Pre-built FastWARC binaries for most Linux platforms can be installed from PyPi:
+
 ```bash
 pip install fastwarc
 ```
-**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old `manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For best performance, see the next section on how to build FastWARC yourself.
+
+**However:** the Linux binaries are provided *solely for your convenience*. Since they are built on the very old
+`manylinux` base system for better compatibility, their performance isn't optimal (though still better than WARCIO). For
+best performance, see the next section on how to build FastWARC yourself.
 
 ## Building FastWARC From Source
-You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
+You can compile FastWARC either from the PyPi source package or directly from this repository, though in any case, you
+need to install all required build-time dependencies first. On Ubuntu, this is done as follows:
+
 ```bash
 sudo apt install build-essential python3-dev zlib1g-dev liblz4-dev
 ```
+
 To build and install FastWARC from PyPi, run
+
 ```bash
 pip install --no-binary fastwarc fastwarc
 ```
+
 That's it. If you prefer to build and install directly from this repository instead, run:
+
 ```bash
 pip install -e fastwarc
 ```
+
 To build the wheels without installing them, run:
+
 ```bash
 pip wheel -e fastwarc
 
@@ -33,10 +51,14 @@ pip install build && python -m build --wheel fastwarc
 ```
 
 ## Usage Instructions
-For detailed usage instructions, please consult the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
+
+For detailed usage instructions, please consult
+the [FastWARC User Manual](https://resiliparse.chatnoir.eu/en/latest/man/fastwarc.html).
 
 ## Cite Us
+
 If you use FastWARC, please consider citing our [OSSYM 2021 abstract paper](https://arxiv.org/abs/2112.03103):
+
 ```bibtex
 @InProceedings{bevendorff:2021,
   author =                {Janek Bevendorff and Martin Potthast and Benno Stein},

fastwarc-1.0.1/fastwarc/__init__.py

@@ -0,0 +1,44 @@
+# Copyright 2026 Janek Bevendorff
+#
+# 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.
+
+import importlib
+
+_native = importlib.import_module("._fastwarc", __name__)
+_legacy_shims = importlib.import_module(".legacy._shims", __name__)
+
+import fastwarc.stream_io as stream_io  # noqa: F401
+import fastwarc.warc as warc  # noqa: F401
+
+# Re-export module attributes
+globals().update({attr: getattr(_native, attr) for attr in _native.__all__})
+
+# Patch legacy shims onto stream_io
+for name in _legacy_shims.__all__:
+    setattr(stream_io, name, getattr(_legacy_shims, name))
+stream_io.__all__ += getattr(_legacy_shims, "__all__", ())  # type: ignore[attr-defined]
+
+FileStream = _legacy_shims.FileStream
+GZipStream = _legacy_shims.GZipStream
+LZ4Stream = _legacy_shims.LZ4Stream
+FastWARCError = _legacy_shims.FastWARCError
+StreamError = _legacy_shims.StreamError
+
+__all__ = [
+    *_native.__all__,
+    'FileStream',
+    'GZipStream',
+    'LZ4Stream',
+    'FastWARCError',
+    'StreamError',
+]

fastwarc-1.0.1/fastwarc/__init__.pyi

@@ -0,0 +1,49 @@
+# Copyright 2026 Janek Bevendorff
+#
+# 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.
+
+from .warc import ArchiveIterator, WarcRecord, WarcRecordType
+from .stream_io import (
+    GzipReader,
+    GzipWriter,
+    ZstdReader,
+    ZstdWriter,
+    Lz4Reader,
+    Lz4Writer,
+
+    # Legacy names
+    FileStream,
+    GZipStream,
+    LZ4Stream,
+    FastWARCError,
+    StreamError,
+)
+
+__all__ = [
+    'ArchiveIterator',
+    'WarcRecord',
+    'WarcRecordType',
+    'GzipReader',
+    'GzipWriter',
+    'ZstdReader',
+    'ZstdWriter',
+    'Lz4Reader',
+    'Lz4Writer',
+
+    # Legacy names
+    'FileStream',
+    'GZipStream',
+    'LZ4Stream',
+    'FastWARCError',
+    'StreamError',
+]

{fastwarc-0.16.0 → fastwarc-1.0.1}/fastwarc/cli.py

@@ -24,9 +24,9 @@ import urllib.request
 import click
 from tqdm import tqdm
 
-from fastwarc.stream_io import FileStream, StreamError, FastWARCError, PythonIOStreamAdapter
-from fastwarc.warc import ArchiveIterator, WarcRecordType
-from fastwarc.tools import CompressionAlg, detect_compression_algorithm, wrap_warc_stream, \
+from fastwarc.legacy.stream_io import FileStream, StreamError, FastWARCError, PythonIOStreamAdapter
+from fastwarc.legacy.warc import ArchiveIterator, WarcRecordType
+from fastwarc.legacy.tools import CompressionAlg, detect_compression_algorithm, wrap_warc_stream, \
     recompress_warc_interactive, verify_digests
 
 
@@ -288,7 +288,7 @@ botocore = None
 s3 = None
 
 
-def _init_s3(endpoint_url, aws_access_key,  aws_secret_key=None):
+def _init_s3(endpoint_url, aws_access_key, aws_secret_key=None):
     global boto3, botocore, s3
 
     if s3 is not None:

fastwarc-1.0.1/fastwarc/legacy/_shims.py

@@ -0,0 +1,202 @@
+# Copyright 2026 Janek Bevendorff
+#
+# 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.
+
+# Legacy shims for making the new Rust extension work with the old type names
+
+import warnings
+
+__all__ = [
+    'wrap_stream',
+    'BufferedReader',
+    'IOStream',
+    'PythonIOStreamAdapter',
+    'CompressingStream',
+    'FileStream',
+    'BytesIOStream',
+    'GZipStream',
+    'LZ4Stream',
+    'BrotliStream',
+    'FastWARCError',
+    'StreamError',
+    'ReaderStaleError',
+]
+
+FastWARCError = OSError
+
+StreamError = OSError
+
+ReaderStaleError = OSError
+
+
+def _warn_deprecated(msg):
+    warnings.warn(msg, FutureWarning, 3)
+
+
+def wrap_stream(raw_stream, mode='rb', fsspec_args=None):
+    _warn_deprecated("wrap_stream is deprecated and will be removed in a future version.")
+    if isinstance(raw_stream, str):
+        if fsspec_args is not False and '://' in raw_stream:
+            try:
+                import fsspec
+                return fsspec.open(raw_stream, mode, **(fsspec_args or {})).open()
+            except ModuleNotFoundError:
+                pass
+        return open(raw_stream, mode)
+
+    return raw_stream
+
+
+class BufferedReader:
+    def __init__(self, stream, *args, **kwargs):
+        _warn_deprecated("BufferedReader is deprecated and will be removed in a future version.")
+        self._stream = stream
+
+    def close(self):
+        return self._stream.close()
+
+    def consume(self, size: int = -1):
+        return self._stream.consume(size)
+
+    def read(self, size: int = -1):
+        return self._stream.read(size)
+
+    def readline(self, crlf=True, max_line_len=8192):
+        return self._stream.readLine(max_line_len)
+
+    def tell(self):
+        return self._stream.tell()
+
+
+class IOStream:
+    def __init__(self, *_, _reader_factory=None, _writer_factory=None, **__):
+        _warn_deprecated(
+            f"{self.__class__.__name__} is deprecated and will be removed in a future version. "
+            "Use the new Reader and Writer classes from stream_io instead.")
+
+        self._reader_factory = _reader_factory
+        self._writer_factory = _writer_factory
+        self._reader = None
+        self._writer = None
+
+    def _get_stream(self):
+        if self._reader is not None:
+            return self._reader
+        if self._writer is not None:
+            return self._writer
+        stream = self._get_reader()
+        if stream is None:
+            stream = self._get_writer()
+        return stream
+
+    def _get_reader(self):
+        if self._reader is None:
+            self._reader = self._reader_factory()
+        return self._reader
+
+    def _get_writer(self):
+        if self._writer is None:
+            self._writer = self._writer_factory()
+        return self._writer
+
+    def read(self, size: int) -> bytes:
+        return self._get_reader().read(size)
+
+    def write(self, data: bytes) -> int:
+        return self._get_writer().write(data)
+
+    def close(self):
+        self._get_stream().close()
+
+    def flush(self):
+        self._get_stream().flush()
+
+    def seek(self, offset: int):
+        self._get_stream().seek(offset)
+
+    def tell(self) -> int:
+        return self._get_stream().tell()
+
+    def __enter__(self):
+        s = self._get_stream()
+        if hasattr(s, '__enter__'):
+            return self._get_stream().__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc, traceback):
+        s = self._get_stream()
+        if hasattr(s, '__exit__'):
+            self._get_stream().__exit__(exc_type, exc, traceback)
+        s.close()
+
+
+class CompressingStream(IOStream):
+    def begin_member(self):
+        pass
+
+    def end_member(self):
+        self._get_writer().finish()
+        self._writer = None
+
+
+class PythonIOStreamAdapter:
+    def __new__(cls, py_stream):
+        return IOStream(_reader_factory=lambda: py_stream,
+                        _writer_factory=lambda: py_stream)
+
+
+class FileStream:
+    def __new__(cls, filename: str, mode: str = 'rb'):
+        if 'b' not in mode:
+            mode += 'b'
+        f = open(filename, mode)
+        return IOStream(_reader_factory=lambda: f, _writer_factory=lambda: f)
+
+
+class BytesIOStream:
+    def __new__(cls, initial_data=None):
+        import io
+        bio = io.BytesIO(initial_data if initial_data is not None else b'')
+        return IOStream(_reader_factory=lambda: bio, _writer_factory=lambda: bio)
+
+
+class GZipStream:
+    def __new__(cls, raw_stream, compression_level=9, zlib=False, fsspec_args=None):
+        from ..stream_io import GzipReader, GzipWriter
+        stream = CompressingStream(
+            _reader_factory=lambda: GzipReader(raw_stream, zlib=zlib, fsspec_args=fsspec_args),
+            _writer_factory=lambda: GzipWriter(raw_stream, compression_level=compression_level, zlib=zlib,
+                                               fsspec_args=fsspec_args))
+        stream._raw_stream = raw_stream
+        return stream
+
+
+class LZ4Stream:
+    def __new__(cls, raw_stream, mode='r', compression_level=12,
+                favor_dec_speed=True, fsspec_args=None):
+        from ..stream_io import Lz4Reader, Lz4Writer
+        stream = CompressingStream(
+            _reader_factory=lambda: Lz4Reader(raw_stream, fsspec_args=fsspec_args),
+            _writer_factory=lambda: Lz4Writer(raw_stream, fsspec_args=fsspec_args))
+        stream._raw_stream = raw_stream
+        return stream
+
+
+class BrotliStream:
+    def __new__(cls, raw_stream, quality=11, lgwin=22, lgblock=0, fsspec_args=None):
+        from ..stream_io import BrotliReader, BrotliWriter
+        stream = CompressingStream(
+            _reader_factory=lambda: BrotliReader(raw_stream, fsspec_args=fsspec_args),
+            _writer_factory=lambda: BrotliWriter(raw_stream, fsspec_args=fsspec_args))
+        stream._raw_stream = raw_stream
+        return stream

{fastwarc-0.16.0/fastwarc → fastwarc-1.0.1/fastwarc/legacy}/tools.pyx

@@ -14,9 +14,9 @@
 
 # distutils: language = c++
 
-from fastwarc.stream_io cimport IOStream, GZipStream, LZ4Stream, FileStream, PythonIOStreamAdapter
-from fastwarc.stream_io import StreamError
-from fastwarc.warc cimport ArchiveIterator, WarcRecordType
+from fastwarc.legacy.stream_io cimport IOStream, GZipStream, LZ4Stream, FileStream, PythonIOStreamAdapter
+from fastwarc.legacy.stream_io import StreamError
+from fastwarc.legacy.warc cimport ArchiveIterator, WarcRecordType
 
 __all__ = [
     'CompressionAlg',

{fastwarc-0.16.0/fastwarc → fastwarc-1.0.1/fastwarc/legacy}/warc.pxd

@@ -16,7 +16,7 @@ from libc.stdint cimport uint16_t
 from libcpp.string cimport string
 from libcpp.vector cimport vector
 
-from fastwarc.stream_io cimport IOStream, BufferedReader
+from fastwarc.legacy.stream_io cimport IOStream, BufferedReader
 
 
 cpdef enum WarcRecordType:

{fastwarc-0.16.0/fastwarc → fastwarc-1.0.1/fastwarc/legacy}/warc.pyx

@@ -36,9 +36,9 @@ from resiliparse_inc.cctype cimport isspace
 from resiliparse_inc.cstdlib cimport strtol
 from resiliparse_inc.utility cimport move
 
-from fastwarc.stream_io cimport BufferedReader, BytesIOStream, CompressingStream, GZipStream, BrotliStream, \
+from fastwarc.legacy.stream_io cimport BufferedReader, BytesIOStream, CompressingStream, GZipStream, BrotliStream, \
     IOStream, wrap_stream
-from fastwarc.stream_io import ReaderStaleError
+from fastwarc.legacy.stream_io import ReaderStaleError
 
 __all__ = [
     'ArchiveIterator',