Liking cljdoc? Tell your friends :D

dk.simongray.podcast.feed.resolve

One answer where the vocabularies give several: the accessors that a podcast app needs.

Each reads plain keys of a feed or an item. A form with two arguments takes the feed and an item, and the item overrides or inherits what the channel declares.

One answer where the vocabularies give several: the accessors that a
podcast app needs.

Each reads plain keys of a feed or an item. A form with two arguments
takes the feed and an item, and the item overrides or inherits what the
channel declares.
raw docstring

ai-content?clj/s

(ai-content? x)
(ai-content? feed item)

Whether AI-generated content went into x, or an item of feed, by its podcast:txt with the purpose ai-content. It's nil when that doesn't tell.

An item without an answer has that of its feed.

Whether AI-generated content went into `x`, or an `item` of `feed`, by
its podcast:txt with the purpose ai-content. It's nil when that doesn't
tell.

An item without an answer has that of its feed.
sourceraw docstring

artworkclj/s

(artwork x)
(artwork feed item)

The URL of the square artwork of x, or of an item of feed, with the item's own before the feed's.

It's the largest podcast:image meant as artwork, or else the iTunes image, the Google Play image, the RSS image or a media thumbnail.

The URL of the square artwork of `x`, or of an `item` of `feed`, with
the item's own before the feed's.

It's the largest podcast:image meant as artwork, or else the iTunes
image, the Google Play image, the RSS image or a media thumbnail.
sourceraw docstring

audio?clj/s

(audio? enclosure)

Whether the enclosure is audio, or nil when nothing tells, as video? tells it.

Whether the `enclosure` is audio, or nil when nothing tells, as video?
tells it.
sourceraw docstring

authorclj/s

(author x)

Who made x, with the name picked out of an "address (Name)" field.

It's the iTunes author, the Dublin Core creator, the Google Play author, or else the RSS author or managing editor.

Who made `x`, with the name picked out of an "address (Name)" field.

It's the iTunes author, the Dublin Core creator, the Google Play author,
or else the RSS author or managing editor.
sourceraw docstring

blocked?clj/s

(blocked? x platform)

Whether x, a feed or an item, asks platform not to show it.

The platform is a keyword or one of the slugs of podcast:block, e.g. :apple, :google or :spotify. A podcast:block that names the platform decides first, then one that names none, and else the legacy itunes:block for Apple and googleplay:block for Google.

Whether `x`, a feed or an item, asks `platform` not to show it.

The platform is a keyword or one of the slugs of podcast:block, e.g.
:apple, :google or :spotify. A podcast:block that names the platform
decides first, then one that names none, and else the legacy
itunes:block for Apple and googleplay:block for Google.
sourceraw docstring

categoriesclj/s

(categories feed)

The Apple categories of feed as paths, subcategory after category, e.g.:

[["News" "Tech News"] ["Technology"]]
The Apple categories of `feed` as paths, subcategory after category,
e.g.:

    [["News" "Tech News"] ["Technology"]]
sourceraw docstring

chapters-urlclj/s

(chapters-url item)

The URL of the JSON chapters file that item links to, if any.

The URL of the JSON chapters file that `item` links to, if any.
sourceraw docstring

chatclj/s

(chat x)
(chat feed item)

The chat of x, or of an item of feed, which is the item's own or else the feed's.

The chat of `x`, or of an `item` of `feed`, which is the item's own or
else the feed's.
sourceraw docstring

complete?clj/s

(complete? feed)

Whether feed says it will publish no more episodes.

Whether `feed` says it will publish no more episodes.
sourceraw docstring

(content-links item)

The places outside the feed where the content of item can be found, e.g. a live stream or the video on a platform, in the order of the feed.

Each is a map with the :href, and the :text that tells the listener where it points, when the feed gives one.

The places outside the feed where the content of `item` can be found,
e.g. a live stream or the video on a platform, in the order of the feed.

Each is a map with the :href, and the :text that tells the listener
where it points, when the feed gives one.
sourceraw docstring

decoding-configurationclj/s

(decoding-configuration {:keys [type bitrate width height framerate channels
                                samplingrate]
                         :as enclosure})

The MediaDecodingConfiguration of the enclosure, one of those that enclosures gives, as a map in kebab-case with keyword enum values, e.g.

