feed2gram 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31ad42be4bf5ec4ba881a78695bc7b9cc0619bb3b399559d668361b3be9872b0
-  data.tar.gz: 38617996403f39ca1eeee6285cb31896be7c4dbbb05033d98713c2ac6a1d245e
+  metadata.gz: 186b11421ce39cc03f041f010e695fbd295edb0631235d80545e42928fe6edca
+  data.tar.gz: 688601d45092f6f1c57c9871af2b337c7df93f441ccefc6b787e01169a8bd236
 SHA512:
-  metadata.gz: e28c8903d7933cd8d55454ccf59df9a50a58a60dbaf2794463dbd1ff623af34d4c6077d9b4b202009e2a85b5a031a967e0e71d1ec8f90f58a46bc38222845ff1
-  data.tar.gz: 3a3d448efa515863ad1f37f4be8e75801e9a71769ed00b376a5d5f3723884d94ffa25a965c14b662a3f92e73c94b1c4b670973ae08164ab51605a1bb3d3afa9c
+  metadata.gz: 4682d5d13f8443ebb0cdc853394fb9e8a0c8677a0e4850daaa0df8feb54d9fcc73cc64eb5c41368dd14c958e8a5be25fe50e2c8a006602d66751161c411c9e13
+  data.tar.gz: 7ca4d2096fa0b0b60df85c0f902f312ab27083a2ec9b7b0590951315370b3dd74fee02c92781ebdc7347945a5dc7142ac9f1204cbfe468125bd523c4b5509964

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-## [Unreleased]
+## [1.1.0]
+
+* Add support for videos and stories, including:
+  * single-video posts (which post as reels), by setting `data-media-type=video`
+  attribute on a feed entry's `<figure>`'s only `<img>` child
+  * single-image and single-video stories, by setting `data-post-type=stories`
+  attribute on a feed entry's `<figure>` element
+  * carousels that contain videos and photos by setting `data-media-type=video`
+  attribute on each `<img>` tag that contains a video
+* Print much more granular feedback when publishing and in verbose mode
+* When all posts are filtered out from the cache, say so (when verbose) and
+don't update the cache file needlessly
 
 ## [1.0.0]
 

data/README.md

@@ -102,13 +102,18 @@ feed2gram uses the first `<figure>` element to generate each Instagram post. Tha
 
 Some things to keep in mind:
 
