test_case = TestCase(test='toRdf-manifest#tc003', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/c003-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#tc003', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/c003-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='expand-manifest#tpr01', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/expand/pr01-in.jsonld'), result='protected term redefinition', req=None, extract_all_scripts=False)

    @pytest.mark.parametrize('test_case', load_tests(tests.ExpandTest), ids=_.test)
    def test_expand(test_case: TestCase):
        if isinstance(test_case.result, str):
            try:
>               expanded_document = yaml_ld.expand(
                    test_case.input,
                    extract_all_scripts=test_case.extract_all_scripts,
                )

tests/test_specification.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
yaml_ld/expand.py:53: in expand
    return jsonld.expand(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:163: in expand
    return JsonLdProcessor().expand(input_, options)
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:870: in expand
    expanded = self._expand(active_ctx, None, document, options,
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2329: in _expand
    self._expand_object(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2728: in _expand_object
    expanded_value = self._expand(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2302: in _expand
    active_ctx = self._process_context(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:3288: in _process_context
    self._create_term_definition(rval, ctx, k, defined, options,
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pyld.jsonld.JsonLdProcessor object at 0x7f816d90bb50>
active_ctx = {'@vocab': 'http://example.com/', '_uuid': 'a712b545-c3a7-11ee-b5d5-e119631cc8ec', 'mappings': {}, 'processingMode': 'json-ld-1.1'}
local_ctx = {'protected': 'http://example.com/something-else'}
term = 'protected'
defined = {'@protected': False, '_uuid': True, 'protected': False}
options = {'base': '', 'contextResolver': <pyld.context_resolver.ContextResolver object at 0x7f816d90a200>, 'documentLoader': <function requests_document_loader.<locals>.loader at 0x7f817271e200>, 'extractAllScripts': False, ...}
override_protected = False, validate_scoped = True

    def _create_term_definition(self, active_ctx, local_ctx, term, defined, options,
            override_protected=False,
            validate_scoped=True):
        """
        Creates a term definition during context processing.
    
        :param active_ctx: the current active context.
        :param local_ctx: the local context being processed.
        :param term: the key in the local context to define the mapping for.
        :param defined: a map of defining/defined keys to detect cycles
          and prevent double definitions.
        :param options: the context processing options.
        :param override_protected protected terms may be cleared
            (default: False).
        :param validate_scoped: if True, load remote contexts if not already loaded.
            if False, do not load scoped contexts.
        """
        if term in defined:
            # term already defined
            if defined[term]:
                return
            # cycle detected
            raise JsonLdError(
                'Cyclical context definition detected.',
                'jsonld.CyclicalContext', {
                    'context': local_ctx,
                    'term': term
                }, code='cyclic IRI mapping')
    
        # now defining term
        defined[term] = False
    
        # get context term value
        value = local_ctx.get(term, None)
    
        if (term == '@type' and
            _is_object(value) and
            value.get('@container', '@set') == '@set' and
            self._processing_mode(active_ctx, 1.1)):
            if (not value or
                any(v not in ['@container', '@id', '@protected'] for v in value.keys())):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; keywords cannot be overridden.',
                    'jsonld.SyntaxError', {'context': local_ctx, 'term': term},
                    code='keyword redefinition')
        elif _is_keyword(term):
            raise JsonLdError(
                'Invalid JSON-LD syntax; keywords cannot be overridden.',
                'jsonld.SyntaxError', {'context': local_ctx, 'term': term},
                code='keyword redefinition')
        elif re.match(KEYWORD_PATTERN, term):
            warnings.warn(
                'terms beginning with "@" are reserved'
                ' for future use and ignored',
                SyntaxWarning)
            return
        elif term == '':
            raise JsonLdError(
                'Invalid JSON-LD syntax; a term cannot be an empty string.',
                'jsonld.SyntaxError', {'context': local_ctx},
                code='invalid term definition')
    
        # remove old mapping
        if term in active_ctx['mappings']:
            previous_mapping = active_ctx['mappings'][term]
            del active_ctx['mappings'][term]
        else:
            previous_mapping = None
    
        # get context term value
        value = local_ctx[term]
    
        # convert short-hand value to object w/@id
        _simple_term = False
        if _is_string(value) or value is None:
            _simple_term = True
            value = {'@id': value}
    
        if not _is_object(value):
            raise JsonLdError(
                'Invalid JSON-LD syntax; @context property values must be '
                'strings or objects.', 'jsonld.SyntaxError',
                {'context': local_ctx}, code='invalid term definition')
    
        # create new mapping
        mapping = {'reverse': False, 'protected': False, '_prefix': False}
    
        # make sure term definition only has expected keywords
        valid_keys = ['@container', '@id', '@language', '@reverse', '@type']
        if self._processing_mode(active_ctx, 1.1):
            valid_keys.extend(['@context', '@direction', '@index', '@nest', '@prefix', '@protected'])
        for kw in value:
            if kw not in valid_keys:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; a term definition must not contain ' + kw,
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid term definition')
    
        # always compute whether term has a colon as an optimization for _compact_iri
        colon = term.find(':')
        mapping['_term_has_colon'] = colon > 0
    
        if '@reverse' in value:
            if '@id' in value:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; an @reverse term definition must '
                    'not contain @id.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid reverse property')
            if '@nest' in value:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; an @reverse term definition must '
                    'not contain @nest.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid reverse property')
            reverse = value['@reverse']
            if not _is_string(reverse):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @reverse value must be '
                    'a string.', 'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': reverse},
                    code='invalid IRI mapping')
    
            if re.match(KEYWORD_PATTERN, reverse):
                warnings.warn('values beginning with "@" are reserved'
                    'for future use and ignored',
                    SyntaxWarning)
    
                if previous_mapping:
                    active_ctx['mappings'][term] = previous_mapping
                elif term in active_ctx['mappings']:
                    del active_ctx['mappings'][term]
    
                return
    
            # expand and add @id mapping
            id_ = self._expand_iri(
                active_ctx, reverse, vocab=True,
                local_ctx=local_ctx, defined=defined)
            if not _is_absolute_iri(id_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @reverse value must be '
                    'an absolute IRI or a blank node identifier.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': id_},
                    code='invalid IRI mapping')
    
            mapping['@id'] = id_
            mapping['reverse'] = True
        elif '@id' in value:
            id_ = value['@id']
            if id_ and not _is_string(id_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @id value must be a '
                    'string.', 'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': id_},
                    code='invalid IRI mapping')
    
            if id_ is None:
                mapping['@id'] = None
            elif not _is_keyword(id_) and re.match(KEYWORD_PATTERN, id_):
                warnings.warn('values beginning with "@" are reserved'
                    'for future use and ignored',
                    SyntaxWarning)
    
                if previous_mapping:
                    active_ctx['mappings'][term] = previous_mapping
                elif term in active_ctx['mappings']:
                    del active_ctx['mappings'][term]
    
                return
            elif id_ != term:
                # add @id to mapping
                id_ = self._expand_iri(
                    active_ctx, id_, vocab=True,
                    local_ctx=local_ctx, defined=defined)
                if not _is_absolute_iri(id_) and not _is_keyword(id_):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; @context @id value must be '
                        'an absolute IRI, a blank node identifier, or a '
                        'keyword.', 'jsonld.SyntaxError',
                        {'context': local_ctx, 'iri': id_},
                        code='invalid IRI mapping')
    
                # if term has the form of an IRI it must map the same
                if re.match(r'.*((:[^:])|/)', term):
                    updated_defined = defined.copy()
                    updated_defined.update({term: True})
                    term_iri = self._expand_iri(
                        active_ctx, term, vocab=True,
                        local_ctx=local_ctx, defined=updated_defined)
                    if term_iri != id_:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; term in form of IRI must '
                            'expand to definition.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx, 'iri': id_},
                            code='invalid IRI mapping')
    
                mapping['@id'] = id_
                mapping['_prefix'] = (
                    _simple_term and
                    not mapping['_term_has_colon'] and
                    bool(re.match(r'.*[:/\?#\[\]@]$', id_)))
        if '@id' not in mapping:
            # see if the term has a prefix
            if mapping['_term_has_colon']:
                prefix = term[0:colon]
                if prefix in local_ctx:
                    # define parent prefix
                    self._create_term_definition(
                        active_ctx, local_ctx, prefix, defined, options)
    
                # set @id based on prefix parent
                if active_ctx['mappings'].get(prefix) is not None:
                    suffix = term[colon + 1:]
                    mapping['@id'] = (
                            active_ctx['mappings'][prefix]['@id'] + suffix)
                # term is an absolute IRI
                else:
                    mapping['@id'] = term
            elif term == '@type':
                mapping['@id'] = term
            else:
                # non-IRIs MUST define @ids if @vocab not available
                if '@vocab' not in active_ctx:
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; @context terms must define '
                        'an @id.', 'jsonld.SyntaxError', {
                            'context': local_ctx,
                            'term': term
                        }, code='invalid IRI mapping')
                # prepend vocab to term
                mapping['@id'] = active_ctx['@vocab'] + term
    
        if (value.get('@protected') or
            (defined.get('@protected') and value.get('@protected') != False)):
            mapping['protected'] = True
    
        if '@type' in value:
            type_ = value['@type']
            if not _is_string(type_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @type value must be '
                    'a string.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid type mapping')
            if type_ == '@json' or type_ == '@none':
                if self._processing_mode(active_ctx, 1.0):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type value must not be ' +
                        type_ +
                        ' in JSON-LD 1.0 mode.', 'jsonld.SyntaxError',
                        {'context': local_ctx}, code='invalid type mapping')
            elif type_ != '@id' and type_ != '@vocab':
                # expand @type to full IRI
                type_ = self._expand_iri(
                    active_ctx, type_, vocab=True,
                    local_ctx=local_ctx, defined=defined)
                if not _is_absolute_iri(type_):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type value must '
                        'be an absolute IRI.', 'jsonld.SyntaxError',
                        {'context': local_ctx}, code='invalid type mapping')
                if type_.startswith('_:'):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type values '
                        'must be an IRI, not a blank node identifier.',
                        'jsonld.SyntaxError', {'context': local_ctx},
                        code='invalid type mapping')
            # add @type to mapping
            mapping['@type'] = type_
    
        if '@container' in value:
            container = JsonLdProcessor.arrayify(value['@container'])
            valid_containers = ['@list', '@set', '@index', '@language']
            is_valid = True
            has_set = '@set' in container
    
            if self._processing_mode(active_ctx, 1.1):
                valid_containers.extend(['@graph', '@id', '@type'])
    
                # check container length
                if '@list' in container:
                    if len(container) != 1:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; @context @container with @list must have no other values.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid container mapping')
                elif '@graph' in container:
                    _extra_keys = [kw for kw in container if kw not in ['@graph', '@id', '@index', '@set']]
                    if _extra_keys:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; @context @container with @graph must have no other values ' +
                            'other than @id, @index, and @set',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid container mapping')
                else:
                    is_valid = is_valid and (len(container) <= (2 if has_set else 1))
    
                if '@type' in container:
                    # if mapping does not have an @type, set it to @id
                    if not mapping.get('@type'):
                        mapping['@type'] = '@id'
    
                    if mapping['@type'] != '@id' and mapping['@type'] != '@vocab':
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; container: @type requires @type to be '
                            '@id or @vocab.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid type mapping')
            else: # json-ld-1.0
                is_valid = is_valid and _is_string(value['@container'])
    
            # check against valid containers
            is_valid = is_valid and not [kw for kw in container if kw not in valid_containers]
    
            # @set not allowed with @list
            is_valid = is_valid and not (has_set and '@list' in container)
    
            if not is_valid:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @container value '
                    'must be one of the following: ' + ', '.join(valid_containers) + '.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid container mapping')
            _extra_reverse_keys = [kw for kw in container if kw not in ['@index', '@set']]
            if (mapping['reverse'] and _extra_reverse_keys):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @container value for '
                    'an @reverse type definition must be @index or @set.',
                    'jsonld.SyntaxError', {'context': local_ctx},
                    code='invalid reverse property')
    
            # add @container to mapping
            mapping['@container'] = container
    
        if '@index' in value:
            if not '@container' in value or not '@index' in mapping['@container']:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @index without @index in @container.',
                    'jsonld.SyntaxError',
                    {
                        'context': local_ctx,
                        'term': term,
                        'index': value['@index']
                    },
                    code='invalid term definition')
    
            if not _is_string(value['@index']) or value['@index'].find('@') == 0:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @index must expand to an IRI.',
                    'jsonld.SyntaxError',
                    {
                        'context': local_ctx,
                        'term': term,
                        'index': value['@index']
                    },
                    code='invalid term definition')
            mapping['@index'] = value['@index']
    
        # scoped contexts
        if '@context' in value:
            # record as falss, if None
            mapping['@context'] = value['@context'] if value['@context'] else False
    
        if '@language' in value and '@type' not in value:
            language = value['@language']
            if not (language is None or _is_string(language)):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @language value must be '
                    'a string or null.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid language mapping')
            # add @language to mapping
            if language is not None:
                language = language.lower()
            mapping['@language'] = language
    
        # term may be used as prefix
        if '@prefix' in value:
            if re.match(r'.*(:|/)', term):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @prefix used on a compact IRI term.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid term definition')
            if _is_keyword(mapping['@id']):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @keywords may not be used as prefixes.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid term definition')
            if not _is_bool(value['@prefix']):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context value for @prefix must be boolean.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid @prefix value')
            mapping['_prefix'] = value['@prefix']
    
        # direction
        if '@direction' in value:
            direction = value['@direction']
            if direction and direction != 'ltr' and direction != 'rtl':
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @direction value must be null, "ltr", or "rtl".',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid base direction')
            mapping['@direction'] = direction
    
        # nesting
        if '@nest' in value:
            nest = value['@nest']
            if not _is_string(nest) or (nest != '@nest' and nest[0] == '@'):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @nest value must be ' +
                    'a string which is not a keyword other than @nest.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid @nest value')
            mapping['@nest'] = nest
    
        # disallow aliasing @context and @preserve
        id_ = mapping['@id']
        if id_ == '@context' or id_ == '@preserve':
            raise JsonLdError(
                'Invalid JSON-LD syntax; @context and @preserve '
                'cannot be aliased.', 'jsonld.SyntaxError',
                {'context': local_ctx}, code='invalid keyword alias')
    
        if (previous_mapping and
            previous_mapping['protected'] and
            not override_protected):
            # force new term to continue to be protected and see if the mappings would be equal
            mapping['protected'] = True
    
            if previous_mapping != mapping:
>               raise JsonLdError(
                    'Invalid JSON-LD syntax; tried to redefine a protected term.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='protected term redefinition')
E               pyld.jsonld.JsonLdError: ('Invalid JSON-LD syntax; tried to redefine a protected term.',)
E               Type: jsonld.SyntaxError
E               Code: protected term redefinition
E               Details: {'context': {'protected': 'http://example.com/something-else'}}

../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:5429: JsonLdError

test_case = TestCase(test='expand-manifest#t0111', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specification...-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/expand/0111-out.jsonld'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize('test_case', load_tests(tests.ExpandTest), ids=_.test)
    def test_expand(test_case: TestCase):
        if isinstance(test_case.result, str):
            try:
                expanded_document = yaml_ld.expand(
                    test_case.input,
                    extract_all_scripts=test_case.extract_all_scripts,
                )
            except YAMLLDError as error:
                assert error.code == test_case.result
            else:
                pytest.fail(str(FailureToFail(
                    expected_error_code=test_case.result,
                    raw_document=test_case.input,
                    expanded_document=expanded_document,
                )))
    
        elif isinstance(test_case.result, Path):
            expected = yaml_ld.parse(test_case.result.read_text())
            actual = yaml_ld.expand(
                test_case.input,
                extract_all_scripts=test_case.extract_all_scripts,
            )
>           assert actual == expected
E           AssertionError: assert [{'@id': 'rel...root'}], ...}] == [{'@id': 'htt...root'}], ...}]
E             At index 0 diff: {'http://example.com/vocabulary/./rel2##fragment-works': [{'@value': '#fragment-works'}], 'http://example.com/vocabulary/./rel2#../': [{'@value': '../'}], 'http://example.com/vocabulary/./rel2#../../../../../still-root': [{'@value': '../../../../../still-root'}], 'http://example.com/vocabulary/./rel2#../.././.././../../too-many-dots': [{'@value': '../.././.././../../too-many-dots'}], 'http://example.com/vocabulary/./rel2#../../parent-parent-eq-root': [{'@value': '../../parent-parent-eq-root'}], 'http://example.com/vocabulary/./rel2#../parent': [{'@value': '../parent'}], 'http://example.com/vocabulary/./rel2#./': [{'@value': './'}], 'http://example.com/vocabulary/./rel2#//example.org/scheme-relative': [{'@value': '//example.org/scheme-relative'}], 'http://example.com/vocabulary/./rel2#/absolute': [{'@value': '/absolute'}], 'http://example.com/vocabulary/./rel2#?query=works': [{'@value': '?query=works'}], '@id': 'relativePropertyIris', 'http://example.com/vocabulary/./rel2#link': [{'@value': 'link'}]} != {'@id': 'http://example.com/some/deep/directory/and/file/relativePropertyIris', 'http://example.com/vocabulary/./rel2##fragment-works': [{'@value': '#fragment-works'}], 'http://example.com/vocabulary/./rel2#../': [{'@value': '../'}], 'http://example.com/vocabulary/./rel2#../../../../../still-root': [{'@value': '../../../../../still-root'}], 'http://example.com/vocabulary/./rel2#../.././.././../../too-many-dots': [{'@value': '../.././.././../../too-many-dots'}], 'http://example.com/vocabulary/./rel2#../../parent-parent-eq-root': [{'@value': '../../parent-parent-eq-root'}], 'http://example.com/vocabulary/./rel2#../parent': [{'@value': '../parent'}], 'http://example.com/vocabulary/./rel2#./': [{'@value': './'}], 'http://example.com/vocabulary/./rel2#//example.org/scheme-relative': [{'@value': '//example.org/scheme-relative'}], 'http://example.com/vocabulary/./rel2#/absolute': [{'@value': '/absolute'}], 'http://example.com/vocabulary/./rel2#?query=works': [{'@value': '?query=works'}], 'http://example.com/vocabulary/./rel2#link': [{'@value': 'link'}]}
E             Full diff:
E               [
E             -  {'@id': 'http://example.com/some/deep/directory/and/file/relativePropertyIris',
E             +  {'@id': 'relativePropertyIris',
E                 'http://example.com/vocabulary/./rel2##fragment-works': [{'@value': '#fragment-works'}],
E                 'http://example.com/vocabulary/./rel2#../': [{'@value': '../'}],
E                 'http://example.com/vocabulary/./rel2#../../../../../still-root': [{'@value': '../../../../../still-root'}],
E                 'http://example.com/vocabulary/./rel2#../.././.././../../too-many-dots': [{'@value': '../.././.././../../too-many-dots'}],
E                 'http://example.com/vocabulary/./rel2#../../parent-parent-eq-root': [{'@value': '../../parent-parent-eq-root'}],
E                 'http://example.com/vocabulary/./rel2#../parent': [{'@value': '../parent'}],
E                 'http://example.com/vocabulary/./rel2#./': [{'@value': './'}],
E                 'http://example.com/vocabulary/./rel2#//example.org/scheme-relative': [{'@value': '//example.org/scheme-relative'}],
E                 'http://example.com/vocabulary/./rel2#/absolute': [{'@value': '/absolute'}],
E                 'http://example.com/vocabulary/./rel2#?query=works': [{'@value': '?query=works'}],
E                 'http://example.com/vocabulary/./rel2#link': [{'@value': 'link'}]},
E               ]

tests/test_specification.py:61: AssertionError

test_case = TestCase(test='expand-manifest#tpi04', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/expand/pi04-in.jsonld'), result='invalid term definition', req=None, extract_all_scripts=False)

    @pytest.mark.parametrize('test_case', load_tests(tests.ExpandTest), ids=_.test)
    def test_expand(test_case: TestCase):
        if isinstance(test_case.result, str):
            try:
>               expanded_document = yaml_ld.expand(
                    test_case.input,
                    extract_all_scripts=test_case.extract_all_scripts,
                )

tests/test_specification.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
yaml_ld/expand.py:53: in expand
    return jsonld.expand(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:163: in expand
    return JsonLdProcessor().expand(input_, options)
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:870: in expand
    expanded = self._expand(active_ctx, None, document, options,
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2302: in _expand
    active_ctx = self._process_context(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:3288: in _process_context
    self._create_term_definition(rval, ctx, k, defined, options,
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pyld.jsonld.JsonLdProcessor object at 0x7f816d9758d0>
active_ctx = {'@version': 1.1, '@vocab': 'http://example.com/', '_uuid': 'a712b548-c3a7-11ee-b5d5-e119631cc8ec', 'mappings': {}, ...}
local_ctx = {'@version': 1.1, '@vocab': 'http://example.com/', 'container': {'@container': '@index', '@id': 'http://example.com/container', '@index': True}}
term = 'container'
defined = {'@protected': False, '@version': True, '@vocab': True, '_uuid': True, ...}
options = {'base': '', 'contextResolver': <pyld.context_resolver.ContextResolver object at 0x7f816d974730>, 'documentLoader': <function requests_document_loader.<locals>.loader at 0x7f817271e200>, 'extractAllScripts': False, ...}
override_protected = False, validate_scoped = True

    def _create_term_definition(self, active_ctx, local_ctx, term, defined, options,
            override_protected=False,
            validate_scoped=True):
        """
        Creates a term definition during context processing.
    
        :param active_ctx: the current active context.
        :param local_ctx: the local context being processed.
        :param term: the key in the local context to define the mapping for.
        :param defined: a map of defining/defined keys to detect cycles
          and prevent double definitions.
        :param options: the context processing options.
        :param override_protected protected terms may be cleared
            (default: False).
        :param validate_scoped: if True, load remote contexts if not already loaded.
            if False, do not load scoped contexts.
        """
        if term in defined:
            # term already defined
            if defined[term]:
                return
            # cycle detected
            raise JsonLdError(
                'Cyclical context definition detected.',
                'jsonld.CyclicalContext', {
                    'context': local_ctx,
                    'term': term
                }, code='cyclic IRI mapping')
    
        # now defining term
        defined[term] = False
    
        # get context term value
        value = local_ctx.get(term, None)
    
        if (term == '@type' and
            _is_object(value) and
            value.get('@container', '@set') == '@set' and
            self._processing_mode(active_ctx, 1.1)):
            if (not value or
                any(v not in ['@container', '@id', '@protected'] for v in value.keys())):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; keywords cannot be overridden.',
                    'jsonld.SyntaxError', {'context': local_ctx, 'term': term},
                    code='keyword redefinition')
        elif _is_keyword(term):
            raise JsonLdError(
                'Invalid JSON-LD syntax; keywords cannot be overridden.',
                'jsonld.SyntaxError', {'context': local_ctx, 'term': term},
                code='keyword redefinition')
        elif re.match(KEYWORD_PATTERN, term):
            warnings.warn(
                'terms beginning with "@" are reserved'
                ' for future use and ignored',
                SyntaxWarning)
            return
        elif term == '':
            raise JsonLdError(
                'Invalid JSON-LD syntax; a term cannot be an empty string.',
                'jsonld.SyntaxError', {'context': local_ctx},
                code='invalid term definition')
    
        # remove old mapping
        if term in active_ctx['mappings']:
            previous_mapping = active_ctx['mappings'][term]
            del active_ctx['mappings'][term]
        else:
            previous_mapping = None
    
        # get context term value
        value = local_ctx[term]
    
        # convert short-hand value to object w/@id
        _simple_term = False
        if _is_string(value) or value is None:
            _simple_term = True
            value = {'@id': value}
    
        if not _is_object(value):
            raise JsonLdError(
                'Invalid JSON-LD syntax; @context property values must be '
                'strings or objects.', 'jsonld.SyntaxError',
                {'context': local_ctx}, code='invalid term definition')
    
        # create new mapping
        mapping = {'reverse': False, 'protected': False, '_prefix': False}
    
        # make sure term definition only has expected keywords
        valid_keys = ['@container', '@id', '@language', '@reverse', '@type']
        if self._processing_mode(active_ctx, 1.1):
            valid_keys.extend(['@context', '@direction', '@index', '@nest', '@prefix', '@protected'])
        for kw in value:
            if kw not in valid_keys:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; a term definition must not contain ' + kw,
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid term definition')
    
        # always compute whether term has a colon as an optimization for _compact_iri
        colon = term.find(':')
        mapping['_term_has_colon'] = colon > 0
    
        if '@reverse' in value:
            if '@id' in value:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; an @reverse term definition must '
                    'not contain @id.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid reverse property')
            if '@nest' in value:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; an @reverse term definition must '
                    'not contain @nest.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid reverse property')
            reverse = value['@reverse']
            if not _is_string(reverse):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @reverse value must be '
                    'a string.', 'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': reverse},
                    code='invalid IRI mapping')
    
            if re.match(KEYWORD_PATTERN, reverse):
                warnings.warn('values beginning with "@" are reserved'
                    'for future use and ignored',
                    SyntaxWarning)
    
                if previous_mapping:
                    active_ctx['mappings'][term] = previous_mapping
                elif term in active_ctx['mappings']:
                    del active_ctx['mappings'][term]
    
                return
    
            # expand and add @id mapping
            id_ = self._expand_iri(
                active_ctx, reverse, vocab=True,
                local_ctx=local_ctx, defined=defined)
            if not _is_absolute_iri(id_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @reverse value must be '
                    'an absolute IRI or a blank node identifier.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': id_},
                    code='invalid IRI mapping')
    
            mapping['@id'] = id_
            mapping['reverse'] = True
        elif '@id' in value:
            id_ = value['@id']
            if id_ and not _is_string(id_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @id value must be a '
                    'string.', 'jsonld.SyntaxError',
                    {'context': local_ctx, 'iri': id_},
                    code='invalid IRI mapping')
    
            if id_ is None:
                mapping['@id'] = None
            elif not _is_keyword(id_) and re.match(KEYWORD_PATTERN, id_):
                warnings.warn('values beginning with "@" are reserved'
                    'for future use and ignored',
                    SyntaxWarning)
    
                if previous_mapping:
                    active_ctx['mappings'][term] = previous_mapping
                elif term in active_ctx['mappings']:
                    del active_ctx['mappings'][term]
    
                return
            elif id_ != term:
                # add @id to mapping
                id_ = self._expand_iri(
                    active_ctx, id_, vocab=True,
                    local_ctx=local_ctx, defined=defined)
                if not _is_absolute_iri(id_) and not _is_keyword(id_):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; @context @id value must be '
                        'an absolute IRI, a blank node identifier, or a '
                        'keyword.', 'jsonld.SyntaxError',
                        {'context': local_ctx, 'iri': id_},
                        code='invalid IRI mapping')
    
                # if term has the form of an IRI it must map the same
                if re.match(r'.*((:[^:])|/)', term):
                    updated_defined = defined.copy()
                    updated_defined.update({term: True})
                    term_iri = self._expand_iri(
                        active_ctx, term, vocab=True,
                        local_ctx=local_ctx, defined=updated_defined)
                    if term_iri != id_:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; term in form of IRI must '
                            'expand to definition.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx, 'iri': id_},
                            code='invalid IRI mapping')
    
                mapping['@id'] = id_
                mapping['_prefix'] = (
                    _simple_term and
                    not mapping['_term_has_colon'] and
                    bool(re.match(r'.*[:/\?#\[\]@]$', id_)))
        if '@id' not in mapping:
            # see if the term has a prefix
            if mapping['_term_has_colon']:
                prefix = term[0:colon]
                if prefix in local_ctx:
                    # define parent prefix
                    self._create_term_definition(
                        active_ctx, local_ctx, prefix, defined, options)
    
                # set @id based on prefix parent
                if active_ctx['mappings'].get(prefix) is not None:
                    suffix = term[colon + 1:]
                    mapping['@id'] = (
                            active_ctx['mappings'][prefix]['@id'] + suffix)
                # term is an absolute IRI
                else:
                    mapping['@id'] = term
            elif term == '@type':
                mapping['@id'] = term
            else:
                # non-IRIs MUST define @ids if @vocab not available
                if '@vocab' not in active_ctx:
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; @context terms must define '
                        'an @id.', 'jsonld.SyntaxError', {
                            'context': local_ctx,
                            'term': term
                        }, code='invalid IRI mapping')
                # prepend vocab to term
                mapping['@id'] = active_ctx['@vocab'] + term
    
        if (value.get('@protected') or
            (defined.get('@protected') and value.get('@protected') != False)):
            mapping['protected'] = True
    
        if '@type' in value:
            type_ = value['@type']
            if not _is_string(type_):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @type value must be '
                    'a string.', 'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid type mapping')
            if type_ == '@json' or type_ == '@none':
                if self._processing_mode(active_ctx, 1.0):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type value must not be ' +
                        type_ +
                        ' in JSON-LD 1.0 mode.', 'jsonld.SyntaxError',
                        {'context': local_ctx}, code='invalid type mapping')
            elif type_ != '@id' and type_ != '@vocab':
                # expand @type to full IRI
                type_ = self._expand_iri(
                    active_ctx, type_, vocab=True,
                    local_ctx=local_ctx, defined=defined)
                if not _is_absolute_iri(type_):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type value must '
                        'be an absolute IRI.', 'jsonld.SyntaxError',
                        {'context': local_ctx}, code='invalid type mapping')
                if type_.startswith('_:'):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; an @context @type values '
                        'must be an IRI, not a blank node identifier.',
                        'jsonld.SyntaxError', {'context': local_ctx},
                        code='invalid type mapping')
            # add @type to mapping
            mapping['@type'] = type_
    
        if '@container' in value:
            container = JsonLdProcessor.arrayify(value['@container'])
            valid_containers = ['@list', '@set', '@index', '@language']
            is_valid = True
            has_set = '@set' in container
    
            if self._processing_mode(active_ctx, 1.1):
                valid_containers.extend(['@graph', '@id', '@type'])
    
                # check container length
                if '@list' in container:
                    if len(container) != 1:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; @context @container with @list must have no other values.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid container mapping')
                elif '@graph' in container:
                    _extra_keys = [kw for kw in container if kw not in ['@graph', '@id', '@index', '@set']]
                    if _extra_keys:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; @context @container with @graph must have no other values ' +
                            'other than @id, @index, and @set',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid container mapping')
                else:
                    is_valid = is_valid and (len(container) <= (2 if has_set else 1))
    
                if '@type' in container:
                    # if mapping does not have an @type, set it to @id
                    if not mapping.get('@type'):
                        mapping['@type'] = '@id'
    
                    if mapping['@type'] != '@id' and mapping['@type'] != '@vocab':
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; container: @type requires @type to be '
                            '@id or @vocab.',
                            'jsonld.SyntaxError',
                            {'context': local_ctx}, code='invalid type mapping')
            else: # json-ld-1.0
                is_valid = is_valid and _is_string(value['@container'])
    
            # check against valid containers
            is_valid = is_valid and not [kw for kw in container if kw not in valid_containers]
    
            # @set not allowed with @list
            is_valid = is_valid and not (has_set and '@list' in container)
    
            if not is_valid:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @container value '
                    'must be one of the following: ' + ', '.join(valid_containers) + '.',
                    'jsonld.SyntaxError',
                    {'context': local_ctx}, code='invalid container mapping')
            _extra_reverse_keys = [kw for kw in container if kw not in ['@index', '@set']]
            if (mapping['reverse'] and _extra_reverse_keys):
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @context @container value for '
                    'an @reverse type definition must be @index or @set.',
                    'jsonld.SyntaxError', {'context': local_ctx},
                    code='invalid reverse property')
    
            # add @container to mapping
            mapping['@container'] = container
    
        if '@index' in value:
            if not '@container' in value or not '@index' in mapping['@container']:
                raise JsonLdError(
                    'Invalid JSON-LD syntax; @index without @index in @container.',
                    'jsonld.SyntaxError',
                    {
                        'context': local_ctx,
                        'term': term,
                        'index': value['@index']
                    },
                    code='invalid term definition')
    
            if not _is_string(value['@index']) or value['@index'].find('@') == 0:
>               raise JsonLdError(
                    'Invalid JSON-LD syntax; @index must expand to an IRI.',
                    'jsonld.SyntaxError',
                    {
                        'context': local_ctx,
                        'term': term,
                        'index': value['@index']
                    },
                    code='invalid term definition')
E               pyld.jsonld.JsonLdError: ('Invalid JSON-LD syntax; @index must expand to an IRI.',)
E               Type: jsonld.SyntaxError
E               Code: invalid term definition
E               Details: {'context': {'@version': 1.1, '@vocab': 'http://example.com/', 'container': {'@id': 'http://example.com/container', '@container': '@index', '@index': True}}, 'term': 'container', 'index': True}

../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:5346: JsonLdError

test_case = TestCase(test='html-manifest#tr022', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications/...python-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/html/r022-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='html-manifest#tr022', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications/...python-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/html/r022-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='expand-manifest#tin07', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/expand/in07-in.jsonld'), result='invalid @included value', req=None, extract_all_scripts=False)

    @pytest.mark.parametrize('test_case', load_tests(tests.ExpandTest), ids=_.test)
    def test_expand(test_case: TestCase):
        if isinstance(test_case.result, str):
            try:
>               expanded_document = yaml_ld.expand(
                    test_case.input,
                    extract_all_scripts=test_case.extract_all_scripts,
                )

tests/test_specification.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
yaml_ld/expand.py:53: in expand
    return jsonld.expand(
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:163: in expand
    return JsonLdProcessor().expand(input_, options)
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:870: in expand
    expanded = self._expand(active_ctx, None, document, options,
../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2329: in _expand
    self._expand_object(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pyld.jsonld.JsonLdProcessor object at 0x7f817058f130>
active_ctx = frozendict.frozendict({'mappings': {}, 'processingMode': 'json-ld-1.1', '@version': 1.1, '@vocab': 'http://example.org/', '_uuid': 'a712b54e-c3a7-11ee-b5d5-e119631cc8ec'})
active_property = None, expanded_active_property = None
element = {'@context': {'@version': 1.1, '@vocab': 'http://example.org/'}, '@included': 'string'}
expanded_parent = {}
options = {'base': '', 'contextResolver': <pyld.context_resolver.ContextResolver object at 0x7f817058f070>, 'documentLoader': <function requests_document_loader.<locals>.loader at 0x7f817271e200>, 'extractAllScripts': False, ...}
inside_list = False, type_key = None
type_scoped_ctx = frozendict.frozendict({'mappings': {}, 'processingMode': 'json-ld-1.1', '@version': 1.1, '@vocab': 'http://example.org/', '_uuid': 'a712b54e-c3a7-11ee-b5d5-e119631cc8ec'})

    def _expand_object(
            self, active_ctx, active_property, expanded_active_property,
            element, expanded_parent, options,
            inside_list=False,
            type_key=None,
            type_scoped_ctx=None):
        """
        Expand each key and value of element adding to result.
    
        :param active_ctx: the context to use.
        :param active_property: the property for the element, None for none.
        :param expanded_active_property: the expansion of active_property
        :param element: the element to expand.
        :param expanded_parent: the expanded result into which to add values.
        :param options: the expansion options.
        :param inside_list: True if the property is a list, False if not.
    
        :return: the expanded value.
        """
    
        nests = []
        unexpanded_value = None
        is_json_type = False
    
        if type_key in element:
            if element[type_key] and _is_array(element[type_key]):
                t = element[type_key][0]
            else:
                t = element[type_key]
            is_json_type = self._expand_iri(
                active_ctx, t, vocab=True) == '@json'
    
        for key, value in sorted(element.items()):
            if key == '@context':
                continue
    
            # expand key to IRI
            expanded_property = self._expand_iri(
                active_ctx, key, vocab=True)
    
            # drop non-absolute IRI keys that aren't keywords
            if (expanded_property is None or
                not (
                    _is_absolute_iri(expanded_property) or
                    _is_keyword(expanded_property))):
                continue
    
            if _is_keyword(expanded_property):
                if expanded_active_property == '@reverse':
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; a keyword cannot be used as '
                        'a @reverse property.',
                        'jsonld.SyntaxError', {'value': value},
                        code='invalid reverse property map')
                if (expanded_property in expanded_parent and
                    expanded_property != '@included' and
                    expanded_property != '@type'):
                    raise JsonLdError(
                        'Invalid JSON-LD syntax; colliding keywords detected.',
                        'jsonld.SyntaxError', {'keyword': expanded_property},
                        code='colliding keywords')
    
            # syntax error if @id is not a string
            if expanded_property == '@id':
                if not _is_string(value):
                    if not options.get('isFrame'):
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; "@id" value must be a '
                            'string.', 'jsonld.SyntaxError',
                            {'value': value}, code='invalid @id value')
                    if _is_object(value):
                        if not _is_empty_object(value):
                            raise JsonLdError(
                                'Invalid JSON-LD syntax; "@id" value must be a '
                                'string or an empty object or array of strings.',
                                'jsonld.SyntaxError',
                                {'value': value}, code='invalid @id value')
                    elif _is_array(value):
                        if not all(_is_string(v) for v in value):
                            raise JsonLdError(
                                'Invalid JSON-LD syntax; "@id" value an empty object or array of strings, if framing',
                                'jsonld.SyntaxError',
                                {'value': value}, code='invalid @id value')
                    else:
                        raise JsonLdError(
                            'Invalid JSON-LD syntax; "@id" value an empty object or array of strings, if framing',
                            'jsonld.SyntaxError',
                            {'value': value}, code='invalid @id value')
    
                expanded_values = []
                for v in JsonLdProcessor.arrayify(value):
                    expanded_values.append(v if \
                        _is_object(v) else \
                        self._expand_iri(active_ctx, v, base=options.get('base', '')))
    
                JsonLdProcessor.add_value(
                    expanded_parent, '@id', expanded_values,
                    {'propertyIsArray': options['isFrame']})
                continue
    
            if expanded_property == '@type':
                if _is_object(value):
                    # if framing, can be a default object, but need to expand
                    # key to determine that
                    new_value = {}
                    for k, v in value.items():
                        ek = self._expand_iri(type_scoped_ctx, k, vocab=True)
                        ev = [self._expand_iri(type_scoped_ctx, vv, vocab=True, base=options.get('base', ''))
                              for vv in JsonLdProcessor.arrayify(v)]
                        new_value[ek] = ev
                    value = new_value
                else:
                    value = JsonLdProcessor.arrayify(value)
                _validate_type_value(value, options.get('isFrame'))
                expanded_values = []
                for v in JsonLdProcessor.arrayify(value):
                    expanded_values.append(self._expand_iri(type_scoped_ctx, v, vocab=True, base=options.get('base', '')) if _is_string(v) else v)
                JsonLdProcessor.add_value(
                    expanded_parent, '@type', expanded_values,
                    {'propertyIsArray': options['isFrame']})
                continue
    
            # Included blocks are treated as an array of separate object nodes sharing
            # the same referencing active_property.
            # For 1.0, it is skipped as are other unknown keywords
            if (expanded_property == '@included' and
                self._processing_mode(active_ctx, 1.1)):
                included_result = JsonLdProcessor.arrayify(
                    self._expand(active_ctx, active_property, value, options))
                if not all(_is_subject(v) for v in included_result):
>                   raise JsonLdError(
                        'Invalid JSON-LD syntax; "values of @included '
                        'must expand to node objects.',
                        'jsonld.SyntaxError',
                        {'value': value}, code='invalid @included value')
E                   pyld.jsonld.JsonLdError: ('Invalid JSON-LD syntax; "values of @included must expand to node objects.',)
E                   Type: jsonld.SyntaxError
E                   Code: invalid @included value
E                   Details: {'value': 'string'}

../../../.cache/pypoetry/virtualenvs/python-yaml-ld-9I021CQq-py3.10/lib/python3.10/site-packages/pyld/jsonld.py:2552: JsonLdError

test_case = TestCase(test='toRdf-manifest#t0016', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/0016-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#t0016', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/0016-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='toRdf-manifest#tc016', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/c016-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#tc016', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/c016-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='toRdf-manifest#te099', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/e099-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#te099', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/e099-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='toRdf-manifest#tdi11', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/di11-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#tdi11', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/di11-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError

test_case = TestCase(test='toRdf-manifest#tin02', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/in02-out.nq'), req=None, extract_all_scripts=False)

    @pytest.mark.parametrize(
        'test_case',
        load_tests(tests.ToRDFTest),
        ids=operator.attrgetter('test'),
    )
    def test_to_rdf(test_case: TestCase):
>       raw_document = test_case.raw_document

tests/test_specification.py:26: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = TestCase(test='toRdf-manifest#tin02', input=URL('file:///home/runner/work/python-yaml-ld/python-yaml-ld/specifications...ython-yaml-ld/python-yaml-ld/specifications/json-ld-api/tests/toRdf/in02-out.nq'), req=None, extract_all_scripts=False)

    @property
    def raw_document(self) -> bytes:
        """Read the raw input document contents."""
>       return self.input.read_bytes()
E       AttributeError: 'URL' object has no attribute 'read_bytes'

ldtest/models.py:18: AttributeError