Rename components

Author: cthoyt

docs/source/preprocessing.rst

@@ -11,11 +11,10 @@ For example, you always want to fix legacy references to the ``OBO_REL`` namespa
 .. code-block:: python
 
     import curies
-    from curies import PreprocessingRules, PreprocessingConverter
-    from curies.wrapped import Rewrites
+    from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites
 
     rules = PreprocessingRules(
-        rewrites=Rewrites(
+        rewrites=PreprocessingRewrites(
             full={"OBO_REL:is_a": "rdfs:subClassOf"}
         )
     )
@@ -27,3 +26,30 @@ For example, you always want to fix legacy references to the ``OBO_REL`` namespa
 
     >>> converter.parse_curie("OBO_REL:is_a")
     ReferenceTuple('rdfs', 'subClassOf')
+
+Similarly, there may be a whole class of references that need to be fixed
+based on their prefix, such as the ``APOLLO:SV_`` references that are mangled
+by the OWLAPI due to the OBO Foundry's PURL rules
+
+.. code-block:: python
+
+    import curies
+    from curies import PreprocessingRules, PreprocessingConverter, PreprocessingRewrites
+
+    rules = PreprocessingRules(
+        rewrites=PreprocessingRewrites(
+            prefix={"APOLLO:SV_": "APOLLO_SV:"}
+        )
+    )
+
+    converter = curies.get_obo_converter()
+    converter = PreprocessingConverter.from_converter(
+        converter, rules=rules
+    )
+
+    >>> converter.parse_curie("APOLLO:SV_1234567")
+    ReferenceTuple('APOLLO_SV', '1234567')
+
+Some rewrite rules only apply to a specific resource, because of its own quirks
+in curation or encoding. For example, CHMO encodes OrangeBook entries with ``orange``
+as a prefix, which is not typically specific enough to

src/curies/__init__.py

@@ -26,7 +26,7 @@
 )
 from .discovery import discover, discover_from_rdf
 from .preprocessing import (
-    PreprocessingBlacklist,
+    PreprocessingBlocklists,
     PreprocessingConverter,
     PreprocessingRewrites,
     PreprocessingRules,
@@ -51,7 +51,7 @@
     "NamedReference",
     "Prefix",
     "PrefixMap",
-    "PreprocessingBlacklist",
+    "PreprocessingBlocklists",
     "PreprocessingConverter",
     "PreprocessingRewrites",
     "PreprocessingRules",

src/curies/preprocessing.py

@@ -12,8 +12,8 @@
 from .api import Converter, Reference, ReferenceTuple
 
 __all__ = [
-    "BlacklistError",
-    "PreprocessingBlacklist",
+    "BlocklistError",
+    "PreprocessingBlocklists",
     "PreprocessingConverter",
     "PreprocessingRewrites",
     "PreprocessingRules",
@@ -22,8 +22,8 @@
 X = TypeVar("X", bound=Reference)
 
 
-class PreprocessingBlacklist(BaseModel):
-    """A model for prefix and full blacklists."""
+class PreprocessingBlocklists(BaseModel):
+    """A model for prefix and full blocklists."""
 
     full: list[str] = Field(default_factory=list)
     resource_full: dict[str, list[str]] = Field(default_factory=dict)
@@ -40,34 +40,32 @@ def _sort(self) -> None:
         for v in self.resource_prefix.values():
             v.sort()
 
-    def str_has_blacklisted_prefix(
+    def str_has_blocked_prefix(
         self, str_or_curie_or_uri: str, *, context: str | None = None
     ) -> bool:
-        """Check if the CURIE string has a blacklisted prefix."""
+        """Check if the CURIE string has a blocklisted prefix."""
         if context:
             prefixes: list[str] = self.resource_prefix.get(context, [])
             if prefixes and any(str_or_curie_or_uri.startswith(prefix) for prefix in prefixes):
                 return True
         return any(str_or_curie_or_uri.startswith(prefix) for prefix in self.prefix)
 
-    def str_has_blacklisted_suffix(self, str_or_curie_or_uri: str) -> bool:
-        """Check if the CURIE string has a blacklisted suffix."""
+    def str_has_blocked_suffix(self, str_or_curie_or_uri: str) -> bool:
+        """Check if the CURIE string has a blocklisted suffix."""
         return any(str_or_curie_or_uri.endswith(suffix) for suffix in self.suffix)
 
-    def str_is_blacklisted_full(
-        self, str_or_curie_or_uri: str, *, context: str | None = None
-    ) -> bool:
-        """Check if the full CURIE string is blacklisted."""
+    def str_is_blocked_full(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool:
+        """Check if the full CURIE string is blocklisted."""
         if context and str_or_curie_or_uri in self.resource_full.get(context, set()):
             return True
         return str_or_curie_or_uri in self.full
 
-    def str_is_blacklisted(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool:
-        """Check if the full CURIE string is blacklisted."""
+    def str_is_blocked(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool:
+        """Check if the full CURIE string is blocklisted."""
         return (
-            self.str_has_blacklisted_prefix(str_or_curie_or_uri, context=context)
-            or self.str_has_blacklisted_suffix(str_or_curie_or_uri)
-            or self.str_is_blacklisted_full(str_or_curie_or_uri, context=context)
+            self.str_has_blocked_prefix(str_or_curie_or_uri, context=context)
+            or self.str_has_blocked_suffix(str_or_curie_or_uri)
+            or self.str_is_blocked_full(str_or_curie_or_uri, context=context)
         )
 
 
@@ -118,17 +116,17 @@ def remap_prefix(self, str_or_curie_or_uri: str, *, context: str | None = None)
 
 
 class PreprocessingRules(BaseModel):
-    """A model for blacklists and rewrites."""
+    """A model for blocklists and rewrites."""
 
-    blacklists: PreprocessingBlacklist
+    blocklists: PreprocessingBlocklists
     rewrites: PreprocessingRewrites
 
     @classmethod
     def lint_file(cls, path: str | Path) -> None:
         """Lint a file, in place, given a file path."""
         path = Path(path).expanduser().resolve()
         rules = cls.model_validate_json(path.read_text())
-        rules.blacklists._sort()
+        rules.blocklists._sort()
         path.write_text(
             json.dumps(
                 rules.model_dump(exclude_unset=True, exclude_defaults=True),
@@ -137,9 +135,9 @@ def lint_file(cls, path: str | Path) -> None:
             )
         )
 
-    def str_is_blacklisted(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool:
-        """Check if the CURIE string is blacklisted."""
-        return self.blacklists.str_is_blacklisted(str_or_curie_or_uri, context=context)
+    def str_is_blocked(self, str_or_curie_or_uri: str, *, context: str | None = None) -> bool:
+        """Check if the CURIE string is blocked."""
+        return self.blocklists.str_is_blocked(str_or_curie_or_uri, context=context)
 
     def remap_full(
         self,
@@ -165,8 +163,8 @@ def _load_rules(rules: str | Path | PreprocessingRules) -> PreprocessingRules:
     return rules
 
 
-class BlacklistError(ValueError):
-    """An error for blacklist."""
+class BlocklistError(ValueError):
+    """An error for block list."""
 
 
 class PreprocessingConverter(Converter):
@@ -228,8 +226,8 @@ def parse(
         # Remap node's prefix (if necessary)
         str_or_uri_or_curie = self.rules.remap_prefix(str_or_uri_or_curie, context=context)
 
-        if self.rules.str_is_blacklisted(str_or_uri_or_curie, context=context):
-            raise BlacklistError
+        if self.rules.str_is_blocked(str_or_uri_or_curie, context=context):
+            raise BlocklistError
 
         if strict:
             return super().parse(str_or_uri_or_curie, strict=strict)
@@ -256,20 +254,20 @@ def parse_curie(
         :param strict: If the CURIE can't be parsed, should an error be thrown? Defaults
             to false.
         :param context: Is there a context, e.g., an ontology prefix that should be
-            applied to the remapping and blacklist rules?
+            applied to the remapping and blocklist rules?
 
         :returns: A tuple representing a parsed and standardized CURIE
 
-        :raises BlacklistError: If the CURIE is blacklisted
+        :raises BlocklistError: If the CURIE is blocked
         """
         if r1 := self.rules.remap_full(curie, reference_cls=self._reference_cls, context=context):
             return r1.pair
 
         # Remap node's prefix (if necessary)
         curie = self.rules.remap_prefix(curie, context=context)
 
-        if self.rules.str_is_blacklisted(curie, context=context):
-            raise BlacklistError
+        if self.rules.str_is_blocked(curie, context=context):
+            raise BlocklistError
 
         if strict:
             return super().parse_curie(curie, strict=strict)

tests/test_preprocessing.py

@@ -9,8 +9,8 @@
 
 from curies import Converter, ReferenceTuple
 from curies.preprocessing import (
-    BlacklistError,
-    PreprocessingBlacklist,
+    BlocklistError,
+    PreprocessingBlocklists,
     PreprocessingConverter,
     PreprocessingRewrites,
     PreprocessingRules,
@@ -55,7 +55,7 @@ def setUpClass(cls) -> None:
                     },
                 },
             ),
-            blacklists=PreprocessingBlacklist(
+            blocklists=PreprocessingBlocklists(
                 full=["rdf:NOPE"],
                 resource_prefix={
                     "chebi": [
@@ -155,8 +155,8 @@ def test_resource_prefix_rewrite(self) -> None:
         with self.assertRaises(ValueError):
             self.assertIsNone(self.converter.parse_curie("j1234", context="chebi"))
 
-    def test_resource_specific_blacklist(self) -> None:
-        """Test resource-specific blacklist."""
+    def test_resource_specific_blocklist(self) -> None:
+        """Test resource-specific blocklist."""
         self.assertEqual(
             ReferenceTuple("pubmed", "1234"),
             self.converter.parse_curie("pubmed:1234"),
@@ -165,17 +165,17 @@ def test_resource_specific_blacklist(self) -> None:
             ReferenceTuple("pubmed", "1234"),
             self.converter.parse_curie("pubmed:1234", context="doid"),
         )
-        with self.assertRaises(BlacklistError):
+        with self.assertRaises(BlocklistError):
             self.converter.parse_curie("pubmed:1234", context="chebi")
 
         self.converter.parse_curie("omim:1234", context="chebi")
-        # normally, OMIM works, but we configured a specific one for the blacklist
-        with self.assertRaises(BlacklistError):
+        # normally, OMIM works, but we configured a specific one for the blocklist
+        with self.assertRaises(BlocklistError):
             self.converter.parse_curie("omim:1356", context="chebi")
 
-    def test_global_blacklist(self) -> None:
-        """Test global blacklist."""
-        with self.assertRaises(BlacklistError):
+    def test_global_blocklist(self) -> None:
+        """Test global blocklist."""
+        with self.assertRaises(BlocklistError):
             self.converter.parse("rdf:NOPE")
-        with self.assertRaises(BlacklistError):
+        with self.assertRaises(BlocklistError):
             self.converter.parse_curie("rdf:NOPE")