python-frontmatter 1.0.1__tar.gz → 1.2.0__tar.gz

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/MANIFEST.in

@@ -1,5 +1,6 @@
 include LICENSE
 include README.md
+include frontmatter/py.typed
 
 recursive-include tests *
 

{python-frontmatter-1.0.1/python_frontmatter.egg-info → python_frontmatter-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-frontmatter
-Version: 1.0.1
+Version: 1.2.0
 Summary: Parse and manage posts with YAML (or other) frontmatter
 Home-page: https://github.com/eyeseast/python-frontmatter
 Author: Chris Amico
@@ -12,15 +12,35 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-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: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
 Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: toml; extra == "test"
+Requires-Dist: pyaml; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: types-PyYAML; extra == "test"
+Requires-Dist: types-toml; extra == "test"
 Provides-Extra: docs
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # Python Frontmatter
 
@@ -134,10 +154,10 @@ Well, hello there, world.
 Or write to a file (or file-like object):
 
 ```python
->>> from io import BytesIO
->>> f = BytesIO()
+>>> from io import StringIO
+>>> f = StringIO()
 >>> frontmatter.dump(post, f)
->>> print(f.getvalue().decode('utf-8')) # doctest: +NORMALIZE_WHITESPACE
+>>> print(f.getvalue()) # doctest: +NORMALIZE_WHITESPACE
 ---
 excerpt: tl;dr
 layout: post

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/README.md

@@ -110,10 +110,10 @@ Well, hello there, world.
 Or write to a file (or file-like object):
 
 ```python
->>> from io import BytesIO
->>> f = BytesIO()
+>>> from io import StringIO
+>>> f = StringIO()
 >>> frontmatter.dump(post, f)
->>> print(f.getvalue().decode('utf-8')) # doctest: +NORMALIZE_WHITESPACE
+>>> print(f.getvalue()) # doctest: +NORMALIZE_WHITESPACE
 ---
 excerpt: tl;dr
 layout: post

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/frontmatter/__init__.py

@@ -2,13 +2,19 @@
 """
 Python Frontmatter: Parse and manage posts with YAML frontmatter
 """
+from __future__ import annotations
 
-import codecs
-import re
+import io
+import pathlib
+from os import PathLike
+from typing import TYPE_CHECKING, Iterable, TextIO
 
+from .default_handlers import JSONHandler, TOMLHandler, YAMLHandler
+from .util import can_open, is_readable, is_writable, u
 
-from .util import u
-from .default_handlers import YAMLHandler, JSONHandler, TOMLHandler
+
+if TYPE_CHECKING:
+    from .default_handlers import BaseHandler
 
 
 __all__ = ["parse", "load", "loads", "dump", "dumps"]
@@ -22,7 +28,7 @@ handlers = [
 ]
 
 
-def detect_format(text, handlers):
+def detect_format(text: str, handlers: Iterable[BaseHandler]) -> BaseHandler | None:
     """
     Figure out which handler to use, based on metadata.
     Returns a handler instance or None.
@@ -40,7 +46,12 @@ def detect_format(text, handlers):
     return None
 
 
-def parse(text, encoding="utf-8", handler=None, **defaults):
+def parse(
+    text: str,
+    encoding: str = "utf-8",
+    handler: BaseHandler | None = None,
+    **defaults: object,
+) -> tuple[dict[str, object], str]:
     """
     Parse text with frontmatter, return metadata and content.
     Pass in optional metadata defaults as keyword args.
@@ -79,14 +90,14 @@ def parse(text, encoding="utf-8", handler=None, **defaults):
         return metadata, text
 
     # parse, now that we have frontmatter
-    fm = handler.load(fm)
-    if isinstance(fm, dict):
-        metadata.update(fm)
+    fm_data = handler.load(fm)
+    if isinstance(fm_data, dict):
+        metadata.update(fm_data)
 
     return metadata, content.strip()
 
 
-def check(fd, encoding="utf-8"):
+def check(fd: TextIO | PathLike[str] | str, encoding: str = "utf-8") -> bool:
     """
     Check if a file-like object or filename has a frontmatter,
     return True if exists, False otherwise.
@@ -99,17 +110,21 @@ def check(fd, encoding="utf-8"):
         True
 
     """
-    if hasattr(fd, "read"):
+    if is_readable(fd):
         text = fd.read()
 
-    else:
-        with codecs.open(fd, "r", encoding) as f:
+    elif can_open(fd):
+        with open(fd, "r", encoding=encoding) as f:
             text = f.read()
 
+    else:
+        # no idea what we're dealing with
+        return False
+
     return checks(text, encoding)
 
 
-def checks(text, encoding="utf-8"):
+def checks(text: str, encoding: str = "utf-8") -> bool:
     """
     Check if a text (binary or unicode) has a frontmatter,
     return True if exists, False otherwise.
@@ -127,7 +142,12 @@ def checks(text, encoding="utf-8"):
     return detect_format(text, handlers) != None
 
 
-def load(fd, encoding="utf-8", handler=None, **defaults):
+def load(
+    fd: str | io.IOBase | pathlib.Path,
+    encoding: str = "utf-8",
+    handler: BaseHandler | None = None,
+    **defaults: object,
+) -> Post:
     """
     Load and parse a file-like object or filename,
     return a :py:class:`post <frontmatter.Post>`.
@@ -139,18 +159,26 @@ def load(fd, encoding="utf-8", handler=None, **defaults):
         ...     post = frontmatter.load(f)
 
     """
-    if hasattr(fd, "read"):
+    if is_readable(fd):
         text = fd.read()
 
-    else:
-        with codecs.open(fd, "r", encoding) as f:
+    elif can_open(fd):
+        with open(fd, "r", encoding=encoding) as f:
             text = f.read()
 
+    else:
+        raise ValueError(f"Cannot open filename using type {type(fd)}")
+
     handler = handler or detect_format(text, handlers)
     return loads(text, encoding, handler, **defaults)
 
 
-def loads(text, encoding="utf-8", handler=None, **defaults):
+def loads(
+    text: str,
+    encoding: str = "utf-8",
+    handler: BaseHandler | None = None,
+    **defaults: object,
+) -> Post:
     """
     Parse text (binary or unicode) and return a :py:class:`post <frontmatter.Post>`.
 
@@ -166,18 +194,24 @@ def loads(text, encoding="utf-8", handler=None, **defaults):
     return Post(content, handler, **metadata)
 
 
-def dump(post, fd, encoding="utf-8", handler=None, **kwargs):
+def dump(
+    post: Post,
+    fd: str | PathLike[str] | TextIO,
+    encoding: str = "utf-8",
+    handler: BaseHandler | None = None,
+    **kwargs: object,
+) -> None:
     """
     Serialize :py:class:`post <frontmatter.Post>` to a string and write to a file-like object.
     Text will be encoded on the way out (utf-8 by default).
 
     ::
 
-        >>> from io import BytesIO
+        >>> from io import StringIO
         >>> post = frontmatter.load('tests/yaml/hello-world.txt')
-        >>> f = BytesIO()
+        >>> f = StringIO()
         >>> frontmatter.dump(post, f)
-        >>> print(f.getvalue().decode('utf-8'))
+        >>> print(f.getvalue())
         ---
         layout: post
         title: Hello, world!
@@ -188,11 +222,11 @@ def dump(post, fd, encoding="utf-8", handler=None, **kwargs):
 
     .. testcode::
 
-        from io import BytesIO
+        from io import StringIO
         post = frontmatter.load('tests/yaml/hello-world.txt')
-        f = BytesIO()
+        f = StringIO()
         frontmatter.dump(post, f)
-        print(f.getvalue().decode('utf-8'))
+        print(f.getvalue())
 
     .. testoutput::
 
@@ -205,15 +239,18 @@ def dump(post, fd, encoding="utf-8", handler=None, **kwargs):
 
     """
     content = dumps(post, handler, **kwargs)
-    if hasattr(fd, "write"):
-        fd.write(content.encode(encoding))
+    if is_writable(fd):
+        fd.write(content)
 
-    else:
-        with codecs.open(fd, "w", encoding) as f:
+    elif can_open(fd):
+        with open(fd, "w", encoding=encoding) as f:
             f.write(content)
 
+    else:
+        raise ValueError(f"Cannot open filename using type {type(fd)}")
+
 
-def dumps(post, handler=None, **kwargs):
+def dumps(post: Post, handler: BaseHandler | None = None, **kwargs: object) -> str:
     """
     Serialize a :py:class:`post <frontmatter.Post>` to a string and return text.
     This always returns unicode text, which can then be encoded.
@@ -252,6 +289,7 @@ def dumps(post, handler=None, **kwargs):
     if handler is None:
         handler = getattr(post, "handler", None) or YAMLHandler()
 
+    assert handler is not None
     return handler.format(post, **kwargs)
 
 
@@ -265,46 +303,48 @@ class Post(object):
     For convenience, metadata values are available as proxied item lookups.
     """
 
-    def __init__(self, content, handler=None, **metadata):
+    def __init__(
+        self, content: str, handler: BaseHandler | None = None, **metadata: object
+    ) -> None:
         self.content = str(content)
         self.metadata = metadata
         self.handler = handler
 
-    def __getitem__(self, name):
+    def __getitem__(self, name: str) -> object:
         "Get metadata key"
         return self.metadata[name]
 
-    def __contains__(self, item):
+    def __contains__(self, item: object) -> bool:
         "Check metadata contains key"
         return item in self.metadata
 
-    def __setitem__(self, name, value):
+    def __setitem__(self, name: str, value: object) -> None:
         "Set a metadata key"
         self.metadata[name] = value
 
-    def __delitem__(self, name):
+    def __delitem__(self, name: str) -> None:
         "Delete a metadata key"
         del self.metadata[name]
 
-    def __bytes__(self):
+    def __bytes__(self) -> bytes:
         return self.content.encode("utf-8")
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.content
 
-    def get(self, key, default=None):
+    def get(self, key: str, default: object = None) -> object:
         "Get a key, fallback to default"
         return self.metadata.get(key, default)
 
-    def keys(self):
+    def keys(self) -> Iterable[str]:
         "Return metadata keys"
         return self.metadata.keys()
 
-    def values(self):
+    def values(self) -> Iterable[object]:
         "Return metadata values"
         return self.metadata.values()
 
-    def to_dict(self):
+    def to_dict(self) -> dict[str, object]:
         "Post as a dict, for serializing"
         d = self.metadata.copy()
         d["content"] = self.content

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/frontmatter/conftest.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import pytest
 
 
 @pytest.fixture(autouse=True)
-def add_globals(doctest_namespace):
+def add_globals(doctest_namespace: dict[str, object]) -> None:
     import frontmatter
 
     doctest_namespace["frontmatter"] = frontmatter

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/frontmatter/default_handlers.py

@@ -8,8 +8,8 @@ By default, ``frontmatter`` reads and writes YAML metadata. But maybe
 you don't like YAML. Maybe enjoy writing metadata in JSON, or TOML, or
 some other exotic markup not yet invented. For this, there are handlers.
 
-This module includes handlers for YAML, JSON and TOML, as well as a 
-:py:class:`BaseHandler <frontmatter.default_handlers.BaseHandler>` that 
+This module includes handlers for YAML, JSON and TOML, as well as a
+:py:class:`BaseHandler <frontmatter.default_handlers.BaseHandler>` that
 outlines the basic API and can be subclassed to deal with new formats.
 
 **Note**: The TOML handler is only available if the `toml <https://pypi.org/project/toml/>`_
@@ -32,10 +32,10 @@ A handler needs to do four things:
 
 An example:
 
-Calling :py:func:`frontmatter.load <frontmatter.load>` (or :py:func:`loads <frontmatter.loads>`) 
-with the ``handler`` argument tells frontmatter which handler to use. 
-The handler instance gets saved as an attribute on the returned post 
-object. By default, calling :py:func:`frontmatter.dumps <frontmatter.dumps>` 
+Calling :py:func:`frontmatter.load <frontmatter.load>` (or :py:func:`loads <frontmatter.loads>`)
+with the ``handler`` argument tells frontmatter which handler to use.
+The handler instance gets saved as an attribute on the returned post
+object. By default, calling :py:func:`frontmatter.dumps <frontmatter.dumps>`
 on the post will use the attached handler.
 
 
@@ -67,7 +67,7 @@ on the post will use the attached handler.
     <BLANKLINE>
     And this shouldn't break.
 
-Passing a new handler to :py:func:`frontmatter.dumps <frontmatter.dumps>` 
+Passing a new handler to :py:func:`frontmatter.dumps <frontmatter.dumps>`
 (or :py:func:`dump <frontmatter.dump>`) changes the export format:
 
 ::
@@ -116,11 +116,19 @@ All handlers use the interface defined on ``BaseHandler``. Each handler needs to
 
 
 """
+from __future__ import annotations
 
 import json
 import re
 import yaml
 
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Type
+
+SafeDumper: Type[yaml.CDumper] | Type[yaml.SafeDumper]
+SafeLoader: Type[yaml.CSafeLoader] | Type[yaml.SafeLoader]
+toml: ModuleType | None
+
 try:
     from yaml import CSafeDumper as SafeDumper
     from yaml import CSafeLoader as SafeLoader
@@ -136,6 +144,10 @@ except ImportError:
 from .util import u
 
 
+if TYPE_CHECKING:
+    from frontmatter import Post
+
+
 __all__ = ["BaseHandler", "YAMLHandler", "JSONHandler"]
 
 if toml:
@@ -159,11 +171,16 @@ class BaseHandler:
     All default handlers are subclassed from BaseHandler.
     """
 
-    FM_BOUNDARY = None
-    START_DELIMITER = None
-    END_DELIMITER = None
+    FM_BOUNDARY: re.Pattern[str] | None = None
+    START_DELIMITER: str | None = None
+    END_DELIMITER: str | None = None
 
-    def __init__(self, fm_boundary=None, start_delimiter=None, end_delimiter=None):
+    def __init__(
+        self,
+        fm_boundary: re.Pattern[str] | None = None,
+        start_delimiter: str | None = None,
+        end_delimiter: str | None = None,
+    ):
         self.FM_BOUNDARY = fm_boundary or self.FM_BOUNDARY
         self.START_DELIMITER = start_delimiter or self.START_DELIMITER
         self.END_DELIMITER = end_delimiter or self.END_DELIMITER
@@ -176,7 +193,7 @@ class BaseHandler:
                 )
             )
 
