All Tokens in N

[mdorkhah]

p = Seq(Ann(name="tok1", type="type1"),N(Ann(name="tok2", type="type2"), min=1, max=10, matchtype='all', select='all'))
a = AddAnn(name="tok2", anntype="type3")
r = Rule(p,a)
anns2match = doc2.annset("Resume").with_type("type1","type2")
outset = doc.annset("new")
outset.clear()
Pampac(r).run(doc, anns2match, outset=outset)

I try to catch all the 1 to 10 Tokens of "type2" that are placed after the token of "type1" and before the next "type1". But my code only annotates the first token of "type2" as "type3" and not the next ones.
Would you please help?

[johann-petrak]

There could be several reasons for this.

If any of the annotations of type "type2" starts at the same offset as some other annotation (e.g. a "Token"), it will only match if it is the actual next annotation in the annotation sequence (in gatenlp, other than Java GATE, annotations starting at the same offset are still ordered by annotation id).

In order to match any or all annotation at the next offset, try to use "AnnAt" instead of "Ann".

You should not need the match="all" or select="all" settings here, the default "first" should be fine for both.

These parameters are only needed when a pattern can be matched in many different combinations and ways and one needs to find the shortest, longest or all of these combinations.

please check what Seq(Ann(name="tok1", type="type1"),N(AnnAt(name="tok2", type="type2"), min=1, max=10)) does.

[mdorkhah]

Thank you very much! I look forward for your next release.

[mdorkhah]

This is also something that will work in the next release.

For now you can do this:

def annotate_each(succ, context, location):
    res = succ[0]
    for data in res.data:
        context.outset.add(data["span"], "type3")
p = Seq(Ann(name="tok1", type="type1"),
             N(Ann(name="match", type="type2"), 
                 min=1, max=10))
r = Rule(p,annotate_each)
anns2match = doc2.annset("Resume").with_type("type1","type2")
outset = doc.annset("new")
outset.clear()
Pampac(r).run(doc, anns2match, outset=outset)

This uses a function as action instead of the AddAnn predefined action.
The function gets all the match data (since there is only one named binding, we can be sure to get the right one), gets the span for each match data and adds an annotation with type "type3" to the outset for that span.

The next release will instead allow to use AddAnn(anntype="match", name="match", resultidx=0, dataidx=None) where dataidx=None means to apply the action to all data indices individually.

Note that for both approaches the name must be added to the part in the pattern for which we want to get the spans, i.e. the individual type2 annotations.

Hi Johann
Is there anyway to input the "New Type" as an argument to annotate_each function?

[johann-petrak]

I am not sure I understand what you want to achieve?

[mdorkhah]

I am not sure I understand what you want to achieve?

I want something like this, but I can't implement it as succ, context, location are produced after run...

def annotate_each(succ, context, location, newtype):
    res = succ[0]
    for data in res.data:
        context.outset.add(data["span"], newtype)

p = Seq(Ann(name="tok1", type="type1"),
             N(Ann(name="match", type="type2"), 
                 min=1, max=10))
r = Rule(p,annotate_each(succ, context, location, newtype))
anns2match = doc2.annset("Resume").with_type("type1","type2")
Pampac(r).run(doc, anns2match, outset=outset)

[johann-petrak]

What I do not understand is: at which point, at which time do you want to decide which type to use?

In the previous version, the function contained the type "type3" so the decision is made before the rule is created and before it is run.

If you just want to decide when the rule is created, you have two options:

1. create a closure:

typetouse = sometype
def annotate_each(succ, context, location):
    res = succ[0]
    for data in res.data:
        context.outset.add(data["span"], typetouse)

2. use a callable class instead of a function:

class AnnotateEach:
    def __init__(self, anntype):
        self.anntype = anntype

    def __call__(self, succ, context, location):
        res = succ[0]
        for data in res.data:
            context.outset.add(data["span"], self.anntype)

Then create the rule like this:

r = Rule(p, AnnotateEach(sometype))

If you need to make that decision when the pattern actually matches, you need to add the relevant code inside of the function or the __call__ method of the class.

Does that make sense?