{:type :file :audio {:content-type "audio/mpeg" :bitrate 128000}}

It has :video for a video, and for an enclosure whose kind video? doesn't tell, and else :audio. A video has the codec of its audio, if the codecs name one, as :audio under an audio type. Each content type names one codec, of the codecs of the enclosure or of its type, and the rest is what the feed declares: the bitrate, the channels and sample rate of audio, and the width, height and frame rate of a video, which are left out unless the video has them all.

It's nil when the type says nothing of the format: there's none, or it's e.g. application/octet-stream. Such a file is almost always an MP3, so a :playable-pred of enclosure can count it as playable.

The MediaDecodingConfiguration of the `enclosure`, one of those that
enclosures gives, as a map in kebab-case with keyword enum values, e.g.

    {:type :file :audio {:content-type "audio/mpeg" :bitrate 128000}}

It has :video for a video, and for an enclosure whose kind video?
doesn't tell, and else :audio. A video has the codec of its audio, if
the codecs name one, as :audio under an audio type. Each content type
names one codec, of the codecs of the enclosure or of its type, and the
rest is what the feed declares: the bitrate, the channels and sample
rate of audio, and the width, height and frame rate of a video, which
are left out unless the video has them all.

It's nil when the type says nothing of the format: there's none, or
it's e.g. application/octet-stream. Such a file is almost always an
MP3, so a :playable-pred of enclosure can count it as playable.
sourceraw docstring

descriptionclj/s

(description x)

The fullest description of x, HTML allowed: content:encoded, then the RSS description, then the summary of iTunes or Google Play.

The fullest description of `x`, HTML allowed: content:encoded, then the
RSS description, then the summary of iTunes or Google Play.
sourceraw docstring

distinct-itemsclj/s

(distinct-items items)

The items without those that an item before them has the identity of, as guid/item-guid gives it, e.g. an episode that a feed lists twice. Items without an identity all stay.

The `items` without those that an item before them has the identity of,
as guid/item-guid gives it, e.g. an episode that a feed lists twice.
Items without an identity all stay.
sourceraw docstring

downloadable?clj/s

(downloadable? {:keys [url type transport] :as enclosure})

Whether the enclosure, one of those that enclosures gives, is one file that a request over HTTP fetches whole, rather than the playlist of a stream such as HLS, a torrent or an IPFS address.

Whether the `enclosure`, one of those that enclosures gives, is one file
that a request over HTTP fetches whole, rather than the playlist of a
stream such as HLS, a torrent or an IPFS address.
sourceraw docstring

durationclj/s

(duration item)

The duration of item in seconds, from iTunes or Media RSS, in the item or its media:group, or nil when neither gives a number.

The duration of `item` in seconds, from iTunes or Media RSS, in the item
or its media:group, or nil when neither gives a number.
sourceraw docstring

embedded-chaptersclj/s

(embedded-chapters item)

The Podlove chapters embedded in item as a chapters document, or nil.

The Podlove chapters embedded in `item` as a chapters document, or nil.
sourceraw docstring

enclosureclj/s

(enclosure item)
(enclosure item
           {:keys [languages types max-bitrate max-height playable-pred]
            prefer-video? :video?
            :or {playable-pred any?}
            :as opts})

The one thing to play for item: of all that it offers, the one that best fits the opts below, or nil when none can be played.

  • :languages, the wanted languages, most wanted first, e.g. ["da" "en"]
  • :video?, true to prefer video and false to prefer audio, for an item that offers both
  • :types, the wanted types, most wanted first, e.g. ["audio/opus" "audio/mpeg"]
  • :max-bitrate, in bits per second, e.g. 64000
  • :max-height, in pixels, e.g. 720
  • :playable-pred, a predicate of the enclosures that can be played, e.g. audio? for audio alone

The languages count first, where a candidate that names none ranks after the matches and before the mismatches. The kind that :video? prefers counts next, where a candidate whose kind isn't told counts as a video, since most such candidates are HLS streams of video. Then come the types, then the bitrate and the height, where a candidate above the :max-bitrate or the :max-height ranks last. Among equals, the enclosure comes first, then the default alternate, then the rest, the most conventional first.

The one thing to play for `item`: of all that it offers, the one that
best fits the `opts` below, or nil when none can be played.

