def generate_podcast_xml(base, books):
from podgen import Podcast, Episode
from datetime import timedelta
from podgen import Media
p = Podcast()
p.name = "AeonNeo's Audiobooks"
p.description = "Description"
p.website = "www.yangvincent.com"
p.explicit = False
# create episode
for book_name in books:
ep = Episode()
ep.title = book_name[:-4]
full_path = base + '/files/' + book_name
dev_path = 'files/' + book_name
try:
book_size = os.path.getsize(dev_path)
except OSError as e:
print(e)
book_size = 0
ep.media = Media(full_path, type='audio/mp4a', size=book_size)
p.episodes.append(ep)
# Generate rss
p.rss_file('skeleton/rss.xml', minimize=True)
def test_title(self):
ep = Episode()
def get_element():
return ep.rss_entry().find("title")
# Starts out as None or empty.
assert ep.title is None or ep.title == ""
# We test that you cannot create RSS when it's empty or blank in
# another method.
# Test that it is set correctly
ep.title = None
assert ep.title is None
ep.title = ""
self.assertEqual(ep.title, "")
# Test that the title is used correctly
title = "My Fine Title"
ep.title = title
self.assertEqual(ep.title, title)
element = get_element()
assert element is not None
self.assertEqual(element.text, title)
def test_title(self):
ep = Episode()
def get_element():
return ep.rss_entry().find("title")
# Starts out as None or empty.
assert ep.title is None or ep.title == ""
# We test that you cannot create RSS when it's empty or blank in
# another method.
# Test that it is set correctly
ep.title = None
assert ep.title is None
ep.title = ""
self.assertEqual(ep.title, "")
# Test that the title is used correctly
title = "My Fine Title"
ep.title = title
self.assertEqual(ep.title, title)
element = get_element()
assert element is not None
self.assertEqual(element.text, title)
def test_idIsSet(self):
guid = "http://example.com/podcast/episode1"
episode = Episode()
episode.title = "My first episode"
episode.id = guid
item = episode.rss_entry()
assert item.find("guid").text == guid
def test_idNotSetButEnclosureIsUsed(self):
guid = "http://example.com/podcast/episode1.mp3"
episode = Episode()
episode.title = "My first episode"
episode.media = Media(guid, 97423487, "audio/mpeg")
item = episode.rss_entry()
assert item.find("guid").text == guid
def test_idNotSetButEnclosureIsUsed(self):
guid = "http://example.com/podcast/episode1.mp3"
episode = Episode()
episode.title = "My first episode"
episode.media = Media(guid, 97423487, "audio/mpeg")
item = episode.rss_entry()
assert item.find("guid").text == guid
def test_idIsSet(self):
guid = "http://example.com/podcast/episode1"
episode = Episode()
episode.title = "My first episode"
episode.id = guid
item = episode.rss_entry()
assert item.find("guid").text == guid
def test_idSetToFalseSoEnclosureNotUsed(self):
episode = Episode()
episode.title = "My first episode"
episode.media = Media("http://example.com/podcast/episode1.mp3",
34328731, "audio/mpeg")
episode.id = False
item = episode.rss_entry()
assert item.find("guid") is None
def main():
with open('thebugle.json') as f:
episodes = json.load(f)
p = Podcast(
name="TimesOnLine Bugle Archive",
description="Old Bugle episodes, podcast feed",
website="https://www.thebuglepodcast.com/",
explicit=False,
)
for episode in episodes:
ep = p.add_episode(
Episode(title=f"{episode['id']}: {episode['title']}"))
ep.media = Media.create_from_server_response(
f"{MEDIA_BASE_URL}/{episode['file']}")
ep.media.fetch_duration()
date = episode['date'].split('-')
ep.publication_date = datetime(int(date[0]),
int(date[1]),
int(date[2]),
0,
0,
0,
tzinfo=pytz.utc)
print(p.rss_str())
def rss(url_token):
dropbox_access_token, title, description = get_the_latest_token_info(
url_token)
urls = get_temporary_link(dropbox_access_token)
p = Podcast()
p.name = title
p.description = description
p.website = "https://www.google.com"
p.explicit = True
for i, (size, url, uid, name) in enumerate(urls):
my_episode = Episode()
my_episode.title = os.path.splitext(name)[0]
my_episode.id = uid
my_episode.media = Media(url, size=size, type="audio/mpeg")
p.episodes.append(my_episode)
return Response(str(p), mimetype='text/xml')
def genero_feed(puntateList):
if puntateList:
# Creo un nuovo podcast
p = Podcast()
p.name = "Il Ruggito del Coniglio"
p.description = "Il Ruggito del Coniglio, il programma cult di Radio 2 condotto da Marco Presta e Antonello Dose, racconta l'attualita con folgorante ironia."
p.website = "http://www.raiplayradio.it/programmi/ilruggitodelconiglio/"
p.explicit = True
p.image = "https://rss.draghetti.it/ruggitodelconiglio_image.jpg"
p.feed_url = "https://rss.draghetti.it/ruggitodelconiglio.xml"
p.copyright = "Rai Radio 2"
p.language = "it-IT"
for puntata in puntateList:
episode = Episode()
episode.title = puntata[0].encode("ascii", "ignore")
episode.link = puntata[1]
# La dimensione del file e approssimativa
episode.media = Media(puntata[3], puntata[4])
if puntata[2]:
episode.publication_date = datetime.datetime(int(puntata[2].split("/")[2]),
int(puntata[2].split("/")[1]),
int(puntata[2].split("/")[0]), 10,
00, tzinfo=pytz.utc)
else:
episode.publication_date = pytz.utc.localize(datetime.datetime.utcnow())
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def test_constructor(self):
title = "A constructed episode"
subtitle = "We're using the constructor!"
summary = "In this week's episode, we try using the constructor to " \
"create a new Episode object."
long_summary = "In this week's episode, we try to use the constructor " \
"to create a new Episode object. Additionally, we'll " \
"check whether it actually worked or not. Hold your " \
"fingers crossed!"
media = Media("http://example.com/episodes/1.mp3", 1425345346,
"audio/mpeg",
datetime.timedelta(hours=1, minutes=2, seconds=22))
publication_date = datetime.datetime(2016,
6,
7,
13,
37,
0,
tzinfo=pytz.utc)
link = "http://example.com/blog/?i=1"
authors = [Person("John Doe", "*****@*****.**")]
image = "http://example.com/static/1.png"
explicit = True
is_closed_captioned = False
position = 3
withhold_from_itunes = True
ep = Episode(
title=title,
subtitle=subtitle,
summary=summary,
long_summary=long_summary,
media=media,
publication_date=publication_date,
link=link,
authors=authors,
image=image,
explicit=explicit,
is_closed_captioned=is_closed_captioned,
position=position,
withhold_from_itunes=withhold_from_itunes,
)
# Time to check if this works
self.assertEqual(ep.title, title)
self.assertEqual(ep.subtitle, subtitle)
self.assertEqual(ep.summary, summary)
self.assertEqual(ep.long_summary, long_summary)
self.assertEqual(ep.media, media)
self.assertEqual(ep.publication_date, publication_date)
self.assertEqual(ep.link, link)
self.assertEqual(ep.authors, authors)
self.assertEqual(ep.image, image)
self.assertEqual(ep.explicit, explicit)
self.assertEqual(ep.is_closed_captioned, is_closed_captioned)
self.assertEqual(ep.position, position)
self.assertEqual(ep.withhold_from_itunes, withhold_from_itunes)
def index():
'''https://podgen.readthedocs.io/en/latest/'''
urls = get_temporary_link()
p = Podcast()
p.name = "ambience"
p.description = "ambience"
p.website = "LINK HERE"
p.explicit = True
for i, (size, url) in enumerate(urls):
my_episode = Episode()
my_episode.title = "ambience music {}".format(i + 1)
my_episode.media = Media(url,
size=size,
type="audio/mpeg")
p.episodes.append(my_episode)
rss = str(p)
return Response(rss, mimetype='text/xml')
def get_episode(self):
media = Media(get_download_url(self.relative_path),
os.path.getsize(self.full_path),
duration=timedelta(seconds=self.duration_seconds))
return Episode(title=self.title,
media=media,
summary=self.summary,
explicit=False,
image=self.image_url,
publication_date=self.publication_date,
subtitle=self.subtitle)
def episode_from_filename(filename):
info = get_file_info(filename)
media_url = to_slug(filename)
return Episode(
title=filename,
publication_date=info.get('created', datetime.now()),
media=Media(
os.path.join(config.SERVER_BASEURL, 'episodes', media_url),
info.get('size'),
None, # type
info.get('duration')))
def genero_feed(puntateList):
if puntateList:
# Creo un nuovo podcast
p = Podcast()
p.name = "Pascal Rai Radio 2"
p.description = "Pascal un programma di Matteo Caccia in onda su Radio2 che racconta storie di vita. Episodi grandi o piccoli, stravolgenti o minuti, momenti che hanno modificato per sempre la nostra vita o che, anche se di poco, l'hanno indirizzata. Storie che sono il termometro della temperatura di ognuno di noi e che in parte raccontano chi siamo. "
p.website = "http://www.raiplayradio.it/programmi/pascal/"
p.explicit = True
p.image = "https://rss.draghetti.it/pascal_image.jpg"
p.feed_url = "https://rss.draghetti.it/pascal.xml"
p.copyright = "Rai Radio 2"
p.language = "it-IT"
for puntata in puntateList:
episode = Episode()
episode.title = puntata[0].encode("ascii", "ignore")
episode.link = puntata[1]
# La dimensione del file e approssimativa
episode.media = Media(puntata[3], puntata[4])
if puntata[2]:
episode.publication_date = datetime.datetime(int(puntata[2].split("/")[2]),
int(puntata[2].split("/")[1]),
int(puntata[2].split("/")[0]), 20,
00, tzinfo=pytz.utc)
else:
episode.publication_date = pytz.utc.localize(datetime.datetime.utcnow())
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def genero_feed(episodesList):
if episodesList:
# Creo un nuovo podcast
p = Podcast()
p.name = "NECST Tech Time"
p.description = "Feed Podcast non ufficiale di NECST Tech Time - Powered By Andrea Draghetti"
p.website = "http://www.poliradio.it/podcast/programmi/34/necst-tech-time"
p.explicit = True
p.image = "https://rss.draghetti.it/necst_image.jpg"
p.feed_url = "https://rss.draghetti.it/necstpodcast.xml"
p.copyright = "Poli Radio"
p.language = "it-IT"
for episodedetails in episodesList:
episode = Episode()
episode.title = episodedetails[1].encode("ascii", "ignore")
episode.link = episodedetails[2].encode("ascii", "ignore")
# La dimensione e statistica in base alle puntante analizzate
episode.media = Media(episodedetails[3],
30000000,
type="audio/x-m4a",
duration=None)
episode.publication_date = episodedetails[4]
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def genero_feed(episodesList):
if episodesList:
# Creo un nuovo podcast
p = Podcast()
p.name = "All You Can Dance by Dino Brawn"
p.description = "Feed Podcast non ufficiale di All You Can Dance by Dino Brown - Powered By Andrea Draghetti"
p.website = "https://onedance.fm/"
p.explicit = True
p.image = "https://rss.draghetti.it/allyoucandance_image.jpg"
p.feed_url = "https://rss.draghetti.it/allyoucandance.xml"
p.copyright = "One Dance"
p.language = "it-IT"
for episodedetails in episodesList:
episode = Episode()
episode.title = episodedetails[1].encode("ascii", "ignore")
episode.link = episodedetails[2].encode("ascii", "ignore")
# La dimensione e statistica in base alle puntante analizzate
episode.media = Media(episodedetails[3], 30000000, type="audio/x-m4a", duration=None)
episode.publication_date = episodedetails[4]
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def genero_feed(puntateList):
if puntateList:
# Creo un nuovo podcast
p = Podcast()
p.name = "Il Ruggito del Coniglio"
p.description = "Il Ruggito del Coniglio, il programma cult di Radio 2 condotto da Marco Presta e Antonello Dose, racconta l'attualita con folgorante ironia."
p.website = "http://www.raiplayradio.it/programmi/ilruggitodelconiglio/"
p.explicit = True
p.image = "https://rss.draghetti.it/ruggitodelconiglio_image.jpg"
p.feed_url = "https://rss.draghetti.it/ruggitodelconiglio.xml"
p.copyright = "Rai Radio 2"
p.language = "it-IT"
for puntata in puntateList:
episode = Episode()
episode.title = puntata[0].encode("ascii", "ignore")
episode.link = puntata[1]
# La dimensione del file e approssimativa
episode.media = Media(puntata[3], puntata[4])
if puntata[2]:
episode.publication_date = datetime.datetime(int(puntata[2].split("/")[2]),
int(puntata[2].split("/")[1]),
int(puntata[2].split("/")[0]), 10,
00, tzinfo=pytz.utc)
else:
episode.publication_date = pytz.utc.localize(datetime.datetime.utcnow())
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def genero_feed(episodesList):
if episodesList:
# Creo un nuovo podcast
p = Podcast()
p.name = "NECST Tech Time"
p.description = "The NECSTLab (Novel, Emerging Computing System Technologies Laboratory) is a laboratory inside DEIB department of Politecnico di Milano, where there are a number of different research lines on advanced topics in computing systems: from architectural characteristics, to hardware-software codesign methodologies, to security and dependability issues of complex system architectures (scaling from mobile devices to large virtualized datacenters)."
p.website = "http://www.poliradio.it/podcast/programmi/34/necst-tech-time"
p.explicit = True
p.image = "https://rss.draghetti.it/necst_image.jpg"
p.feed_url = "https://rss.draghetti.it/necstpodcast.xml"
p.copyright = "Poli Radio"
p.language = "it-IT"
for episodedetails in episodesList:
episode = Episode()
episode.title = episodedetails[1].encode("ascii", "ignore")
episode.link = episodedetails[2].encode("ascii", "ignore")
# La dimensione e statistica in base alle puntante analizzate
episode.media = Media(episodedetails[3], 30000000, type="audio/x-m4a", duration=None)
episode.publication_date = episodedetails[4]
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def rssfeed(request, programid):
""" Builds the rss feed for a program identified by it's id. (int)
1. Fetches all episodes of the program from the digas db.
2. gets the programinfo from the app db
3. Uses podgen to do the actual XML-generation.
"""
podcasts = DigasPodcast.objects.using('digas').filter(
softdel=0,
program=int(programid)).only('program', 'title', 'remark', 'author',
'createdate', 'broadcastdate', 'filename',
'filesize', 'duration',
'softdel').order_by('-createdate')
programinfo = ProgramInfo.objects.get(programid=int(programid))
# loading globalsettings here, and not at the module_level
# This way django won't explode because of missing
# constance_config table when we start on scratch
# or set up in a new environment.
from .models import globalsettings
p = Podcast(
name=programinfo.name,
subtitle=programinfo.subtitle,
description=programinfo.description,
website=feed_url(programid), # programinfo.website,
explicit=programinfo.explicit,
category=Category(programinfo.category),
authors=[globalsettings.owner],
language=programinfo.language,
owner=globalsettings.owner,
feed_url=feed_url(programid),
new_feed_url=feed_url(programid),
image=programinfo.image_url,
)
for episode in podcasts:
# Get pubdate from createdate or broadcastdate
pubdate = digas2pubdate(episode.createdate, episode.broadcastdate)
# Add the episode to the list
p.episodes.append(
Episode(
title=episode.title,
media=Media(mp3url(episode.filename), episode.filesize),
link=mp3url(episode.filename), # multifeedreader uses this.
id=guid(episode.filename),
summary=episode.remark,
publication_date=pubdate))
# send it as unicode
rss = u'%s' % p
return HttpResponse(rss, content_type='application/xml')
def test_idSetToFalseSoEnclosureNotUsed(self):
episode = Episode()
episode.title = "My first episode"
episode.media = Media("http://example.com/podcast/episode1.mp3",
34328731, "audio/mpeg")
episode.id = False
item = episode.rss_entry()
assert item.find("guid") is None
def setUp(self):
self.itunes_ns = 'http://www.itunes.com/dtds/podcast-1.0.dtd'
self.dublin_ns = 'http://purl.org/dc/elements/1.1/'
fg = Podcast()
self.title = 'Some Testfeed'
self.link = 'http://lernfunk.de'
self.description = 'A cool tent'
self.explicit = False
fg.name = self.title
fg.website = self.link
fg.description = self.description
fg.explicit = self.explicit
fe = fg.add_episode()
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The First Episode'
self.fe = fe
#Use also the list directly
fe = Episode()
fg.episodes.append(fe)
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The Second Episode'
fe = fg.add_episode()
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The Third Episode'
self.fg = fg
warnings.simplefilter("always")
def noop(*args, **kwargs):
pass
warnings.showwarning = noop
def main(event, context):
dynamodb = boto3.resource('dynamodb', region_name='sa-east-1')
table = dynamodb.Table('semservidor-dev')
podcasts = table.scan()
author = Person("Evandro Pires da Silva", "*****@*****.**")
p = Podcast(
name="Sem Servidor",
description=
"Podcast dedicado a arquitetura serverless, com conteúdo de qualidade em português.",
website="https://semservidor.com.br",
explicit=False,
copyright="2020 Evandro Pires da Silva",
language="pr-BR",
authors=[author],
feed_url=
"https://3tz8r90j0d.execute-api.sa-east-1.amazonaws.com/dev/podcasts/rss",
category=Category("Music", "Music History"),
owner=author,
image="http://d30gvsirhz3ono.cloudfront.net/logo_semservidor_teste.jpg",
web_master=Person(None, "*****@*****.**"))
items = podcasts['Items']
for item in items:
base_url = "http://d30gvsirhz3ono.cloudfront.net/"
file_path = base_url + item['info']['arquivo']['nome']
p.episodes += [
Episode(title=item['info']['episodio'],
media=Media(file_path,
int(item['info']['arquivo']['tamanho'])),
summary=item['info']['descricao'],
position=int(item['id']))
]
p.apply_episode_order()
rss = p.rss_str()
response = {
"statusCode": 200,
"headers": {
"content-type": "application/xml"
},
"body": rss
}
return response
def genero_feed(puntateList):
if puntateList:
# Creo un nuovo podcast
p = Podcast()
p.name = "Pascal Rai Radio 2"
p.description = "Pascal un programma di Matteo Caccia in onda su Radio2 che racconta storie di vita. Episodi grandi o piccoli, stravolgenti o minuti, momenti che hanno modificato per sempre la nostra vita o che, anche se di poco, l'hanno indirizzata. Storie che sono il termometro della temperatura di ognuno di noi e che in parte raccontano chi siamo. "
p.website = "http://www.raiplayradio.it/programmi/pascal/"
p.explicit = True
p.image = "https://rss.draghetti.it/pascal_image.jpg"
p.feed_url = "https://rss.draghetti.it/pascal.xml"
p.copyright = "Rai Radio 2"
p.language = "it-IT"
for puntata in puntateList:
episode = Episode()
episode.title = puntata[0].encode("ascii", "ignore")
episode.link = puntata[1]
# La dimensione del file e approssimativa
episode.media = Media(puntata[3], puntata[4])
if puntata[2]:
episode.publication_date = datetime.datetime(
int(puntata[2].split("/")[2]),
int(puntata[2].split("/")[1]),
int(puntata[2].split("/")[0]),
20,
00,
tzinfo=pytz.utc)
else:
episode.publication_date = pytz.utc.localize(
datetime.datetime.utcnow())
p.episodes.append(episode)
# Print to stdout, just as an example
p.rss_file(rssfile, minimize=False)
def setUp(self):
self.itunes_ns = 'http://www.itunes.com/dtds/podcast-1.0.dtd'
self.dublin_ns = 'http://purl.org/dc/elements/1.1/'
fg = Podcast()
self.title = 'Some Testfeed'
self.link = 'http://lernfunk.de'
self.description = 'A cool tent'
self.explicit = False
fg.name = self.title
fg.website = self.link
fg.description = self.description
fg.explicit = self.explicit
fe = fg.add_episode()
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The First Episode'
self.fe = fe
#Use also the list directly
fe = Episode()
fg.episodes.append(fe)
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The Second Episode'
fe = fg.add_episode()
fe.id = 'http://lernfunk.de/media/654321/1'
fe.title = 'The Third Episode'
self.fg = fg
warnings.simplefilter("always")
def noop(*args, **kwargs):
pass
warnings.showwarning = noop
p = Podcast(
name="Short (Morning) Dhamma Talks by Thanissaro Bhikkhu",
description=
"""These short Dhamma talks by Thanissaro Bhikkhu were given at Metta Forest Monastery most mornings in both English and Thai. The English portion has been excerpted and offered here for streaming and downloading. The talks last about 3 to 5 minutes.
Podcast feed generated by [email protected].""",
website="https://www.dhammatalks.org/mp3_short_index.html",
explicit=False,
)
#soup = bs(urlopen(MORNING_TALKS_URL), "html.parser")
d = pq(url=MORNING_TALKS_URL)
for episode_tag in d('a.audio'):
inner_span = episode_tag.find("span")
#embed()
if inner_span is not None:
# todo: warning
inner_span.drop_tree()
name = urllib.parse.unquote(episode_tag.text_content().strip())
url = episode_tag.attrib.get("href")
if url and name:
url = urllib.parse.urljoin(BASE_URL, url)
p.episodes += [Episode(title=name, media=Media(url))]
else:
#todo: warning
pass
rss = p.rss_str()
print(rss)
talks = soup.find_all('div', class_='sqs-audio-embed')
p = Podcast(
name="ASW Talks",
description="Talks from ASW.",
website=URL,
explicit=False,
)
items = []
for talk in talks:
dateSpeaker = talk['data-author'].split(" - ")
date = processDate(dateSpeaker[0])
speaker = "None" if len(dateSpeaker) < 2 else dateSpeaker[1]
if (talk['data-url'] == ""):
continue
else:
items.append(
Episode(title=talk['data-title'],
media=Media(url=talk['data-url']),
summary=f'A talk from ASW by {speaker} on {date}'
# author = speaker,
# pubDate = date
))
# Add some episodes
p.episodes = items
# Generate the RSS feed
rss = p.rss_str()
print(rss)
def test_mandatoryAttributes(self):
ep = Episode()
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.title = "A title"
ep.rss_entry()
ep.title = ""
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.title = None
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.summary = "A summary"
ep.rss_entry()
ep.summary = ""
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.summary = None
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
def create_rss(type, download):
"""Create an example podcast and print it or save it to a file."""
# Create the Podcast & initialize the feed
default_channel = Channel.defaultChannel()
p = Podcast()
p.name = default_channel.name
p.description = default_channel.description
p.website = default_channel.website
p.explicit = default_channel.explicit
p.image = default_channel.image
p.copyright = default_channel.copyright
p.language = default_channel.language
p.feed_url = default_channel.feed_url
p.category = Category(default_channel.category)
# p.category = Category('Technology', 'Podcasting')
# p.xslt = "https://example.com/feed/stylesheet.xsl" # URL of XSLT stylesheet
p.authors = [Person(default_channel.authors, default_channel.authors_email)]
p.owner = Person(default_channel.owner, default_channel.owner_email)
# Other Attributes
p.generator = " "
# Others for iTunes
# p.complete = False
# p.new_feed_url = 'http://example.com/new-feed.rss'
# e1 = p.add_episode()
# e1.id = 'http://lernfunk.de/_MEDIAID_123#1'
# e1.title = 'First Element'
# e1.summary = htmlencode('''Lorem ipsum dolor sit amet, consectetur adipiscing elit. Tamen
# aberramus a proposito, et, ne longius, prorsus, inquam, Piso, si ista
# mala sunt, placet. Aut etiam, ut vestitum, sic sententiam habeas aliam
# domesticam, aliam forensem, ut in fronte ostentatio sit, intus veritas
# occultetur? Cum id fugiunt, re eadem defendunt, quae Peripatetici,
# verba <3.''')
# e1.link = 'http://example.com'
# e1.authors = [Person('Lars Kiesow', '*****@*****.**')]
# e1.publication_date = datetime.datetime(2014, 5, 17, 13, 37, 10, tzinfo=pytz.utc)
# # e1.media = Media("http://example.com/episodes/loremipsum.mp3", 454599964,
# # duration=
# # datetime.timedelta(hours=1, minutes=32, seconds=19))
# e1.media = Media("http://example.com/episodes/loremipsum.mp3", 454599964)
# Add some episodes
p.episodes += [
Episode(title = download.title,
subtitle = download.subtitle,
# id=str(uuid.uuid4()),
position =2,
media = Media(download.media_url, size=download.media_size, duration=timedelta(seconds=download.media_duration)),
image = download.image_url,
publication_date = datetime(year=2021, month=1, day=8, hour=10, minute=0, tzinfo=pytz.utc),
summary = download.summary)
,
Episode(title="Episode 2 - The Crazy Ones",
subtitle="this is a cool episode, this is for th crazy ones",
position=1,
image="https://github.com/oliverbarreto/PersonalPodcast/raw/main/site-logo-1400x1400.png",
media=Media("https://github.com/oliverbarreto/PersonalPodcast/raw/main/downloaded_with_pytube_Apple%20Steve%20Jobs%20Heres%20To%20The%20Crazy%20Ones.mp4", type="audio/mpeg", size=989, duration=timedelta(hours=0, minutes=1, seconds=1)),
publication_date = datetime(year=2021, month=1, day=6, hour=10, minute=0, tzinfo=pytz.utc),
summary=htmlencode("wow wow wow summary"))
,
Episode(title="Episode 3 - The Super Crazy",
subtitle="crazy ones revisited",
position=0,
image="https://github.com/oliverbarreto/PersonalPodcast/raw/main/site-logo-1400x1400.png",
media=Media("https://drive.google.com/file/d/1X5Mwa8V0Su1IDqhcQL7LdzEY0VaMC1Nn", type="audio/mpeg", size=989, duration=timedelta(hours=0, minutes=1, seconds=1)),
publication_date = datetime(year=2021, month=1, day=10, hour=10, minute=0, tzinfo=pytz.utc),
summary=download.summary)
]
# Should we just print out, or write to file?
if type == 'print':
# Print
print_enc(p.rss_str())
elif type== 'feed.xml':
# Write to file
p.rss_file(type, minimize=False)
print("\n")
print("feed.xml created !!!")
p = Podcast(
name="Chapo Cheaters Club",
description="Just taking"
"what isn't mine",
website=host_address,
explicit=False,
)
p.image = host_address + "logo.jpg"
for pod in find_pods():
audio = MP3(os.path.join(base_dir, pod_dir, pod), ID3=EasyID3)
if audio:
title = str(*audio["title"])
else:
title = pod[:~3]
size = os.path.getsize(os.path.join(base_dir, pod_dir, pod))
duration = timedelta(seconds=audio.info.length)
print(f'{pod}, {title}, {size}, {duration}')
p.episodes += [
Episode(title=title,
media=Media(f"{host_address}{pod}",
size=size,
duration=duration),
summary="summary goes here")
]
rss = p.rss_str()
p.rss_file(os.path.join(base_dir, pod_dir, 'rss.xml'))
# Save the meeting details.
with open(f"{output_prefix}.yaml", "w") as fp:
fp.write(yaml.dump(meeting))
# Update podcast.
podcast = Podcast(
name="Zoomerang",
description="Telecons you missed while you were sleeping.",
website=config["zoomerang_remote_addr"],
explicit=False)
meeting_paths = glob(f"{recordings_dir_path}*.yaml")
for meeting_path in meeting_paths:
with open(meeting_path, "r") as fp:
meeting = yaml.load(fp)
podcast.add_episode(
Episode(title=meeting["summary"],
media=Media(meeting["url"],
size=meeting["estimated_file_size"],
type="audio/mpeg",
duration=datetime.timedelta(
seconds=meeting["duration"])),
publication_date=dateutil.parser.parse(
meeting["created_datetime"])))
with open(config["zoomerang_podcast_path"], "w") as fp:
fp.write(f"{podcast}")
print("Updated podcast.")
from podgen import Podcast, Episode, Media
# Create the Podcast
p = Podcast(
name="Animals Alphabetically",
description="Every Tuesday, biologist John Doe and wildlife "
"photographer Foo Bar introduce you to a new animal.",
website="http://example.org/animals-alphabetically",
explicit=False,
)
# Add some episodes
p.episodes += [
Episode(
title="Aardvark",
media=Media("http://example.org/files/aardvark.mp3", 11932295),
summary="With an English name adapted directly from Afrikaans "
'-- literally meaning "earth pig" -- this fascinating '
"animal has both circular teeth and a knack for "
"digging.",
),
Episode(
title="Alpaca",
media=Media("http://example.org/files/alpaca.mp3", 15363464),
summary="Thousands of years ago, alpacas were already "
"domesticated and bred to produce the best fibers. "
"Case in point: we have found clothing made from "
"alpaca fiber that is 2000 years old. How is this "
"possible, and what makes it different from llamas?",
),
]
# Generate the RSS feed
rss = p.rss_str()
print('>>> wrote fresh sessions.json file')
# write the new rss file
p = Podcast()
p.name = "The Objectivism Seminar"
p.category = Category("Society & Culture", "Philosophy")
p.language = "en-US"
p.explicit = True
p.description = (
"A weekly online conference call to systematically study " +
"the philosophy of Objectivism via the works of prominent Rand scholars.")
p.website = "https://www.ObjectivismSeminar.com"
p.image = "https://www.ObjectivismSeminar.com/assets/images/atlas-square.jpg"
p.feed_url = "https://www.ObjectivismSeminar.com/archives/rss"
p.authors = [Person("Greg Perkins, Host", "*****@*****.**")]
p.owner = Person("Greg Perkins", "*****@*****.**")
p.episodes += [
Episode(title=x['title'],
media=Media(x['link'], type="audio/mpeg", size=x['length']),
id=x['GUID'],
publication_date=x['pubDate'],
summary=x['description']) for x in updated_session_items
]
p.rss_file(rss_filename)
print('>>> wrote fresh rss.xml file')
episodes = []
for url in urls_to_follow:
content = requests.get(url).content
soup = BeautifulSoup(content, features="lxml")
res = re.search(b'file : "(.+?)",\\n', content)
title = soup.select("b.vod-title")[0].text
date = soup.select(".vod-data p span.episode-date")[0].text
media_url = res.groups()[0].decode()
head = requests.head(url)
if '\n' in title:
title = title.split('\n')[-1]
episodes.append(
Episode(
title=title.title(),
media=Media(media_url, head.headers["Content-Length"]),
summary=soup.title.text,
publication_date=arrow.get(date, "DD MMM. YYYY", locale="pt").datetime
)
)
# Add some episodes
p.episodes = episodes
# Generate the RSS feed
rss = p.rss_str()
filename = "alta-tensao.xml"
with open(filename, "wb") as f:
f.write(rss.encode())
'filename': file_local_path,
'name': video.title
})
except HTTPError as err:
print('Can not parse this video bacause of HTTPError.')
# Create Podcast object and fill it with episodes
podcast_object = Podcast(
name=CONFIG['podcast_name'],
description=CONFIG['podcast_description'],
website=CONFIG['podcast_website'],
explicit=False,
image=CONFIG['podcast_image'],
language=CONFIG['podcast_language'],
authors=[Person(CONFIG['podcast_author'], CONFIG['podcast_author_email'])],
owner=Person(CONFIG['podcast_owner'], CONFIG['podcast_owner_email']),
category=Category(CONFIG['podcast_category'],
CONFIG['podcast_subcategory']))
for item in db:
web_media_path = "%s/podcast_%s.mp4" % (CONFIG['podcast_media_server'],
item['link'][9:])
podcast_object.add_episode(
Episode(title=item['name'],
media=Media(web_media_path,
os.stat(item['filename']).st_size,
type="audio/mpeg")))
# Generating RSS
podcast_object.rss_file(('%s/rss.xml' % CONFIG['data_path']), minimize=True)
def test_mandatoryAttributes(self):
ep = Episode()
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.title = "A title"
ep.rss_entry()
ep.title = ""
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.title = None
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.summary = "A summary"
ep.rss_entry()
ep.summary = ""
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
ep.summary = None
self.assertRaises((RuntimeError, ValueError), ep.rss_entry)
def generate(name, description, website, explicit, image, author_name,
author_email, feed_path, copyright, language, category, blog,
blog_path, verbose, folder):
"""Generate a podcast from mp3 files located in the provided FOLDER"""
if verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
attrs = locals()
logging.debug('Processing input: %s' % (attrs))
del attrs['folder']
del attrs['author_name']
del attrs['author_email']
del attrs['verbose']
del attrs['feed_path']
del attrs['blog']
del attrs['blog_path']
attrs['authors'] = [Person(author_name, author_email)]
attrs['owner'] = attrs['authors'][0]
attrs['category'] = Category(category)
feed_name = name.lower().replace(' ', '_') + '.rss'
feed_base = '%s/%s' % (website, feed_path)
feed_url = '%s/%s' % (feed_base, feed_name)
attrs['feed_url'] = feed_url
logging.info('Creating podcast %s, feed %s' % (name, feed_url))
p = Podcast(**attrs)
for fpath in sorted(glob.glob('%s*.mp3' % (folder))):
logging.info('Adding episode %s' % (fpath))
fname = os.path.basename(fpath)
size = os.path.getsize(fpath)
logging.debug('Filename: %s, size %i' % (fname, size))
try:
tag = ID3(fpath)
except ID3NoHeaderError:
logging.error('%s is not a valid mp3 file, ignoring it' % (fpath))
continue
logging.debug('Read tag: %s' % (tag))
e = Episode()
if 'TPE1' in tag:
e.authors = [Person(tag['TPE1'][0])]
else:
e.authors = attrs['authors']
e.title = tag['TIT2'][0]
e.subtitle = e.title
if 'COMM::eng' in tag:
e.summary = tag['COMM::eng'][0]
else:
e.summary = description
episode_url = '%s/%s' % (feed_base, fname)
logging.debug('Episode url: %s' % (episode_url))
e.media = Media(episode_url, size, type='audio/mpeg')
e.media.populate_duration_from(fpath)
pubdate = datetime.strptime(tag['TDRC'][0].text[:10], '%Y-%m-%d')
pubdate = pubdate.replace(tzinfo=pytz.utc)
e.publication_date = pubdate
if blog:
blog_post = ''
short_name = re.search('[a-z]*_-_([a-z_]*[#0-9]*)', fname)
if short_name:
blog_post = short_name.group(1).replace('_', '-').\
replace('#', '') + '.html'
e.link = '%s/%s/%s' % (website, blog_path, blog_post)
p.episodes.append(e)
feed_local_path = '%s%s' % (folder, feed_name)
logging.info('Generating feed in %s' % (feed_local_path))
p.rss_file(feed_local_path, minimize=False)
p = Podcast(
name="365 days of plops",
description="Every shit I take "
"you get to hear it",
website="http://example.org/animals-alphabetically",
explicit=False,
)
p.image = "https://github.com/ssk8/365days_of_plops/raw/main/pooping.jpg"
p.episodes += [
Episode(
title="just a turd",
media=Media(
"https://github.com/ssk8/365days_of_plops/raw/main/poop01.mp3",
11932295),
summary="With an English name adapted directly from Afrikaans "
'-- literally meaning "earth pig" -- this fascinating '
"animal has both circular teeth and a knack for "
"digging.",
),
Episode(
title="ya, das ist die heiße scheiße",
media=Media(
"https://github.com/ssk8/365days_of_plops/raw/main/poop02.mp3",
15363464),
summary="Colon evacuation "
"hurt my anus ",
),
Episode(
title="Spicy Shit",
media=Media(