flow.record 3.16.dev1__tar.gz → 3.16.dev3__tar.gz

{flow_record-3.16.dev1/flow.record.egg-info → flow_record-3.16.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flow.record
-Version: 3.16.dev1
+Version: 3.16.dev3
 Summary: A library for defining and creating structured data (called records) that can be streamed to disk or piped to other tools that use flow.record
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/flow/record/base.py

@@ -31,6 +31,7 @@ from urllib.parse import parse_qsl, urlparse
 
 from flow.record.adapter import AbstractReader, AbstractWriter
 from flow.record.exceptions import RecordAdapterNotFound, RecordDescriptorError
+from flow.record.utils import get_stdin, get_stdout
 
 try:
     import lz4.frame as lz4
@@ -812,10 +813,7 @@ def open_path(path: str, mode: str, clobber: bool = True) -> IO:
     # normal file or stdio for reading or writing
     if not fp:
         if is_stdio:
-            if binary:
-                fp = getattr(sys.stdout, "buffer", sys.stdout) if out else getattr(sys.stdin, "buffer", sys.stdin)
-            else:
-                fp = sys.stdout if out else sys.stdin
+            fp = get_stdout(binary=binary) if out else get_stdin(binary=binary)
         else:
             fp = io.open(path, mode)
         # check if we are reading a compressed stream
@@ -867,7 +865,7 @@ def RecordAdapter(
         if url in ("-", "", None) and fileobj is None:
             # For reading stdin, we cannot rely on an extension to know what sort of stream is incoming. Thus, we will
             # treat it as a 'fileobj', where we can peek into the stream and try to select the appropriate adapter.
-            fileobj = getattr(sys.stdin, "buffer", sys.stdin)
+            fileobj = get_stdin(binary=True)
         if fileobj is not None:
             # This record adapter has received a file-like object for record reading
             # We just need to find the right adapter by peeking into the first few bytes.

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/flow/record/fieldtypes/__init__.py

@@ -663,7 +663,7 @@ class path(pathlib.PurePath, FieldType):
                         #
                         # This construction works around that by converting all path parts
                         # to strings first.
-                        args = (str(arg) for arg in args)
+                        args = tuple(str(arg) for arg in args)
                 elif isinstance(path_part, pathlib.PurePosixPath):
                     cls = posix_path
                 elif _is_windowslike_path(path_part):
@@ -671,7 +671,7 @@ class path(pathlib.PurePath, FieldType):
                     # like path separator (\).
                     cls = windows_path
                     if not PY_312:
-                        args = (str(arg) for arg in args)
+                        args = tuple(str(arg) for arg in args)
                 elif _is_posixlike_path(path_part):
                     # This handles any custom PurePath based implementations that don't have a
                     # windows like path separator (\).
@@ -684,13 +684,24 @@ class path(pathlib.PurePath, FieldType):
             obj = super().__new__(cls)
         else:
             obj = cls._from_parts(args)
+
+        obj._empty_path = False
+        if not args or args == ("",):
+            obj._empty_path = True
         return obj
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
             return str(self) == other or self == self.__class__(other)
+        if self._empty_path:
+            return isinstance(other, self.__class__) and other._empty_path
         return super().__eq__(other)
 
+    def __str__(self) -> str:
+        if self._empty_path:
+            return ""
+        return super().__str__()
+
     def __repr__(self) -> str:
         return repr(str(self))
 

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/flow/record/stream.py

@@ -12,6 +12,7 @@ from functools import lru_cache
 from flow.record import RECORDSTREAM_MAGIC, RecordWriter
 from flow.record.fieldtypes import fieldtype_for_value
 from flow.record.selector import make_selector
+from flow.record.utils import is_stdout
 
 from .base import RecordDescriptor, RecordReader
 from .packer import RecordPacker
@@ -70,7 +71,7 @@ class RecordStreamWriter:
         self.write(descriptor)
 
     def close(self):
-        if self.fp and self.fp != getattr(sys.stdout, "buffer", sys.stdout):
+        if self.fp and not is_stdout(self.fp):
             self.fp.close()
             self.fp = None
 

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/flow/record/utils.py

@@ -1,15 +1,51 @@
+from __future__ import annotations
+
 import base64
 import os
 import sys
 from functools import wraps
+from typing import BinaryIO, TextIO
 
 _native = str
 _unicode = type("")
 _bytes = type(b"")
 
 
-def is_stdout(fp):
-    return fp in (sys.stdout, sys.stdout.buffer)
+def get_stdout(binary: bool = False) -> TextIO | BinaryIO:
+    """Return the stdout stream as binary or text stream.
+
+    This function is the preferred way to get the stdout stream in flow.record.
+
+    Arguments:
+        binary: Whether to return the stream as binary stream.
+
+    Returns:
+        The stdout stream.
+    """
+    fp = getattr(sys.stdout, "buffer", sys.stdout) if binary else sys.stdout
+    fp._is_stdout = True
+    return fp
+
+
+def get_stdin(binary: bool = False) -> TextIO | BinaryIO:
+    """Return the stdin stream as binary or text stream.
+
+    This function is the preferred way to get the stdin stream in flow.record.
+
+    Arguments:
+        binary: Whether to return the stream as binary stream.
+
+    Returns:
+        The stdin stream.
+    """
+    fp = getattr(sys.stdin, "buffer", sys.stdin) if binary else sys.stdin
+    fp._is_stdin = True
+    return fp
+
+
+def is_stdout(fp: TextIO | BinaryIO) -> bool:
+    """Returns True if ``fp`` is the stdout stream."""
+    return fp in (sys.stdout, sys.stdout.buffer) or hasattr(fp, "_is_stdout")
 
 
 def to_bytes(value):

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/flow/record/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.16.dev1'
-__version_tuple__ = version_tuple = (3, 16, 'dev1')
+__version__ = version = '3.16.dev3'
+__version_tuple__ = version_tuple = (3, 16, 'dev3')

{flow_record-3.16.dev1 → flow_record-3.16.dev3/flow.record.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flow.record
-Version: 3.16.dev1
+Version: 3.16.dev3
 Summary: A library for defining and creating structured data (called records) that can be streamed to disk or piped to other tools that use flow.record
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{flow_record-3.16.dev1 → flow_record-3.16.dev3}/tests/test_fieldtypes.py

@@ -11,7 +11,7 @@ from datetime import datetime, timedelta, timezone
 import pytest
 
 import flow.record.fieldtypes
-from flow.record import RecordDescriptor, RecordReader, RecordWriter
+from flow.record import RecordDescriptor, RecordReader, RecordWriter, fieldtypes
 from flow.record.fieldtypes import (
     PY_312,
     TYPE_POSIX,
@@ -617,8 +617,8 @@ def test_path():
     assert r.value is None
 
     r = TestRecord("")
-    assert str(r.value) == "."
-    assert r.value == "."
+    assert str(r.value) == ""
+    assert r.value == ""
 
     if os.name == "nt":
         native_path_str = windows_path_str
@@ -1132,5 +1132,79 @@ def test_command_failed() -> None:
         command(b"failed")
 
 
+@pytest.mark.parametrize(
+    "path_cls",
+    [
+        fieldtypes.posix_path,
+        fieldtypes.windows_path,
+        fieldtypes.path,
+    ],
+)
+def test_empty_path(path_cls) -> None:
+    # initialize with empty string
+    p1 = path_cls("")
+    assert p1 == ""
+    assert p1._empty_path
+    assert str(p1) == ""
+    assert p1 != path_cls(".")
+
+    # initialize without any arguments
+    p2 = path_cls()
+    assert p2 == ""
+    assert p2._empty_path
+    assert str(p2) == ""
+    assert p2 != path_cls(".")
+
+    assert p1 == p2
+
+
+def test_empty_path_different_types() -> None:
+    assert fieldtypes.posix_path("") != fieldtypes.windows_path("")
+
+
+def test_record_empty_path() -> None:
+    TestRecord = RecordDescriptor(
+        "test/path",
+        [
+            ("path", "value"),
+        ],
+    )
+
+    r = TestRecord()
+    assert r.value is None
+    assert repr(r) == "<test/path value=None>"
+
+    r = TestRecord("")
+    assert r.value == ""
+    assert repr(r) == "<test/path value=''>"
+
+
+def test_empty_path_serialization(tmp_path) -> None:
+    TestRecord = RecordDescriptor(
+        "test/path",
+        [
+            ("path", "value"),
+        ],
+    )
+
+    # Test path value=None serialization
+    p_tmp_records = tmp_path / "none_path"
+    with RecordWriter(p_tmp_records) as writer:
+        record = TestRecord()
+        writer.write(record)
+    with RecordReader(p_tmp_records) as reader:
+        for record in reader:
+            assert record.value is None
+
+    # Test path value="" serialization
+    p_tmp_records = tmp_path / "empty_str"
+    with RecordWriter(p_tmp_records) as writer:
+        record = TestRecord("")
+        writer.write(record)
+    with RecordReader(p_tmp_records) as reader:
+        for record in reader:
+            assert record.value == ""
+
+
 if __name__ == "__main__":
     __import__("standalone_test").main(globals())