- :languages, the wanted languages, most wanted first, e.g. ["da" "en"]
- :video?, true to prefer video and false to prefer audio, for an item
  that offers both
- :types, the wanted types, most wanted first, e.g.
  ["audio/opus" "audio/mpeg"]
- :max-bitrate, in bits per second, e.g. 64000
- :max-height, in pixels, e.g. 720
- :playable-pred, a predicate of the enclosures that can be played,
  e.g. audio? for audio alone

The languages count first, where a candidate that names none ranks after
the matches and before the mismatches. The kind that :video? prefers
counts next, where a candidate whose kind isn't told counts as a video,
since most such candidates are HLS streams of video. Then come the
types, then the bitrate and the height, where a candidate above the
:max-bitrate or the :max-height ranks last. Among equals, the enclosure
comes first, then the default alternate, then the rest, the most
conventional first.
sourceraw docstring

enclosuresclj/s

(enclosures item)

All that item offers to play, the most conventional first.

The enclosure comes first, then each source of an alternateEnclosure, then the Media RSS contents of the item and of its media:group that aren't images, documents or executables, e.g. the picture of a blog post. Each is a map with the :url and the :source, which is :enclosure, :alternate or :media.

It has what else the feed declares, e.g. the :type, :length, :bitrate in bits per second, :title and :default. An alternate also has its :integrity, and the contentType of its source as :transport, e.g. application/x-bittorrent for a torrent.

All that `item` offers to play, the most conventional first.

The enclosure comes first, then each source of an alternateEnclosure,
then the Media RSS contents of the item and of its media:group that
aren't images, documents or executables, e.g. the picture of a blog
post. Each is a map with the :url and the :source, which is :enclosure,
:alternate or :media.

It has what else the feed declares, e.g. the :type, :length, :bitrate
in bits per second, :title and :default. An alternate also has its
:integrity, and the contentType of its source as :transport, e.g.
application/x-bittorrent for a torrent.
sourceraw docstring

episodesclj/s

(episodes feed)

The items of feed in listening order, as Apple Podcasts presents them, each once, as distinct-items keeps them.

An episodic show, the default, has the newest first, with the trailers ahead. A serial show, as itunes:type says, goes season by season and episode by episode from the first. The trailer of a season comes at its head, and a bonus right after the episode that it belongs to, or at the end of its season. A trailer of the show comes before everything, and a bonus of the show after.

The items of `feed` in listening order, as Apple Podcasts presents them,
each once, as distinct-items keeps them.

An episodic show, the default, has the newest first, with the trailers
ahead. A serial show, as itunes:type says, goes season by season and
episode by episode from the first. The trailer of a season comes at its
head, and a bonus right after the episode that it belongs to, or at the
end of its season. A trailer of the show comes before everything, and a
bonus of the show after.
sourceraw docstring

explicit?clj/s

(explicit? x)
(explicit? feed item)

Whether x, or an item of feed, is marked explicit, or nil when that's unstated.

The iTunes flag comes first, and then the yes, no or clean of Google Play. An item without a flag has that of its feed.

Whether `x`, or an `item` of `feed`, is marked explicit, or nil when
that's unstated.

The iTunes flag comes first, and then the yes, no or clean of Google
Play. An item without a flag has that of its feed.
sourceraw docstring

fundingclj/s

(funding x)
(funding feed item)

The funding links of x, or of an item of feed, which are the item's own or else the feed's.

The funding links of `x`, or of an `item` of `feed`, which are the
item's own or else the feed's.
sourceraw docstring

hubsclj/s

(hubs feed)

The URLs of the WebSub hubs of feed, from its atom:links with rel=hub, in the order of the feed.

The URLs of the WebSub hubs of `feed`, from its atom:links with
rel=hub, in the order of the feed.
sourceraw docstring

imagesclj/s

(images x)

Every image that x offers, the newest vocabulary first.

Each is a map with the :href and the :source, one of :podcast, :itunes, :googleplay, :rss and :media. A podcast:image also has its :purpose, a set of tokens, which is empty when none is declared. The :width, :height, :aspect-ratio, :alt and :type are there when declared, e.g. video/mp4 for a video.

Every image that `x` offers, the newest vocabulary first.

