OpenAlex-url to pyalex-query

How to use The Guardian's API to download article data for content analysis (in Python 3.x)

This example demonstrates how to perform content analysis on Guardian news articles by programmatically downloading article data through The Guardian’s open API. It shows the entire workflow, from constructing API queries with parameters like `from-date`, `to-date`, and `show-fields`, to parsing the returned JSON metadata and article bodies. The Python script uses the `requests` library to fetch paginated results into day-sized chunks, saving the raw JSON files locally for further analysis. The example also highlights the API’s response structure, including fields such as `wordcount`, `byline`, and full article HTML.

GGeorgeMcIntire

44% match

A basic introduction to using the rauth library and the Yelp API.

This example demonstrates how to query the Yelp API for nearby restaurants using the rauth library for OAuth 1.0 authentication. It shows a Python script that iterates over three sets of latitude/longitude coordinates, sending a search request for each location with parameters like restaurant term, radius filter, and a limit of ten results. The code retrieves JSON responses, converts them into Python dictionaries, and includes a rate-limiting sleep between calls to respect API usage. The visualization highlights the workflow of constructing signed requests and parsing structured location data from Yelp’s search endpoint.

EEPBAH

42% match

A brief introduction to JSONiq for NashFP

This example demonstrates the JSONiq query language by showing code snippets for tasks like object navigation, FLWOR expressions, JSON-to-XML conversion, and the Luhn algorithm. The sample queries use JSONiq’s map operator, function libraries like `fn:upper-case` and `fn:fold-left`, and the `keys()` and `members()` functions. Each snippet includes a link to run it in the Zorba engine’s online sandbox, referencing the NashFP presentation context.

Gist 0fbf0f6cbe67ab63e90d47d65cda05ea

This visualization demonstrates a three-stage search pipeline that locates content across numerous blog-post dialogs without loading entire files. Using Python's async/await syntax, the code calls three functions—`get_first_notes`, `get_section_summaries`, and `get_section_content`—in bulk loops to filter a folder down to relevant sections, reducing token usage from tens of thousands to roughly six thousand. The transitions between stages are driven by agent analysis of summaries, with each stage executing as a single kernel call.

深深度碎片

Sample code for extracting, transforming, and loading IA metadata into BaseX

This example demonstrates an XQuery 3.1 pipeline for harvesting Open Library search results and persisting them as structured XML in a BaseX database. It first fetches JSON via `fetch:text` and parses it with `json:parse`, then converts each record into a canonical `book` element with attributes for key and full-text availability, and child elements for title, authors, dates, publishers, and subjects. Subsequent scripts extend the process to paginate through large result sets, and a final query retrieves full book texts from the Internet Archive, storing them alongside the metadata.

XQuery Full-Text Examples

This example demonstrates XQuery Full-Text search and scoring over the TEI-encoded poems of *Les Fleurs du Mal*. It shows basic text matching with the `contains text` operator, then extends to counting results via `ft:count()`, highlighting matches with `ft:mark()`, extracting snippets with `ft:extract()`, and ranking hits by relevance using `ft:score()` with descending order. The final `search.xqy` combines scoring, marking, and base-URI display, filtering out a specific document. The code uses the XQuery 3.1 `=>` arrow operator for function chaining, and relies on the `fn:collection()` function to access the poem corpus.

Extracts entities with geographic attributes using the Alchemy api

This example shows geographic entities extracted from a web-accessible text, filtered to include only those with associated geo-coordinates. The XQuery script sends a POST request to the Alchemy API’s URLGetRankedNamedEntities endpoint, supplying an API key and a target URL, then parses the returned XML to select entities that contain a `<geo>` element. The visualization relies on the Alchemy API for entity extraction and geographic tagging, while the code itself handles the HTTP request and response processing without additional rendering libraries. The data source is a plain-text file hosted on GitHub, and the output is a list of entities with location data.

DPLA Data

This example queries the Digital Public Library of America (DPLA) API to fetch and display search results as a simple webpage. It shows a list of image thumbnails with titles, each linked to its source item. The code uses the XQuery `fetch:text` or `fn:json-doc` functions to retrieve JSON data from the DPLA API, then parses it with `json:parse` or direct JSON navigation. It constructs HTML `<li>` elements containing an `<img>` tag and anchor, filtering out results without a thumbnail or title.