iolanta 2.0.5__py3-none-any.whl → 2.0.7__py3-none-any.whl

iolanta/loaders/local_file.py

@@ -1,107 +0,0 @@
-import logging
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable, Optional, TextIO, Type
-
-from rdflib import Literal, URIRef
-
-from iolanta.conversions import url_to_iri
-from iolanta.loaders.base import Loader
-from iolanta.loaders.errors import IsAContext, ParserNotFound
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.namespaces import IOLANTA
-from iolanta.parsers.base import Parser
-from iolanta.parsers.json import JSON
-from iolanta.parsers.markdown import Markdown
-from iolanta.parsers.yaml import YAML
-
-
-def choose_parser_by_extension(path: Path) -> Type[Parser]:
-    """
-    Choose parser class based on file extension.
-
-    FIXME this is currently hard coded; need to change to a more extensible
-      mechanism.
-    """
-    try:
-        return {
-            '.json': JSON,
-            '.jsonld': JSON,
-
-            '.yaml': YAML,
-            '.yamlld': YAML,
-
-            '.md': Markdown,
-        }[path.suffix]
-    except KeyError:
-        raise ParserNotFound(path=path)
-
-
-@dataclass(frozen=True)
-class LocalFile(Loader[Path]):
-    """
-    Retrieve Linked Data from a file on local disk.
-
-    Requires Path with file:// scheme as input.
-    """
-
-    def find_context(self, source: str) -> LDContext:
-        return {}
-
-    def choose_parser_class(self, source: Path) -> Type[Parser]:
-        return choose_parser_by_extension(source)
-
-    def as_quad_stream(
-        self,
-        source: Path,
-        root_loader: Loader[Path],
-        iri: Optional[URIRef] = None,
-        context: Optional[LDContext] = None,
-    ) -> Iterable[Quad]:
-        """Extract a sequence of quads from a local file."""
-        if source.stem == 'context':
-            raise IsAContext(path=source)
-
-        try:
-            parser_class = self.choose_parser_class(source)
-        except ParserNotFound:
-            return []
-
-        if iri is None:
-            iri = url_to_iri(source)
-
-        self.logger.info('Loading data into graph: %s', source)
-        with source.open() as text_io:
-            yield from parser_class().as_quad_stream(
-                raw_data=text_io,
-                iri=iri,
-                context=context,
-                root_loader=root_loader,
-            )
-
-            yield Quad(
-                iri,
-                IOLANTA.fileName,
-                Literal(source.name),
-                URIRef('https://iolanta.tech/loaders/local-file'),
-            )
-
-    def as_file(self, source: Path) -> TextIO:
-        """Construct a file-like object."""
-        with source.open() as text_io:
-            return text_io
-
-    def as_jsonld_document(
-        self,
-        source: Path,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        """As JSON-LD document."""
-        parser_class: Type[Parser] = self.choose_parser_class(source)
-        with source.open() as text_io:
-            document = parser_class().as_jsonld_document(text_io)
-
-        if iri is not None and isinstance(document, dict):
-            document.setdefault('@id', str(iri))
-
-        return document

iolanta/loaders/scheme_choice.py

@@ -1,72 +0,0 @@
-from dataclasses import dataclass
-from typing import Dict, Iterable, Optional
-
-from rdflib import URIRef
-from yarl import URL
-
-from iolanta.conversions import url_to_iri
-from iolanta.ensure_is_context import ensure_is_context
-from iolanta.loaders.base import Loader, PyLDOptions, PyLDResponse
-from iolanta.models import LDContext, LDDocument, Quad
-
-
-@dataclass(frozen=True)
-class SchemeChoiceLoader(Loader[URL]):
-    """Try to load a file via several loaders."""
-
-    loader_by_scheme: Dict[str, Loader[URL]]
-
-    def __call__(self, source: str, options: PyLDOptions) -> PyLDResponse:
-        """Compile document for PyLD."""
-        source = URL(source)
-
-        document = ensure_is_context(
-            self.as_jsonld_document(
-                source=source,
-                iri=url_to_iri(source),
-            ),
-        )
-
-        return {
-            'document': document,
-            'contextUrl': None,
-            'contentType': 'application/ld+json',
-            'documentUrl': str(source),
-        }
-
-    def resolve_loader_by_url(self, url: URL):
-        """Find loader instance by URL."""
-        try:
-            return self.loader_by_scheme[url.scheme]
-        except (KeyError, AttributeError):
-            raise ValueError(f'Cannot find a loader for URL: {url}')
-
-    def as_jsonld_document(
-        self,
-        source: URL,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        """Represent a file as a JSON-LD document."""
-        return self.resolve_loader_by_url(
-            url=source,
-        ).as_jsonld_document(
-            source=source,
-            iri=iri,
-        )
-
-    def as_quad_stream(
-        self,
-        source: str,
-        iri: Optional[URIRef],
-        root_loader: Optional[Loader[URL]] = None,
-        context: Optional[LDContext] = None,
-    ) -> Iterable[Quad]:
-        """Convert data into a stream of RDF quads."""
-        return self.resolve_loader_by_url(
-            url=source,
-        ).as_quad_stream(
-            source=source,
-            iri=iri,
-            root_loader=root_loader or self,
-            context=context,
-        )

iolanta/parsers/base.py

@@ -1,41 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-from typing import Generic, Iterable, Optional, TypeVar
-
-from rdflib import URIRef
-
-from iolanta.loaders.base import Loader
-from iolanta.models import LDContext, LDDocument, Quad
-
-RawDataType = TypeVar('RawDataType')
-
-
-@dataclass(frozen=True)
-class Parser(ABC, Generic[RawDataType]):
-    """
-    Parser reads data from a file-like object and interprets them.
-
-    For interpretation, it is also supplied with a context.
-    """
-
-    blank_node_prefix: str = ''
-
-    def as_jsonld_document(
-        self,
-        raw_data: RawDataType,
-    ) -> LDDocument:
-        """Generate a JSON-LD document."""
-        raise NotImplementedError(
-            f'{self}.as_json_document() is not implemented.',
-        )
-
-    def as_quad_stream(
-        self,
-        raw_data: RawDataType,
-        iri: Optional[URIRef],
-        context: LDContext,
-        root_loader: Loader,
-    ) -> Iterable[Quad]:
-        raise NotImplementedError(
-            f'{self}.as_quad_stream() is not implemented.',
-        )

iolanta/parsers/dict_parser.py

@@ -1,171 +0,0 @@
-import dataclasses
-import itertools
-import json
-import uuid
-from dataclasses import dataclass
-from typing import Any, Iterable, Optional
-
-from documented import DocumentedError
-from pyld.jsonld import _resolved_context_cache  # noqa: WPS450
-from pyld.jsonld import JsonLdError, expand, flatten, to_rdf  # noqa: WPS347
-from rdflib import BNode, URIRef
-from yarl import URL
-
-from iolanta.errors import UnresolvedIRI
-from iolanta.loaders import Loader
-from iolanta.models import LDContext, LDDocument, NotLiteralNode, Quad
-from iolanta.namespaces import IOLANTA, LOCAL, RDF
-from iolanta.parse_quads import parse_quads
-from iolanta.parsers.base import Parser, RawDataType
-
-
-class DictParser(Parser[LDDocument]):
-    """
-    Old version of dict parser.
-
-    FIXME: Remove this.
-    """
-
-    def as_jsonld_document(self, raw_data: LDDocument) -> LDDocument:
-        """Do nothing."""
-        return raw_data
-
-    def as_quad_stream(
-        self,
-        raw_data: RawDataType,
-        iri: Optional[NotLiteralNode],
-        context: LDContext,
-        root_loader: Loader,
-    ) -> Iterable[Quad]:
-        """Do nonsense."""
-        # This helps avoid weird bugs when loading data.
-        _resolved_context_cache.clear()
-
-        document = raw_data
-
-        if iri is None:
-            uid = uuid.uuid4().hex
-            iri = BNode(f'_:dict:{uid}')
-
-        document = assign_key_if_not_present(
-            document=document,
-            key='iolanta:subjectOf',
-            default_value={
-                '$id': str(iri),
-            },
-        )
-
-        try:
-            document = expand(
-                document,
-                options={
-                    'expandContext': context,
-                    'documentLoader': root_loader,
-
-                    # Explanation:
-                    #   https://github.com/digitalbazaar/pyld/issues/143
-                    'base': str(LOCAL),
-                },
-            )
-        except (JsonLdError, KeyError, TypeError) as err:
-            raise ExpandError(
-                message=str(err),
-                document=document,
-                context=context,
-                iri=iri,
-                document_loader=root_loader,
-            ) from err
-
-        document = flatten(document)
-
-        static_quads = [
-            Quad(iri, RDF.type, IOLANTA.File, iri),
-        ]
-
-        try:
-            parsed_quads = list(
-                parse_quads(
-                    quads_document=to_rdf(document),
-                    # FIXME:
-                    #   title: Can iri be None in a parser?
-                    #   description: |
-                    #     Does it make sense? If not, just change
-                    #     the annotation.
-                    graph=iri,  # type: ignore
-                    blank_node_prefix=str(iri),
-                ),
-            )
-        except UnresolvedIRI as err:
-            raise dataclasses.replace(
-                err,
-                context=context,
-                iri=iri,
-            )
-
-        return list(
-            itertools.chain(
-                parsed_quads,
-                static_quads,
-            ),
-        )
-
-
-def assign_key_if_not_present(  # type: ignore
-    document: LDDocument,
-    key: str,
-    default_value: Any,
-) -> LDDocument:
-    """Add key to document if it does not exist yet."""
-    if isinstance(document, dict):
-        if document.get(key) is None:
-            return {
-                key: default_value,
-                **document,
-            }
-
-        return document
-
-    elif isinstance(document, list):
-        return [
-            assign_key_if_not_present(    # type: ignore
-                document=sub_document,
-                key=key,
-                default_value=default_value,
-            )
-            for sub_document in document
-        ]
-
-    return document
-
-
-@dataclass
-class ExpandError(DocumentedError):
-    """
-    JSON-LD expand operation failed.
-
-    IRI: {self.iri}
-
-    Context: {self.formatted_context}
-
-    Document: {self.formatted_data}
-
-    Error: {self.message}
-
-    Document Loader: {self.document_loader}
-    """
-
-    message: str
-    document: LDDocument
-    context: LDContext
-    iri: Optional[URIRef]
-    document_loader: Loader[URL]
-
-    @property
-    def formatted_data(self) -> str:
-        """Format document for printing."""
-        return json.dumps(self.document, indent=2, ensure_ascii=False)
-
-    @property
-    def formatted_context(self):
-        """Format context for printing."""
-        return json.dumps(self.context, indent=2, ensure_ascii=False)

iolanta/parsers/errors.py

@@ -1,35 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from documented import DocumentedError
-from rdflib import URIRef
-
-
-@dataclass
-class YAMLError(DocumentedError):
-    """
-    Invalid YAML.
-
-    File: {self.iri}
-
-    {self.error}
-    """
-
-    iri: Optional[URIRef]
-    error: Exception
-
-
-@dataclass
-class SpaceInProperty(DocumentedError):
-    """
-    Space in property.
-
-    That impedes JSON-LD parsing.
-
-    Please do not use spaces in property names in JSON or YAML data; use `title`
-    or other methods instead.
-
-    Document IRI: {self.iri}
-    """
-
-    iri: Optional[URIRef] = None

iolanta/parsers/json.py

@@ -1,35 +0,0 @@
-import json
-from typing import Iterable, Optional, TextIO
-
-from rdflib import URIRef
-from yarl import URL
-
-from iolanta.loaders.base import Loader
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.parsers.base import Parser
-from iolanta.parsers.dict_parser import DictParser
-
-
-class JSON(Parser[TextIO]):
-    """Load JSON data."""
-
-    def as_jsonld_document(self, raw_data: TextIO) -> LDDocument:
-        """Read JSON content as a JSON-LD document."""
-        return json.load(raw_data)
-
-    def as_quad_stream(
-        self,
-        raw_data: TextIO,
-        iri: Optional[URIRef],
-        context: LDContext,
-        root_loader: Loader[URL],
-    ) -> Iterable[Quad]:
-        """Read JSON-LD data into a quad stream."""
-        document = self.as_jsonld_document(raw_data)
-
-        return DictParser().as_quad_stream(
-            raw_data=document,
-            iri=iri,
-            context=context,
-            root_loader=root_loader,
-        )

iolanta/parsers/markdown.py

@@ -1,58 +0,0 @@
-import json
-from io import StringIO
-from typing import Iterable, Optional, TextIO
-
-import frontmatter
-from rdflib import URIRef
-from yaml.parser import ParserError
-from yaml.scanner import ScannerError
-
-from iolanta.loaders import Loader
-from iolanta.loaders.base import SourceType
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.parsers.errors import YAMLError
-from iolanta.parsers.json import JSON
-from iolanta.parsers.yaml import YAML
-
-try:  # noqa
-    from yaml import CSafeLoader as SafeLoader  # noqa
-except ImportError:
-    from yaml import SafeLoader  # type: ignore   # noqa
-
-
-class Markdown(YAML):
-    """Load YAML data."""
-
-    def as_jsonld_document(self, raw_data: TextIO) -> LDDocument:
-        """Read YAML content and adapt it to JSON-LD format."""
-        raw_data.seek(0)
-        return frontmatter.load(raw_data).metadata
-
-    def as_quad_stream(
-        self,
-        raw_data: TextIO,
-        iri: Optional[URIRef],
-        context: LDContext,
-        root_loader: Loader[SourceType],
-    ) -> Iterable[Quad]:
-        """Assign iolanta:url and generate quad stream."""
-        try:
-            json_data = self.as_jsonld_document(raw_data)
-        except (ScannerError, ParserError) as err:
-            raise YAMLError(
-                iri=iri,
-                error=err,
-            ) from err
-
-        return JSON().as_quad_stream(
-            raw_data=StringIO(
-                json.dumps(
-                    json_data,
-                    ensure_ascii=False,
-                    default=str,
-                ),
-            ),
-            iri=iri,
-            context=context,
-            root_loader=root_loader,
-        )

iolanta/parsers/yaml.py

@@ -1,46 +0,0 @@
-import json
-from io import StringIO
-from typing import Iterable, Optional, TextIO
-
-import yaml
-from rdflib import URIRef
-
-from iolanta.loaders import Loader
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.parsers.json import JSON
-
-try:  # noqa
-    from yaml import CSafeLoader as SafeLoader  # noqa
-except ImportError:
-    from yaml import SafeLoader  # type: ignore   # noqa
-
-
-class YAML(JSON):
-    """Load YAML data."""
-
-    def as_jsonld_document(self, raw_data: TextIO) -> LDDocument:
-        """Read YAML content and adapt it to JSON-LD format."""
-        return yaml.load(raw_data, Loader=SafeLoader)
-
-    def as_quad_stream(
-        self,
-        raw_data: TextIO,
-        iri: Optional[URIRef],
-        context: LDContext,
-        root_loader: Loader,
-    ) -> Iterable[Quad]:
-        """Read YAML-LD data into a quad stream."""
-        json_data = self.as_jsonld_document(raw_data)
-
-        return JSON().as_quad_stream(
-            raw_data=StringIO(
-                json.dumps(
-                    json_data,
-                    ensure_ascii=False,
-                    default=str,
-                ),
-            ),
-            iri=iri,
-            context=context,
-            root_loader=root_loader,
-        )

iolanta/shortcuts.py

@@ -1,63 +0,0 @@
-from logging import Logger
-from pathlib import Path
-from typing import Dict, Iterable, Type
-
-from rdflib import URIRef
-from yarl import URL
-
-from iolanta.loaders.data_type_choice import DataTypeChoiceLoader
-from iolanta.loaders.dict_loader import DictLoader
-from iolanta.loaders.http import HTTP
-from iolanta.loaders.local_directory import Loader, LocalDirectory
-from iolanta.loaders.local_file import LocalFile
-from iolanta.loaders.scheme_choice import SchemeChoiceLoader
-from iolanta.models import LDContext, LDDocument, Quad
-
-
-def choose_loader_by_url(url: URL) -> Type[Loader[URL]]:
-    """Find loader by URL scheme."""
-    return LocalDirectory
-
-
-def as_document(path: Path) -> LDDocument:
-    """Retrieve the document presented by the specified URL."""
-    return LocalFile().as_jsonld_document(path)
-
-
-def construct_root_loader(logger: Logger) -> DataTypeChoiceLoader:
-    # FIXME: Generalize this using endpoints
-    return DataTypeChoiceLoader(
-        logger=logger,
-        loader_by_data_type={
-            dict: DictLoader(logger=logger),
-            Path: LocalDirectory(logger=logger),
-            URL: SchemeChoiceLoader(
-                logger=logger,
-                loader_by_scheme={
-                    'file': LocalDirectory(logger=logger),
-                    'http': HTTP(logger=logger),
-                    'https': HTTP(logger=logger),
-                },
-            ),
-        },
-    )
-
-
-def as_quad_stream(
-    url: URL,
-    iri: URIRef,
-    default_context: LDContext,
-    root_directory: Path,
-    named_contexts: Dict[str, LDContext],
-) -> Iterable[Quad]:
-    """Retrieve the stream presented by the specified URL."""
-    root_loader = construct_root_loader(
-        default_context=default_context,
-        root_directory=root_directory,
-    )
-
-    return root_loader.as_quad_stream(
-        source=url,
-        iri=iri,
-        context=default_context,
-    )