Skip to main content
SimilarExport ZIP
100%

A vanilla py-script to download all Pocket.com data via API.

✓ Published0🌍 Public
BBastiTee
Last edited Jul 19, 2022
Created on Jul 19, 2022

This example demonstrates how to download a complete archive of all Pocket.com saved articles using the Pocket API. It shows the OAuth authentication flow, which opens a browser for user approval, then retrieves every article in batches of ten, displaying each article’s title and URL as it processes them. The script uses Python’s `requests` library to make HTTP POST calls to the Pocket API endpoints, along with the `json` module to parse responses and `subprocess` to trigger browser opening. It saves the full article list as a JSON file.

AI-generated description

Similar vizzes

Loading thumbnail…

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
59% match
Loading thumbnail…

A script to download all of a user's tweets into a csv

This script downloads a user’s entire tweet history into a CSV file, preserving each tweet’s ID, creation timestamp, and text. It demonstrates the Twitter API’s pagination limits by repeatedly fetching batches of 200 tweets via Tweepy’s `user_timeline` method, using the `max_id` parameter to retrieve older tweets until none remain. The final output is written with Python’s built-in `csv` module, encoding text as UTF-8. The example relies on Tweepy for API authentication and data retrieval, and shows a practical pattern for handling rate-limited, cursor-based API responses.

BBenHeubl
56% match
Loading thumbnail…

Gist d003ece0b6ca171be8e095e0bc90af7e

This notebook example demonstrates how to programmatically scrape, parse, and structure a corpus of New York Times articles into a pandas DataFrame. The code loads a pre-saved pickle file of 50 article links, iterates through each URL using the `newspaper` library's `Article` class, and extracts the article’s text, title, publication date, keywords, and summary. It then stores the results in a list of dictionaries and converts that list into a structured DataFrame. The script includes error handling for unparseable articles, inserting `NaN` values, and prints the total execution time, which took roughly 38.5 seconds for this run. The displayed table shows the resulting columns: date, keywords, link, summary, text, and title.

GGeorgeMcIntire
52% match
Loading thumbnail…

looping over list of video links for downloading

This example shows a bare-bones automation script that downloads a series of videos by iterating through a list of URLs. It constructs a shell command using the `youtube-dl` tool for each link, then executes it via Python’s `subprocess.call` function with `shell=True`. The script relies solely on Python’s standard library, with no external visualization or plotting libraries. The data source is the hardcoded `links` list, and the rendering approach is simply terminal output from the download commands.

KKristinHenry
50% match
Loading thumbnail…

Parse a card from Pokemon-card.com (output a JSON file)

This example parses a single Pokémon card page from pokemon-card.com into a structured JSON file. It extracts the card’s name, type, HP, moves, abilities, weaknesses, resistances, and evolution tree, along with illustrator and regulation-mark metadata. The Python script uses `requests` to fetch the HTML, `bs4` (BeautifulSoup) to parse the DOM, and `json` to output the results. It also handles subclasses like 進化 variants and reads card details from the page’s left and right boxes, returning a complete card record for downstream applications.

KKevinGutowski
50% match
Loading thumbnail…

Gist 58c79c81e9a950a0cdafc7d2d0275742

This example shows a dynamic, browser-automated web-scraping workflow that captures rendered page content. It uses Selenium’s `webdriver` to launch a Chrome browser, wait for elements via `WebDriverWait` and `expected_conditions`, and then extracts page HTML with BeautifulSoup. The script programmatically sends keyboard inputs via `Keys`, and also employs the `requests` library for direct HTTP calls. It parses the returned data with `json`, timestamps actions with `datetime`, and structures results into a pandas DataFrame. The process includes randomized delays (`random` and `time`) to mimic human browsing behavior, though no explicit visualization or rendering library is used beyond the raw captured markup.

AArizonaTay
49% match
Loading thumbnail…

Gist a0b52845de084cc3c135d878987abc87

This example demonstrates a Python script that logs into the Premier League fantasy football website and captures authentication cookies. It shows the redirect chain and cookie-handling process during login. The code uses the `requests` library to post login credentials and manually follows HTTP redirects while printing cookie names and values at each step. It relies on credentials imported from a `constants` module and includes a hardcoded `datadome` cookie from a prior session. The visualization is a code-based demonstration of session management, not a graphical output.

CConorAspell
49% match
Loading thumbnail…

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.

深深度碎片
49% match