Each is a map with the :href and the :source, one of :podcast, :itunes,
:googleplay, :rss and :media. A podcast:image also has its :purpose, a
set of tokens, which is empty when none is declared. The :width,
:height, :aspect-ratio, :alt and :type are there when declared, e.g.
video/mp4 for a video.
sourceraw docstring

inferred-chaptersclj/s

(inferred-chapters item)

The chapters listed as timestamps in the show notes of item, as a chapters document, or nil. They're what to fall back on when the item has no other chapters.

The chapters listed as timestamps in the show notes of `item`, as a
chapters document, or nil. They're what to fall back on when the item
has no other chapters.
sourceraw docstring

licenseclj/s

(license x)
(license feed item)

The license of x, or of an item of feed, which is the item's own or else the feed's.

The license of `x`, or of an `item` of `feed`, which is the item's own
or else the feed's.
sourceraw docstring

(link x)

The web page of x: its link, or its guid when that's a permalink.

The web page of `x`: its link, or its guid when that's a permalink.
sourceraw docstring

list-feed?clj/s

(list-feed? feed)

Whether feed is a list of remote items rather than of its own: a medium that ends in L, or mixed.

Whether `feed` is a list of remote items rather than of its own: a
medium that ends in L, or mixed.
sourceraw docstring

listening-keyclj/s

(listening-key feed item)

Where item falls in the listening order of feed, as a key for sort-by.

Where `item` falls in the listening order of `feed`, as a key for
sort-by.
sourceraw docstring

live-itemsclj/s

(live-items feed)

The live items of feed: on air first, then upcoming, the soonest first, then ended, the most recent first.

The live items of `feed`: on air first, then upcoming, the soonest
first, then ended, the most recent first.
sourceraw docstring

live?clj/s

(live? {:keys [status start end] :as live-item} at)

Whether the live-item is on air at at: its status says so, or the time falls between its start and end, and it hasn't been declared ended.

Whether the `live-item` is on air at `at`: its status says so, or the
time falls between its start and end, and it hasn't been declared ended.
sourceraw docstring

locationsclj/s

(locations x)
(locations feed item)

The locations of x, or of an item of feed, which are the item's own or else the feed's.

The locations of `x`, or of an `item` of `feed`, which are the item's
own or else the feed's.
sourceraw docstring

locked?clj/s

(locked? feed)

Whether feed forbids other platforms to import it.

Whether `feed` forbids other platforms to import it.
sourceraw docstring

media-kindsclj/s

(media-kinds item)

The kinds of media that item offers, a set of :audio and :video, from those of its enclosures whose kind is told.

The kinds of media that `item` offers, a set of :audio and :video, from
those of its enclosures whose kind is told.
sourceraw docstring

mediumclj/s

(medium feed)

What the content of feed is, in lower case, or "podcast" when that's unstated.

What the content of `feed` is, in lower case, or "podcast" when that's
unstated.
sourceraw docstring

new-feed-urlclj/s

(new-feed-url feed)
(new-feed-url feed urls)

Where feed says that it has moved to, if anywhere, judged by the urls that it was fetched from.

A feed that names itself, by its self link or by one of the urls, hasn't moved, as every feed of Podbean and Substack names itself.

Where `feed` says that it has moved to, if anywhere, judged by the
`urls` that it was fetched from.

A feed that names itself, by its self link or by one of the `urls`,
hasn't moved, as every feed of Podbean and Substack names itself.
sourceraw docstring

next-pageclj/s

(next-page feed)

The URL of the page with the older items of feed, when the feed comes in pages as RFC 5005, sections 3 and 4, defines them.

It's the atom:link rel=next of a paged feed, or else the rel=prev-archive of an archived feed. It's as the feed writes it, so it can be relative to the URL of the page.

The URL of the page with the older items of `feed`, when the feed comes
in pages as RFC 5005, sections 3 and 4, defines them.

It's the atom:link rel=next of a paged feed, or else the
rel=prev-archive of an archived feed. It's as the feed writes it, so it
can be relative to the URL of the page.
sourceraw docstring

notes-urlclj/s

(notes-url base s)

The URL s of a link or an image in show notes, as a listener can follow it from base, the web page of the show or the episode, or nil.

An absolute URL stays as it is. A URL that starts with a domain, such as example.com/page, or with //, gets https in front, and any other is made absolute against base.

