nitter/src/parser.nim

418 lines
13 KiB
Nim
Raw Normal View History

2021-12-27 01:37:38 +00:00
# SPDX-License-Identifier: AGPL-3.0-only
import strutils, options, tables, times, math
import packedjson, packedjson/deserialiser
import types, parserutils, utils
import experimental/parser/unifiedcard
2020-06-01 00:16:24 +00:00
proc parseUser(js: JsonNode; id=""): User =
if js.isNull: return
result = User(
2020-06-01 00:16:24 +00:00
id: if id.len > 0: id else: js{"id_str"}.getStr,
username: js{"screen_name"}.getStr,
fullname: js{"name"}.getStr,
location: js{"location"}.getStr,
bio: js{"description"}.getStr,
2022-01-06 02:57:14 +00:00
userPic: js{"profile_image_url_https"}.getImageStr.replace("_normal", ""),
2020-06-01 00:16:24 +00:00
banner: js.getBanner,
following: js{"friends_count"}.getInt,
followers: js{"followers_count"}.getInt,
tweets: js{"statuses_count"}.getInt,
likes: js{"favourites_count"}.getInt,
media: js{"media_count"}.getInt,
2020-06-01 00:16:24 +00:00
verified: js{"verified"}.getBool,
protected: js{"protected"}.getBool,
joinDate: js{"created_at"}.getTime
)
result.expandUserEntities(js)
2020-06-01 00:16:24 +00:00
proc parseGraphList*(js: JsonNode): List =
if js.isNull: return
2020-06-01 00:16:24 +00:00
var list = js{"data", "user_by_screen_name", "list"}
if list.isNull:
2020-06-01 00:16:24 +00:00
list = js{"data", "list"}
if list.isNull:
2020-06-01 00:16:24 +00:00
return
result = List(
id: list{"id_str"}.getStr,
2021-10-02 08:13:56 +00:00
name: list{"name"}.getStr,
2020-06-01 00:16:24 +00:00
username: list{"user", "legacy", "screen_name"}.getStr,
2021-12-15 14:46:33 +00:00
userId: list{"user", "rest_id"}.getStr,
2020-06-01 00:16:24 +00:00
description: list{"description"}.getStr,
members: list{"member_count"}.getInt,
banner: list{"custom_banner_media", "media_info", "url"}.getImageStr
2020-06-01 00:16:24 +00:00
)
proc parsePoll(js: JsonNode): Poll =
let vals = js{"binding_values"}
# name format is pollNchoice_*
for i in '1' .. js{"name"}.getStr[4]:
let choice = "choice" & i
result.values.add parseInt(vals{choice & "_count"}.getStrVal("0"))
result.options.add vals{choice & "_label"}.getStrVal
let time = vals{"end_datetime_utc", "string_value"}.getDateTime
2021-12-20 02:11:12 +00:00
if time > now():
let timeLeft = $(time - now())
2020-06-01 00:16:24 +00:00
result.status = timeLeft[0 ..< timeLeft.find(",")]
else:
result.status = "Final results"
result.leader = result.values.find(max(result.values))
result.votes = result.values.sum
proc parseGif(js: JsonNode): Gif =
result = Gif(
url: js{"video_info", "variants"}[0]{"url"}.getImageStr,
thumb: js{"media_url_https"}.getImageStr
2020-06-01 00:16:24 +00:00
)
proc parseVideo(js: JsonNode): Video =
result = Video(
thumb: js{"media_url_https"}.getImageStr,
2020-06-01 00:16:24 +00:00
views: js{"ext", "mediaStats", "r", "ok", "viewCount"}.getStr,
available: js{"ext_media_availability", "status"}.getStr == "available",
title: js{"ext_alt_text"}.getStr,
2022-01-02 09:58:02 +00:00
durationMs: js{"video_info", "duration_millis"}.getInt
2020-11-07 21:48:30 +00:00
# playbackType: mp4
2020-06-01 00:16:24 +00:00
)
2020-06-10 15:09:38 +00:00
with title, js{"additional_media_info", "title"}:
result.title = title.getStr
with description, js{"additional_media_info", "description"}:
result.description = description.getStr
2020-06-01 00:16:24 +00:00
for v in js{"video_info", "variants"}:
let
contentType = parseEnum[VideoType](v{"content_type"}.getStr("summary"))
url = v{"url"}.getStr
2022-06-03 23:16:37 +00:00
2020-06-01 00:16:24 +00:00
result.variants.add VideoVariant(
contentType: contentType,
2020-06-01 00:16:24 +00:00
bitrate: v{"bitrate"}.getInt,
url: url,
2022-06-03 23:16:37 +00:00
resolution: if contentType == mp4: getMp4Resolution(url) else: 0
2020-06-01 00:16:24 +00:00
)
proc parsePromoVideo(js: JsonNode): Video =
result = Video(
thumb: js{"player_image_large"}.getImageVal,
2020-06-01 00:16:24 +00:00
available: true,
durationMs: js{"content_duration_seconds"}.getStrVal("0").parseInt * 1000,
playbackType: vmap
2020-06-01 00:16:24 +00:00
)
var variant = VideoVariant(
contentType: vmap,
url: js{"player_hls_url"}.getStrVal(js{"player_stream_url"}.getStrVal(
js{"amplify_url_vmap"}.getStrVal()))
2020-06-01 00:16:24 +00:00
)
if "m3u8" in variant.url:
variant.contentType = m3u8
result.playbackType = m3u8
2020-06-01 00:16:24 +00:00
result.variants.add variant
proc parseBroadcast(js: JsonNode): Card =
let image = js{"broadcast_thumbnail_large"}.getImageVal
2020-06-01 00:16:24 +00:00
result = Card(
kind: broadcast,
url: js{"broadcast_url"}.getStrVal,
title: js{"broadcaster_display_name"}.getStrVal,
text: js{"broadcast_title"}.getStrVal,
image: image,
video: some Video(thumb: image)
2020-06-01 00:16:24 +00:00
)
proc parseCard(js: JsonNode; urls: JsonNode): Card =
const imageTypes = ["summary_photo_image", "player_image", "promo_image",
"photo_image_full_size", "thumbnail_image", "thumbnail",
2020-06-10 14:13:40 +00:00
"event_thumbnail", "image"]
2020-06-01 00:16:24 +00:00
let
vals = ? js{"binding_values"}
name = js{"name"}.getStr
kind = parseEnum[CardKind](name[(name.find(":") + 1) ..< name.len], unknown)
2020-06-01 00:16:24 +00:00
if kind == unified:
return parseUnifiedCard(vals{"unified_card", "string_value"}.getStr)
2020-06-01 00:16:24 +00:00
result = Card(
kind: kind,
url: vals.getCardUrl(kind),
dest: vals.getCardDomain(kind),
title: vals.getCardTitle(kind),
text: vals{"description"}.getStrVal
)
if result.url.len == 0:
result.url = js{"url"}.getStr
case kind
2020-06-10 14:13:40 +00:00
of promoVideo, promoVideoConvo, appPlayer, videoDirectMessage:
2020-06-01 00:16:24 +00:00
result.video = some parsePromoVideo(vals)
if kind == appPlayer:
result.text = vals{"app_category"}.getStrVal(result.text)
2020-06-01 00:16:24 +00:00
of broadcast:
result = parseBroadcast(vals)
of liveEvent:
result.text = vals{"event_title"}.getStrVal
2020-06-01 00:16:24 +00:00
of player:
result.url = vals{"player_url"}.getStrVal
if "youtube.com" in result.url:
result.url = result.url.replace("/embed/", "/watch?v=")
of audiospace, unknown:
result.title = "This card type is not supported."
2020-06-01 00:16:24 +00:00
else: discard
for typ in imageTypes:
with img, vals{typ & "_large"}:
result.image = img.getImageVal
2020-06-01 00:16:24 +00:00
break
for u in ? urls:
if u{"url"}.getStr == result.url:
result.url = u{"expanded_url"}.getStr
break
2020-06-10 14:13:40 +00:00
if kind in {videoDirectMessage, imageDirectMessage}:
result.url.setLen 0
if kind in {promoImageConvo, promoImageApp, imageDirectMessage} and
result.url.len == 0 or result.url.startsWith("card://"):
result.url = getPicUrl(result.image)
2020-06-01 00:16:24 +00:00
proc parseTweet(js: JsonNode): Tweet =
if js.isNull: return
2020-06-01 00:16:24 +00:00
result = Tweet(
id: js{"id_str"}.getId,
threadId: js{"conversation_id_str"}.getId,
replyId: js{"in_reply_to_status_id_str"}.getId,
text: js{"full_text"}.getStr,
time: js{"created_at"}.getTime,
2022-02-27 00:02:34 +00:00
source: getSource(js),
hasThread: js{"self_thread"}.notNull,
2020-06-01 00:16:24 +00:00
available: true,
user: User(id: js{"user_id_str"}.getStr),
2020-06-01 00:16:24 +00:00
stats: TweetStats(
replies: js{"reply_count"}.getInt,
retweets: js{"retweet_count"}.getInt,
likes: js{"favorite_count"}.getInt,
quotes: js{"quote_count"}.getInt
2020-06-01 00:16:24 +00:00
)
)
result.expandTweetEntities(js)
if js{"is_quote_status"}.getBool:
result.quote = some Tweet(id: js{"quoted_status_id_str"}.getId)
with rt, js{"retweeted_status_id_str"}:
result.retweet = some Tweet(id: rt.getId)
return
with jsCard, js{"card"}:
let name = jsCard{"name"}.getStr
if "poll" in name:
if "image" in name:
result.photos.add jsCard{"binding_values", "image_large"}.getImageVal
2020-06-01 00:16:24 +00:00
result.poll = some parsePoll(jsCard)
elif name == "amplify":
result.video = some(parsePromoVideo(jsCard{"binding_values"}))
2020-06-01 00:16:24 +00:00
else:
result.card = some parseCard(jsCard, js{"entities", "urls"})
with jsMedia, js{"extended_entities", "media"}:
for m in jsMedia:
case m{"type"}.getStr
of "photo":
result.photos.add m{"media_url_https"}.getImageStr
2020-06-01 00:16:24 +00:00
of "video":
result.video = some(parseVideo(m))
2020-06-10 15:05:55 +00:00
with user, m{"additional_media_info", "source_user"}:
result.attribution = some(parseUser(user))
2020-06-01 00:16:24 +00:00
of "animated_gif":
result.gif = some(parseGif(m))
else: discard
2021-12-26 05:48:55 +00:00
with jsWithheld, js{"withheld_in_countries"}:
2021-12-29 05:41:00 +00:00
let withheldInCountries: seq[string] =
if jsWithheld.kind != JArray: @[]
else: jsWithheld.to(seq[string])
2021-12-26 05:48:55 +00:00
# XX - Content is withheld in all countries
# XY - Content is withheld due to a DMCA request.
if js{"withheld_copyright"}.getBool or
withheldInCountries.len > 0 and ("XX" in withheldInCountries or
"XY" in withheldInCountries or
"withheld" in result.text):
2021-12-29 05:41:00 +00:00
result.text.removeSuffix(" Learn more.")
2021-12-26 05:48:55 +00:00
result.available = false
2020-06-01 00:16:24 +00:00
proc finalizeTweet(global: GlobalObjects; id: string): Tweet =
2020-06-04 03:03:25 +00:00
let intId = if id.len > 0: parseBiggestInt(id) else: 0
2020-06-01 00:16:24 +00:00
result = global.tweets.getOrDefault(id, Tweet(id: intId))
if result.quote.isSome:
let quote = get(result.quote).id
if $quote in global.tweets:
result.quote = some global.tweets[$quote]
else:
result.quote = some Tweet()
if result.retweet.isSome:
let rt = get(result.retweet).id
if $rt in global.tweets:
result.retweet = some finalizeTweet(global, $rt)
else:
result.retweet = some Tweet()
proc parsePin(js: JsonNode; global: GlobalObjects): Tweet =
let pin = js{"pinEntry", "entry", "entryId"}.getStr
if pin.len == 0: return
let id = pin.getId
if id notin global.tweets: return
global.tweets[id].pinned = true
return finalizeTweet(global, id)
proc parseGlobalObjects(js: JsonNode): GlobalObjects =
result = GlobalObjects()
let
tweets = ? js{"globalObjects", "tweets"}
users = ? js{"globalObjects", "users"}
for k, v in users:
result.users[k] = parseUser(v, k)
2020-06-01 00:16:24 +00:00
for k, v in tweets:
var tweet = parseTweet(v)
if tweet.user.id in result.users:
tweet.user = result.users[tweet.user.id]
2020-06-01 00:16:24 +00:00
result.tweets[k] = tweet
proc parseThread(js: JsonNode; global: GlobalObjects): tuple[thread: Chain, self: bool] =
result.thread = Chain()
let thread = js{"content", "item", "content", "conversationThread"}
with cursor, thread{"showMoreCursor"}:
result.thread.cursor = cursor{"value"}.getStr
result.thread.hasMore = true
for t in thread{"conversationComponents"}:
let content = t{"conversationTweetComponent", "tweet"}
if content{"displayType"}.getStr == "SelfThread":
2020-06-01 00:16:24 +00:00
result.self = true
var tweet = finalizeTweet(global, content{"id"}.getStr)
if not tweet.available:
tweet.tombstone = getTombstone(content{"tombstone"})
result.thread.content.add tweet
2020-06-01 00:16:24 +00:00
proc parseConversation*(js: JsonNode; tweetId: string): Conversation =
result = Conversation(replies: Result[Chain](beginning: true))
let global = parseGlobalObjects(? js)
let instructions = ? js{"timeline", "instructions"}
if instructions.len == 0:
return
2020-06-01 00:16:24 +00:00
for e in instructions[0]{"addEntries", "entries"}:
let entry = e{"entryId"}.getStr
2020-11-07 21:48:49 +00:00
if "tweet" in entry or "tombstone" in entry:
let tweet = finalizeTweet(global, e.getEntryId)
2020-06-01 00:16:24 +00:00
if $tweet.id != tweetId:
result.before.content.add tweet
else:
result.tweet = tweet
elif "conversationThread" in entry:
let (thread, self) = parseThread(e, global)
if thread.content.len > 0:
if self:
result.after = thread
else:
result.replies.content.add thread
elif "cursor-showMore" in entry:
result.replies.bottom = e.getCursor
elif "cursor-bottom" in entry:
result.replies.bottom = e.getCursor
2022-01-23 06:45:01 +00:00
proc parseStatus*(js: JsonNode): Tweet =
with e, js{"errors"}:
if e.getError == tweetNotFound:
return
2022-01-23 06:45:01 +00:00
result = parseTweet(js)
if not result.isNil:
result.user = parseUser(js{"user"})
2022-01-23 09:15:54 +00:00
with quote, js{"quoted_status"}:
result.quote = some parseStatus(js{"quoted_status"})
2020-06-07 05:53:40 +00:00
proc parseInstructions[T](res: var Result[T]; global: GlobalObjects; js: JsonNode) =
if js.kind != JArray or js.len == 0:
return
for i in js:
when T is Tweet:
if res.beginning and i{"pinEntry"}.notNull:
with pin, parsePin(i, global):
res.content.add pin
with r, i{"replaceEntry", "entry"}:
if "top" in r{"entryId"}.getStr:
res.top = r.getCursor
elif "bottom" in r{"entryId"}.getStr:
res.bottom = r.getCursor
2020-06-01 00:16:24 +00:00
proc parseTimeline*(js: JsonNode; after=""): Timeline =
result = Timeline(beginning: after.len == 0)
let global = parseGlobalObjects(? js)
let instructions = ? js{"timeline", "instructions"}
if instructions.len == 0: return
2020-06-07 05:53:40 +00:00
result.parseInstructions(global, instructions)
2020-06-01 00:16:24 +00:00
2022-02-07 20:58:06 +00:00
var entries: JsonNode
for i in instructions:
if "addEntries" in i:
entries = i{"addEntries", "entries"}
for e in ? entries:
2020-06-01 00:16:24 +00:00
let entry = e{"entryId"}.getStr
if "tweet" in entry or entry.startsWith("sq-I-t") or "tombstone" in entry:
2020-11-07 21:48:49 +00:00
let tweet = finalizeTweet(global, e.getEntryId)
2020-06-01 00:16:24 +00:00
if not tweet.available: continue
result.content.add tweet
elif "cursor-top" in entry:
result.top = e.getCursor
elif "cursor-bottom" in entry:
result.bottom = e.getCursor
elif entry.startsWith("sq-C"):
with cursor, e{"content", "operation", "cursor"}:
if cursor{"cursorType"}.getStr == "Bottom":
result.bottom = cursor{"value"}.getStr
else:
result.top = cursor{"value"}.getStr
2020-06-01 00:16:24 +00:00
2020-06-07 05:54:20 +00:00
proc parsePhotoRail*(js: JsonNode): PhotoRail =
2020-06-16 22:20:34 +00:00
for tweet in js:
let
t = parseTweet(tweet)
url = if t.photos.len > 0: t.photos[0]
elif t.video.isSome: get(t.video).thumb
elif t.gif.isSome: get(t.gif).thumb
elif t.card.isSome: get(t.card).image
else: ""
if url.len == 0: continue
result.add GalleryPhoto(url: url, tweetId: $t.id)