py-jsonl 1.0.0__tar.gz

py_jsonl-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rolando Morales Perez
+
+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.

py_jsonl-1.0.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.1
+Name: py-jsonl
+Version: 1.0.0
+Summary: A Python Library for Handling JSON Lines Files
+Home-page: https://github.com/rmoralespp/jsonl
+Author: rmoralespp
+Author-email: rmoralespp@gmail.com
+License: MIT
+Keywords: jsonlines,ndjson,jsonl
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Classifier: Topic :: Utilities
+Classifier: Topic :: File Formats :: JSON
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# jsonl
+
+[![CI](https://github.com/rmoralespp/jsonl/workflows/CI/badge.svg)](https://github.com/rmoralespp/jsonl/actions?query=event%3Arelease+workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/jsonl.svg)](https://pypi.python.org/pypi/jsonl-py)
+[![versions](https://img.shields.io/pypi/pyversions/jsonl.svg)](https://github.com/rmoralespp/jsonl)
+[![codecov](https://codecov.io/gh/rmoralespp/jsonl/branch/main/graph/badge.svg)](https://app.codecov.io/gh/rmoralespp/jsonl)
+[![license](https://img.shields.io/github/license/rmoralespp/jsonl.svg)](https://github.com/rmoralespp/jsonl/blob/main/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Linter: ruff](https://img.shields.io/badge/linter-_ruff-orange)](https://github.com/charliermarsh/ruff)
+
+### About
+
+jsonl is a Python Library for Handling JSON Lines Files
+
+`jsonl` exposes an API similar to the `json` module from the standard library.
+
+### Installation (via pip)
+
+```pip install jsonl```
+
+### Tests
+
+```
+(env)$ pip install -r requirements.txt   # Ignore this command if it has already been executed
+(env)$ pytest tests/
+(env)$ pytest --cov jsonl # Tests with coverge
+```
+
+### Usage
+
+#####  dumps
+```
+dumps(iterable, **kwargs)
+
+Serialize iterable to a JSON lines formatted string.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param kwargs: `json.dumps` kwargs
+:rtype: str
+```
+
+#####  dump
+```
+dump(iterable, fp, **kwargs)
+
+Serialize iterable as a JSON lines formatted stream to file-like object.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param fp: file-like object
+:param kwargs: `json.dumps` kwargs
+
+Example:
+    import jsonl.dump
+
+    data = ({'foo': 1}, {'bar': 2})
+    with open('myfile.jsonl', mode='w', encoding='utf-8') as file:
+        jsonl.dump(data, file)
+```
+
+
+#####  dump_into
+```
+dump_into(filename, iterable, encoding=utf_8, **kwargs)
+
+Dump iterable to a JSON lines file.
+
+Example:
+    import jsonl.dump_into
+
+    data = ({'foo': 1}, {'bar': 2})
+    jsonl.dump_into("myfile.jsonl", data)
+```
+
+#####  dump_fork
+```
+dump_fork(iterable_by_path, encoding=utf_8, dump_if_empty=True, **kwargs)
+
+Incrementally dumps different groups of elements into
+the indicated JSON lines file.
+***Useful to reduce memory consumption***
+
+:param Iterable[file_path, Iterable[dict]] iterable_by_path: Group items by file path
+:param encoding: file encoding. 'utf-8' used by default
+:param bool dump_if_empty: If false, don't create an empty JSON lines file.
+:param kwargs: `json.dumps` kwargs
+
+Examples:
+    import jsonl.dump_fork
+
+    path_items = (
+        ("num.jsonl", ({"value": 1}, {"value": 2})),
+        ("num.jsonl", ({"value": 3},)),
+        ("foo.jsonl", ({"a": "1"}, {"b": 2})),
+        ("baz.jsonl", ()),
+    )
+    jsonl.dump_fork(path_items)
+```
+
+#####  load
+```
+load(fp, **kwargs)
+
+Deserialize a file-like object containing JSON Lines into a Python iterable of objects.
+
+:param fp: file-like object
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[Any]
+```
+
+#####  load_from
+```
+def load_from(filename, encoding=utf_8, **kwargs)
+ 
+Deserialize a JSON Lines file into a Python iterable of objects.
+
+:param filename: path
+:param encoding: file encoding. 'utf-8' used by default
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[str]
+
+Examples:
+    import jsonl.load_from
+
+    it = jsonl.load_from("myfile.jsonl")
+    next(it)
+
+```

py_jsonl-1.0.0/README.md

@@ -0,0 +1,127 @@
+# jsonl
+
+[![CI](https://github.com/rmoralespp/jsonl/workflows/CI/badge.svg)](https://github.com/rmoralespp/jsonl/actions?query=event%3Arelease+workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/jsonl.svg)](https://pypi.python.org/pypi/jsonl-py)
+[![versions](https://img.shields.io/pypi/pyversions/jsonl.svg)](https://github.com/rmoralespp/jsonl)
+[![codecov](https://codecov.io/gh/rmoralespp/jsonl/branch/main/graph/badge.svg)](https://app.codecov.io/gh/rmoralespp/jsonl)
+[![license](https://img.shields.io/github/license/rmoralespp/jsonl.svg)](https://github.com/rmoralespp/jsonl/blob/main/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Linter: ruff](https://img.shields.io/badge/linter-_ruff-orange)](https://github.com/charliermarsh/ruff)
+
+### About
+
+jsonl is a Python Library for Handling JSON Lines Files
+
+`jsonl` exposes an API similar to the `json` module from the standard library.
+
+### Installation (via pip)
+
+```pip install jsonl```
+
+### Tests
+
+```
+(env)$ pip install -r requirements.txt   # Ignore this command if it has already been executed
+(env)$ pytest tests/
+(env)$ pytest --cov jsonl # Tests with coverge
+```
+
+### Usage
+
+#####  dumps
+```
+dumps(iterable, **kwargs)
+
+Serialize iterable to a JSON lines formatted string.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param kwargs: `json.dumps` kwargs
+:rtype: str
+```
+
+#####  dump
+```
+dump(iterable, fp, **kwargs)
+
+Serialize iterable as a JSON lines formatted stream to file-like object.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param fp: file-like object
+:param kwargs: `json.dumps` kwargs
+
+Example:
+    import jsonl.dump
+
+    data = ({'foo': 1}, {'bar': 2})
+    with open('myfile.jsonl', mode='w', encoding='utf-8') as file:
+        jsonl.dump(data, file)
+```
+
+
+#####  dump_into
+```
+dump_into(filename, iterable, encoding=utf_8, **kwargs)
+
+Dump iterable to a JSON lines file.
+
+Example:
+    import jsonl.dump_into
+
+    data = ({'foo': 1}, {'bar': 2})
+    jsonl.dump_into("myfile.jsonl", data)
+```
+
+#####  dump_fork
+```
+dump_fork(iterable_by_path, encoding=utf_8, dump_if_empty=True, **kwargs)
+
+Incrementally dumps different groups of elements into
+the indicated JSON lines file.
+***Useful to reduce memory consumption***
+
+:param Iterable[file_path, Iterable[dict]] iterable_by_path: Group items by file path
+:param encoding: file encoding. 'utf-8' used by default
+:param bool dump_if_empty: If false, don't create an empty JSON lines file.
+:param kwargs: `json.dumps` kwargs
+
+Examples:
+    import jsonl.dump_fork
+
+    path_items = (
+        ("num.jsonl", ({"value": 1}, {"value": 2})),
+        ("num.jsonl", ({"value": 3},)),
+        ("foo.jsonl", ({"a": "1"}, {"b": 2})),
+        ("baz.jsonl", ()),
+    )
+    jsonl.dump_fork(path_items)
+```
+
+#####  load
+```
+load(fp, **kwargs)
+
+Deserialize a file-like object containing JSON Lines into a Python iterable of objects.
+
+:param fp: file-like object
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[Any]
+```
+
+#####  load_from
+```
+def load_from(filename, encoding=utf_8, **kwargs)
+ 
+Deserialize a JSON Lines file into a Python iterable of objects.
+
+:param filename: path
+:param encoding: file encoding. 'utf-8' used by default
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[str]
+
+Examples:
+    import jsonl.load_from
+
+    it = jsonl.load_from("myfile.jsonl")
+    next(it)
+
+```

py_jsonl-1.0.0/jsonl.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+
+"""
+Useful functions for working with JSON lines data as
+described: https://jsonlines.org/
+
+`jsonl` exposes an API similar to the `json` module from the standard library.
+"""
+
+__version__ = "1.0.0"
+__all__ = [
+    "dump",
+    "dumps",
+    "dump_into",
+    "dump_fork",
+    "load",
+    "load",
+    "load_from",
+]
+__title__ = "py-jsonl"
+
+import functools
+import json
+import os
+
+empty = object()
+dumps_line = functools.partial(json.dumps, ensure_ascii=False)
+utf_8 = "utf-8"
+new_line = "\n"
+
+
+def dumper(iterable, **kwargs):
+    """Generator yielding JSON lines."""
+
+    encode = functools.partial(dumps_line, **kwargs)
+    for obj in iter(iterable):
+        yield encode(obj)
+        yield new_line
+
+
+def dumps(iterable, **kwargs):
+    """
+    Serialize iterable to a JSON lines formatted string.
+
+    :param Iterable[Any] iterable: Iterable of objects
+    :param kwargs: `json.dumps` kwargs
+    :rtype: str
+    """
+
+    return "".join(dumper(iterable, **kwargs))
+
+
+def dump(iterable, fp, **kwargs):
+    """
+    Serialize iterable as a JSON lines formatted stream to file-like object.
+
+    :param Iterable[Any] iterable: Iterable of objects
+    :param fp: file-like object
+    :param kwargs: `json.dumps` kwargs
+
+    Example:
+        import jsonl.dump
+
+        data = ({'foo': 1}, {'bar': 2})
+        with open('myfile.jsonl', mode='w', encoding='utf-8') as file:
+            jsonl.dump(data, file)
+    """
+
+    fp.writelines(dumper(iterable, **kwargs))
+
+
+def dump_into(filename, iterable, encoding=utf_8, **kwargs):
+    """
+    Dump iterable to a JSON lines file.
+
+    Example:
+        import jsonl.dump_into
+
+        data = ({'foo': 1}, {'bar': 2})
+        jsonl.dump_into("myfile.jsonl", data)
+    """
+
+    with open(filename, mode="w", encoding=encoding) as f:
+        dump(iterable, f, **kwargs)
+
+
+def dump_fork(iterable_by_path, encoding=utf_8, dump_if_empty=True, **kwargs):
+    """
+    Incrementally dumps different groups of elements into
+    the indicated JSON lines file.
+    ***Useful to reduce memory consumption***
+
+    :param Iterable[file_path, Iterable[dict]] iterable_by_path: Group items by file path
+    :param encoding: file encoding. 'utf-8' used by default
+    :param bool dump_if_empty: If false, don't create an empty JSON lines file.
+    :param kwargs: `json.dumps` kwargs
+
+    Examples:
+        import jsonl.dump_fork
+
+        path_items = (
+            ("num.jsonl", ({"value": 1}, {"value": 2})),
+            ("num.jsonl", ({"value": 3},)),
+            ("foo.jsonl", ({"a": "1"}, {"b": 2})),
+            ("baz.jsonl", ()),
+        )
+        jsonl.dump_fork(path_items)
+    """
+
+    def get_writer(dst):
+        nothing = True
+        with open(dst, mode="w", encoding=encoding) as fd:
+            try:
+                while True:
+                    obj = yield
+                    if nothing:
+                        nothing = False
+                    else:
+                        fd.write(new_line)
+                    fd.write(encoder(obj))
+            except GeneratorExit:
+                pass
+        if nothing and not dump_if_empty:
+            os.unlink(dst)
+
+    encoder = functools.partial(dumps_line, **kwargs)
+    writers = dict()
+
+    for path, iterable in iterable_by_path:
+        if path in writers:
+            writer = writers[path]
+        else:
+            writer = get_writer(path)
+            writer.send(None)
+            writers[path] = writer
+
+        for item in iterable:
+            writer.send(item)
+    # Cleanup
+    for writer in writers.values():
+        writer.close()
+
+
+def load(fp, **kwargs):
+    """
+    Deserialize a file-like object containing JSON Lines into a Python iterable of objects.
+
+    :param fp: file-like object
+    :param kwargs: `json.loads` kwargs
+    :rtype: Iterable[Any]
+    """
+
+    decode = functools.partial(json.loads, **kwargs)
+    yield from map(decode, fp)
+
+
+def load_from(filename, encoding=utf_8, **kwargs):
+    """
+    Deserialize a JSON Lines file into a Python iterable of objects.
+
+    :param filename: file path
+    :param encoding: file encoding. 'utf-8' used by default
+    :param kwargs: `json.loads` kwargs
+    :rtype: Iterable[Any]
+
+    Examples:
+        import jsonl.load_from
+
+        iterable = jsonl.load_from("myfile.jsonl")
+    """
+
+    with open(filename, encoding=encoding) as f:
+        yield from load(f, **kwargs)

py_jsonl-1.0.0/py_jsonl.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.1
+Name: py-jsonl
+Version: 1.0.0
+Summary: A Python Library for Handling JSON Lines Files
+Home-page: https://github.com/rmoralespp/jsonl
+Author: rmoralespp
+Author-email: rmoralespp@gmail.com
+License: MIT
+Keywords: jsonlines,ndjson,jsonl
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet
+Classifier: Topic :: Utilities
+Classifier: Topic :: File Formats :: JSON
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# jsonl
+
+[![CI](https://github.com/rmoralespp/jsonl/workflows/CI/badge.svg)](https://github.com/rmoralespp/jsonl/actions?query=event%3Arelease+workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/jsonl.svg)](https://pypi.python.org/pypi/jsonl-py)
+[![versions](https://img.shields.io/pypi/pyversions/jsonl.svg)](https://github.com/rmoralespp/jsonl)
+[![codecov](https://codecov.io/gh/rmoralespp/jsonl/branch/main/graph/badge.svg)](https://app.codecov.io/gh/rmoralespp/jsonl)
+[![license](https://img.shields.io/github/license/rmoralespp/jsonl.svg)](https://github.com/rmoralespp/jsonl/blob/main/LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Linter: ruff](https://img.shields.io/badge/linter-_ruff-orange)](https://github.com/charliermarsh/ruff)
+
+### About
+
+jsonl is a Python Library for Handling JSON Lines Files
+
+`jsonl` exposes an API similar to the `json` module from the standard library.
+
+### Installation (via pip)
+
+```pip install jsonl```
+
+### Tests
+
+```
+(env)$ pip install -r requirements.txt   # Ignore this command if it has already been executed
+(env)$ pytest tests/
+(env)$ pytest --cov jsonl # Tests with coverge
+```
+
+### Usage
+
+#####  dumps
+```
+dumps(iterable, **kwargs)
+
+Serialize iterable to a JSON lines formatted string.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param kwargs: `json.dumps` kwargs
+:rtype: str
+```
+
+#####  dump
+```
+dump(iterable, fp, **kwargs)
+
+Serialize iterable as a JSON lines formatted stream to file-like object.
+
+:param Iterable[Any] iterable: Iterable of objects
+:param fp: file-like object
+:param kwargs: `json.dumps` kwargs
+
+Example:
+    import jsonl.dump
+
+    data = ({'foo': 1}, {'bar': 2})
+    with open('myfile.jsonl', mode='w', encoding='utf-8') as file:
+        jsonl.dump(data, file)
+```
+
+
+#####  dump_into
+```
+dump_into(filename, iterable, encoding=utf_8, **kwargs)
+
+Dump iterable to a JSON lines file.
+
+Example:
+    import jsonl.dump_into
+
+    data = ({'foo': 1}, {'bar': 2})
+    jsonl.dump_into("myfile.jsonl", data)
+```
+
+#####  dump_fork
+```
+dump_fork(iterable_by_path, encoding=utf_8, dump_if_empty=True, **kwargs)
+
+Incrementally dumps different groups of elements into
+the indicated JSON lines file.
+***Useful to reduce memory consumption***
+
+:param Iterable[file_path, Iterable[dict]] iterable_by_path: Group items by file path
+:param encoding: file encoding. 'utf-8' used by default
+:param bool dump_if_empty: If false, don't create an empty JSON lines file.
+:param kwargs: `json.dumps` kwargs
+
+Examples:
+    import jsonl.dump_fork
+
+    path_items = (
+        ("num.jsonl", ({"value": 1}, {"value": 2})),
+        ("num.jsonl", ({"value": 3},)),
+        ("foo.jsonl", ({"a": "1"}, {"b": 2})),
+        ("baz.jsonl", ()),
+    )
+    jsonl.dump_fork(path_items)
+```
+
+#####  load
+```
+load(fp, **kwargs)
+
+Deserialize a file-like object containing JSON Lines into a Python iterable of objects.
+
+:param fp: file-like object
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[Any]
+```
+
+#####  load_from
+```
+def load_from(filename, encoding=utf_8, **kwargs)
+ 
+Deserialize a JSON Lines file into a Python iterable of objects.
+
+:param filename: path
+:param encoding: file encoding. 'utf-8' used by default
+:param kwargs: `json.loads` kwargs
+:rtype: Iterable[str]
+
+Examples:
+    import jsonl.load_from
+
+    it = jsonl.load_from("myfile.jsonl")
+    next(it)
+
+```

py_jsonl-1.0.0/py_jsonl.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+jsonl.py
+setup.py
+py_jsonl.egg-info/PKG-INFO
+py_jsonl.egg-info/SOURCES.txt
+py_jsonl.egg-info/dependency_links.txt
+py_jsonl.egg-info/not-zip-safe
+py_jsonl.egg-info/top_level.txt
+tests/test_dump.py
+tests/test_dump_fork.py
+tests/test_dump_into.py
+tests/test_dumper.py
+tests/test_dumps.py
+tests/test_load.py
+tests/test_load_from.py

py_jsonl-1.0.0/py_jsonl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_jsonl-1.0.0/py_jsonl.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

py_jsonl-1.0.0/py_jsonl.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonl

py_jsonl-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py_jsonl-1.0.0/setup.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+import setuptools
+
+import jsonl
+
+
+def read(filename):
+    with open(filename, encoding="utf-8") as f:
+        return f.read()
+
+
+setuptools.setup(
+    name=jsonl.__title__,
+    version=jsonl.__version__,
+    description="A Python Library for Handling JSON Lines Files",
+    long_description=read("README.md"),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3 :: Only",
+        "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",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Information Technology",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Internet",
+        "Topic :: Utilities",
+        "Topic :: File Formats :: JSON",
+    ],
+    keywords=["jsonlines", "ndjson", "jsonl"],
+    author="rmoralespp",
+    author_email="rmoralespp@gmail.com",
+    url="https://github.com/rmoralespp/jsonl",
+    license="MIT",
+    py_modules=["jsonl"],
+    zip_safe=False,  # https://mypy.readthedocs.io/en/latest/installed_packages.html
+    python_requires=">=3.8",
+)

py_jsonl-1.0.0/tests/test_dump.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+import io
+
+import jsonl
+
+
+def test_dump_empty():
+    fp = io.StringIO()
+    jsonl.dump((), fp)
+    result = fp.getvalue()
+    assert result == ""
+
+
+def test_dump_iter():
+    value = iter(({"foo": 1}, {"ño": 2}))
+    expected = '{"foo": 1}\n{"ño": 2}\n'
+    fp = io.StringIO()
+    jsonl.dump(value, fp)
+    result = fp.getvalue()
+    assert result == expected

py_jsonl-1.0.0/tests/test_dump_fork.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+import os
+import tempfile
+
+import pytest
+
+import jsonl
+import tests
+
+
+def test_dumped_iter_data():
+    with tempfile.TemporaryDirectory() as tmp:
+        foo_path = os.path.join(tmp, "foo.jsonl")
+        var_path = os.path.join(tmp, "var.jsonl")
+        baz_path = os.path.join(tmp, "baz.jsonl")
+
+        path_items = (
+            (foo_path, ({"foo": 1}, {"ño": 2})),
+            (foo_path, ({"extra": True},)),
+            (var_path, ({"foo": 1}, {"ño": 2})),
+            (baz_path, ()),
+        )
+        jsonl.dump_fork(iter(path_items))
+
+        assert tests.read(foo_path) == '{"foo": 1}\n{"ño": 2}\n{"extra": true}'
+        assert tests.read(var_path) == '{"foo": 1}\n{"ño": 2}'
+        assert tests.read(baz_path) == ""
+
+
+@pytest.mark.parametrize("dump_if_empty", (True, False))
+def test_dumped_empty_data(dump_if_empty):
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "foo.jsonl")
+        path_items = ((path, ()),)
+        jsonl.dump_fork(iter(path_items), dump_if_empty=dump_if_empty)
+        if dump_if_empty:
+            assert tests.read(path) == ""
+        else:
+            assert not os.path.exists(path)

py_jsonl-1.0.0/tests/test_dump_into.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+import os
+import tempfile
+
+import jsonl
+
+
+def test_exists_file():
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "foo.jsonl")
+        jsonl.dump_into(path, ())
+        assert os.path.exists(path)
+
+
+def test_dumped_iter_data():
+    value = iter(({"foo": 1}, {"ño": 2}))
+    expected = '{"foo": 1}\n{"ño": 2}\n'
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "foo.jsonl")
+        jsonl.dump_into(path, value)
+        with open(path, encoding="utf-8") as f:
+            result = f.read()
+    assert result == expected

py_jsonl-1.0.0/tests/test_dumper.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+import jsonl
+
+
+def test_empty():
+    expected = ()
+    result = jsonl.dumper(())
+    assert tuple(result) == expected
+
+
+def test_no_empty():
+    value = iter(({"foo": 1}, {"ño": 2}))
+    expected = ('{"foo": 1}', "\n", '{"ño": 2}', "\n")
+    result = jsonl.dumper(value)
+    assert tuple(result) == expected

py_jsonl-1.0.0/tests/test_dumps.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+import jsonl
+
+
+def test_dumps_empty():
+    assert not jsonl.dumps(())
+
+
+def test_dumps_data():
+    expected = '{"ño": 1}\n{"foo": "var"}\n'
+    value = ({"ño": 1}, {"foo": "var"})
+    result = jsonl.dumps(iter(value))
+    assert result == expected

py_jsonl-1.0.0/tests/test_load.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+import io
+import json
+
+import pytest
+
+import jsonl
+import tests
+
+
+def test_invalid_lines():
+    result = jsonl.load(io.StringIO("[1, 2]\n\n[3]"))
+    with pytest.raises(json.JSONDecodeError):
+        tests.consume(result)
+
+
+def test_invalid_utf8() -> None:
+    result = jsonl.load(io.BytesIO(b"\xff\xff"))
+    with pytest.raises(UnicodeDecodeError):
+        tests.consume(result)
+
+
+def test_load_empty():
+    result = jsonl.load(io.StringIO())
+    assert tuple(result) == ()
+
+
+def test_load_data():
+    value = '{"foo": 1}\n{"ño": 2}\n'
+    expected = ({"foo": 1}, {"ño": 2})
+    result = jsonl.load(io.StringIO(value))
+    assert tuple(result) == expected

py_jsonl-1.0.0/tests/test_load_from.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+import os
+import tempfile
+
+import pytest
+
+import jsonl
+import tests
+
+
+def test_load_empty():
+    expected = ()
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "foo.jsonl")
+        tests.write(path)
+        result = tuple(jsonl.load_from(path))
+    assert result == expected
+
+
+def test_load_data():
+    value = '{"foo": 1}\n{"ño": 2}\n'
+    expected = ({"foo": 1}, {"ño": 2})
+
+    with tempfile.TemporaryDirectory() as tmp:
+        path = os.path.join(tmp, "foo.jsonl")
+        tests.write(path, value)
+        result = tuple(jsonl.load_from(path))
+
+    assert result == expected
+
+
+def test_file_not_found():
+    with pytest.raises(FileNotFoundError):
+        tests.consume(jsonl.load_from("jsonl.json"))