Avoid repetition of arguments when using Language.factory with maker

[vmenger]

Hi all,

I implemented a custom component that wraps a trained Transformer model to detect whether a Span is negated (more details not important I think). It has some configuration options of itself, and also passes some config args to its superclass. This component will end up in a package with multiple components that detect negations (in a specific domain).

As recommended in the docs, I use the Language.factory wrapper with a maker function. A minimized examle looks like this:

from typing import Optional

from spacy import Language
from spacy.tokens import Doc

_defaults = {
    "token_window": 32,
    "strip_entities": True,
    "placeholder": None,
    "negation_threshold": 0.5,
    "negation_detector_args": None
}

@Language.factory(
    name="negation_detector",
    default_config=_defaults,
    requires=["doc.ents"],
    assigns=[f"span._.is_negated"],
)
def make_negation_detector(
    nlp: Language, name: str, token_window, strip_entities, placeholder, negation_threshold, negation_detector_args: dict
):
    return TransformerBasedNegationDetector(
        nlp,
        token_window=token_window,
        strip_entities=strip_entities,
        placeholder=placeholder,
        negation_threshold=negation_threshold,
        **negation_detector_args
    )


class NegationDetector:
    pass


class TransformerBasedNegationDetector(NegationDetector):
    def __init__(
        self,
        nlp: Language,
        token_window: int = _defaults["token_window"],
        strip_entities: bool = _defaults["strip_entities"],
        placeholder: Optional[str] = _defaults["placeholder"],
        negation_threshold: float = _defaults["negation_threshold"],
        **kwargs
    ):
        self.nlp = nlp
        self.token_window = token_window
        self.strip_entities = strip_entities
        self.placeholder = placeholder
        self.negation_threshold = negation_threshold

        super().__init__(**kwargs)

    def __call__(self, doc: Doc):
        ...

My question is: is there any way to avoid repetition of the arguments so many times and reduce the amount of boilerplate code?

Solutions I tried are:

• Getting creative with **kwargs in the above example, but spaCy does not accept/understand this
• Removing the maker and using the wrapper on the class directly, but now I can't use **kwargs at all
• Trying to remove the inheritance, but then I need to copy/paste a lot of boilerplate code into other classes

Any suggestions appreciated!

[vmenger]

@BramVanroy I noticed you had a similar question here (#10606) but didn't see your final solution, any suggestions? (Sorry if I'm being too forward by tagging you directly 😊)

[BramVanroy]

I'm afraid I didn't come up with a better solution than that.

[vmenger]

Thanks anyway for the quick reply!

[danieldk]

As far as I am aware, it is not possible to simplify the function arguments. confection inspects the function signature to get the configuration fields and types. The procedure is described in this blog post:

https://explosion.ai/blog/spacy-design-concepts#type-hints

Even though it is extremely hacky, you may be able to get away with locals():

def foo(a, *, b=10, c="hello"):
    Bar(**locals())

class Bar:
    def __init__(self, *, a, b, c):
	    print(a, b, c)

foo(42, c="world")

You could also use inspect to inspect the frame and pry out the argments:

import inspect

def get_args():
    parent_frame = inspect.currentframe().f_back
    args, _, _, locals = inspect.getargvalues(parent_frame)
    return {arg: locals[arg] for arg in args}


def foo(a, *, b=10, c="hello"):
    Bar(**get_args())


class Bar:
    def __init__(self, *, a, b, c):
        print(a, b, c)


foo(42, c="world")

But I am not sure if it is worth using relatively brittle code for this.

[vmenger]

Thanks. The components should end up in production at some point, so rather than use something brittle, I'll have to maintain some extra boilerplate code. Which is not the end of the world by any means.