renard-pipeline 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

renard/pipeline/ner.py

@@ -16,6 +16,7 @@ from renard.ner_utils import ner_entities
 if TYPE_CHECKING:
     from transformers.tokenization_utils_base import BatchEncoding
     from transformers import PreTrainedModel, PreTrainedTokenizerFast
+    from renard.pipeline.core import Pipeline
 
 
 @dataclass
@@ -214,10 +215,10 @@ class BertNamedEntityRecognizer(PipelineStep):
 
         super().__init__()
 
-    def _pipeline_init_(self, lang: str, progress_reporter: ProgressReporter):
+    def _pipeline_init_(self, lang: str, **kwargs):
         from transformers import AutoModelForTokenClassification, AutoTokenizer  # type: ignore
 
-        super()._pipeline_init_(lang, progress_reporter)
+        super()._pipeline_init_(lang, **kwargs)
 
         # init model if needed (this happens if the user did not pass
         # the instance of a model)

renard/pipeline/progress.py

@@ -1,4 +1,6 @@
+from __future__ import annotations
 from typing import Iterable, Literal, Optional, TypeVar, Generator
+import sys
 from tqdm import tqdm
 
 
@@ -20,6 +22,10 @@ class ProgressReporter:
         """Update reporter current message."""
         pass
 
+    def get_subreporter(self) -> ProgressReporter:
+        """Get the subreporter corresponding to that reporter."""
+        raise NotImplementedError
+
 
 class NoopProgressReporter(ProgressReporter):
     def reset_(self):
@@ -28,6 +34,28 @@ class NoopProgressReporter(ProgressReporter):
     def update_progress_(self, added_progress: int):
         pass
 
+    def get_subreporter(self) -> ProgressReporter:
+        return NoopProgressReporter()
+
+
+class TQDMSubProgressReporter(ProgressReporter):
+    def __init__(self, reporter: TQDMProgressReporter) -> None:
+        super().__init__()
+        self.reporter = reporter
+
+    def start_(self, total: int):
+        super().start_(total)
+        self.progress = 0
+
+    def update_progress_(self, added_progress: int):
+        self.progress += added_progress
+        self.reporter.tqdm.set_postfix(step=f"({self.progress}/{self.total})")
+
+    def update_message_(self, message: str):
+        self.reporter.tqdm.set_postfix(
+            step=f"({self.progress}/{self.total})", message=message
+        )
+
 
 class TQDMProgressReporter(ProgressReporter):
     def start_(self, total: int):
@@ -40,6 +68,9 @@ class TQDMProgressReporter(ProgressReporter):
     def update_message_(self, message: str):
         self.tqdm.set_description_str(message)
 
+    def get_subreporter(self) -> ProgressReporter:
+        return TQDMSubProgressReporter(self)
+
 
 T = TypeVar("T")
 
@@ -62,5 +93,5 @@ def get_progress_reporter(name: Optional[Literal["tqdm"]]) -> ProgressReporter:
         return NoopProgressReporter()
     if name == "tqdm":
         return TQDMProgressReporter()
-    print(f"[warning] unknown progress reporter: {name}")
+    print(f"[warning] unknown progress reporter: {name}", file=sys.stderr)
     return NoopProgressReporter()

renard/pipeline/speaker_attribution.py

@@ -49,13 +49,12 @@ class BertSpeakerDetector(PipelineStep):
 
         super().__init__()
 
-    def _pipeline_init_(self, lang: str, progress_reporter: ProgressReporter):
+    def _pipeline_init_(self, lang: str, **kwargs):
         from transformers import AutoTokenizer
 
-        super()._pipeline_init_(lang, progress_reporter)
+        super()._pipeline_init_(lang, **kwargs)
 
         if self.model is None:
-
             # the user supplied a huggingface ID: load model from the HUB
             if not self.huggingface_model_id is None:
                 self.model = SpeakerAttributionModel.from_pretrained(

renard/pipeline/tokenization.py

@@ -1,49 +1,78 @@
-from typing import Dict, Any, List, Optional, Set, Union, Literal
-import itertools
-import torch
+from typing import Dict, Any, Set, Union, Literal, List, Tuple
+from more_itertools import windowed
 import nltk
-from transformers.tokenization_utils_base import BatchEncoding
-from more_itertools.recipes import flatten
+from nltk.data import load
+from nltk.tokenize.destructive import NLTKWordTokenizer
 from renard.pipeline.core import PipelineStep
-from renard.pipeline.progress import ProgressReporter
 from renard.nltk_utils import NLTK_ISO_STRING_TO_LANG
 
 
+def make_char2token(text: str, token2chars: List[Tuple[int, int]]) -> List[int]:
+    if len(token2chars) == 0:
+        return []
+
+    c2t = [None] * len(text)
+    for token_i, chars in enumerate(token2chars):
+        for char_i in range(*chars):
+            c2t[char_i] = token_i  # type: ignore
+
+    for char_i in range(0, token2chars[0][0]):
+        c2t[char_i] = 0  # type: ignore
+    for chars1, chars2 in windowed(token2chars, 2):
+        if chars1 is None or chars2 is None:
+            continue
+        end1 = chars1[1]
+        start2 = chars2[0]
+        for char_i in range(end1, start2):
+            c2t[char_i] = c2t[end1 - 1]
+    for char_i in range(token2chars[-1][1], len(c2t)):
+        c2t[char_i] = token2chars[-1][1]  # type: ignore
+
+    assert all([not i is None for i in c2t])
+    return c2t  # type: ignore
+
+
 class NLTKTokenizer(PipelineStep):
-    """Construct a nltk word tokenizer"""
+    """A NLTK-based tokenizer"""
 
     def __init__(self):
         nltk.download("punkt", quiet=True)
+        self.word_tokenizer = None
+        self.sent_tokenizer = None
         super().__init__()
 
-    def __call__(
-        self, text: str, chapters: Optional[List[str]] = None, **kwargs
-    ) -> Dict[str, Any]:
-        """
-        :param text:
-        """
-        if not chapters is None:
-            out_dicts = [self.__call__(chapter, None) for chapter in chapters]
-            return {
-                "tokens": list(itertools.chain(*[d["tokens"] for d in out_dicts])),
-                "sentences": list(
-                    itertools.chain(*[d["sentences"] for d in out_dicts])
-                ),
-                "chapter_tokens": [d["tokens"] for d in out_dicts],
-            }
-
-        sentences = nltk.sent_tokenize(
-            text, language=NLTK_ISO_STRING_TO_LANG[self.lang]
-        )
+    def _pipeline_init_(self, lang: str, **kwargs):
+        assert lang in NLTK_ISO_STRING_TO_LANG
+        nltk_lang = NLTK_ISO_STRING_TO_LANG[lang]
+        self.word_tokenizer = NLTKWordTokenizer()
+        self.sent_tokenizer = load(f"tokenizers/punkt/{nltk_lang}.pickle")
+        super()._pipeline_init_(lang, **kwargs)
+
+    def __call__(self, text: str, **kwargs) -> Dict[str, Any]:
+        assert not self.word_tokenizer is None
+        assert not self.sent_tokenizer is None
+
+        sent_indices = self.sent_tokenizer.span_tokenize(text)
 
         tokens = []
+        token2chars = []
         tokenized_sentences = []
-        for sent in sentences:
-            sent_tokens = nltk.word_tokenize(sent)
+        for sent_start, sent_end in sent_indices:
+            sent = text[sent_start:sent_end]
+            sent_tokens_indices = list(self.word_tokenizer.span_tokenize(sent))
+            token2chars += [
+                (start + sent_start, end + sent_start)
+                for start, end in sent_tokens_indices
+            ]
+            sent_tokens = [sent[start:end] for start, end in sent_tokens_indices]
             tokenized_sentences.append(sent_tokens)
             tokens += sent_tokens
 
-        return {"tokens": tokens, "sentences": tokenized_sentences}
+        return {
+            "tokens": tokens,
+            "char2token": make_char2token(text, token2chars),
+            "sentences": tokenized_sentences,
+        }
 
     def supported_langs(self) -> Union[Set[str], Literal["any"]]:
         return set(NLTK_ISO_STRING_TO_LANG.keys())
@@ -52,4 +81,4 @@ class NLTKTokenizer(PipelineStep):
         return {"text"}
 
     def production(self) -> Set[str]:
-        return {"tokens", "chapter_tokens", "sentences"}
+        return {"tokens", "char2token", "sentences"}

renard/plot_utils.py

@@ -15,53 +15,66 @@ CharactersGraphLayout = Union[
 
 
 def layout_nx_graph_reasonably(G: nx.Graph) -> Dict[Any, np.ndarray]:
-    return nx.spring_layout(G, k=2 / math.sqrt(len(G.nodes)))  # type: ignore
+    return nx.spring_layout(G, k=min(1.5, 8 / math.sqrt(len(G.nodes))))  # type: ignore
 
 
-def plot_nx_graph_reasonably(G: nx.Graph, ax=None, layout: Optional[dict] = None):
+def plot_nx_graph_reasonably(
+    G: nx.Graph,
+    ax=None,
+    layout: Optional[dict] = None,
+    node_kwargs: Optional[Dict[str, Any]] = None,
+    edge_kwargs: Optional[Dict[str, Any]] = None,
+    label_kwargs: Optional[Dict[str, Any]] = None,
+):
     """Try to plot a :class:`nx.Graph` with 'reasonable' parameters
 
     :param G: the graph to draw
     :param ax: matplotlib axes
     :param layout: if given, this graph layout will be applied.
         Otherwise, use :func:`layout_nx_graph_reasonably`.
+    :param node_kwargs: passed to :func:`nx.draw_networkx_nodes`
+    :param edge_kwargs: passed to :func:`nx.draw_networkx_nodes`
+    :param label_kwargs: passed to :func:`nx.draw_networkx_labels`
     """
     pos = layout
     if pos is None:
         pos = layout_nx_graph_reasonably(G)
 
-    nx.draw_networkx_nodes(
-        G,
-        pos,
-        node_color=[degree for _, degree in G.degree],  # type: ignore
-        cmap=plt.get_cmap("winter_r"),
-        node_size=[1 + degree * 10 for _, degree in G.degree],  # type: ignore
-        ax=ax,
+    node_kwargs = node_kwargs or {}
+    node_kwargs["node_color"] = node_kwargs.get(
+        "node_color", [degree for _, degree in G.degree]
     )
+    node_kwargs["cmap"] = node_kwargs.get("cmap", "viridis")
+    node_kwargs["node_size"] = node_kwargs.get(
+        "node_size", [1 + degree * 10 for _, degree in G.degree]
+    )
+    nx.draw_networkx_nodes(G, pos, ax=ax, **node_kwargs)
 
+    edge_kwargs = edge_kwargs or {}
     edges_attrs = graph_edges_attributes(G)
-    if "polarity" in edges_attrs:
+    if (
+        not "edge_color" in edge_kwargs
+        and not "edge_cmap" in edge_kwargs
+        and "polarity" in edges_attrs
+    ):
         # we draw the polarity of interactions if the 'polarity'
         # attribute is present in the graph
         polarities = [d.get("polarity", 0) for *_, d in G.edges.data()]  # type: ignore
-        edge_color = ["g" if p > 0 else "r" for p in polarities]
-        edge_cmap = None
-
+        edge_kwargs["edge_color"] = ["g" if p > 0 else "r" for p in polarities]
+        edge_kwargs["edge_cmap"] = None
     else:
-        edge_color = [math.log(d["weight"]) for *_, d in G.edges.data()]
-        edge_cmap = plt.get_cmap("winter_r")
-    nx.draw_networkx_edges(
-        G,
-        pos,
-        edge_color=edge_color,
-        edge_cmap=edge_cmap,
-        edge_vmax=1,
-        edge_vmin=-1,
-        width=[1 + math.log(d["weight"]) for _, _, d in G.edges.data()],  # type: ignore
-        alpha=0.35,
-        ax=ax,
+        edge_kwargs["edge_color"] = edge_kwargs.get(
+            "edge_color", [math.log(d["weight"]) for *_, d in G.edges.data()]
+        )
+        edge_kwargs["edge_cmap"] = edge_kwargs.get("edge_cmap", plt.get_cmap("viridis"))
+    edge_kwargs["width"] = edge_kwargs.get(
+        "width", [1 + math.log(d["weight"]) for _, _, d in G.edges.data()]
     )
+    edge_kwargs["alpha"] = edge_kwargs.get("alpha", 0.35)
+    nx.draw_networkx_edges(G, pos, ax=ax, **edge_kwargs)
 
-    nx.draw_networkx_labels(
-        G, pos=pos, ax=ax, verticalalignment="top", font_size=8, alpha=0.75
-    )
+    label_kwargs = label_kwargs or {}
+    label_kwargs["verticalalignment"] = label_kwargs.get("verticalalignment", "top")
+    label_kwargs["font_size"] = label_kwargs.get("font_size", 8)
+    label_kwargs["alpha"] = label_kwargs.get("alpha", 0.75)
+    nx.draw_networkx_labels(G, pos=pos, ax=ax, **label_kwargs)

renard/resources/hypocorisms/hypocorisms.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Set, Tuple
 from collections import defaultdict
-import os
+import os, sys
 
 script_dir = os.path.dirname(os.path.abspath(__file__))
 
@@ -24,7 +24,8 @@ class HypocorismGazetteer:
         """
         if not lang in HypocorismGazetteer.supported_langs:
             print(
-                f"[warning] {lang} not supported by {type(self)} (supported languages: {HypocorismGazetteer.supported_langs})"
+                f"[warning] {lang} not supported by {type(self)} (supported languages: {HypocorismGazetteer.supported_langs})",
+                file=sys.stderr,
             )
 
         self.name_to_nicknames = defaultdict(set)

renard/utils.py

@@ -1,4 +1,5 @@
-from typing import List, Tuple, TypeVar, Collection, Iterable, cast
+from typing import List, Literal, Tuple, TypeVar, Collection, Iterable, cast, Union
+import sys
 from more_itertools.more import windowed
 import torch
 
@@ -76,3 +77,58 @@ def search_pattern(seq: Iterable[R], pattern: List[R]) -> List[int]:
         if list(subseq) == pattern:
             start_indices.append(subseq_i)
     return start_indices
+
+
+#: A `BlockBounds` delimits blocks in either raw text ("characters") or
+#: tokenized text ("tokens"). It has the following form:
+#:
+#: ([(block start, block end), ...], unit)
+#:
+#: see :func:`block_indices` to easily create `BlockBounds`
+BlockBounds = Tuple[List[Tuple[int, int]], Literal["characters", "tokens"]]
+
+
+def block_bounds(blocks: Union[List[str], List[List[str]]]) -> BlockBounds:
+    """Return the boundaries of a series of blocks.
+
+    :param blocks: either a list of raw texts or a list of tokenized
+        texts.
+
+    :return: A `BlockBounds` with the correct unit.
+    """
+    if len(blocks) == 0:
+        print("[warning] computing block bounds on 0 blocks.", file=sys.stderr)
+        return ([], ("characters"))
+
+    if isinstance(blocks[0], str):
+        unit = "characters"
+    elif isinstance(blocks[0], list):
+        unit = "tokens"
+    else:
+        raise ValueError(blocks)
+
+    indices = []
+    start = 0
+    for block in blocks:
+        end = start + len(block)
+        indices.append((start, end))
+        start = end
+
+    return (indices, unit)
+
+
+def charbb2tokenbb(char_bb: BlockBounds, char2token: List[int]) -> BlockBounds:
+    """Convert a `BlockBounds` in characters to a `BlockBounds` in
+    tokens.
+
+    :param char_bb: block bounds, in 'characters'.
+    :param char2token: a list with ``char2token[i]`` being the index
+        of token corresponding to character ``i``.
+
+    :return: a `BlockBounds`, in 'tokens'.
+    """
+    assert char_bb[1] == "characters"
+    tokens_blocks = []
+    for char_block_start, char_block_end in char_bb[0]:
+        tokens_blocks.append((char2token[char_block_start], char2token[char_block_end]))
+    return (tokens_blocks, "tokens")

{renard_pipeline-0.4.1.dist-info → renard_pipeline-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: renard-pipeline
-Version: 0.4.1
+Version: 0.5.0
 Summary: Relationships Extraction from NARrative Documents
 Home-page: https://github.com/CompNet/Renard
 License: GPL-3.0-only
@@ -28,7 +28,7 @@ Requires-Dist: seqeval (==1.2.2)
 Requires-Dist: spacy (>=3.5.0,<4.0.0) ; extra == "spacy"
 Requires-Dist: spacy-transformers (>=1.2.1,<2.0.0) ; extra == "spacy"
 Requires-Dist: stanza (>=1.3.0,<2.0.0) ; extra == "stanza"
-Requires-Dist: tibert (>=0.3.0,<0.4.0)
+Requires-Dist: tibert (>=0.4.0,<0.5.0)
 Requires-Dist: torch (>=2.0.0,!=2.0.1)
 Requires-Dist: tqdm (>=4.62.3,<5.0.0)
 Requires-Dist: transformers (>=4.36.0,<5.0.0)
@@ -38,9 +38,11 @@ Description-Content-Type: text/markdown
 
 # Renard
 
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06574/status.svg)](https://doi.org/10.21105/joss.06574)
+
 Renard (Relationships Extraction from NARrative Documents) is a library for creating and using custom character networks extraction pipelines. Renard can extract dynamic as well as static character networks.
 
-![Character network extracted from "Pride and Prejudice"](./docs/pp_white_bg.svg)
+![The Renard logo](./docs/renard.svg)
 
 
 # Installation
@@ -102,3 +104,25 @@ Expensive tests are disabled by default. These can be run by setting the environ
 
 see [the "Contributing" section of the documentation](https://compnet.github.io/Renard/contributing.html).
 
+
+# How to cite
+
+If you use Renard in your research project, please cite it as follows:
+
+```bibtex
+@Article{Amalvy2024,
+  doi	       = {10.21105/joss.06574},
+  year	       = {2024},
+  publisher    = {The Open Journal},
+  volume       = {9},
+  number       = {98},
+  pages	       = {6574},
+  author       = {Amalvy, A. and Labatut, V. and Dufour, R.},
+  title	       = {Renard: A Modular Pipeline for Extracting Character
+                  Networks from Narrative Texts},
+  journal      = {Journal of Open Source Software},
+} 
+```
+
+We would be happy to hear about your usage of Renard, so don't hesitate to reach out!
+

{renard_pipeline-0.4.1.dist-info → renard_pipeline-0.5.0.dist-info}/RECORD

@@ -1,35 +1,35 @@
 renard/gender.py,sha256=HDtJQKOqIkV8F-Mxva95XFXWJoKRKckQ3fc93OBM6sw,102
-renard/graph_utils.py,sha256=5jwky9JgJ-WMVHfeaiXkAAQwEfhR2BFSrWhck1Qmpgo,5812
-renard/ner_utils.py,sha256=jN1AQkaV0Kx-Bc0oc3SYBEmSUuKPBbzXqByOlaqH62k,11263
+renard/graph_utils.py,sha256=EV0_56KtI3VOElCu7wxd2kL8QVPsOu7itE6wGJAJsNA,6073
+renard/ner_utils.py,sha256=dfcPzoONjMXAnD1pfWkDF3oHPtitu71PJvvtnFKwg1A,11425
 renard/nltk_utils.py,sha256=mUJiwMrEDZV4Fla7WuMR-hA_OC2ZIwSXgW_0Ew18VSo,977
 renard/pipeline/__init__.py,sha256=8Yim2mmny8YGvM7N5-na5zK-C9UDxUb77K9ml-VirUA,35
-renard/pipeline/character_unification.py,sha256=GcnC8UYqn1RBOGVhYS9LVcTNqpxm9YoT-lPsE3vodek,14818
-renard/pipeline/characters_extraction.py,sha256=NzF8H9X19diW6rqwS5ERrRku7rFueO3S077H5C6kb7I,363
-renard/pipeline/core.py,sha256=luKNUTCDtZfwKzxVIaImyIMwFFvIknfT1LdQtongj24,22570
+renard/pipeline/character_unification.py,sha256=VntpU9FCLERUx_-FTirIOw8qwFRnVsUfrbHlBMCv1AU,15694
+renard/pipeline/characters_extraction.py,sha256=bMic8dtlYKUmAlTzQqDPraYy5VsGWoGkho35mA8w3_Y,396
+renard/pipeline/core.py,sha256=bBB3sXhTyS1ygYGJxQaA7TYjCJVZRVvqZ9S3_UDIyV8,26941
 renard/pipeline/corefs/__init__.py,sha256=9c9AaXBcRrDBf1jhTtJ7DyjOJhX_Zej3FjlcGak7MK8,44
-renard/pipeline/corefs/corefs.py,sha256=nzYT6S9ify3FlgGB3FSDpAhs2UQYgW9c3CL2GRYzTms,11508
-renard/pipeline/graph_extraction.py,sha256=n0T_nzNGiwE9bDubpPknHe7bbDhJ4ndnqmoMmyfbeWg,19468
-renard/pipeline/ner.py,sha256=5zqZlEjhO__0iuRQAN9rvhCbcd9QmNCcH9_NP_BaTbc,11261
+renard/pipeline/corefs/corefs.py,sha256=CpcY7cy9vvCR-xw2KrCu1IsnZjb0GyxX44MpeaYGX2Q,11415
+renard/pipeline/graph_extraction.py,sha256=Ga3wfUW9tDtatcTv2taLrNky9jz2wUwZ8uzoXJoSVk8,22928
+renard/pipeline/ner.py,sha256=VQ4D-S8bcBu49VMFRu0fxQRoaLBB7VGTyKTI5vJYtEY,11271
 renard/pipeline/preconfigured.py,sha256=j4-0OUZrmtC8rQfwGWEAAGNxc8-4hlY7N823Uami5lk,5392
 renard/pipeline/preprocessing.py,sha256=OsdsYzmRweAiQV_CtP7uiz--OGogZtQlsdR8XX5DCk0,952
-renard/pipeline/progress.py,sha256=VQsIxTuz0QQnepXPevHhMU-dHXMa1RWsjmMfBgoWdiY,1684
+renard/pipeline/progress.py,sha256=PJ174ssaqr5qHaTrVQ8HqJtvpvX6QhtHM5PHT893_Xk,2689
 renard/pipeline/quote_detection.py,sha256=FyldJhynIT843fB7rwVtHmDZJqTKkjGml6qTLjsIhMA,2045
 renard/pipeline/sentiment_analysis.py,sha256=76MPin4L1-vSswJe5yGrbCSSDim1LYxSEgNj_BdQDvk,1464
-renard/pipeline/speaker_attribution.py,sha256=qCY-Z1haDDgZy8L4k8pAc6xIcSFmtcuuESu631QxRUY,4366
+renard/pipeline/speaker_attribution.py,sha256=Uts6JdUo_sbWyIb2AJ6SO5JuUbgROIpcbUNTg4dHo4U,4329
 renard/pipeline/stanford_corenlp.py,sha256=14b6Ee6oPz1EL-bNRT688aNxVTk_Jwa_vJ20FiBODC4,8189
-renard/pipeline/tokenization.py,sha256=RllOxSjaV_Sdu3CH8vKIbceNj3Noeey31mKircxWoyM,1806
-renard/plot_utils.py,sha256=bmIBybleFJ-YiVPLPPWYW8x1UHpkuXTE7O9lQlRiWrk,2133
+renard/pipeline/tokenization.py,sha256=BzLBG_QndbLLf2VtZtkIsFSbB0whvgrI4_hzVw_jxZY,2910
+renard/plot_utils.py,sha256=Xqga28tf1pAbAfsYE4fj87SKrs-l7-BwwUriIcTbEGA,3064
 renard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 renard/resources/hypocorisms/__init__.py,sha256=vlsY9PqxQCIpijxm79Y0KYh2c0S4S1pgrC9w-AUQGvE,55
 renard/resources/hypocorisms/datas/License.txt,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
 renard/resources/hypocorisms/datas/hypocorisms.csv,sha256=CKTo7A5i14NzN6JRBz7U2NJnxrEo8VOlmmdhzEZnqlI,21470
-renard/resources/hypocorisms/hypocorisms.py,sha256=vgqdKTpOvz6pqWeCpc25FirLy4yFsYdFSyf_nNgmfQw,2848
+renard/resources/hypocorisms/hypocorisms.py,sha256=rFFKKr-rEsd5wbz_SYjadrgKdEWwxMwVR1NQu_wcPqI,2887
 renard/resources/pronouns/__init__.py,sha256=62h0zuXp8kCToTLTyg8D8rJ-MXQpT8Vyc6mljcD1RGU,49
 renard/resources/pronouns/pronouns.py,sha256=YJ8hM6H8QHrF2Xx6O5blqc-Sqe1D1YFL0sRdqO_rroE,817
 renard/resources/titles/__init__.py,sha256=Jcg4B7stsWiAaXbFgNl_L3ICtCQmFe9bo3YjdkVL50w,45
 renard/resources/titles/titles.py,sha256=GsFccVJuTkgDWiAqWZpFd2R9pGvFKQZBOk4RWWuWDkw,968
-renard/utils.py,sha256=8J3swFqSi4YqhgYNXvttJ0s-DmJbl_yEYri6JpGEWH8,2340
-renard_pipeline-0.4.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-renard_pipeline-0.4.1.dist-info/METADATA,sha256=KgpnPAR6BtLS4RNjsxIBWqUygUcoRdJfkqHigzZMSqU,3697
-renard_pipeline-0.4.1.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-renard_pipeline-0.4.1.dist-info/RECORD,,
+renard/utils.py,sha256=WL6djr3iu5Kzo2Jq6qDllHXgvZcEnmqBxPkQf1drq7c,4072
+renard_pipeline-0.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+renard_pipeline-0.5.0.dist-info/METADATA,sha256=fX4hE68M-gnnpocVqV2FqvfypIsv4gNl3Usz3n5kc7Q,4379
+renard_pipeline-0.5.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+renard_pipeline-0.5.0.dist-info/RECORD,,

{renard_pipeline-0.4.1.dist-info → renard_pipeline-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.5.2
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any