pyflexicon 4.1.2__tar.gz → 4.2.0__tar.gz

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/CHANGELOG.md

@@ -15,6 +15,65 @@ _Nothing yet. Non-breaking fixes and breaking changes accumulate here until the
 
 ---
 
+## [4.2.0]
+
+### Added
+- **`MsaFactoryOperations.CreateStem` / `CreateUnclassifiedAffix`** now
+  accept `pos=None` for a category-less stem or unclassified-affix MSA
+  (a valid, blank-category-cell FLEx state), mirroring the existing
+  `CreateDerivAff` `to_pos=None` precedent. Unblocks cross-project
+  transfer of category-less MSAs (9c04ab8).
+
+### Fixed
+- **`MsaFactoryOperations.CreateInflAff`** accepts `pos=None` for a
+  category-less inflectional affix, matching `CreateStem` /
+  `CreateUnclassifiedAffix` (6f316b3).
+- **Morph-type classification** unified into a single shared module
+  (`Shared/morph_type_utils.py`); `LexEntryOperations`,
+  `AllomorphOperations`, and `LexSenseOperations` no longer each carry
+  independently drifting stem/affix GUID sets. Fixes a silent logical
+  inversion in `LexSenseOperations.__EntryHasAffixMorphType`'s GUID set.
+  `MorphRuleOperations.Duplicate` now defaults `deep=True`, matching the
+  LexEntry/Text family (#203, #213, #214).
+- **`wrap_enumerable`** now catches bare Python iterators/generators (not
+  just raw C# `IEnumerable`), so `GetAll()`/`GetAnalyses()`-style methods
+  across ~20 Operations classes reliably return a subscriptable,
+  `len()`-able collection instead of raising `TypeError` on `entries[0]`
+  or `len(entries)` (#201).
+- **`MediaOperations.Create`** now owns a new `CmFile` in the appropriate
+  `CmFolder` before setting `InternalPath`, fixing a
+  `NullReferenceException` that made the add-a-picture/media surface
+  (`AddPicture`, `CopyToProject`, `Create`, `AddMediaFile`) unusable.
+  `CopyToProject`'s `LinkedFilesRootDir` guard now reads from `ILangProject`
+  instead of the `LcmCache` (#226).
+- **`GetCustomFieldValue`** on a bare `ITsMultiString` (no
+  `BestAnalysisVernacularAlternative` accessor) now resolves the best
+  alternative by writing-system priority instead of failing (#224).
+  Transaction entry no longer logs a misleading "NoneType is not
+  callable" warning when the LCM `Mark` API is unavailable; it logs at
+  debug level and proceeds without rollback capability (#221).
+- **`BaseOperations._ValidateParam`** guards against stale/deleted LCM
+  objects (`IsValidObject is False`), raising `FP_ParameterError` naming
+  the parameter instead of an opaque `NullReferenceException` deep
+  inside LCM (#205).
+- **`SegmentOperations.GetAnalyses`** / `WfiGlossOperations` — polymorphic
+  `IAnalysis` tokens (`IWfiWordform` / `IWfiAnalysis` / `IWfiGloss` /
+  `IPunctuationForm`) are now resolved by `ClassName` rather than
+  `isinstance`, which is unreliable against base-typed LCM refs. Adds
+  `SegmentOperations.GetGloss`, `WfiAnalysisOperations.GetCategoryAbbrev`,
+  and `GetMorphemeBundles` polymorphic helpers (#212).
+
+### Changed
+- **`FLExProject`** singular/plural accessor aliases (e.g.
+  `InflectionFeature`/`InflectionFeatures`) are now generated from a
+  single table (`_op_aliases.py`, 58 aliases) instead of ~10 hand-written
+  properties, closing the gap where a guessed accessor name raised
+  `AttributeError`. All previously hand-written aliases are preserved;
+  each now emits a `DeprecationWarning` naming the canonical accessor
+  (#200).
+
+---
+
 ## [4.1.2]
 
 ### Fixed

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyflexicon
-Version: 4.1.2
+Version: 4.2.0
 Summary: flexicon: a user-centric Python library for FieldWorks Language Explorer (FLEx) projects via the SIL Language and Culture Model (LCM) API
 Author-email: Matthew Lee <matthew_lee@sil.org>
 Maintainer-email: Matthew Lee <matthew_lee@sil.org>

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/BaseOperations.py

@@ -117,12 +117,64 @@ class EnumerableWrapper:
         return f"EnumerableWrapper({self._enumerable})"
 
 
+def _needs_enumerable_wrap(result):
+    """
+    Decide whether `result` needs to be wrapped in EnumerableWrapper.
+
+    Historically this only checked for raw C# IEnumerable objects (those
+    exposing `GetEnumerator`). That missed two common return shapes used
+    throughout the Operations classes:
+
+    - `self.project.ObjectsIn(...)`, which already calls Python's
+      built-in `iter()` on the underlying C# enumerable before returning
+      it. The resulting object exposes `__next__`/`__iter__` but *not*
+      `GetEnumerator`, so it slipped past the old check untouched.
+    - Generator-function GetAll()/GetAnalyses() implementations (using
+      `yield`), which return a plain Python generator object -- also has
+      `__next__` but no `GetEnumerator`, and is not subscriptable and
+      has no `len()`.
+
+    Both shapes produced the exact bug in issue #201: callers got back a
+    bare iterator/generator that looked list-like but raised
+    `TypeError` on `entries[0]` or `len(entries)`.
+
+    Anything that already supports both indexing and `len()` (plain
+    lists, tuples, existing EnumerableWrapper/SmartCollection instances,
+    etc.) is left alone -- there's nothing to fix and no need to
+    re-wrap it.
+
+    Args:
+        result: The raw value returned by the wrapped method.
+
+    Returns:
+        bool: True if `result` should be wrapped in EnumerableWrapper.
+    """
+    if result is None:
+        return False
+    if isinstance(result, EnumerableWrapper):
+        return False
+    # Raw C# IEnumerable (pythonnet objects exposing GetEnumerator).
+    if hasattr(result, "GetEnumerator"):
+        return True
+    # Plain Python iterator/generator (has __next__) that does not
+    # already behave like a sequence (no __len__ + __getitem__ pair).
+    # This covers both `iter(repo.AllInstances())` (from ObjectsIn())
+    # and generator-function bodies using `yield`.
+    if hasattr(result, "__next__"):
+        already_sequence = hasattr(result, "__len__") and hasattr(result, "__getitem__")
+        if not already_sequence:
+            return True
+    return False
+
+
 class wrap_enumerable:
     """
-    Descriptor to automatically wrap IEnumerable return values.
+    Descriptor to automatically wrap IEnumerable/iterator return values.
 
-    Wraps methods that return C# IEnumerable collections to make them
-    Pythonic with .Count property and indexing support.
+    Wraps methods that return C# IEnumerable collections -- or plain
+    Python iterators/generators built on top of them (e.g. via
+    `self.project.ObjectsIn(...)` or a `yield`-based method body) -- to
+    make them Pythonic with `.Count`, `len()`, and indexing support.
 
     Must be a descriptor to properly delegate to OperationsMethod's __get__,
     ensuring the descriptor protocol works correctly when stacked decorators
@@ -140,6 +192,7 @@ class wrap_enumerable:
             items = GetAll(project)
             count = items.Count      # Works!
             first = items[0]         # Works!
+            length = len(items)      # Works!
     """
 
     def __init__(self, func):
@@ -169,8 +222,7 @@ class wrap_enumerable:
         # Return a wrapper that will wrap the result
         def wrapped_method(*args, **kwargs):
             result = inner_method(*args, **kwargs)
-            # Only wrap if it looks like an IEnumerable (has GetEnumerator)
-            if result is not None and hasattr(result, "GetEnumerator"):
+            if _needs_enumerable_wrap(result):
                 return EnumerableWrapper(result)
             return result
 
@@ -179,13 +231,12 @@ class wrap_enumerable:
     def __call__(self, *args, **kwargs):
         """
         Direct call support (when decorator is applied to a function, not a method).
-        
+
         This is called when the wrapped method is invoked without going through
         the descriptor protocol (rare, but needed for some edge cases).
         """
         result = self.func(*args, **kwargs)
-        # Only wrap if it looks like an IEnumerable (has GetEnumerator)
-        if result is not None and hasattr(result, "GetEnumerator"):
+        if _needs_enumerable_wrap(result):
             return EnumerableWrapper(result)
         return result
 
@@ -1775,10 +1826,12 @@ class BaseOperations:
 
     def _ValidateParam(self, param: any, param_name: str = "parameter") -> None:
         """
-        Validate that a parameter is not None.
+        Validate that a parameter is not None and not a stale LCM object.
 
         This method performs a null check on a required parameter. Use this for
-        any parameter that must be provided and non-None.
+        any parameter that must be provided and non-None. When the parameter is
+        a live LCM object reference, it is additionally rejected if it refers to
+        a deleted/invalid object (``IsValidObject`` is False).
 
         Args:
             param: The parameter value to validate (any type).
@@ -1789,7 +1842,9 @@ class BaseOperations:
             None
 
         Raises:
-            Exception: If param is None.
+            FP_NullParameterError: If param is None.
+            FP_ParameterError: If param is an LCM object that has been deleted
+                or otherwise invalidated (``IsValidObject`` is False).
 
         Example:
             >>> def SetGloss(self, sense, gloss):
@@ -1811,11 +1866,25 @@ class BaseOperations:
 
         Implementation Notes:
             - Simple if param is None check
+            - Stale-reference guard: a cascade-deleted LCM object keeps a live
+              .NET reference but its Cache/Services pointers are torn down, so
+              touching any property raises a NullReferenceException from deep
+              inside LCM. ICmObject exposes IsValidObject (False once deleted);
+              mirrors LCM's own guard pattern (OverridesLing_Lex.cs:1500).
+            - getattr(..., None) means non-LCM params (str/int/dict/etc.) have
+              no IsValidObject attribute -> None -> skipped. Only an explicit
+              False triggers the error, so a True value is never mistaken.
             - No side effects
             - Exception message includes parameter name
         """
         if param is None:
             raise FP_NullParameterError()
+        # Reject stale LCM object references (cascade-deleted / invalidated).
+        # Non-LCM params return None here and are left untouched.
+        if getattr(param, "IsValidObject", None) is False:
+            raise FP_ParameterError(
+                f"{param_name} refers to a deleted or invalid LCM object"
+            )
 
     def _ValidateParamNotEmpty(self, param: any, param_name: str = "parameter") -> None:
         """

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/Discourse/ConstChartOperations.py

@@ -82,7 +82,7 @@ class ConstChartOperations(BaseOperations):
         """
         Get all constituent charts in the project.
 
-        This method returns an iterator over all IDsConstChart objects in the
+        This method returns an EnumerableWrapper (subscriptable, len()-able, lazily materialized) over all IDsConstChart objects in the
         project database, allowing iteration over all discourse analysis charts.
 
         Yields:
@@ -97,7 +97,7 @@ class ConstChartOperations(BaseOperations):
             Mark 1 Analysis (32 rows)
 
         Notes:
-            - Returns an iterator for memory efficiency
+            - Returns an EnumerableWrapper (subscriptable, len()-able) for memory efficiency; the underlying LCM enumerator is only materialized into a list on first len()/index/iteration access
             - Charts are returned in database order
             - Each chart can contain multiple rows for analysis
             - Use GetName() to access the chart name

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/FLExProject.py

@@ -38,7 +38,7 @@ import logging
 import os
 import clr
 
-from .Shared.string_utils import normalize_ws_handle
+from .Shared.string_utils import normalize_ws_handle, best_multistring_alternative
 
 clr.AddReference("System")
 import System
@@ -2407,42 +2407,10 @@ class FLExProject(object):
             self._constchartclausemarker_ops = ConstChartClauseMarkerOperations(self)
         return self._constchartclausemarker_ops
 
-    # Singular aliases for backward compatibility
-
-    @property
-    def Agent(self):
-        """Alias for Agents (singular form for backward compatibility)."""
-        return self.Agents
-
-    @property
-    def PossibilityList(self):
-        """Alias for PossibilityLists (singular form for backward compatibility)."""
-        return self.PossibilityLists
-
-    @property
-    def WritingSystem(self):
-        """Alias for WritingSystems (singular form for backward compatibility)."""
-        return self.WritingSystems
-
-    @property
-    def Overlay(self):
-        """Alias for Overlays (singular form for backward compatibility)."""
-        return self.Overlays
-
-    @property
-    def Publication(self):
-        """Alias for Publications (singular form for backward compatibility)."""
-        return self.Publications
-
-    @property
-    def TranslationType(self):
-        """Alias for TranslationTypes (singular form for backward compatibility)."""
-        return self.TranslationTypes
-
-    @property
-    def Note(self):
-        """Alias for Notes (singular form for backward compatibility)."""
-        return self.Notes
+    # Singular/plural aliases for backward compatibility are generated at
+    # module scope from FLExProject._OP_NAMESPACE_ALIASES (see the end of
+    # this module). Each generated alias emits a DeprecationWarning that
+    # names the canonical accessor. See issue #200.
 
     def ImportLocalizedLists(self, language_code, progress=None):
         """Deprecated. Use ``project.LocalizedLists.Import(language_code)``."""
@@ -2469,21 +2437,6 @@ class FLExProject(object):
             progress=progress
         )
 
-    @property
-    def AnnotationDef(self):
-        """Alias for AnnotationDefs (singular form for backward compatibility)."""
-        return self.AnnotationDefs
-
-    @property
-    def Check(self):
-        """Alias for Checks (singular form for backward compatibility)."""
-        return self.Checks
-
-    @property
-    def CustomField(self):
-        """Alias for CustomFields (singular form for backward compatibility)."""
-        return self.CustomFields
-
     # --- General ---
 
     def ProjectName(self):
@@ -2711,9 +2664,10 @@ class FLExProject(object):
         """
         import os
 
-        # Try to get LinkedFilesRootDir from project
-        if hasattr(self.project, "LinkedFilesRootDir") and self.project.LinkedFilesRootDir:
-            return self.project.LinkedFilesRootDir
+        # Try to get LinkedFilesRootDir. It lives on ILangProject (self.lp), not
+        # on the LcmCache (self.project) — see issue #226.
+        if getattr(self.lp, "LinkedFilesRootDir", None):
+            return self.lp.LinkedFilesRootDir
 
         # Fallback: construct default path from project folder
         if hasattr(self.project, "ProjectId") and hasattr(self.project.ProjectId, "ProjectFolder"):
@@ -3352,7 +3306,27 @@ class FLExProject(object):
                 WSHandle = self.__WSHandle(languageTagOrHandle, None)
                 return mua.get_String(WSHandle)
             else:
-                return ITsString(mua.BestAnalysisVernacularAlternative)
+                # mua is a bare ITsMultiString (SIL.LCModel.Core.KernelInterfaces),
+                # which has no BestAnalysisVernacularAlternative accessor (that
+                # lives on IMultiAccessorBase). Reimplement the "best available
+                # alternative" priority walk on top of get_String() instead.
+                # See issue #224.
+                analWsHandles = [int(ws.Handle) for ws in self.lp.CurrentAnalysisWritingSystems]
+                vernWsHandles = [int(ws.Handle) for ws in self.lp.CurrentVernacularWritingSystems]
+                best = best_multistring_alternative(
+                    mua,
+                    self.project.DefaultAnalWs,
+                    self.project.DefaultVernWs,
+                    analWsHandles,
+                    vernWsHandles,
+                )
+                if best is not None:
+                    return best
+                # Total miss across every configured WS: still return a
+                # (possibly empty) ITsString so this branch's contract
+                # matches the sibling branches above/below, which always
+                # return ITsString.
+                return ITsString(mua.get_String(self.project.DefaultAnalWs))
 
         elif fieldType == CellarPropertyType.Integer:
             return self.project.DomainDataByFlid.get_IntProp(hvo, fieldID)
@@ -4421,3 +4395,20 @@ class FLExProject(object):
                     yield name, "\n".join(content)
                 else:
                     yield "\n".join(content)
+
+
+# ============================================================================
+# Operation-namespace naming aliases (issue #200)
+# ============================================================================
+# Deprecated singular/plural aliases for the operation-namespace accessors are
+# generated from a single table in the SIL-free ._op_aliases module and
+# attached here. Each alias forwards to the canonical accessor and emits a
+# DeprecationWarning. Keeping the table and generator SIL-free lets them be
+# unit-tested without FieldWorks (tests/test_flexproject_aliases.py).
+from ._op_aliases import (  # noqa: E402
+    OP_NAMESPACE_ALIASES as _OP_NAMESPACE_ALIASES,
+    install_op_namespace_aliases as _install_op_namespace_aliases,
+)
+
+FLExProject._OP_NAMESPACE_ALIASES = _OP_NAMESPACE_ALIASES
+_install_op_namespace_aliases(FLExProject)

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/Grammar/MorphRuleOperations.py

@@ -262,6 +262,7 @@ class MorphRuleOperations(BaseOperations):
             return AffixTemplateCollection(wrapped)
         return AffixTemplateCollection()
 
+    @wrap_enumerable
     @OperationsMethod
     def GetAllAdhocCoProhibitions(self):
         """
@@ -736,7 +737,7 @@ class MorphRuleOperations(BaseOperations):
     # ========== DUPLICATION ==========
 
     @OperationsMethod
-    def Duplicate(self, item_or_hvo, insert_after=True):
+    def Duplicate(self, item_or_hvo, insert_after=True, deep=True):
         """
         Duplicate a morphological rule or template, creating a copy with a new GUID.
 
@@ -748,10 +749,15 @@ class MorphRuleOperations(BaseOperations):
             item_or_hvo: The rule object or HVO to duplicate.
             insert_after (bool): If True (default), insert after the source.
                 If False, insert at end of collection.
-            deep (bool): If True, copy reference sequences (slot assignments
-                for affix templates). If False (default), only copy simple
+            deep (bool): If True (default), copy reference sequences (slot
+                assignments for affix templates). If False, only copy simple
                 properties.
 
+                Note: this default (True) matches LexEntry/Text (deep by
+                default); it differs from Media/Wordform (deep=False by
+                default). See issue #203 -- the split is deliberate per
+                object family, not an inconsistency to "fix" elsewhere.
+
         Returns:
             The newly created duplicate with a new GUID.
 

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/Lexicon/AllomorphOperations.py

@@ -25,7 +25,6 @@ from SIL.LCModel import (
     IMoAffixAllomorphFactory,
     ILexEntry,
     IPhEnvironment,
-    MoMorphTypeTags,
 )
 from SIL.LCModel.Core.KernelInterfaces import ITsString
 from SIL.LCModel.Core.Text import TsStringUtils
@@ -38,6 +37,10 @@ from ..FLExProject import (
 # Import string utilities
 from ..Shared.string_utils import normalize_text
 
+# Import shared morph-type resolution utilities (single source of truth
+# shared with LexEntryOperations.Create -- see issue #213/#214)
+from ..Shared.morph_type_utils import find_morph_type, is_stem_morph_type, morph_type_not_found_error
+
 # Import wrapper classes
 from .allomorph import Allomorph
 from .allomorph_collection import AllomorphCollection
@@ -258,27 +261,13 @@ class AllomorphOperations(BaseOperations):
         wsHandle = self.__WSHandle(wsHandle)
 
         # Accept morph type as a string name (with or without display markers).
+        # Uses the SAME resolver as LexEntryOperations.Create (see issue #213)
+        # so '=enclitic', 'proclitic=', '-suffix', etc. all resolve identically
+        # regardless of which operations class is used.
         if isinstance(morphType, str):
-            bare = morphType.strip('-=~<>')
-            morph_types = self.project.lp.LexDbOA.MorphTypesOA
-            from ..Shared.string_utils import normalize_match_key, best_analysis_text
-            target = normalize_match_key(bare, casefold=True)
-            def _find(possibilities):
-                for mt in possibilities:
-                    mt_name = best_analysis_text(mt.Name)
-                    if mt_name and normalize_match_key(mt_name, casefold=True) == target:
-                        return mt
-                    if mt.SubPossibilitiesOS.Count > 0:
-                        found = _find(mt.SubPossibilitiesOS)
-                        if found:
-                            return found
-                return None
-            resolved = _find(morph_types.PossibilitiesOS) if morph_types else None
+            resolved = find_morph_type(self.project, morphType)
             if resolved is None:
-                raise FP_ParameterError(
-                    f"Morph type '{morphType}' not found. "
-                    "Use project.LexEntry.GetAvailableMorphTypes() to see valid names."
-                )
+                raise FP_ParameterError(morph_type_not_found_error(morphType))
             morphType = resolved
 
         # If no morphType provided, inherit from entry's LexemeFormOA (FLEx behavior)
@@ -1127,32 +1116,29 @@ class AllomorphOperations(BaseOperations):
         Determine if a morph type should use MoStemAllomorph or MoAffixAllomorph.
 
         Args:
-            morph_type: IMoMorphType object
+            morph_type: IMoMorphType object, or a string morph-type name.
 
         Returns:
             bool: True if stem type (uses MoStemAllomorph), False if affix type
 
+        Raises:
+            FP_ParameterError: If morph_type is a string that does not
+                resolve to a known morph type.
+
         Notes:
-            Based on FLEx logic - matches LexEntryOperations.__IsStemType
+            Delegates to Shared.morph_type_utils.is_stem_morph_type -- the
+            same classification used by LexEntryOperations.__IsStemType.
+            Accepts a string here (in addition to an IMoMorphType object)
+            so that callers passing a raw name never hit an AttributeError
+            deep in this helper (see issue #213).
         """
-        if morph_type is None:
-            return True  # Default to stem
-
-        # Check GUID against known stem types
-        stem_guids = {
-            MoMorphTypeTags.kguidMorphStem,
-            MoMorphTypeTags.kguidMorphRoot,
-            MoMorphTypeTags.kguidMorphBoundRoot,
-            MoMorphTypeTags.kguidMorphBoundStem,
-            MoMorphTypeTags.kguidMorphClitic,
-            MoMorphTypeTags.kguidMorphEnclitic,
-            MoMorphTypeTags.kguidMorphProclitic,
-            MoMorphTypeTags.kguidMorphParticle,
-            MoMorphTypeTags.kguidMorphPhrase,
-            MoMorphTypeTags.kguidMorphDiscontiguousPhrase,
-        }
-
-        return morph_type.Guid in stem_guids
+        if isinstance(morph_type, str):
+            resolved = find_morph_type(self.project, morph_type)
+            if resolved is None:
+                raise FP_ParameterError(morph_type_not_found_error(morph_type))
+            morph_type = resolved
+
+        return is_stem_morph_type(morph_type)
 
     def __WSHandle(self, wsHandle):
         """

{pyflexicon-4.1.2 → pyflexicon-4.2.0}/flexicon/code/Lexicon/LexEntryOperations.py

@@ -29,7 +29,6 @@ from SIL.LCModel import (
     IMoStemAllomorphFactory,
     IMoAffixAllomorphFactory,
     IMoForm,
-    MoMorphTypeTags,
     ILexEntryRef,
     ILexEntryRefFactory,
     LexEntryRefTags,
@@ -48,6 +47,15 @@ from ..FLExProject import (
 # Import string utilities
 from ..Shared.string_utils import normalize_text, normalize_match_key, best_analysis_text, best_vernacular_text
 
+# Import shared morph-type resolution utilities (single source of truth
+# for name lookup, display-marker normalization, and stem/affix
+# classification -- also used by AllomorphOperations)
+from ..Shared.morph_type_utils import (
+    find_morph_type,
+    is_stem_morph_type,
+    morph_type_not_found_error,
+)
+
 
 class LexEntryOperations(BaseOperations):
     """
@@ -101,7 +109,7 @@ class LexEntryOperations(BaseOperations):
         """
         Get all lexical entries in the project.
 
-        This method returns an iterator over all ILexEntry objects in the
+        This method returns an EnumerableWrapper (subscriptable, len()-able, lazily materialized) over all ILexEntry objects in the
         project database, allowing iteration over the complete lexicon.
 
         Yields:
@@ -117,7 +125,7 @@ class LexEntryOperations(BaseOperations):
             house (4 senses)
 
         Notes:
-            - Returns an iterator for memory efficiency with large lexicons
+            - Returns an EnumerableWrapper (subscriptable, len()-able) for memory efficiency with large lexicons; the underlying LCM enumerator is only materialized into a list on first len()/index/iteration access
             - Entries are returned in database order (not alphabetical)
             - Use GetHeadword() to access the display form
             - For sorted entries, use FLExProject.LexiconAllEntriesSorted()
@@ -201,9 +209,7 @@ class LexEntryOperations(BaseOperations):
         # Find the morph type
         morph_type = self.__FindMorphType(morph_type_name)
         if morph_type is None:
-            raise FP_ParameterError(
-                f"Morph type '{morph_type_name}' not found. " f"Use one of: stem, root, prefix, suffix, infix, etc."
-            )
+            raise FP_ParameterError(morph_type_not_found_error(morph_type_name))
 
         with self._TransactionCM(f"Create entry '{lexeme_form}'"):
             # Create the new entry using the factory
@@ -1520,7 +1526,7 @@ class LexEntryOperations(BaseOperations):
         if isinstance(morph_type_or_name, str):
             morph_type = self.__FindMorphType(morph_type_or_name)
             if morph_type is None:
-                raise FP_ParameterError(f"Morph type '{morph_type_or_name}' not found")
+                raise FP_ParameterError(morph_type_not_found_error(morph_type_or_name))
         else:
             morph_type = morph_type_or_name
 
@@ -3129,25 +3135,11 @@ class LexEntryOperations(BaseOperations):
             Based on FLEx logic in MorphTypeAtomicLauncher.cs
             Stem types include: stem, root, bound root/stem, clitics, particles, phrases
             Affix types include: prefix, suffix, infix, circumfix, etc.
+            Delegates to Shared.morph_type_utils.is_stem_morph_type so this
+            classification lives in exactly one place (also used by
+            AllomorphOperations).
         """
-        if morph_type is None:
-            return True  # Default to stem
-
-        # Check GUID against known stem types (from MoMorphTypeTags)
-        stem_guids = {
-            MoMorphTypeTags.kguidMorphStem,
-            MoMorphTypeTags.kguidMorphRoot,
-            MoMorphTypeTags.kguidMorphBoundRoot,
-            MoMorphTypeTags.kguidMorphBoundStem,
-            MoMorphTypeTags.kguidMorphClitic,
-            MoMorphTypeTags.kguidMorphEnclitic,
-            MoMorphTypeTags.kguidMorphProclitic,
-            MoMorphTypeTags.kguidMorphParticle,
-            MoMorphTypeTags.kguidMorphPhrase,
-            MoMorphTypeTags.kguidMorphDiscontiguousPhrase,
-        }
-
-        return morph_type.Guid in stem_guids
+        return is_stem_morph_type(morph_type)
 
     def __WSHandleAnalysis(self, wsHandle):
         """
@@ -3176,28 +3168,10 @@ class LexEntryOperations(BaseOperations):
 
         Returns:
             IMoMorphType or None: The morph type object if found, None otherwise
-        """
-        # Strip display markers (prefix '-', '=', '~'; postfix '-', '=', '~', '<', '>')
-        # that FLEx shows in the UI but that are NOT part of the canonical IMoMorphType.Name.
-        bare = name.strip('-=~<>')
-        target = normalize_match_key(bare, casefold=True)
-        wsHandle = self.project.project.DefaultAnalWs
-
-        morph_types = self.project.lp.LexDbOA.MorphTypesOA
-        if morph_types is None:
-            return None
 
-        # Search through all morph types (including subcategories)
-        def search_morph_types(possibilities):
-            for mt in possibilities:
-                mt_name = best_analysis_text(mt.Name)
-                if mt_name and normalize_match_key(mt_name, casefold=True) == target:
-                    return mt
-                # Search subcategories
-                if mt.SubPossibilitiesOS.Count > 0:
-                    found = search_morph_types(mt.SubPossibilitiesOS)
-                    if found:
-                        return found
-            return None
-
-        return search_morph_types(morph_types.PossibilitiesOS)
+        Notes:
+            Delegates to Shared.morph_type_utils.find_morph_type so this is
+            the single lookup used by both LexEntryOperations and
+            AllomorphOperations (see issue #213/#214).
+        """
+        return find_morph_type(self.project, name)