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

iolanta/loaders/__init__.py

@@ -1,2 +0,0 @@
-from iolanta.loaders.base import Loader
-from iolanta.loaders.local_directory import LocalDirectory

iolanta/loaders/base.py

@@ -1,124 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-from logging import Logger
-from typing import (
-    Any,
-    Dict,
-    Generic,
-    Iterable,
-    Optional,
-    TextIO,
-    TypedDict,
-    TypeVar,
-)
-
-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.models import LDContext, LDDocument, Quad
-from iolanta.namespaces import PYTHON
-
-SourceType = TypeVar('SourceType')
-
-
-PyLDOptions = Dict[str, Any]   # type: ignore
-
-PyLDResponse = TypedDict(
-    'PyLDResponse', {
-        'contentType': str,
-        'contextUrl': Optional[str],
-        'documentUrl': str,
-        'document': LDDocument,
-    },
-)
-
-
-def term_for_python_class(cls: type) -> URIRef:
-    """Construct term for Python class."""
-    return PYTHON.term(f'{cls.__module__}.{cls.__qualname__}')
-
-
-# noinspection TaskProblemsInspection
-@dataclass(frozen=True)
-class Loader(ABC, Generic[SourceType]):
-    """
-    Base class for loaders.
-
-    Loader receives a URL (or a path) to certain location. It is responsible for
-    reading data from that location and returning it as a stream of RDF quads.
-
-    Usually, depending on the data format, Loader leverages Parsers for that
-    purpose.
-    """
-
-    logger: Logger
-
-    @classmethod
-    def loader_class_iri(cls) -> URIRef:
-        """Import path to the loader class."""
-        return term_for_python_class(cls)
-
-    def choose_parser_class(self, source: SourceType):
-        """Find which parser class to use for this URL."""
-        raise NotImplementedError(
-            f'{self}.choose_parser_class() is not implemented.',
-        )
-
-    def as_jsonld_document(
-        self,
-        source: SourceType,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        """Represent a file as a JSON-LD document."""
-        raise NotImplementedError(
-            f'{self}.as_jsonld_document() is not implemented.',
-        )
-
-    def as_file(self, source: SourceType) -> TextIO:
-        """Construct a file-like object."""
-        raise NotImplementedError()
-
-    def as_quad_stream(
-        self,
-        source: SourceType,
-        iri: Optional[URIRef],
-        root_loader: 'Loader[SourceType]',
-        context: Optional[LDContext] = None,
-    ) -> Iterable[Quad]:
-        """Convert data into a stream of RDF quads."""
-        raise NotImplementedError(
-            f'{self}.as_quad_stream() is not implemented.',
-        )
-
-    def find_context(self, source: SourceType) -> LDContext:
-        """Find context for the file."""
-        raise NotImplementedError(
-            f'{self}.find_context() is not implemented.',
-        )
-
-    def __call__(self, source: str, options: PyLDOptions) -> PyLDResponse:
-        """
-        Call the loader to retrieve the document in a PYLD friendly format.
-
-        Used to resolve remote contexts.
-
-        The type of `source` parameter is intentionally `str`: that's the only
-        thing which pyld can do.
-        """
-        source = URL(source)
-
-        document = ensure_is_context(
-            self.as_jsonld_document(
-                source=URL(source),
-                iri=url_to_iri(source),
-            ),
-        )
-
-        return {
-            'document': document,
-            'contextUrl': None,
-            'documentUrl': source,
-            'contentType': 'application/ld+json',
-        }

iolanta/loaders/data_type_choice.py

@@ -1,66 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, Iterable, Optional, TextIO
-
-from rdflib import URIRef
-from yarl import URL
-
-from iolanta.loaders.base import Loader, SourceType
-from iolanta.models import LDContext, LDDocument, Quad
-
-
-@dataclass(frozen=True)
-class DataTypeChoiceLoader(Loader[Any]):   # type: ignore
-    """Try to load a file via several loaders."""
-
-    loader_by_data_type: Dict[type, Loader[Any]]    # type: ignore
-
-    def choose_parser_class(self, source: SourceType):
-        raise ValueError('choose_parser_class')
-
-    def as_file(self, source: SourceType) -> TextIO:
-        raise ValueError('as_file')
-
-    def find_context(self, source: SourceType) -> LDContext:
-        raise ValueError('find_context')
-
-    def resolve_loader(self, source: Any):   # type: ignore
-        """Find loader instance by URL."""
-        for source_type, loader in self.loader_by_data_type.items():
-            if isinstance(source, source_type):
-                return loader
-
-        source_type = type(source)
-        raise ValueError(
-            f'Cannot find a loader for source: {source} '
-            f'of type: {source_type}',
-        )
-
-    def as_jsonld_document(
-        self,
-        source: URL,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        """Represent a file as a JSON-LD document."""
-        return self.resolve_loader(
-            source=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(
-            source=source,
-        ).as_quad_stream(
-            source=source,
-            iri=iri,
-            root_loader=root_loader or self,
-            context=context,
-        )

iolanta/loaders/dict_loader.py

@@ -1,57 +0,0 @@
-from dataclasses import dataclass
-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.dict_parser import DictParser
-from iolanta.parsers.json import JSON
-from iolanta.parsers.markdown import Markdown
-from iolanta.parsers.yaml import YAML
-
-
-@dataclass(frozen=True)
-class DictLoader(Loader[LDDocument]):
-    """
-    Retrieve Linked Data from a file on local disk.
-
-    Requires a dict of raw JSON-LD data.
-    """
-
-    def find_context(self, source: str) -> LDContext:
-        raise ValueError('???WTF?')
-
-    def choose_parser_class(self, source: LDDocument) -> Type[Parser]:
-        return DictParser(source)
-
-    def as_quad_stream(
-        self,
-        source: LDDocument,
-        root_loader: Loader[LDDocument],
-        iri: Optional[URIRef] = None,
-        context: Optional[LDContext] = None,
-    ) -> Iterable[Quad]:
-        """Extract a sequence of quads."""
-        yield from DictParser().as_quad_stream(
-            raw_data=source,
-            iri=iri,
-            context=context,
-            root_loader=root_loader,
-        )
-
-    def as_file(self, source: LDDocument) -> TextIO:
-        """Construct a file-like object."""
-        raise ValueError('FOO')
-
-    def as_jsonld_document(
-        self,
-        source: LDDocument,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        """As JSON-LD document."""
-        return source

iolanta/loaders/errors.py

@@ -1,29 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-from documented import DocumentedError
-from yarl import URL
-
-
-@dataclass
-class IsAContext(DocumentedError):
-    """
-    The provided file is a context.
-
-        - Path: {self.path}
-
-    This file is not a piece of data and cannot be loaded into the graph.
-    """
-
-    path: URL
-
-
-@dataclass
-class ParserNotFound(DocumentedError):
-    """
-    Parser not found.
-
-        Path: {self.path}
-    """
-
-    path: Path

iolanta/loaders/http.py

@@ -1,127 +0,0 @@
-import json
-import re
-from dataclasses import dataclass, field
-from functools import reduce
-from io import StringIO
-from pathlib import Path
-from typing import Iterable, List, Optional, TextIO, Type, Union
-
-from documented import DocumentedError
-from rdflib import URIRef
-from rdflib.parser import URLInputSource
-from requests import Response
-from yarl import URL
-
-from iolanta.context import merge
-from iolanta.conversions import url_to_iri, url_to_path
-from iolanta.loaders.base import Loader
-from iolanta.loaders.errors import IsAContext, ParserNotFound
-from iolanta.loaders.local_file import choose_parser_by_extension
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.parsers.base import Parser
-from iolanta.parsers.json import JSON
-from iolanta.parsers.markdown import Markdown
-from iolanta.parsers.yaml import YAML
-
-
-@dataclass(frozen=True)
-class HTTP(Loader[URL]):
-    """
-    Retrieve Linked Data from a file on the Web.
-    """
-
-    context: LDContext = field(default_factory=dict)
-
-    def choose_parser_class(self, source: URL, response: Response):
-        # FIXME hard code. Make this extensible.
-        try:
-            return choose_parser_by_extension(source)
-        except ParserNotFound:
-            content_type = response.headers['Content-Type']
-
-            raise ValueError(f'Content type: {content_type}')
-
-    def extract_alternate_url(
-        self,
-        source: URL,
-        response: Response,
-    ) -> URL | None:
-        link = response.headers.get('Link')
-
-        if link is None:
-            return None
-
-        match = re.match(
-            r'<([^>]+)>; rel="alternate"; type="application/ld\+json"',
-            link,
-        )
-        if match is None:
-            return None
-
-        return source / match.group(1)
-
-    def as_jsonld_document(
-        self,
-        source: URL,
-        iri: Optional[URIRef] = None,
-    ) -> LDDocument:
-        if iri is None:
-            iri = url_to_iri(source)
-
-        response = source.get()
-        response.raise_for_status()
-        alternate_url = self.extract_alternate_url(
-            source=source,
-            response=response,
-        )
-        if alternate_url is not None:
-            return self.as_jsonld_document(
-                source=alternate_url,
-                iri=iri,
-            )
-
-        # `response.text` doesn't work.
-        # Reasoning: https://stackoverflow.com/a/72621231/1245471
-        response_as_file = StringIO(response.content.decode('utf-8'))
-
-        parser_class: Type[Parser] = self.choose_parser_class(
-            source=source,
-            response=response,
-        )
-        try:
-            document = parser_class().as_jsonld_document(response_as_file)
-        except Exception:
-            raise ValueError(response)
-
-        if iri is not None and isinstance(document, dict):
-            document.setdefault('@id', str(iri))
-
-        return document
-
-    def as_file(self, source: URL) -> TextIO:
-        raise ValueError('!!!')
-
-    def as_quad_stream(
-        self,
-        source: URL,
-        iri: Optional[URIRef],
-        root_loader: 'Loader[URL]',
-    ) -> Iterable[Quad]:
-        try:
-            parser_class = self.choose_parser_class(source)
-        except ParserNotFound:
-            return []
-
-        if iri is None:
-            iri = url_to_iri(source)
-
-        with source.open() as text_io:
-            return parser_class().as_quad_stream(
-                raw_data=text_io,
-                iri=iri,
-                context=self.context,
-                root_loader=root_loader,
-            )
-
-    def find_context(self, source: str) -> LDContext:
-        raise ValueError('??!!?')

iolanta/loaders/local_directory.py

@@ -1,148 +0,0 @@
-import dataclasses
-from dataclasses import dataclass, field
-from functools import reduce
-from pathlib import Path
-from typing import Iterable, List, Optional, TextIO, Type
-
-from rdflib import URIRef
-
-from iolanta.context import merge
-from iolanta.conversions import path_to_iri
-from iolanta.ensure_is_context import NotAContext, ensure_is_context
-from iolanta.loaders.base import Loader, SourceType
-from iolanta.loaders.local_file import LocalFile
-from iolanta.models import LDContext, LDDocument, Quad
-from iolanta.namespaces import IOLANTA
-from iolanta.parsers.base import Parser
-
-
-def merge_contexts(*contexts: LDContext) -> LDContext:
-    return reduce(
-        merge,
-        filter(bool, contexts),
-        {},
-    )
-
-
-@dataclass(frozen=True)
-class LocalDirectory(Loader[Path]):
-    """
-    Retrieve Linked Data from a file on local disk.
-
-    Requires Path with file:// scheme as input.
-    """
-
-    context_filenames: List[str] = field(
-        default_factory=lambda: [
-            'context.yaml',
-            'context.yml',
-            'context.json',
-        ],
-    )
-    include_hidden_directories: bool = False
-
-    def find_context(self, source: SourceType) -> LDContext:
-        raise ValueError('?!!!???')
-
-    def directory_level_context(self, path: Path) -> Optional[LDContext]:
-        for file_name in self.context_filenames:
-            if (context_path := path / file_name).is_file():
-                document = LocalFile(logger=self.logger).as_jsonld_document(
-                    source=context_path,
-                )
-
-                if document:
-                    try:
-                        return ensure_is_context(document)
-                    except NotAContext as err:
-                        raise dataclasses.replace(
-                            err,
-                            path=context_path,
-                        )
-        return None
-
-    def choose_parser_class(self, source: Path) -> Type[Parser]:
-        """Choose parser class based on file extension."""
-        raise ValueError('This is a directory')
-
-    def as_quad_stream(
-        self,
-        source: Path,
-        iri: Optional[URIRef],
-        root_loader: Loader[Path],
-        context: Optional[LDContext] = None,
-    ) -> Iterable[Quad]:
-        """Extract a sequence of quads from a local file."""
-        if iri is None:
-            iri = path_to_iri(source.absolute())
-
-        if not source.is_dir():
-            yield from LocalFile(logger=self.logger).as_quad_stream(
-                source=source,
-                root_loader=root_loader,
-                iri=iri,
-                context=context,
-            )
-            return
-
-        context = merge_contexts(
-            context,
-            self.directory_level_context(source),
-        )
-
-        for child in source.iterdir():
-            if not iri.endswith('/'):
-                iri = URIRef(f'{iri}/')
-
-            child_iri = URIRef(f'{iri}{child.name}')
-
-            if child.is_dir():
-                if (
-                    not self.include_hidden_directories
-                    and child.name.startswith('.')
-                ):
-                    self.logger.info(
-                        'Skipping a hidden directory: %s',
-                        child,
-                    )
-                    continue
-
-                child_iri += '/'
-
-                yield from LocalDirectory(logger=self.logger).as_quad_stream(
-                    source=child,
-                    iri=child_iri,
-                    root_loader=root_loader,
-                    context=context,
-                )
-
-            elif child.stem != 'context':
-                yield from LocalFile(logger=self.logger).as_quad_stream(
-                    source=child,
-                    iri=child_iri,
-                    root_loader=root_loader,
-                    context=context,
-                )
-
-            if iri is not None:
-                yield Quad(
-                    subject=child_iri,
-                    predicate=IOLANTA.isChildOf,
-                    object=iri,
-                    graph=URIRef(
-                        'https://iolanta.tech/loaders/local-directory',
-                    ),
-                )
-
-    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."""
-        raise ValueError('This is a directory.')

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