import fixes

7 files changed, 32 insertions, 28 deletions

diff --git a/bsie/base/extractor.py b/bsie/base/extractor.py
index bfa403c..a5c7846 100644
--- a/bsie/base/extractor.py
+++ b/bsie/base/extractor.py
@@ -11,6 +11,7 @@ import typing
 # bsie imports
 from bsie.utils import node
 from bsie.utils.bsfs import schema as _schema, typename
+from bsie.utils import bsfs, node, ns
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -62,10 +63,10 @@ class Extractor(abc.ABC):
         self.schema = schema
 
     def __str__(self) -> str:
-        return typename(self)
+        return bsfs.typename(self)
 
     def __repr__(self) -> str:
-        return f'{typename(self)}()'
+        return f'{bsfs.typename(self)}()'
 
     def __eq__(self, other: typing.Any) -> bool:
         return isinstance(other, type(self)) \
diff --git a/bsie/extractor/generic/constant.py b/bsie/extractor/generic/constant.py
index 7da792a..f9e3415 100644
--- a/bsie/extractor/generic/constant.py
+++ b/bsie/extractor/generic/constant.py
@@ -11,6 +11,7 @@ import typing
 from bsie.base import extractor
 from bsie.utils.bsfs import URI, schema as _schema
 from bsie.utils.node import Node
+from bsie.utils import bsfs, node
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -26,14 +27,14 @@ class Constant(extractor.Extractor):
     CONTENT_READER = None
 
     # predicate/value pairs to be produced.
-    _tuples: typing.Tuple[typing.Tuple[_schema.Predicate, typing.Any], ...]
+    _tuples: typing.Tuple[typing.Tuple[bsfs.schema.Predicate, typing.Any], ...]
 
     def __init__(
             self,
             schema: str,
-            tuples: typing.Iterable[typing.Tuple[URI, typing.Any]],
+            tuples: typing.Iterable[typing.Tuple[bsfs.URI, typing.Any]],
             ):
-        super().__init__(_schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + schema))
+        super().__init__(bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + schema))
         # NOTE: Raises a KeyError if the predicate is not part of the schema
         self._tuples = tuple((self.schema.predicate(p_uri), value) for p_uri, value in tuples)
         # FIXME: use schema instance for value checking
@@ -47,7 +48,7 @@ class Constant(extractor.Extractor):
 
     def extract(
             self,
-            subject: Node,
+            subject: node.Node,
             content: None,
             predicates: typing.Iterable[_schema.Predicate],
             ) -> typing.Iterator[typing.Tuple[Node, _schema.Predicate, typing.Any]]:
diff --git a/bsie/extractor/generic/path.py b/bsie/extractor/generic/path.py
index e6b901e..2cc592a 100644
--- a/bsie/extractor/generic/path.py
+++ b/bsie/extractor/generic/path.py
@@ -10,8 +10,8 @@ import typing
 
 # bsie imports
 from bsie.base import extractor
-from bsie.utils import node, ns
 from bsie.utils.bsfs import schema
+from bsie.utils import bsfs, node, ns
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -27,10 +27,10 @@ class Path(extractor.Extractor):
     CONTENT_READER = 'bsie.reader.path.Path'
 
     # mapping from predicate to handler function.
-    _callmap: typing.Dict[schema.Predicate, typing.Callable[[str], typing.Any]]
+    _callmap: typing.Dict[bsfs.schema.Predicate, typing.Callable[[str], typing.Any]]
 
     def __init__(self):