The URL `s` of a link or an image in show notes, as a listener can
follow it from `base`, the web page of the show or the episode, or nil.

An absolute URL stays as it is. A URL that starts with a domain, such as
example.com/page, or with //, gets https in front, and any other is made
absolute against `base`.
sourceraw docstring

numberingclj/s

(numbering item)

The season and episode of item, from the podcast namespace first and iTunes second, e.g.:

{:type "full" :season 2 :season-name "…" :episode 3
 :episode-display "Ch.3"}

The :type is always there, and the rest as declared. A number that didn't read in one namespace leaves the other to answer.

The season and episode of `item`, from the podcast namespace first and
iTunes second, e.g.:

    {:type "full" :season 2 :season-name "…" :episode 3
     :episode-display "Ch.3"}

The :type is always there, and the rest as declared. A number that
didn't read in one namespace leaves the other to answer.
sourceraw docstring

peopleclj/s

(people x)
(people feed item)

The people credited on x, or on an item of feed, as maps of :name, :role, :group, :img and :href.

The roles and groups are in lower case, with the defaults of podcast:person filled in. The people of an item replace those of its feed entirely when the item names any, as podcast:person says.

The people credited on `x`, or on an `item` of `feed`, as maps of :name,
:role, :group, :img and :href.

The roles and groups are in lower case, with the defaults of
podcast:person filled in. The people of an item replace those of its
feed entirely when the item names any, as podcast:person says.
sourceraw docstring

podrollclj/s

(podroll feed)

The shows that feed recommends, from its podcast:podroll, in the order of the feed.

Each is a remote item with the :feed-guid, and the :feed-url and :title when the feed declares them. An item that names no guid and no URL is left out. Where the guid and the URL lead to different feeds, the guid wins, since a guid outlives a URL.

The shows that `feed` recommends, from its podcast:podroll, in the order
of the feed.

Each is a remote item with the :feed-guid, and the :feed-url and :title
when the feed declares them. An item that names no guid and no URL is
left out. Where the guid and the URL lead to different feeds, the guid
wins, since a guid outlives a URL.
sourceraw docstring

posterclj/s

(poster x)
(poster feed item)

The URL of the poster of x, or of an item of feed, with the item's own before the feed's: the picture that a player shows before a video plays, or nil.

It's the largest podcast:image whose purpose is poster.

The URL of the poster of `x`, or of an `item` of `feed`, with the item's
own before the feed's: the picture that a player shows before a video
plays, or nil.

It's the largest podcast:image whose purpose is poster.
sourceraw docstring

propertiesclj/s

(properties feed)
(properties feed item)

Every property that the accessors answer for feed, or for its item, as one map with plain keys, without those that have no answer.

For a feed alone, the properties are those of the show, :title to :categories. For a feed and an item, they're those of the episode, inheriting from the feed as each accessor does. What needs a time or a platform is left out, e.g. the next check.

(merge item (properties feed item))
;; => {:rss/title "…" :title "…" :artwork "…" …}

A map merged like this is for reading, since writing it as a feed would take its plain keys with string values as attributes.

Every property that the accessors answer for `feed`, or for its `item`,
as one map with plain keys, without those that have no answer.

For a feed alone, the properties are those of the show, :title to
:categories. For a feed and an item, they're those of the episode,
inheriting from the feed as each accessor does. What needs a time or a
platform is left out, e.g. the next check.

    (merge item (properties feed item))
    ;; => {:rss/title "…" :title "…" :artwork "…" …}

A map merged like this is for reading, since writing it as a feed would
take its plain keys with string values as attributes.
sourceraw docstring

publishedclj/s

(published x)

When x was published, as an instant, or nil when it gave no readable date.

When `x` was published, as an instant, or nil when it gave no readable
date.
sourceraw docstring

publisherclj/s

(publisher feed)

The publisher feed of feed, as a remote item, or nil when no remote item names a guid or a URL.

The remote item has the :feed-guid, and the :feed-url and :title when the feed declares them. It's the remote item of the podcast:publisher of the feed. Some feeds write the publisher without that element, as a remote item of the channel with the medium publisher. Such an item is the answer when the feed has no podcast:publisher, and is neither a list feed nor a publisher feed.