+* A `<figure>` may specify a `data-post-type` with a value of `reels`, `stories`, or `post` (if unspecified, the type defaults to `post`)
+  * If `data-post-type` is set to `stories` or `reels`, exactly one image or video must be included. If `post`, then multiple (up to ten) images and videos can be included and will publish as a carousel post
+  * Posting stories (i.e. `<figure data-post-type="stories">`) requires a _business_ account, not a creator one (in which case a, "the user is not an Instagram Business," error will be returned)
 * If one `<img>` tag is present, a single photo post will be created. If there are more, a [carousel post](https://developers.facebook.com/docs/instagram-api/guides/content-publishing/#carousel-posts) will be created
 * Because Facebook's servers actually _download your image_ as opposed to receiving them as uploads via the API, every `<img>` tag's `src` attribute must be set to a publicly-reachable, fully-qualified URL
-* Images can't be more than 8MB, or else posting will fail
-* Images must be standard-issue JPEGs, or else posting will fail
+* To post videos, stories, or reels, set the `data-media-type` attribute on the `<img>` tag to `video` or `image` (a media type of `image` will be assumed by default if left unspecified). Note that while `image` and `video` media may be interspersed throughout a carousel
 * For carousel posts, the aspect ratio of the first image determines the aspect ratio of the rest, so be mindful of how you order the images based on how you want them to appear in the app
 * Only one caption will be published, regardless of whether it's a single photo post or a carousel
 * The caption limit is 2200 characters, so feed2gram will truncate it if necessary
+* The API is pretty strict about media file formats, too, so you may wish to preprocess images and videos to avoid errors in processing:
+  * Images can't be more than 8MB and must be standard-issue JPEGs
+  * Videos are even stricter (best to just [read the docs](https://developers.facebook.com/docs/instagram-api/reference/ig-user/media#creating), including this bit on [reels](https://developers.facebook.com/docs/video-api/guides/reels-publishing)). Videos that appear in carousels seem to have additional no-longer-documented restrictions (in my testing, 9:16 videos routinely failed but 16:9, 1:1, 4:3, and 3:4 succeeded)
 
 Here's an example `<entry>` from my blog feed:
 
@@ -207,7 +212,7 @@ Look at your cache file (by default, `feed2gram.cache.yml`) and you should see
 all the Atom feed entry URLs that succeeded, failed, or were (by the `--populate-cache` option) skipped. If you don't see the error in the log, try
 removing the relevant URL from the cache and running `feed2gram` again.
 
-### What are the valid aspect ratios?
+### What are the valid aspect ratios for images?
 
 If you're seeing an embedded API error like this one:
 
@@ -216,6 +221,6 @@ The submitted image with aspect ratio ('719/194',) cannot be published. Please s
 ```
 
 It means your photo is too avant garde for a mainstream normie platform like
-Instagram. Make sure all images' aspect ratiosa re between 4:5 and 1.91:1 or
+Instagram. Make sure all images' aspect ratios are between 4:5 and 1.91:1 or
 else the post will fail.
 

data/lib/feed2gram/parses_entries.rb

@@ -2,20 +2,56 @@ require "nokogiri"
 require "open-uri"
 
 module Feed2Gram
-  Post = Struct.new(:url, :images, :caption, keyword_init: true)
+  Media = Struct.new(:media_type, :url, keyword_init: true) do
+    def video?
+      media_type == "VIDEO"
+    end
+  end
+  Post = Struct.new(:media_type, :url, :medias, :caption, keyword_init: true)
 
   class ParsesEntries
     def parse(feed_url)
       feed = Nokogiri::XML(URI.parse(feed_url).open)
       feed.xpath("//*:entry").map { |entry|
         html = Nokogiri::HTML(entry.xpath("*:content[1]").text)
+        medias = html.xpath("//figure[1]/img").map { |img|
+          Media.new(
+            media_type: (img["data-media-type"] || "image").upcase,
+            url: img["src"]
+          )
+        }
 
         Post.new(
+          media_type: determine_post_media_type(html, medias),
           url: entry.xpath("*:id[1]").text,
-          images: html.xpath("//figure[1]/img").map { |img| img["src"] },
+          medias: medias,
           caption: html.xpath("//figure[1]/figcaption").text.strip
         )
-      }.reject { |post| post.images.empty? }
+      }.select { |post|
+        if post.medias.empty?
+          warn "Skipping post with no <img> tag: #{post.url}"
+        elsif ["STORIES", "REELS"].include?(post.media_type) && post.medias.size > 1
+          warn "Skipping #{post.media_type.downcase} with more than one <img> tag (only one allowed): #{post.url}"
+        else
+          true
+        end
+      }
+    end
+
+    private
+
+    def determine_post_media_type(html, medias)
+      post_type = html.at("//figure[1]")["data-post-type"]&.upcase
+      if ["STORIES", "REELS"].include?(post_type)
+        post_type
+      elsif medias.size > 1
+        "CAROUSEL"
+      elsif medias.first.media_type == "VIDEO"
+        # The VIDEO value for media_type is deprecated outside carousel items. Use the REELS media type to publish a video to your Instagram feed. Please visit  https://developers.facebook.com/docs/instagram-api/reference/ig-user/media#creating to publish a video.
+        "REELS"
+      else
+        "IMAGE"
+      end
     end
   end
 end

data/lib/feed2gram/publishes_posts.rb

@@ -9,12 +9,12 @@ module Feed2Gram
       # reverse to post oldest first (most Atom feeds are reverse-chronological)
       posts.reverse.take(post_limit).map { |post|
         begin
-          if post.images.size == 1
-            puts "Publishing single image post for: #{post.url}" if options.verbose
-            publish_single_image(post, config)
+          if post.medias.size == 1
+            puts "Publishing #{post.media_type.downcase} for: #{post.url}" if options.verbose
+            publish_single_media(post, config, options)
           else
-            puts "Publishing carousel post for: #{post.url}" if options.verbose
-            publish_carousel(post, config)
+            puts "Publishing carousel for: #{post.url}" if options.verbose
+            publish_carousel(post, config, options)
           end
         rescue => e
           warn "Failed to post #{post.url}: #{e.message}"
@@ -25,39 +25,85 @@ module Feed2Gram
 
     private
 
-    def publish_single_image(post, config)
-      container_response = Http.post("/#{config.instagram_id}/media", {
-        image_url: post.images.first,
-        caption: post.caption,
-        access_token: config.access_token
-      })
+    def publish_single_media(post, config, options)
+      media = post.medias.first
+
+      puts "Creating media resource for URL - #{media.url}" if options.verbose
+      container_id = Http.post("/#{config.instagram_id}/media", {
+        :media_type => post.media_type,
+        :caption => post.caption,
+        :access_token => config.access_token,
+        media.video? ? :video_url : :image_url => media.url
+      }.compact)[:id]
+
+      if media.video?
+        wait_for_media_to_upload!(media.url, container_id, config, options)
+      end
+
+      puts "Publishing media for URL - #{media.url}" if options.verbose
       Http.post("/#{config.instagram_id}/media_publish", {
-        creation_id: container_response[:id],
+        creation_id: container_id,
         access_token: config.access_token
       })
       Result.new(post: post, status: :posted)
     end
 
-    def publish_carousel(post, config)
-      image_containers = post.images.take(10).map { |image|
+    def publish_carousel(post, config, options)
+      media_containers = post.medias.take(10).map { |media|
+        puts "Creating media resource for URL - #{media.url}" if options.verbose
         res = Http.post("/#{config.instagram_id}/media", {
-          is_carousel_item: true,
-          image_url: image,
-          access_token: config.access_token
-        })
+          :media_type => media.media_type,
+          :is_carousel_item => true,
+          :access_token => config.access_token,
+          media.video? ? :video_url : :image_url => media.url
+        }.compact)
         res[:id]
       }
-      carousel_container = Http.post("/#{config.instagram_id}/media", {
+      post.medias.select(&:video?).zip(media_containers).each { |media, container_id|
+        wait_for_media_to_upload!(media.url, container_id, config, options)
+      }
+
+      puts "Creating carousel media resource for post - #{post.url}" if options.verbose
+      carousel_id = Http.post("/#{config.instagram_id}/media", {
         caption: post.caption,
-        media_type: "CAROUSEL",
-        children: image_containers.join(","),
+        media_type: post.media_type,
+        children: media_containers.join(","),
         access_token: config.access_token
-      })
+      })[:id]
+      wait_for_media_to_upload!(post.url, carousel_id, config, options)
+
+      puts "Publishing carousel media for post - #{post.url}" if options.verbose
       Http.post("/#{config.instagram_id}/media_publish", {
-        creation_id: carousel_container[:id],
+        creation_id: carousel_id,
         access_token: config.access_token
       })
       Result.new(post: post, status: :posted)
     end
+
+    # Good ol' loop-and-sleep. Haven't loop do'd in a while
+    def wait_for_media_to_upload!(url, container_id, config, options)
+      wait_attempts = 0
+      loop do
+        if wait_attempts > 90
+          warn "Giving up waiting for media to upload after waiting 120 seconds: #{url}"
+          break
+        end
+
+        res = Http.get("/#{container_id}", {
+          fields: "status_code",
+          access_token: config.access_token
+        })
+        puts "Upload status #{res[:status_code]} after #{wait_attempts + 1} check for #{url}" if options.verbose
+        if res[:status_code] == "FINISHED"
+          break
+        elsif res[:status_code] == "IN_PROGRESS"
+          wait_attempts += 1
+          sleep 1
+        else
+          warn "Unexpected status code (#{res[:status_code]}) uploading: #{url}"
+          break
+        end
+      end
+    end
   end
 end

data/lib/feed2gram/version.rb

@@ -1,3 +1,3 @@
 module Feed2Gram
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/feed2gram.rb

@@ -26,12 +26,16 @@ module Feed2Gram
     entries = ParsesEntries.new.parse(config.feed_url)
     puts "Found #{entries.size} entries in feed" if options.verbose
     posts = FiltersPosts.new.filter(entries, cache)
-    results = if options.populate_cache
-      puts "Populating cache, marking #{posts.size} posts as skipped" if options.verbose
-      posts.map { |post| Result.new(post: post, status: :skipped) }
+    if posts.empty?
+      puts "No new posts to publish after filtering already-processed posts in #{options.cache_path}" if options.verbose
     else
-      PublishesPosts.new.publish(posts, config, options)
+      results = if options.populate_cache
+        puts "Populating cache, marking #{posts.size} posts as skipped" if options.verbose
+        posts.map { |post| Result.new(post: post, status: :skipped) }
+      else
+        PublishesPosts.new.publish(posts, config, options)
+      end
+      UpdatesCache.new.update!(cache, results, options)
     end
-    UpdatesCache.new.update!(cache, results, options)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: feed2gram
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-08 00:00:00.000000000 Z
+date: 2023-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -73,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.17
+rubygems_version: 3.4.21
 signing_key:
 specification_version: 4
 summary: Reads an Atom feed and posts its entries to Instagram