-    def detect(self, text):
+    def detect(self, text: str) -> bool:
         """
         Decide whether this handler can parse the given ``text``,
         and return True or False.
@@ -184,30 +201,32 @@ class BaseHandler:
         Note that this is *not* called when passing a handler instance to
         :py:func:`frontmatter.load <frontmatter.load>` or :py:func:`loads <frontmatter.loads>`.
         """
+        assert self.FM_BOUNDARY is not None
         if self.FM_BOUNDARY.match(text):
             return True
         return False
 
-    def split(self, text):
+    def split(self, text: str) -> tuple[str, str]:
         """
         Split text into frontmatter and content
         """
+        assert self.FM_BOUNDARY is not None
         _, fm, content = self.FM_BOUNDARY.split(text, 2)
         return fm, content
 
-    def load(self, fm):
+    def load(self, fm: str) -> dict[str, Any]:
         """
         Parse frontmatter and return a dict
         """
         raise NotImplementedError
 
-    def export(self, metadata, **kwargs):
+    def export(self, metadata: dict[str, object], **kwargs: object) -> str:
         """
         Turn metadata back into text
         """
         raise NotImplementedError
 
-    def format(self, post, **kwargs):
+    def format(self, post: Post, **kwargs: object) -> str:
         """
         Turn a post into a string, used in ``frontmatter.dumps``
         """