The podcast namespace, in The Publisher Medium, asks for links both ways, so an app trusts the link only when the remote items of the publisher feed list feed.

The publisher feed of `feed`, as a remote item, or nil when no remote
item names a guid or a URL.

The remote item has the :feed-guid, and the :feed-url and :title when
the feed declares them. It's the remote item of the podcast:publisher of
the feed. Some feeds write the publisher without that element, as a
remote item of the channel with the medium publisher. Such an item is
the answer when the feed has no podcast:publisher, and is neither a list
feed nor a publisher feed.

The podcast namespace, in The Publisher Medium, asks for links both
ways, so an app trusts the link only when the remote items of the
publisher feed list `feed`.
sourceraw docstring

remote-itemsclj/s

(remote-items feed)

The remote items of the channel of feed, in the order of the feed.

They're the entries of a list feed, most often items of other feeds, or the shows of a publisher feed. Each is a map with the :feed-guid, and the :feed-url, :item-guid, :title and :medium when the feed declares them. An item that names no guid and no URL is left out.

The remote items of the channel of `feed`, in the order of the feed.

They're the entries of a list feed, most often items of other feeds, or
the shows of a publisher feed. Each is a map with the :feed-guid, and
the :feed-url, :item-guid, :title and :medium when the feed declares
them. An item that names no guid and no URL is left out.
sourceraw docstring

seasonsclj/s

(seasons feed)

The items of feed grouped by season, in listening order:

({:season 2 :name "The Sequel" :items [...]} ...)

Seasons come in the order that listening reaches them, so newest first for an episodic show, and ascending for a serial one. Items without a season form a group without one, where their first item falls.

The items of `feed` grouped by season, in listening order:

    ({:season 2 :name "The Sequel" :items [...]} ...)

Seasons come in the order that listening reaches them, so newest first
for an episodic show, and ascending for a serial one. Items without a
season form a group without one, where their first item falls.
sourceraw docstring

self-urlclj/s

(self-url feed)

The canonical URL of feed, from its atom:link rel=self.

The canonical URL of `feed`, from its atom:link rel=self.
sourceraw docstring

social-interactsclj/s

(social-interacts x)
(social-interacts feed item)

Where the public comments on x, or on an item of feed, are: the root posts of the threads that its podcast:socialInteract elements name.

Each is a map with the :protocol in lower case and the :uri, and the :account-id, :account-url and :priority when the feed declares them. The lowest priority number comes first, and those without a priority come last.

When one of them has the protocol "disabled", the podcaster wants no public comments shown, and the answer is [{:protocol "disabled"}]. An item without an answer has that of its feed.

Where the public comments on `x`, or on an `item` of `feed`, are: the
root posts of the threads that its podcast:socialInteract elements name.

Each is a map with the :protocol in lower case and the :uri, and the
:account-id, :account-url and :priority when the feed declares them. The
lowest priority number comes first, and those without a priority come
last.

When one of them has the protocol "disabled", the podcaster wants no
public comments shown, and the answer is [{:protocol "disabled"}]. An
item without an answer has that of its feed.
sourceraw docstring

soundbitesclj/s

(soundbites item)

The soundbites of item in the order of the feed, the parts that its creator selected to preview or share it.

A soundbite is a map with the :start-time and :duration in seconds, and the :title when it has one. The podcast namespace leaves the title of a soundbite without one to the app, e.g. the title of the item. A soundbite is left out when it has no start of zero seconds or more, or no duration above zero.

The soundbites of `item` in the order of the feed, the parts that its
creator selected to preview or share it.

A soundbite is a map with the :start-time and :duration in seconds, and
the :title when it has one. The podcast namespace leaves the title of a
soundbite without one to the app, e.g. the title of the item. A
soundbite is left out when it has no start of zero seconds or more, or
no duration above zero.
sourceraw docstring

sourcesclj/s

(sources feed)
(sources feed item)

Where the properties of feed, or of its item, were read from.

For each property that the accessors answer, it's the paths whose value alone gives the same answer, e.g. [:rss/title] for a show, and [:item :rss/title] or [:feed :itunes/explicit] for an episode. Several paths mean that several fields agree. A property put together from more than one field, or answered by a default, is left out.

Where the properties of `feed`, or of its `item`, were read from.