-        super().__init__(schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
+        super().__init__(bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
             bse:filename rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:string ;
diff --git a/bsie/extractor/generic/stat.py b/bsie/extractor/generic/stat.py
index 6493d37..dfde7d2 100644
--- a/bsie/extractor/generic/stat.py
+++ b/bsie/extractor/generic/stat.py
@@ -10,8 +10,8 @@ import typing
 
 # bsie imports
 from bsie.base import extractor
-from bsie.utils import node, ns
 from bsie.utils.bsfs import schema as _schema
+from bsie.utils import bsfs, node, ns
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -27,10 +27,10 @@ class Stat(extractor.Extractor):
     CONTENT_READER = 'bsie.reader.stat.Stat'
 
     # mapping from predicate to handler function.
-    _callmap: typing.Dict[_schema.Predicate, typing.Callable[[os.stat_result], typing.Any]]
+    _callmap: typing.Dict[bsfs.schema.Predicate, typing.Callable[[os.stat_result], typing.Any]]
 
     def __init__(self):
-        super().__init__(_schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
+        super().__init__(bsfs.schema.Schema.from_string(extractor.SCHEMA_PREAMBLE + '''
             bse:filesize rdfs:subClassOf bsfs:Predicate ;
                 rdfs:domain bsfs:Entity ;
                 rdfs:range xsd:integer ;
diff --git a/bsie/lib/bsie.py b/bsie/lib/bsie.py
index aeccc8c..3aeee2b 100644
--- a/bsie/lib/bsie.py
+++ b/bsie/lib/bsie.py
@@ -9,8 +9,9 @@ import typing
 
 # bsie imports
 from bsie.tools.pipeline import Pipeline
-from bsie.utils import node, ns
 from bsie.utils.bsfs import URI, schema as schema_
+from bsie.tools import Pipeline
+from bsie.utils import bsfs, node, ns
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -39,10 +40,10 @@ class BSIE():
             self,
             # pipeline builder.
             pipeline: Pipeline,
-            # predicates to extract at most. None implies all available w.r.t. extractors.
-            collect: typing.Optional[typing.Iterable[URI]] = None,
-            # predicates to discard.
-            discard: typing.Optional[typing.Iterable[URI]] = None,
+            # principals to extract at most. None implies all available w.r.t. extractors.
+            collect: typing.Optional[typing.Iterable[bsfs.URI]] = None,
+            # principals to discard.
+            discard: typing.Optional[typing.Iterable[bsfs.URI]] = None,
             ):
         # store pipeline
         self.pipeline = pipeline
diff --git a/bsie/tools/builder.py b/bsie/tools/builder.py
index 8f7a410..8c6b931 100644
--- a/bsie/tools/builder.py
+++ b/bsie/tools/builder.py
@@ -13,6 +13,7 @@ import typing
 from bsie import base
 from bsie.base import errors
 from bsie.utils.bsfs import URI, typename
+from bsie.utils import bsfs
 
 # inner-module imports
 from . import pipeline
@@ -61,7 +62,7 @@ def _unpack_name(name):
 
 
 class ReaderBuilder():
-    """Build `bsie.base.reader.Reader` instances.
+    """Build `bsie.base.Reader` instances.
 
     Readers are defined via their qualified class name
     (e.g., bsie.reader.path.Path) and optional keyword
@@ -83,7 +84,7 @@ class ReaderBuilder():
         self.kwargs = kwargs
         self.cache = {}
 
-    def build(self, name: str) -> base.reader.Reader:
+    def build(self, name: str) -> base.Reader:
         """Return an instance for the qualified class name."""
         # return cached instance
         if name in self.cache:
@@ -98,7 +99,7 @@ class ReaderBuilder():
         # get kwargs
         kwargs = self.kwargs.get(name, {})
         if not isinstance(kwargs, dict):
-            raise TypeError(f'expected a kwargs dict, found {typename(kwargs)}')
+            raise TypeError(f'expected a kwargs dict, found {bsfs.typename(kwargs)}')
 
         try: # build, cache, and return instance
             obj = cls(**kwargs)
@@ -108,11 +109,11 @@ class ReaderBuilder():
             return obj
 
         except Exception as err:
-            raise errors.BuilderError(f'failed to build reader {name} due to {typename(err)}: {err}') from err
+            raise errors.BuilderError(f'failed to build reader {name} due to {bsfs.typename(err)}: {err}') from err
 
 
 class ExtractorBuilder():
-    """Build `bsie.base.extractor.Extractor instances.
+    """Build `bsie.base.Extractor instances.
 
     It is permissible to build multiple instances of the same extractor
     (typically with different arguments), hence the ExtractorBuilder
@@ -133,14 +134,14 @@ class ExtractorBuilder():
         """Iterate over extractor specifications."""
         return iter(range(len(self.specs)))
 
-    def build(self, index: int) -> base.extractor.Extractor:
+    def build(self, index: int) -> base.Extractor:
         """Return an instance of the n'th extractor (n=*index*)."""
         # get build instructions
         specs = self.specs[index]
 
         # check specs structure. expecting[{name: {kwargs}}]
         if not isinstance(specs, dict):
-            raise TypeError(f'expected a dict, found {typename(specs)}')
+            raise TypeError(f'expected a dict, found {bsfs.typename(specs)}')
         if len(specs) != 1:
             raise TypeError(f'expected a dict of length one, found {len(specs)}')
 
@@ -150,7 +151,7 @@ class ExtractorBuilder():
 
         # check kwargs structure
         if not isinstance(kwargs, dict):
-            raise TypeError(f'expected a dict, found {typename(kwargs)}')
+            raise TypeError(f'expected a dict, found {bsfs.typename(kwargs)}')
 
         # check name and get module/class components
         module_name, class_name = _unpack_name(name)
diff --git a/bsie/tools/pipeline.py b/bsie/tools/pipeline.py
index da422c0..7fdd935 100644
--- a/bsie/tools/pipeline.py
+++ b/bsie/tools/pipeline.py
@@ -11,9 +11,9 @@ import typing
 
 # bsie imports
 from bsie import base
-from bsie.utils import ns
 from bsie.utils.node import Node
 from bsie.utils.bsfs import schema as _schema, URI, uuid as _uuid, typename
+from bsie.utils import bsfs, node, ns
 
 # exports
 __all__: typing.Sequence[str] = (
@@ -56,10 +56,10 @@ class Pipeline():
         self.schema = _schema.Schema.Union(ext.schema for ext in ext2rdr)
 
     def __str__(self) -> str:
-        return typename(self)
+        return bsfs.typename(self)
 
     def __repr__(self) -> str:
-        return f'{typename(self)}(...)'
+        return f'{bsfs.typename(self)}(...)'
 
     def __hash__(self) -> int:
         return hash((type(self), self._prefix, self.schema, tuple(self._ext2rdr), tuple(self._ext2rdr.values())))