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 = "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 test_warningWhenSettingSizeToZero(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
self.assertEqual(len(w), 0)
# Set size to zero, triggering a warning
m = Media(self.url, type=self.type)
self.assertEqual(len(w), 1)
assert issubclass(w[-1].category, UserWarning)
# No warning when setting to an actual integer
m.size = 253634535
self.assertEqual(len(w), 1)
# Nor when using a string
m.size = "15kB"
self.assertEqual(len(w), 1)
# Warning when setting to None
m.size = None
self.assertEqual(len(w), 2)
assert issubclass(w[-1].category, UserWarning)
# Or zero
m.size = 0
self.assertEqual(len(w), 3)
assert issubclass(w[-1].category, UserWarning)
def test_pickling(self, mock_requests):
m = Media(self.url, self.size, self.type, self.duration)
m2 = pickle.loads(pickle.dumps(m))
self.assertEqual(m.url, m2.url)
self.assertEqual(m.size, m2.size)
self.assertEqual(m.type, m2.type)
self.assertEqual(m.duration, m2.duration)
def album(self):
album_info_content = requests.get(self.album_info_api).content
album_info_data = json.loads(album_info_content)
album_list_content = requests.get(self.album_list_api).content
album_list_data = json.loads(album_list_content)
self.podcast = Podcast()
self.podcast.name = album_info_data['data']['title']
self.podcast.authors.append(Person("Powered by maijver", '*****@*****.**'))
self.podcast.website = self.url
self.podcast.copyright = 'cc-by'
self.podcast.description = album_info_data['data']['description']
self.podcast.language = 'cn'
self.podcast.image = album_info_data['data']['thumbs']['small_thumb'].replace('!200', '')
self.podcast.feed_url = 'http://podcast.forecho.com/qingting/%s.rss' % self.album_id
self.podcast.category = Category('Technology', 'Podcasting')
self.podcast.explicit = False
self.podcast.complete = False
self.podcast.owner = Person("maijver", '*****@*****.**')
for each in album_list_data['data']:
episode = self.podcast.add_episode()
episode.id = str(each['id'])
episode.title = each['title']
print(self.podcast.name + '=====' + each['title'])
episode.image = album_info_data['data']['thumbs']['small_thumb'].replace('!200', '')
episode.summary = each['title']
episode.link = 'http://www.qingting.fm/channels/{}/programs/{}'.format(self.album_id, each['id'])
episode.authors = [Person("forecho", '*****@*****.**')]
episode.publication_date = self.reduction_time(each['update_time'])
episode.media = Media("http://od.qingting.fm/{}".format(each['mediainfo']['bitrates_url'][0]['file_path']),
each['duration'])
self.podcast.rss_file('qingting/{}.rss'.format(self.album_id), minimize=True)
def get_episode(self, episode_id):
trycount = 0
findepisode = False
while not findepisode:
if trycount > 0:
print("再接続中" + str(trycount) + "......")
if trycount > 1:
print("error url: " + self.episode_detail_url.format(episode_id) + "\n")
return False, "error url: " + self.episode_detail_url.format(episode_id) + "\n"
webpage = tools.get_url(self.episode_detail_url.format(episode_id), self.headers)
detail = json.loads(webpage.decode('utf-8'))
episode = self.podcast.add_episode()
episode.id = str('ximalaya_' + str(episode_id))
episode.title = detail['title']
# print(self.podcast.name + '=====' + episode.title)
if 'intro' in detail:
episode.summary = detail['intro'].replace('\r', '\\r').replace('\n', '\\n')
episode.publication_date = tools.publication_time(detail['createdAt'])
episode.media = Media(detail['playUrl32'], duration=timedelta(milliseconds=detail['duration']))
# episode.media = Media.create_from_server_response(detail['playUrl32'],
# duration=timedelta(seconds=detail['duration']))
episode.position = 1
findepisode = True
if not findepisode:
trycount += 1
print("30秒後に再接続する.......")
sleep(30)
return True, detail['playUrl32'] + '\n'
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 = "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 episode(self, show, episode_dict):
# Find the publication date
publication_datetime_str = str(episode_dict['dato']) + " 00:00:00"
publication_datetime_format = "%Y%m%d %H:%M:%S"
# Start out with midnight
publication_date = datetime.datetime.strptime(
publication_datetime_str, publication_datetime_format)
# Then go to the specified time
publication_datetime_naive = \
publication_date + datetime.timedelta(seconds=episode_dict['time'])
# And associate a timezone with that datetime
timezone = pytz.timezone("Europe/Oslo")
publication_datetime_aware = \
timezone.localize(publication_datetime_naive)
# Create our episode object
return Episode(
show=show,
media=Media(episode_dict['url'], episode_dict['filesize'], None,
datetime.timedelta(seconds=episode_dict['duration'])),
id="radiorevolt.no/podkast/episode/" + str(episode_dict['id']),
deprecated_url=episode_dict['deprecated_url'],
title=episode_dict['title'],
long_summary=linkify(htmlencode(episode_dict['comment'])).replace(
"\n", "<br/>\n"),
publication_date=publication_datetime_aware,
authors=[Person(name=episode_dict['author'])]
if episode_dict['author'] else [],
)
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 main():
"""Create an example podcast and print it or save it to a file."""
# There must be exactly one argument, and it is must end with rss
if len(sys.argv) != 2 or not (
sys.argv[1].endswith('rss')):
# Invalid usage, print help message
# print_enc is just a custom function which functions like print,
# except it deals with byte arrays properly.
print_enc ('Usage: %s ( <file>.rss | rss )' % \
'python -m podgen')
print_enc ('')
print_enc (' rss -- Generate RSS test output and print it to stdout.')
print_enc (' <file>.rss -- Generate RSS test teed and write it to file.rss.')
print_enc ('')
exit()
# Remember what type of feed the user wants
arg = sys.argv[1]
from podgen import Podcast, Person, Media, Category, htmlencode
# Initialize the feed
p = Podcast()
p.name = 'Testfeed'
p.authors.append(Person("Lars Kiesow", "*****@*****.**"))
p.website = 'http://example.com'
p.copyright = 'cc-by'
p.description = 'This is a cool feed!'
p.language = 'de'
p.feed_url = 'http://example.com/feeds/myfeed.rss'
p.category = Category('Technology', 'Podcasting')
p.explicit = False
p.complete = False
p.new_feed_url = 'http://example.com/new-feed.rss'
p.owner = Person('John Doe', '*****@*****.**')
p.xslt = "http://example.com/stylesheet.xsl"
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))
# Should we just print out, or write to file?
if arg == 'rss':
# Print
print_enc(p.rss_str())
elif arg.endswith('rss'):
# Write to file
p.rss_file(arg, minimize=True)
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_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 album(self):
page = requests.get(self.album_url, headers=self.header)
soup = BeautifulSoup(page.content, "lxml")
# 初始化
self.podcast = Podcast()
self.podcast.name = soup.find('h1', 'title').get_text()
self.podcast.authors.append(Person("Powered by forecho", '*****@*****.**'))
self.podcast.website = self.album_url
self.podcast.copyright = 'cc-by'
if soup.find('div', 'album-intro') and soup.find('div', 'album-intro').get_text():
self.podcast.description = soup.find('div', 'album-intro').get_text()
else:
self.podcast.description = self.podcast.name
self.podcast.language = 'cn'
self.podcast.image = soup.find('div', 'album-info').find('img').get('src').split('!')[0]
self.podcast.feed_url = 'http://podcast.forecho.com/ximalaya/%s.rss' % self.album_id
self.podcast.category = Category('Technology', 'Podcasting')
self.podcast.explicit = False
self.podcast.complete = False
self.podcast.owner = Person("forecho", '*****@*****.**')
album_list_content = requests.get(self.album_list_api, headers=self.header).content
album_list_data = json.loads(album_list_content.decode('utf-8'))
count = len(album_list_data['data']['tracksAudioPlay'])
for each in album_list_data['data']['tracksAudioPlay']:
try:
detail_url = 'http://www.ximalaya.com/tracks/%s.json' % each['trackId']
response = requests.get(detail_url, headers=self.header)
item = json.loads(response.content)
episode = self.podcast.add_episode()
episode.id = str(each['index'])
episode.title = each['trackName']
print(self.podcast.name + '=====' + each['trackName'])
image = each['trackCoverPath'].split('!')[0]
if (image[-4:] == '.gif' or image[-4:] == '.bmp'):
episode.image = self.podcast.image
else:
episode.image = image
if item['intro']:
episode.summary = item['intro'].replace('\r\n', '')
else:
episode.summary = each['trackName']
episode.link = 'http://www.ximalaya.com%s' % each['albumUrl']
episode.authors = [Person("forecho", '*****@*****.**')]
episode.publication_date = self.reduction_time(item['time_until_now'], item['formatted_created_at'])
episode.media = Media(each['src'], each['duration'])
episode.position = count - each['index'] + 1
except Exception as e:
print('异常:', e)
print('异常 URL:', 'http://www.ximalaya.com%s' % each['trackUrl'])
traceback.print_exc()
# 生成文件
# print self.podcast.rss_str()
self.podcast.rss_file('ximalaya/%s.rss' % self.album_id, minimize=True)
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 test_assigningUrl(self):
m = Media(self.url)
another_url = "http://example.com/2016/5/17/The+awful+episode.mp3"
m.url = another_url
assert m.url == another_url
# Test that setting url to None or empty string fails
self.assertRaises((ValueError, TypeError), setattr, m, "url", None)
assert m.url == another_url
self.assertRaises((ValueError, TypeError), setattr, m, "url", "")
assert m.url == another_url
def test_assigningType(self):
m = Media(self.url, self.size, self.type)
another_type = "audio/x-mpeg-3"
m.type = another_type
assert m.type == another_type
# Test that setting type to None or empty string fails
self.assertRaises((ValueError, TypeError), setattr, m, "type", None)
assert m.type == another_type
self.assertRaises((ValueError, TypeError), setattr, m, "type", "")
assert m.type == another_type
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 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 test_calculateDuration(self, mock_tinytag):
# Return the correct number of seconds from TinyTag
seconds = 14.0 * 60.0
mock_tinytag.get.return_value.duration = seconds
filename = "my_little_file.mp3"
m = Media(self.url, self.size, self.type)
m.populate_duration_from(filename)
self.assertAlmostEqual(m.duration.total_seconds(), seconds, places=0)
# Check that the underlying library is used correctly
mock_tinytag.get.assert_called_once_with(filename)
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_media(self):
media = Media("http://example.org/episodes/1.mp3", 14536453,
"audio/mpeg")
self.fe.media = media
enclosure = self.fe.rss_entry().find("enclosure")
self.assertEqual(enclosure.get("url"), media.url)
self.assertEqual(enclosure.get("length"), str(media.size))
self.assertEqual(enclosure.get("type"), media.type)
# Ensure duck-typing is checked at assignment time
self.assertRaises(TypeError, setattr, self.fe, "media", media.url)
self.assertRaises(TypeError, setattr, self.fe, "media",
(media.url, media.size, media.type))
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 generate_rss_from_articles(feed_settings, articles):
"""
Creates a FeedGenerator feed from a set of feed_entries.
:param feed_settings: a feed_settings object containing
:param articles:
:return:
"""
# Initialize the feed
podcast = Podcast()
podcast.name = feed_settings.title
author = Person(feed_settings.author['name'], feed_settings.author['email'])
podcast.authors.append(author)
podcast.website = feed_settings.source_page_url
podcast.copyright = feed_settings.copyright
podcast.description = feed_settings.subtitle
podcast.summary = feed_settings.subtitle
podcast.subtitle = feed_settings.subtitle
podcast.language = 'vi'
podcast.feed_url = feed_settings.output_url
podcast.image = feed_settings.img_url
podcast.category = Category('Music', 'Music Commentary')
podcast.explicit = False
# p.complete = False
# p.new_feed_url = 'http://example.com/new-feed.rss'
podcast.owner = author
# p.xslt = "http://example.com/stylesheet.xsl"
vt_tz = pytz.timezone('Asia/Ho_Chi_Minh')
pastdate = datetime.datetime(2000, 1, 1, 0, 0).astimezone(vt_tz)
# podcast.last_updated = datetime.datetime.now(vt_tz)
for article in articles:
episode = podcast.add_episode()
episode.id = article.link
episode.title = article.title
episode.summary = article.description
episode.link = article.link
# episode.authors = [Person('Lars Kiesow', '*****@*****.**')]
episode.publication_date = article.pub_date
pastdate = max(pastdate, article.pub_date)
# episode.media = Media.create_from_server_response(article.media, size=None, duration=None)
episode.media = Media(article.media, size=None, duration=None, type=article.type)
podcast.last_updated = pastdate
podcast.publication_date = pastdate
return podcast
def detail(self, sound_id, date):
detail_url = 'http://www.ximalaya.com/tracks/%s.json' % sound_id
response = requests.get(detail_url, headers=self.header)
item = json.loads(response.content)
episode = self.podcast.add_episode()
episode.id = str(item['id'])
episode.title = item['title']
episode.image = item['cover_url_142'].split('?')[0]
episode.summary = (item['intro'].replace('\n', '') if item['intro'] else '')
episode.link = 'http://www.ximalaya.com/sound/%d' % item['id']
episode.authors = [Person("forecho", '*****@*****.**')]
episode.publication_date = self.reduction_time(
date, item['formatted_created_at'])
episode.media = Media(item['play_path_64'], 454599964)
print self.podcast.name + '=====' + item['title']
def add_episodes(p, response):
e = p.add_episode()
e.id = response[1]
e.title = response[3]
e.summary = response[4]
e.publication_date = response[5]
e.image = "http://3.15.38.214/zarahatkay/cover_art.png" #response[6]
e.explicit = False
e.media = Media(
response[2],
#size=17475653,
type="audio/mpeg" # Optional, can be determined
# from the url
#duration=timedelta(hours=1, minutes=2, seconds=36)
)
return p
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 test_warningGivenIfNotSupportedByItunes(self):
with warnings.catch_warnings(record=True) as w:
self.assertEqual(len(w), 0)
# Use a type not supported by itunes
self.test_anyExtensionAllowedWithType()
# Check that two warnings were issued
self.assertEqual(len(w), 2)
# Warning: file extension not recognized
assert issubclass(w[0].category, NotSupportedByItunesWarning), \
str(w[0])
# Warning: type not recognized
assert issubclass(w[1].category, NotSupportedByItunesWarning)
# Use url extension supported by itunes, but a type not supported
m = Media(self.url, self.size, "audio/mpeg3")
# Check that a new warning was issued
assert len(w) == 3
# Warning: type not recognized
assert issubclass(w[2].category, NotSupportedByItunesWarning)
def test_autoRecognizeType(self):
url = "http://example.com/2016/5/17/The+converted+episode%s"
# Mapping between url file extension and type given by iTunes
# https://help.apple.com/itc/podcasts_connect/#/itcb54353390
types = {
'.mp3': set(["audio/mpeg"]),
'.MP3': set(["audio/mpeg"]), # case shouldn't matter
'.m4a': set(["audio/x-m4a"]),
'.mov': set(["video/quicktime"]),
'.mp4': set(["video/mp4"]),
'.m4v': set(["video/x-m4v"]),
'.pdf': set(["application/pdf"]),
'.epub': set(["document/x-epub"]),
}
for (file_extension, allowed_types) in iteritems(types):
m = Media(url % file_extension)
assert m.type in allowed_types, "%s gave type %s, expected %s" % \
(file_extension, m.type,
allowed_types)
def test_durationToStr(self):
m = Media(self.url, self.size, self.type, timedelta(hours=1))
self.assertEqual(m.duration_str, "01:00:00")
m.duration = timedelta(days=1)
self.assertEqual(m.duration_str, "24:00:00")
m.duration = timedelta(minutes=1)
self.assertEqual(m.duration_str, "01:00")
m.duration = timedelta(seconds=1)
self.assertEqual(m.duration_str, "00:01")
m.duration = timedelta(days=1, hours=2)
self.assertEqual(m.duration_str, "26:00:00")
m.duration = timedelta(hours=1, minutes=32, seconds=13)
self.assertEqual(m.duration_str, "01:32:13")
m.duration = timedelta(hours=1, minutes=9, seconds=3)
self.assertEqual(m.duration_str, "01:09:03")