For each property that the accessors answer, it's the paths whose value
alone gives the same answer, e.g. [:rss/title] for a show, and
[:item :rss/title] or [:feed :itunes/explicit] for an episode. Several
paths mean that several fields agree. A property put together from more
than one field, or answered by a default, is left out.
sourceraw docstring

titleclj/s

(title x)

The title of x: the RSS title, or else the iTunes one.

The title of `x`: the RSS title, or else the iTunes one.
sourceraw docstring

transcriptclj/s

(transcript item)
(transcript feed item)
(transcript
  feed
  item
  {:keys [types languages timed?] :or {types transcript-preference} :as opts})

The transcript reference of item that an app is best served by, given the feed, which can be nil, and the opts below. It's one of those that transcripts gives.

  • :types, the wanted types, by default WebVTT, SRT, JSON, HTML and plain text
  • :languages, the wanted languages, most wanted first, e.g. ["da" "en"]
  • :timed?, whether to prefer rel=captions or a timed type

The language counts first, the timings second, and the type third. A reference that names no language counts as in the feed's language. Without a feed, it ranks after the matches and before the mismatches. The result is never nil when the item has transcripts.

The transcript reference of `item` that an app is best served by, given
the `feed`, which can be nil, and the `opts` below. It's one of those
that transcripts gives.

- :types, the wanted types, by default WebVTT, SRT, JSON, HTML and plain
  text
- :languages, the wanted languages, most wanted first, e.g. ["da" "en"]
- :timed?, whether to prefer rel=captions or a timed type

The language counts first, the timings second, and the type third. A
reference that names no language counts as in the feed's language. Without
a feed, it ranks after the matches and before the mismatches. The result
is never nil when the item has transcripts.
sourceraw docstring

transcriptsclj/s

(transcripts item)

Every transcript and caption file that item links to: those of the podcast namespace, then the Media RSS subtitles of its media contents, its media:group and the item itself.

A Media RSS subtitle is a map of the :url, the :type and :language when declared, the :rel captions, since it's a subtitle or caption file, and the :source :media.

Every transcript and caption file that `item` links to: those of the
podcast namespace, then the Media RSS subtitles of its media contents,
its media:group and the item itself.

A Media RSS subtitle is a map of the :url, the :type and :language when
declared, the :rel captions, since it's a subtitle or caption file, and
the :source :media.
sourceraw docstring

txtclj/s

(txt x)

The free-form texts of x by purpose, from podcast:txt, e.g.:

{"applepodcastsverify" ["05124"] nil ["abc"]}

Each purpose is in lower case, and the texts that name no purpose are under nil. An item doesn't inherit the texts of its feed.

The free-form texts of `x` by purpose, from podcast:txt, e.g.:

    {"applepodcastsverify" ["05124"] nil ["abc"]}

Each purpose is in lower case, and the texts that name no purpose are
under nil. An item doesn't inherit the texts of its feed.
sourceraw docstring

valueclj/s

(value x)
(value feed item)
(value feed item type)

The value block of x, or the one that applies to an item of feed, which is the item's own when it declares one. With type, only blocks of that type count, e.g. "lightning".

The value block of `x`, or the one that applies to an `item` of `feed`,
which is the item's own when it declares one. With `type`, only blocks
of that type count, e.g. "lightning".
sourceraw docstring

video?clj/s

(video? {:keys [medium type codecs height]})

Whether the enclosure is a video, or nil when nothing tells.

The enclosure is one of those that enclosures gives, or any map of the same keys, e.g. a variant of an HLS stream or what format.media reads of a file. Its Media RSS medium tells first, then an audio or video type, then the codecs, and then a height above 0, which only a video has. A stream such as HLS often tells nothing.

Whether the `enclosure` is a video, or nil when nothing tells.

The `enclosure` is one of those that enclosures gives, or any map of
the same keys, e.g. a variant of an HLS stream or what format.media
reads of a file. Its Media RSS medium tells first, then an audio or
video type, then the codecs, and then a height above 0, which only a
video has. A stream such as HLS often tells nothing.
sourceraw docstring

cljdoc builds & hosts documentation for Clojure/Script libraries

Keyboard shortcuts
Ctrl+kJump to recent docs
←Move to previous article
→Move to next article
Ctrl+/Jump to the search field
× close