@@ -233,14 +252,14 @@ class YAMLHandler(BaseHandler):
     FM_BOUNDARY = re.compile(r"^-{3,}\s*$", re.MULTILINE)
     START_DELIMITER = END_DELIMITER = "---"
 
-    def load(self, fm, **kwargs):
+    def load(self, fm: str, **kwargs: object) -> Any:
         """
         Parse YAML front matter. This uses yaml.SafeLoader by default.
         """
         kwargs.setdefault("Loader", SafeLoader)
-        return yaml.load(fm, **kwargs)
+        return yaml.load(fm, **kwargs)  # type: ignore[arg-type]
 
-    def export(self, metadata, **kwargs):
+    def export(self, metadata: dict[str, object], **kwargs: object) -> str:
         """
         Export metadata as YAML. This uses yaml.SafeDumper by default.
         """
@@ -248,8 +267,8 @@ class YAMLHandler(BaseHandler):
         kwargs.setdefault("default_flow_style", False)
         kwargs.setdefault("allow_unicode", True)
 
-        metadata = yaml.dump(metadata, **kwargs).strip()
-        return u(metadata)  # ensure unicode
+        metadata_str = yaml.dump(metadata, **kwargs).strip()  # type: ignore[call-overload]
+        return u(metadata_str)  # ensure unicode
 
 
 class JSONHandler(BaseHandler):
