Add tdl.AVM.aggregate(); use in init

This helps with merging repeated attributes instead of reassigning
them or getting strange errors.

Resolves #395

Author: goodmami

CHANGELOG.md

@@ -7,9 +7,19 @@
 * Removed Python 3.8 support ([#396])
 * Added Python 3.13 support ([#396])
 
+### Added
+
+* `delphin.tdl.AVM.aggregate()` ([#395])
+
 ### Fixed
 
 * Parse TDL comments after letter-sets and wild-cards ([#395])
+* Repeated features in AVMs get merged instead of reassigned ([#395])
+
+### Changed
+
+* `tdl.AVM` initialization uses `AVM.aggregate()` instead of
+  assignment of values on features ([#395])
 
 
 ## [v1.9.1]

delphin/tdl.py

@@ -5,8 +5,9 @@
 import re
 import textwrap
 import warnings
+from collections.abc import Mapping, Sequence
 from pathlib import Path
-from typing import Generator, Tuple, Union
+from typing import Generator, Optional, Tuple, Union
 
 from delphin import util
 
@@ -33,6 +34,9 @@
 _line_width = 79  # try not to go beyond this number of characters
 
 
+AttrSeq = Sequence[tuple[str, Union['Conjunction', 'Term']]]
+AttrMap = Mapping[str, Union['Conjunction', 'Term']]
+
 # Exceptions
 
 class TDLError(PyDelphinException):
@@ -190,21 +194,78 @@ class AVM(FeatureStructure, Term):
         docstring (str): documentation string
     """
 
-    def __init__(self, featvals=None, docstring=None):
+    def __init__(
+        self,
+        featvals: Union[AttrSeq, AttrMap, None] = None,
+        docstring=None,
+    ) -> None:
         # super() doesn't work because I need to split the parameters
-        FeatureStructure.__init__(self, featvals)
+        FeatureStructure.__init__(self)
         Term.__init__(self, docstring=docstring)
+        if featvals is not None:
+            self.aggregate(featvals)
 
     @classmethod
     def _default(cls):
-        return AVM()
+        return _ImplicitAVM()
 
-    def __setitem__(self, key, val):
+    def __setitem__(self, key: str, val: Union['Conjunction', Term]) -> None:
         if not (val is None or isinstance(val, (Term, Conjunction))):
-            raise TypeError('invalid attribute value type: {}'.format(
-                type(val).__name__))
+            raise TypeError(
+                'invalid attribute value type: {}'.format(type(val).__name__)
+            )
         super(AVM, self).__setitem__(key, val)
 
+    def aggregate(self, featvals: Union[AttrSeq, AttrMap]) -> None:
+        """Combine features in a single AVM.
+
+        This function takes feature paths and values and merges them
+        into the AVM, but does not do full unification. For example:
+
+        >>> avm = tdl.AVM([("FEAT", tdl.TypeIdentifier("val1"))])
+        >>> avm.aggregate([
+        ...     ("FEAT", tdl.TypeIdentifier("val2")),
+        ...     ("FEAT.SUB", tdl.TypeIdentifier("val3")),
+        ... ])
+        >>> print(tdl.format(avm))
+        [ FEAT val1 & val2 & [ SUB val3 ] ]
+
+        The *featvals* argument may be an sequence of (feature, value)
+        pairs or a mapping of features to values.
+
+        """
+        if hasattr(featvals, 'items'):
+            featvals = list(featvals.items())
+        for feat, val in featvals:
+            avm = self
+            feat = feat.upper()
+            while feat:
+                subkey, _, rest = feat.partition(".")
+                cur_val = avm.get(subkey)
+                # new feature, just assign
+                if subkey not in avm:
+                    avm[feat] = val
+                    break
+                # last feature on path, conjoin
+                elif not rest:
+                    avm[subkey] = cur_val & val
+                # non-conjunction implicit AVM; follow the dots
+                elif isinstance(cur_val, _ImplicitAVM):
+                    avm = cur_val
+                # conjunction with implicit AVM; follow the AVM's dots
+                elif (
+                    isinstance(cur_val, Conjunction)
+                    and (avm_ := cur_val._last_avm())
+                    and isinstance(avm_, _ImplicitAVM)
+                ):
+                    avm = avm_
+                # some other term; create conjunction with implicit AVM
+                else:
+                    avm_ = _ImplicitAVM()
+                    avm[subkey] = cur_val & avm_
+                    avm = avm_
+                feat = rest
+
     def normalize(self):
         """
         Reduce trivial AVM conjunctions to just the AVM.
@@ -255,7 +316,7 @@ def features(self, expand=False):
 
 
 class _ImplicitAVM(AVM):
-    """AVM implicitly constructed by list syntax."""
+    """AVM implicitly constructed by dot-notation and list syntax."""
 
 
 class ConsList(AVM):
@@ -514,13 +575,10 @@ def __getitem__(self, key):
 
     def __setitem__(self, key, val):
         """Set *key* to *val* in the last AVM in the conjunction"""
-        avm = None
-        for term in self._terms:
-            if isinstance(term, AVM):
-                avm = term
-        if avm is None:
+        if avm := self._last_avm():
+            avm[key] = val
+        else:
             raise TDLError('no AVM in Conjunction')
-        avm[key] = val
 
     def __delitem__(self, key):
         """Delete *key* from all AVMs in the conjunction"""
@@ -614,6 +672,12 @@ def string(self):
                 return str(term)
         return None  # conjunction does not have a string type (not an error)
 
+    def _last_avm(self) -> Optional[AVM]:
+        for term in reversed(self._terms):
+            if isinstance(term, AVM):
+                return term
+        return None
+
 
 class TypeDefinition:
     """
@@ -1399,6 +1463,7 @@ def _format_term(term, indent):
         Regex: _format_regex,
         Coreference: _format_coref,
         AVM: _format_avm,
+        _ImplicitAVM: _format_avm,
         ConsList: _format_conslist,
         DiffList: _format_difflist,
     }.get(term.__class__, None)

delphin/tfs.py

@@ -64,9 +64,9 @@ def __eq__(self, other: Any) -> bool:
 
     def __setitem__(self, key: str, val: Any) -> None:
         avm = self._avm
-        subkeys = key.split('.', 1)
-        subkey = subkeys[0].upper()
-        if len(subkeys) == 1:
+        subkey, _, rest = key.partition(".")
+        subkey = subkey.upper()
+        if not rest:
             avm[subkey] = val
         else:
             if subkey in avm:
@@ -77,7 +77,7 @@ def __setitem__(self, key: str, val: Any) -> None:
                         f'{subkey} does not support item assignment')
             else:
                 subdef = avm[subkey] = self._default()
-            subdef[subkeys[1]] = val
+            subdef[rest] = val
 
     def __getitem__(self, key: str) -> Any:
         first, _, remainder = key.partition('.')

tests/tdl_test.py

@@ -1008,3 +1008,20 @@ def test_issue_357():
     assert isinstance(c, ConsList)
     assert len(c.values()) == 2
     assert tdl.format(t) == 'id := < a . < b . c > >.'
+
+
+def test_promote_conjunction_issue_395():
+    t = tdlparse('a := b & [ ABC x, ABC [ DEF y ] ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC x & [ DEF y ] ].'
+    t = tdlparse('a := b & [ ABC x, ABC.DEF y ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC x & [ DEF y ] ].'
+    t = tdlparse('a := b & [ ABC.DEF y, ABC x ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC [ DEF y ] & x ].'
+    t = tdlparse('a := b & [ ABC [ DEF x ], ABC [ GHI y ] ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC [ DEF x ] & [ GHI y ] ].'
+    t = tdlparse('a := b & [ ABC [ DEF x ], ABC.DEF y ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC [ DEF x ] & [ DEF y ] ].'
+    t = tdlparse('a := b & [ ABC [ DEF x ], ABC.GHI y ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC [ DEF x ] & [ GHI y ] ].'
+    t = tdlparse('a := b & [ ABC x & [ DEF y ], ABC z ].')
+    assert tdl.format(t) == 'a := b &\n  [ ABC x & [ DEF y ] & z ].'