tag, so we have to get that text 68 | # somewhow. 69 | full_text = entry_text_element.text 70 | paragraphs = entry.find_elements(By.TAG_NAME, "p") 71 | second_paragraph_text = paragraphs[ 72 | 0 73 | ].text # Second paragraph is the first
tag in the entry 74 | first_paragraph_text = full_text.split(second_paragraph_text)[0] 75 | 76 | entry_text.append(first_paragraph_text + " ") 77 | paragraph_counter = 1 78 | segment_counter = 0 79 | for paragraph in paragraphs: 80 | if ( 81 | "paragraphs" in splits[segment_counter] 82 | and splits[segment_counter]["paragraphs"] == paragraph_counter 83 | ): 84 | # This segment is finished, start the next 85 | paragraph_counter = 0 86 | segment_counter += 1 87 | entry_text.append("") 88 | entry_text[-1] = entry_text[-1] + paragraph.text + " " 89 | paragraph_counter += 1 90 | 91 | details = {"title": title, "date": date, "url": url, "entry_text": entry_text} 92 | return details 93 | -------------------------------------------------------------------------------- /image_size.py: -------------------------------------------------------------------------------- 1 | from constants import MARGIN 2 | 3 | 4 | def calculate_optimal_segments(entry_height, possible_splits, num_segments): 5 | """Return an array of locations at which to split the image to achieve the target number of segments. 6 | 7 | Args: 8 | entry_height: Total height of entry in px, multiplied by scaling factor 9 | possible_splits: Possible y coordinates to split the image. Each element corresponds to a paragraph, starting 10 | at the second paragraph in the entry. 11 | num_segments: Number of segments to target in result 12 | 13 | Returns: 14 | Array of objects containing the y coordinate at which to split the image, and the number of paragraphs included 15 | in the segment (later used to align alt text with the image segments) 16 | """ 17 | segments = [] 18 | rough_height = entry_height / num_segments # Approx height of each segment 19 | target = rough_height # Y position of the next target split 20 | last = 0 21 | paragraph_count = 0 22 | for current in possible_splits: 23 | paragraph_count += 1 24 | if last < target < current: 25 | # Choose the split that's closest to the target 26 | if last != 0 and abs(target - last) < abs(target - current): 27 | segments.append({"y": last + MARGIN, "paragraphs": paragraph_count}) 28 | else: 29 | segments.append({"y": current + MARGIN, "paragraphs": paragraph_count}) 30 | if len(segments) == num_segments - 1: 31 | break 32 | paragraph_count = 0 33 | target += rough_height 34 | last = current 35 | return segments 36 | -------------------------------------------------------------------------------- /insta.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import os 3 | from constants import * 4 | from instagrapi import Client 5 | from PIL import Image 6 | from secrets import * 7 | 8 | 9 | def authenticate(): 10 | """ 11 | Authenticate user with Instagram username and password. Requires 2FA. 12 | Returns: 13 | Authenticated Instagram client. 14 | """ 15 | client = Client() 16 | mfa = input("Instagram 2FA code: ") 17 | client.login(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD, verification_code=mfa) 18 | return client 19 | 20 | 21 | def convert_images(num_screenshots): 22 | """ 23 | Convert screenshots to JPGs because Instagram is weirdly picky about file format. 24 | Args: 25 | num_screenshots: Number of screenshots for this post. 26 | 27 | Returns: 28 | List of screenshot paths. 29 | """ 30 | paths = [] 31 | force_aspect_ratio = ( 32 | num_screenshots > 1 33 | ) # When there are multiple images, the images will be cropped if the aspect ratios differ 34 | tallest_height = 0 35 | 36 | # Get height of tallest screenshot 37 | if force_aspect_ratio: 38 | for ind in range(num_screenshots): 39 | png_path = os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 40 | image = Image.open(png_path) 41 | width, height = image.size 42 | if height > tallest_height: 43 | tallest_height = height 44 | 45 | for ind in range(num_screenshots): 46 | png_path = os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 47 | jpg_path = os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".jpg") 48 | image = Image.open(png_path) 49 | if force_aspect_ratio: 50 | original_width, original_height = image.size 51 | if original_height < tallest_height: 52 | canvas = Image.new( 53 | "RGBA", (original_width, tallest_height), (238, 238, 238, 255) 54 | ) # Canvas with light grey background in target size 55 | offset = 0, int(round(tallest_height - original_height) / 2) 56 | canvas.paste(image, offset) 57 | image = canvas 58 | rgb = image.convert("RGB") # Discard transparency 59 | rgb.save(jpg_path) 60 | paths.append(jpg_path) 61 | return paths 62 | 63 | 64 | def send_instagram(post_text, num_screenshots, entry_details): 65 | """ 66 | Create and send the Instagram post for this entry. 67 | 68 | Args: 69 | post_text: Text to post as the skeet contents. 70 | num_screenshots: Number of screenshots to be attached. 71 | entry_details: Object containing title, url, date, and array of entry text 72 | 73 | Returns: 74 | String containing ID of the Instagram post that was just posted, or None if the post fails. 75 | """ 76 | logger = logging.getLogger(__name__) 77 | try: 78 | images = convert_images(num_screenshots) 79 | 80 | client = authenticate() 81 | if len(images) == 1: 82 | path = images[0] 83 | media = client.photo_upload( 84 | path, 85 | post_text, 86 | extra_data={ 87 | "custom_accessibility_caption": entry_details["entry_text"][0] 88 | }, 89 | ) 90 | logger.info("Sending Instagram post (one image)") 91 | 92 | else: 93 | media = client.album_upload( 94 | images, 95 | post_text, 96 | extra_data={ 97 | "custom_accessibility_caption": entry_details["entry_text"][0] 98 | }, 99 | ) 100 | logger.info("Sending Instagram post (multiple images)") 101 | 102 | return media.code 103 | except Exception as e: 104 | print(e) 105 | return None 106 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | attrs==23.1.0 2 | beautifulsoup4==4.12.2 3 | blurhash==1.1.4 4 | cachetools==5.3.1 5 | certifi==2023.7.22 6 | chardet==5.2.0 7 | charset-normalizer==3.2.0 8 | decorator==4.4.2 9 | exceptiongroup==1.1.3 10 | future==0.18.3 11 | google-auth==2.22.0 12 | h11==0.14.0 13 | huepy==1.2.1 14 | idna==3.4 15 | imageio==2.33.0 16 | imageio-ffmpeg==0.4.9 17 | iniconfig==2.0.0 18 | instagrapi==2.0.0 19 | Mastodon.py==1.8.1 20 | mock==5.1.0 21 | moviepy==1.0.3 22 | numpy==1.26.2 23 | oauthlib==3.2.2 24 | outcome==1.2.0 25 | packaging==23.2 26 | Pillow==10.0.0 27 | pluggy==1.3.0 28 | proglog==0.1.10 29 | pyasn1==0.5.0 30 | pyasn1-modules==0.3.0 31 | pycryptodomex==3.18.0 32 | pydantic==1.10.9 33 | PySocks==1.7.1 34 | pytest==7.4.3 35 | python-dateutil==2.8.2 36 | python-magic==0.4.27 37 | pytz==2023.3.post1 38 | PyYAML==6.0.1 39 | requests==2.31.0 40 | requests-oauthlib==1.3.1 41 | requests-toolbelt==1.0.0 42 | responses==0.24.1 43 | rsa==4.9 44 | schedule==1.2.1 45 | selenium==4.16.0 46 | six==1.16.0 47 | sniffio==1.3.0 48 | sortedcontainers==2.4.0 49 | soupsieve==2.5 50 | tenacity==8.2.3 51 | tomli==2.0.1 52 | tqdm==4.66.1 53 | trio==0.22.2 54 | trio-websocket==0.10.4 55 | tweepy==4.14.0 56 | typing_extensions==4.8.0 57 | urllib3==1.26.16 58 | wsproto==1.2.0 59 | -------------------------------------------------------------------------------- /screenshotter.py: -------------------------------------------------------------------------------- 1 | from constants import * 2 | from image_size import calculate_optimal_segments 3 | 4 | from selenium.webdriver.common.by import By 5 | from selenium.common.exceptions import NoSuchElementException 6 | 7 | from PIL import Image 8 | 9 | import logging 10 | import os 11 | 12 | 13 | def get_screenshot(entry): 14 | """Load the page and capture a screenshot of the post with the specified ID. If the screenshot is overly long, split 15 | it into two or three segments at paragraph breaks. 16 | 17 | Args: 18 | entry: WebElement to capture 19 | 20 | Returns: 21 | Array with split information (y coordinate of split, and number of paragraphs included in each split). 22 | """ 23 | 24 | logger = logging.getLogger(__name__) 25 | image_bottom = None 26 | splits = [] 27 | num_segments = None 28 | if entry.size["height"] > MAX_IMAGE_HEIGHT: 29 | # This is a tall entry that we'll want to split into multiple screenshots 30 | num_segments = 3 if entry.size["height"] > (MAX_IMAGE_HEIGHT * 2) else 2 31 | 32 | # Avoid splitting through an image if there is one 33 | try: 34 | image = entry.find_element(By.CLASS_NAME, "captioned-image") 35 | if image: 36 | image_bottom = ( 37 | image.rect["y"] + image.rect["height"] - entry.location["y"] 38 | ) * SCALING_FACTOR 39 | except NoSuchElementException: 40 | pass 41 | 42 | # Get array of possible split coordinates (top of each
) 43 | paragraphs = entry.find_elements(By.TAG_NAME, "p") 44 | heights = [ 45 | (p.rect["y"] - entry.location["y"]) * SCALING_FACTOR for p in paragraphs 46 | ] 47 | if image_bottom: 48 | heights = list(filter(lambda x: x > image_bottom, heights)) 49 | 50 | # Decide which of the split possibilities to go with 51 | splits = calculate_optimal_segments( 52 | entry.size["height"] * SCALING_FACTOR, heights, num_segments 53 | ) 54 | 55 | # Grab screenshot 56 | logger.debug("Capturing screenshot") 57 | screenshot_path = os.path.join(OUTPUT_DIR, "screenshot.png") 58 | entry.screenshot(screenshot_path) 59 | 60 | with Image.open(screenshot_path) as image: 61 | entry_with_margin = Image.new( 62 | "RGB", 63 | (image.width + MARGIN * 2, image.height + MARGIN * 2), 64 | (238, 238, 238), 65 | ) 66 | entry_with_margin.paste(image, (MARGIN, MARGIN)) 67 | 68 | splits.append({"y": entry_with_margin.height}) 69 | if len(splits) > 1: 70 | logger.debug(f"Splitting screenshot into target {num_segments} segments.") 71 | last_crop = 0 72 | for ind, split in enumerate(splits): 73 | filename = os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 74 | cp = entry_with_margin.copy() 75 | cp = cp.crop((0, last_crop, entry_with_margin.width, split["y"])) 76 | cp = cp.resize((int(cp.width * 0.75), int(cp.height * 0.75))) 77 | cp.save(filename) 78 | last_crop = split["y"] 79 | else: 80 | entry_with_margin = entry_with_margin.resize( 81 | (int(entry_with_margin.width * 0.75), int(entry_with_margin.height * 0.75)) 82 | ) 83 | entry_with_margin.save(os.path.join(OUTPUT_DIR, FILENAME_ROOT + "0.png")) 84 | 85 | os.remove(screenshot_path) # Clean up intermediate file that's not needed anymore 86 | 87 | return splits 88 | -------------------------------------------------------------------------------- /skeet.py: -------------------------------------------------------------------------------- 1 | from constants import * 2 | from PIL import Image 3 | from secrets import * 4 | from tenacity import retry, stop_after_attempt, retry_if_exception_type 5 | 6 | from datetime import datetime, timezone 7 | import logging 8 | import os 9 | import requests 10 | 11 | 12 | def authenticate(): 13 | """ 14 | Authenticate user with BlueSky identifier and password (password can be an app password). 15 | 16 | Returns: 17 | Tuple containing the JWT and DID. Note the JWT is short-lived and this script has no refresh functionality -- 18 | that would need to be added if this was a persistent process rather than a one-off call. 19 | """ 20 | resp = requests.post( 21 | BLUESKY_BASE_URL + "/com.atproto.server.createSession", 22 | json={"identifier": BLUESKY_USERNAME, "password": BLUESKY_PASSWORD}, 23 | ) 24 | resp_data = resp.json() 25 | jwt = resp_data["accessJwt"] 26 | did = resp_data["did"] 27 | return jwt, did 28 | 29 | 30 | @retry( 31 | stop=stop_after_attempt(3), 32 | retry=( 33 | retry_if_exception_type(requests.exceptions.Timeout) 34 | | retry_if_exception_type(requests.exceptions.ChunkedEncodingError) 35 | ), 36 | ) 37 | def upload_blob(ind, headers): 38 | """Try to upload an image. This is prone to errors, so retry a few times if needed. 39 | 40 | Args: 41 | ind: Index of the image to try to upload 42 | headers: HTTP headers to include in the request. 43 | 44 | Returns: 45 | Blob to send along with the post to attach the image. 46 | """ 47 | image_path = os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 48 | with open(image_path, "rb") as image_file: 49 | image = image_file.read() 50 | resp = requests.post( 51 | BLUESKY_BASE_URL + "/com.atproto.repo.uploadBlob", 52 | data=image, 53 | headers={**headers, "Content-Type": "image/png"}, 54 | timeout=(5, 20), 55 | ) 56 | blob = resp.json().get("blob") 57 | 58 | # Get image aspect ratio 59 | with Image.open(image_path) as pil_image: 60 | width, height = pil_image.size 61 | aspect_ratio = {"width": width, "height": height} 62 | 63 | return blob, aspect_ratio 64 | 65 | 66 | def send_skeet(post_text, num_screenshots, entry_details): 67 | """ 68 | Create and send the skeet for this entry. 69 | 70 | Args: 71 | post_text: Text to post as the skeet contents. 72 | num_screenshots: Number of screenshots to be attached. 73 | entry_details: Object containing title, url, date, and array of entry text 74 | 75 | Returns: 76 | String containing ID of the skeet that was just posted, or None if the post fails. 77 | """ 78 | logger = logging.getLogger(__name__) 79 | try: 80 | (jwt, did) = authenticate() 81 | headers = {"Authorization": "Bearer " + jwt} 82 | 83 | # Upload screenshots 84 | blobs = [] 85 | ratios = [] 86 | for ind in range(num_screenshots): 87 | logger.debug(f"Uploading Bluesky image {ind}") 88 | blob, ratio = upload_blob(ind, headers) 89 | blobs.append(blob) 90 | ratios.append(ratio) 91 | 92 | iso_timestamp = datetime.now(timezone.utc).isoformat() 93 | iso_timestamp = ( 94 | iso_timestamp[:-6] + "Z" 95 | ) # bsky uses Z format, so trim off +00:00 and add Z 96 | 97 | # Hydrate screenshot images with alt text 98 | images = [] 99 | for ind, blob in enumerate(blobs): 100 | alt_text = entry_details["entry_text"][ind] 101 | if ind == 0: 102 | alt_text = entry_details["title"] + "\n" + alt_text 103 | images.append( 104 | { 105 | "image": blob, 106 | "alt": alt_text[:BLUESKY_ALT_TEXT_LIMIT], 107 | "aspectRatio": ratios[ind], 108 | } 109 | ) 110 | 111 | # Create rich text information to turn the W3IGG URL into a clickable link 112 | post_text_bytes = bytes(post_text, "utf-8") 113 | facets = [ 114 | { 115 | "features": [ 116 | { 117 | "uri": entry_details["url"], 118 | "$type": "app.bsky.richtext.facet#link", 119 | } 120 | ], 121 | "index": { 122 | "byteStart": post_text_bytes.find(bytes("https://", "utf-8")), 123 | "byteEnd": len(post_text_bytes), 124 | }, 125 | } 126 | ] 127 | 128 | post_data = { 129 | "repo": did, 130 | "collection": "app.bsky.feed.post", 131 | "record": { 132 | "$type": "app.bsky.feed.post", 133 | "text": post_text, 134 | "createdAt": iso_timestamp, 135 | "embed": {"$type": "app.bsky.embed.images", "images": images}, 136 | "facets": facets, 137 | }, 138 | } 139 | 140 | logger.info("Sending skeet") 141 | resp = requests.post( 142 | BLUESKY_BASE_URL + "/com.atproto.repo.createRecord", 143 | json=post_data, 144 | headers=headers, 145 | ) 146 | 147 | if resp.status_code != 200: 148 | logger.error(f"Failed to post skeet: {resp.status_code} {resp.text}") 149 | return None 150 | # Grab just the post ID without the full URI 151 | return resp.json()["uri"].split("/")[-1] 152 | 153 | except Exception as e: 154 | print(e) 155 | return None 156 | -------------------------------------------------------------------------------- /tests/test_format_post_title.py: -------------------------------------------------------------------------------- 1 | from crossposter import format_post_title, ZWSP 2 | 3 | 4 | def test_escape_url(): 5 | title = "Crypto.com did something" 6 | formatted = format_post_title(title) 7 | assert formatted[6] == ZWSP 8 | 9 | 10 | def test_dont_escape_number(): 11 | title = "Someone hacked for $1.5 million" 12 | formatted = format_post_title(title) 13 | assert ZWSP not in formatted 14 | 15 | 16 | def test_escape_multiple(): 17 | title = "Crypto.com something.net" 18 | formatted = format_post_title(title) 19 | assert formatted.count(ZWSP) == 2 20 | -------------------------------------------------------------------------------- /tests/test_image_size.py: -------------------------------------------------------------------------------- 1 | from image_size import * 2 | from constants import MARGIN 3 | 4 | 5 | def test_calculate_splits_for_two_segment_post(): 6 | possible_splits = [100, 200, 340, 450, 500, 600] 7 | splits = calculate_optimal_segments(700, possible_splits, 2) 8 | assert len(splits) == 1 9 | assert splits[0]["y"] == 340 + MARGIN 10 | assert splits[0]["paragraphs"] == 4 11 | 12 | 13 | def test_calculate_splits_for_three_segment_post(): 14 | possible_splits = [100, 200, 300, 400, 500, 600] 15 | splits = calculate_optimal_segments(700, possible_splits, 3) 16 | assert len(splits) == 2 17 | assert splits[0]["y"] == 200 + MARGIN 18 | assert splits[0]["paragraphs"] == 3 19 | assert splits[1]["y"] == 500 + MARGIN 20 | assert splits[1]["paragraphs"] == 2 21 | 22 | 23 | def test_calculate_splits_for_wonky_post(): 24 | # This is tall enough that it should get three segments, but there aren't enough options for places to split 25 | possible_splits = [3000] 26 | splits = calculate_optimal_segments(3200, possible_splits, 3) 27 | assert len(splits) == 1 28 | assert splits[0]["y"] == 3000 + MARGIN 29 | assert splits[0]["paragraphs"] == 1 30 | 31 | 32 | def test_calculate_splits_with_no_split_options(): 33 | splits = calculate_optimal_segments(900, [], 2) 34 | assert splits == [] 35 | -------------------------------------------------------------------------------- /threads.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import os 3 | from time import sleep 4 | 5 | from constants import * 6 | from element_has_text_value import element_has_text_value 7 | from webdriver import get_driver 8 | 9 | from selenium.webdriver.common.by import By 10 | from selenium.webdriver.common.action_chains import ActionChains 11 | from selenium.common.exceptions import ( 12 | TimeoutException, 13 | ) 14 | from selenium.webdriver.support import expected_conditions 15 | from selenium.webdriver.support.wait import WebDriverWait 16 | 17 | FILE_INPUT_XPATH = "//input[@type='file']" 18 | ALT_TEXT_BUTTONS_XPATH = "//div[@role='button'][.//span[text()='Alt']]" 19 | CONTENT_EDITABLE_DIV_XPATH = "//div[@contenteditable='true']" 20 | LEXICAL_TEXT_SPAN_XPATH = "//span[@data-lexical-text='true']" 21 | POST_BUTTON_XPATH = "//div[@role='button'][.//div[text()='Post']]" 22 | VIEW_BUTTON_XPATH = "//a[text()='View']" 23 | 24 | 25 | def send_threads(post_text, num_screenshots, entry_details): 26 | """ 27 | Create and send the Threads post for this entry. 28 | 29 | Args: 30 | post_text: Text to post as the tweet contents. 31 | num_screenshots: Number of screenshots to be attached. 32 | entry_details: Object containing title, url, date, and array of entry text 33 | driver: WebDriver instance 34 | 35 | Returns: 36 | String containing ID of the Threads post that was just posted, or None if the post fails. 37 | """ 38 | logger = logging.getLogger(__name__) 39 | driver = get_driver(headless=True, screenshot_resolution=False) 40 | driver.get(THREADS_URL) 41 | try: 42 | WebDriverWait(driver, 10).until( 43 | expected_conditions.presence_of_element_located( 44 | (By.XPATH, "//img[contains(@alt, 'profile picture')]") 45 | ) 46 | ) 47 | except TimeoutException: 48 | logger.error("Threads page didn't load within ten seconds.") 49 | driver.quit() 50 | 51 | else: 52 | # Open post modal 53 | create_button = driver.find_element( 54 | By.XPATH, "//div[@role='button'][.//*[name()='svg'][@aria-label='Create']]" 55 | ) 56 | create_button.click() 57 | 58 | try: 59 | WebDriverWait(driver, 10).until( 60 | expected_conditions.presence_of_element_located( 61 | (By.XPATH, POST_BUTTON_XPATH) 62 | ) 63 | ) 64 | WebDriverWait(driver, 10).until( 65 | expected_conditions.presence_of_element_located( 66 | (By.XPATH, FILE_INPUT_XPATH) 67 | ) 68 | ) 69 | except TimeoutException: 70 | logger.error("Threads post modal didn't load within ten seconds.") 71 | driver.quit() 72 | else: 73 | try: 74 | # Grab a reference to the post button to use later 75 | post_button = driver.find_element(By.XPATH, POST_BUTTON_XPATH) 76 | 77 | # Attach screenshot files 78 | for ind in range(num_screenshots): 79 | media_upload_input = driver.find_element(By.XPATH, FILE_INPUT_XPATH) 80 | # Attach image 81 | filename = os.path.abspath( 82 | os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 83 | ) 84 | media_upload_input.send_keys(filename) 85 | 86 | # Add alt text to the image that was just attached 87 | alt_text = entry_details["entry_text"][ind] 88 | if ind == 0: 89 | alt_text = entry_details["title"] + " " + alt_text 90 | alt_text = alt_text.replace( 91 | "\n", " " 92 | ) # Threads doesn't like newlines in alt text 93 | alt_text = alt_text[:THREADS_ALT_TEXT_LIMIT] 94 | 95 | WebDriverWait(driver, 10).until( 96 | expected_conditions.presence_of_element_located( 97 | (By.XPATH, ALT_TEXT_BUTTONS_XPATH) 98 | ) 99 | ) 100 | sleep(1) # Selenium hates me 101 | alt_text_buttons = driver.find_elements( 102 | By.XPATH, ALT_TEXT_BUTTONS_XPATH 103 | ) 104 | alt_text_buttons[-1].click() 105 | 106 | # Wait for alt text box to animate 107 | WebDriverWait(driver, 10).until( 108 | expected_conditions.presence_of_element_located( 109 | ( 110 | By.XPATH, 111 | "//*[contains(text(), 'Describe this for people')]", 112 | ) 113 | ) 114 | ) 115 | actions = ActionChains(driver) 116 | actions.send_keys(alt_text).perform() 117 | WebDriverWait(driver, 10).until( 118 | element_has_text_value( 119 | (By.XPATH, LEXICAL_TEXT_SPAN_XPATH), alt_text 120 | ) 121 | ) 122 | 123 | driver.find_element( 124 | By.XPATH, "//div[@role='button'][.//*[text()='Done']]" 125 | ).click() 126 | WebDriverWait(driver, 10).until( 127 | expected_conditions.visibility_of(post_button) 128 | ) 129 | 130 | # Enter post text 131 | driver.find_element(By.XPATH, CONTENT_EDITABLE_DIV_XPATH).click() 132 | sleep(1) 133 | actions = ActionChains(driver) 134 | actions.send_keys(post_text).perform() 135 | 136 | WebDriverWait(driver, 10).until( 137 | element_has_text_value( 138 | (By.XPATH, CONTENT_EDITABLE_DIV_XPATH), post_text 139 | ) 140 | ) 141 | 142 | # Click post button 143 | # There is a hidden post button under the modal that is disabled, so we need the additional selector here 144 | # to avoid trying to click that one 145 | post_button = driver.find_element( 146 | By.XPATH, 147 | "//div[@role='dialog']//div[@role='button'][.//div[text()='Post']]", 148 | ) 149 | post_button.click() 150 | 151 | # Wait for post to send, then get its ID 152 | WebDriverWait(driver, 20).until( 153 | expected_conditions.visibility_of_element_located( 154 | (By.XPATH, VIEW_BUTTON_XPATH) 155 | ) 156 | ) 157 | view_button = driver.find_element(By.XPATH, VIEW_BUTTON_XPATH) 158 | href = view_button.get_attribute("href") 159 | post_id = href.split("/")[-1] 160 | 161 | # Clean up and return post ID 162 | driver.quit() 163 | return post_id 164 | except Exception as e: 165 | logger.error("Something else went wrong during Threads post.") 166 | logger.error(e) 167 | driver.quit() 168 | 169 | return None 170 | -------------------------------------------------------------------------------- /toot.py: -------------------------------------------------------------------------------- 1 | from constants import * 2 | from secrets import * 3 | import logging 4 | import os 5 | 6 | from mastodon import Mastodon 7 | 8 | 9 | def authenticate(): 10 | """ 11 | Authenticate to Mastodon. 12 | 13 | Returns: 14 | Authenticated Mastodon client. 15 | """ 16 | api = Mastodon(client_id="mastodon.secret") 17 | api.log_in(MASTODON_EMAIL, MASTODON_PASSWORD, to_file="mastodon_user.secret") 18 | return api 19 | 20 | 21 | def send_toot(post_text, num_screenshots, entry_details): 22 | """ 23 | Create and send the toot for this entry. 24 | 25 | Args: 26 | post_text: Text to post as the toot contents. 27 | num_screenshots: Number of screenshots to be attached. 28 | entry_details: Object containing title, url, date, and array of entry text 29 | 30 | Returns: 31 | String containing ID of the toot that was just posted, or None if the post fails. 32 | """ 33 | logger = logging.getLogger(__name__) 34 | try: 35 | api = authenticate() 36 | 37 | # Upload screenshots 38 | media_ids = [] 39 | for ind in range(num_screenshots): 40 | logger.debug(f"Uploading Mastodon image {ind}") 41 | # Get alt text for this image 42 | alt_text = entry_details["entry_text"][ind] 43 | if ind == 0: 44 | alt_text = entry_details["title"] + "\n" + alt_text 45 | 46 | resp = api.media_post( 47 | os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png"), 48 | description=alt_text[:MASTODON_ALT_TEXT_LIMIT], 49 | focus=(0, -1), # Set focus to center top of post 50 | ) 51 | media_ids.append(resp.id) 52 | 53 | # Send tweet 54 | logger.info("Sending toot.") 55 | toot = api.status_post(post_text, media_ids=media_ids) 56 | return str(toot["id"]) 57 | 58 | except Exception as e: 59 | print(e) 60 | return None 61 | -------------------------------------------------------------------------------- /tweet.py: -------------------------------------------------------------------------------- 1 | from constants import * 2 | from secrets import * 3 | import logging 4 | import os 5 | import tweepy 6 | 7 | 8 | def authenticate(): 9 | """ 10 | Authenticate to Twitter. 11 | 12 | Returns: 13 | Tuple containing the Client (for posting tweet) and the API (for v1.1 media upload endpoint) 14 | """ 15 | client = tweepy.Client( 16 | consumer_key=TWITTER_API_KEY, 17 | consumer_secret=TWITTER_API_KEY_SECRET, 18 | access_token=TWITTER_ACCESS_TOKEN, 19 | access_token_secret=TWITTER_ACCESS_TOKEN_SECRET, 20 | ) 21 | auth = tweepy.OAuth1UserHandler( 22 | TWITTER_API_KEY, 23 | TWITTER_API_KEY_SECRET, 24 | TWITTER_ACCESS_TOKEN, 25 | TWITTER_ACCESS_TOKEN_SECRET, 26 | ) 27 | api = tweepy.API(auth) 28 | return client, api 29 | 30 | 31 | def send_tweet(post_text, url, num_screenshots, entry_details): 32 | """ 33 | Create and send the tweet for this entry. 34 | 35 | Args: 36 | post_text: Text to post as the tweet contents. 37 | url: W3IGG URL for the entry. 38 | num_screenshots: Number of screenshots to be attached. 39 | entry_details: Object containing title, url, date, and array of entry text 40 | 41 | Returns: 42 | String containing ID of the tweet that was just posted, or None if the post fails. 43 | """ 44 | logger = logging.getLogger(__name__) 45 | try: 46 | (client, api) = authenticate() 47 | 48 | # Upload screenshots 49 | media_ids = [] 50 | for ind in range(num_screenshots): 51 | logger.debug(f"Uploading Twitter image {ind}") 52 | resp = api.media_upload( 53 | os.path.join(OUTPUT_DIR, FILENAME_ROOT + str(ind) + ".png") 54 | ) 55 | 56 | # Add alt text to the image that was just uploaded 57 | alt_text = entry_details["entry_text"][ind] 58 | if ind == 0: 59 | alt_text = entry_details["title"] + "\n" + alt_text 60 | api.create_media_metadata(resp.media_id, alt_text[:TWITTER_ALT_TEXT_LIMIT]) 61 | 62 | media_ids.append(resp.media_id) 63 | 64 | # Send tweet 65 | logger.info("Sending tweet") 66 | tweet = client.create_tweet(text=post_text, user_auth=True, media_ids=media_ids) 67 | client.create_tweet( 68 | text=url, user_auth=True, in_reply_to_tweet_id=tweet.data["id"] 69 | ) 70 | return tweet.data["id"] 71 | except Exception as e: 72 | print(e) 73 | return None 74 | -------------------------------------------------------------------------------- /update_entry.py: -------------------------------------------------------------------------------- 1 | from constants import CLOUD_FUNCTIONS_URL 2 | from google.oauth2 import service_account 3 | from google.auth.transport.requests import AuthorizedSession, Request 4 | 5 | 6 | def update_entry_with_social_ids(entry_id, post_ids): 7 | """Add any post IDs to the W3IGG entry.""" 8 | function_url = CLOUD_FUNCTIONS_URL + "/addSocialPostIds" 9 | credentials = service_account.IDTokenCredentials.from_service_account_file( 10 | "gcp-secret.secret", 11 | target_audience=function_url, 12 | ) 13 | session = AuthorizedSession(credentials) 14 | 15 | resp = session.post( 16 | function_url, 17 | json={"entryId": entry_id, **post_ids}, 18 | ) 19 | resp.raise_for_status() 20 | return resp.json() 21 | -------------------------------------------------------------------------------- /webdriver.py: -------------------------------------------------------------------------------- 1 | from constants import * 2 | from selenium import webdriver 3 | 4 | 5 | def get_driver(headless=True, screenshot_resolution=True): 6 | """Get the driver with requisite options already set. 7 | 8 | Returns: 9 | Configured WebDriver instance. 10 | """ 11 | options = webdriver.FirefoxOptions() 12 | if headless: 13 | options.add_argument("--headless") 14 | options.profile = webdriver.FirefoxProfile( 15 | "/Users/molly/Library/Application Support/Firefox/Profiles/9e81e71e.w3igg-archiver", 16 | ) 17 | options.set_preference("general.useragent.override", USER_AGENT) 18 | if screenshot_resolution: 19 | options.set_preference("layout.css.devPixelsPerPx", str(SCALING_FACTOR)) 20 | options.set_preference("ui.textScaleFactor", 100) 21 | driver = webdriver.Firefox(options=options) 22 | if screenshot_resolution: 23 | driver.set_window_size(800, 5000) 24 | return driver 25 | --------------------------------------------------------------------------------