def test_expand_uri_no_document(self, db_session, normalized, expected_uris): uris = storage.expand_uri(db_session, "http://example.com/", normalized=normalized) assert uris == expected_uris
def _normalize_uris(self, query_uris, normalize_method=uri.normalize): uris = set() for query_uri in query_uris: expanded = storage.expand_uri(self.request.db, query_uri) uris.update([normalize_method(uri) for uri in expanded]) return list(uris)
def _normalize_uris(self, query_uris, normalize_method=uri.normalize): uris = set() for query_uri in query_uris: expanded = storage.expand_uri(self.request.db, query_uri) us = [normalize_method(u) for u in expanded] uris.update(us) return list(uris)
def _expand_uris(session, clause): uris = clause["value"] expanded = set() if not isinstance(uris, list): uris = [uris] for item in uris: expanded.update(storage.expand_uri(session, item)) clause["value"] = list(expanded)
def test_expand_uri_document_uris(self, db_session): document = Document(document_uris=[ DocumentURI(uri='http://foo.com/', claimant='http://bar.com'), DocumentURI(uri='http://bar.com/', claimant='http://bar.com'), ]) db_session.add(document) db_session.flush() assert storage.expand_uri(db_session, 'http://foo.com/') == [ 'http://foo.com/', 'http://bar.com/' ]
def test_expand_uri_document_doesnt_expand_canonical_uris(self, db_session): document = Document(document_uris=[ DocumentURI(uri='http://foo.com/', claimant='http://example.com'), DocumentURI(uri='http://bar.com/', claimant='http://example.com'), DocumentURI(uri='http://example.com/', type='rel-canonical', claimant='http://example.com'), ]) db_session.add(document) db_session.flush() assert storage.expand_uri(db_session, "http://example.com/") == [ "http://example.com/"]
def test_expand_uri_document_uris(self, db_session): document = Document(document_uris=[ DocumentURI(uri="http://foo.com/", claimant="http://bar.com"), DocumentURI(uri="http://bar.com/", claimant="http://bar.com"), ]) db_session.add(document) db_session.flush() assert storage.expand_uri(db_session, "http://foo.com/") == [ "http://foo.com/", "http://bar.com/", ]
def __call__(self, search, params): if 'uri' not in params and 'url' not in params: return search query_uris = popall(params, 'uri') + popall(params, 'url') uris = set() for query_uri in query_uris: expanded = storage.expand_uri(self.request.db, query_uri) us = [uri.normalize(u) for u in expanded] uris.update(us) return search.filter('terms', **{'target.scope': list(uris)})
def test_expand_uri_document_uris(self, db_session): document = Document( document_uris=[ DocumentURI(uri="http://foo.com/", claimant="http://bar.com"), DocumentURI(uri="http://bar.com/", claimant="http://bar.com"), ] ) db_session.add(document) db_session.flush() assert storage.expand_uri(db_session, "http://foo.com/") == [ "http://foo.com/", "http://bar.com/", ]
def test_expand_uri_document_uris(self, db_session, normalized, expected_uris): document = Document(document_uris=[ DocumentURI(uri="http://example.com/", claimant="http://example.com"), DocumentURI(uri="http://alt.example.com/", claimant="http://example.com"), ]) db_session.add(document) db_session.flush() uris = storage.expand_uri(db_session, "http://alt.example.com/", normalized=normalized) assert uris == expected_uris
def __call__(self, params): if 'uri' not in params and 'url' not in params: return None query_uris = [v for k, v in params.items() if k in ['uri', 'url']] if 'uri' in params: del params['uri'] if 'url' in params: del params['url'] uris = set() for query_uri in query_uris: expanded = storage.expand_uri(self.request.db, query_uri) us = [uri.normalize(u) for u in expanded] uris.update(us) return {"terms": {"target.scope": list(uris)}}
def test_expand_uri_document_doesnt_expand_canonical_uris( self, db_session, normalized, expected_uris): document = Document(document_uris=[ DocumentURI( uri="http://example.com/", type="rel-canonical", claimant="http://example.com", ), DocumentURI(uri="http://noise.example.com/", claimant="http://example.com"), ]) db_session.add(document) db_session.flush() uris = storage.expand_uri(db_session, "http://example.com/", normalized=normalized) assert uris == expected_uris
def matching(cls, sockets, annotation, session): """ Find sockets with matching filters for the given annotation. For this to work, the sockets must have first had `set_filter()` called on them. :param sockets: Iterable of sockets to check :param annotation: Annotation to match :param session: DB session :return: A generator of matching socket objects """ values = { "/id": [annotation.id], "/group": [annotation.groupid], # Expand the URI to ensure we match any variants of it. This should # match the normalization when searching (see `h.search.query`) "/uri": set( storage.expand_uri(session, annotation.target_uri, normalized=True)), "/references": set(annotation.references), } for socket in sockets: # Some sockets might not yet have the filter applied (or had a non # parsable filter etc.) if not hasattr(socket, "filter_rows"): continue # Iterate over the filter_rows added by `set_filter()` for field, value in socket.filter_rows: try: # pylint: disable=too-many-try-statements if value in values[field]: yield socket break except KeyError: continue
def list(self, user, group=None, uris=None): """ Return a list of flags made by the given user. :param user: The user to filter flags on. :type user: h.models.User :param group: The annotation group pubid for filtering flags. :type group: unicode :param uris: A list of annotation uris for filtering flags. :type uris: list of unicode :returns: list of flags (``h.models.Flag``) :rtype: list """ query = self.session.query(models.Flag).filter_by(user=user) joined_annotation = False if group is not None: joined_annotation = True query = query.join(models.Annotation) \ .filter(models.Annotation.groupid == group) if uris: query_uris = set() for u in uris: expanded = storage.expand_uri(self.session, u) query_uris.update([uri.normalize(e) for e in expanded]) if not joined_annotation: joined_annotation = True query = query.join(models.Annotation) query = query.filter( models.Annotation.target_uri_normalized.in_(query_uris)) return query
def test_expand_uri_no_document(self, db_session): actual = storage.expand_uri(db_session, "http://example.com/") assert actual == ["http://example.com/"]
def test_expand_uri_no_document(self, db_session): actual = storage.expand_uri(db_session, 'http://example.com/') assert actual == ['http://example.com/']