@@ -263,23 +282,24 @@ class JSONHandler(BaseHandler):
     START_DELIMITER = ""
     END_DELIMITER = ""
 
-    def split(self, text):
+    def split(self, text: str) -> tuple[str, str]:
+        assert self.FM_BOUNDARY is not None
         _, fm, content = self.FM_BOUNDARY.split(text, 2)
         return "{" + fm + "}", content
 
-    def load(self, fm, **kwargs):
-        return json.loads(fm, **kwargs)
+    def load(self, fm: str, **kwargs: object) -> Any:
+        return json.loads(fm, **kwargs)  # type: ignore[arg-type]
 
-    def export(self, metadata, **kwargs):
+    def export(self, metadata: dict[str, object], **kwargs: object) -> str:
         "Turn metadata into JSON"
         kwargs.setdefault("indent", 4)
-        metadata = json.dumps(metadata, **kwargs)
-        return u(metadata)
+        metadata_str = json.dumps(metadata, **kwargs)  # type: ignore[arg-type]
+        return u(metadata_str)
 
 
 if toml:
 
-    class TOMLHandler(BaseHandler):
+    class TOMLHandler(BaseHandler):  # pyright: ignore
         """
         Load and export TOML metadata.
 
@@ -289,14 +309,15 @@ if toml:
         FM_BOUNDARY = re.compile(r"^\+{3,}\s*$", re.MULTILINE)
         START_DELIMITER = END_DELIMITER = "+++"
 
-        def load(self, fm, **kwargs):
+        def load(self, fm: str, **kwargs: object) -> Any:
+            assert toml is not None
             return toml.loads(fm, **kwargs)
 
-        def export(self, metadata, **kwargs):
+        def export(self, metadata: dict[str, object], **kwargs: object) -> str:
             "Turn metadata into TOML"
-            metadata = toml.dumps(metadata)
-            return u(metadata)
-
+            assert toml is not None
+            metadata_str = toml.dumps(metadata)
+            return u(metadata_str)
 
 else:
-    TOMLHandler = None
+    TOMLHandler: Type[TOMLHandler] | None = None  #  type: ignore[no-redef]

python_frontmatter-1.2.0/frontmatter/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. This package uses inline types.

python_frontmatter-1.2.0/frontmatter/util.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+"""
+Utilities for handling unicode and other repetitive bits
+"""
+from os import PathLike
+from typing import TypeGuard, TextIO
+
+
+def is_readable(fd: object) -> TypeGuard[TextIO]:
+    return callable(getattr(fd, "read", None))
+
+
+def is_writable(fd: object) -> TypeGuard[TextIO]:
+    return callable(getattr(fd, "write", None))
+
+
+def can_open(fd: object) -> TypeGuard[str | PathLike[str]]:
+    return isinstance(fd, str) or isinstance(fd, PathLike)
+
+
+def u(text: str | bytes, encoding: str = "utf-8") -> str:
+    "Return unicode text, no matter what"
+
+    if isinstance(text, bytes):
+        text_str: str = text.decode(encoding)
+    else:
+        text_str = str(text)
+
+    # it's already unicode
+    text_str = text_str.replace("\r\n", "\n")
+    return text_str

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0/python_frontmatter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-frontmatter
-Version: 1.0.1
+Version: 1.2.0
 Summary: Parse and manage posts with YAML (or other) frontmatter
 Home-page: https://github.com/eyeseast/python-frontmatter
 Author: Chris Amico
@@ -12,15 +12,35 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-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: Programming Language :: Python :: 3.13
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
 Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: toml; extra == "test"
+Requires-Dist: pyaml; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: types-PyYAML; extra == "test"
+Requires-Dist: types-toml; extra == "test"
 Provides-Extra: docs
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # Python Frontmatter
 
@@ -134,10 +154,10 @@ Well, hello there, world.
 Or write to a file (or file-like object):
 
 ```python
->>> from io import BytesIO
->>> f = BytesIO()
+>>> from io import StringIO
+>>> f = StringIO()
 >>> frontmatter.dump(post, f)
->>> print(f.getvalue().decode('utf-8')) # doctest: +NORMALIZE_WHITESPACE
+>>> print(f.getvalue()) # doctest: +NORMALIZE_WHITESPACE
 ---
 excerpt: tl;dr
 layout: post

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/python_frontmatter.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ setup.py
 frontmatter/__init__.py
 frontmatter/conftest.py
 frontmatter/default_handlers.py
+frontmatter/py.typed
 frontmatter/util.py
 python_frontmatter.egg-info/PKG-INFO
 python_frontmatter.egg-info/SOURCES.txt

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/python_frontmatter.egg-info/requires.txt

@@ -7,3 +7,6 @@ sphinx
 pytest
 toml
 pyaml
+mypy
+types-PyYAML
+types-toml

{python-frontmatter-1.0.1 → python_frontmatter-1.2.0}/setup.py

@@ -11,7 +11,7 @@ with open("README.md") as f:
     readme = f.read()
 
 
-VERSION = "1.0.1"
+VERSION = "1.2.0"
 
 
 setup(
@@ -24,9 +24,13 @@ setup(
     author_email="eyeseast@gmail.com",
     url="https://github.com/eyeseast/python-frontmatter",
     packages=["frontmatter"],
+    package_data={"frontmatter": ["py.typed"]},
     include_package_data=True,
     install_requires=["PyYAML"],
-    extras_require={"test": ["pytest", "toml", "pyaml"], "docs": ["sphinx"]},
+    extras_require={
+        "test": ["pytest", "toml", "pyaml", "mypy", "types-PyYAML", "types-toml"],
+        "docs": ["sphinx"],
+    },
     tests_require=["python-frontmatter[test]"],
     license="MIT",
     zip_safe=False,
@@ -37,11 +41,11 @@ setup(
         "License :: OSI Approved :: MIT License",
         "Natural Language :: English",
         "Programming Language :: Python :: 3",
-        "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",
+        "Programming Language :: Python :: 3.13",
     ],
     test_suite="test",
 )

python-frontmatter-1.0.1/frontmatter/util.py

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Utilities for handling unicode and other repetitive bits
-"""
-
-
-def u(text, encoding="utf-8"):
-    "Return unicode text, no matter what"
-
-    if isinstance(text, bytes):
-        text = text.decode(encoding)
-
-    # it's already unicode
-    text = text.replace("\r\n", "\n")
-    return text