def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("datafile")
parser.add_argument("--sections", default="")
asmyoutube.add_auth_args(parser)
args = parser.parse_args(argv[1:])
yt_service = asmyoutube.get_authenticated_service(args)
entry_data = asmmetadata.parse_file(open(args.datafile, "rb"))
if args.sections:
included_sections = set(
[x.lower().strip() for x in args.sections.split(",")])
included_entries = []
for entry in entry_data.entries:
if entry["section"]["key"] in included_sections:
included_entries.append(entry)
entry_data.entries = included_entries
try:
update_youtube_info(yt_service, entry_data)
except KeyboardInterrupt:
print "Interrupted"
return os.EX_DATAERR
return os.EX_OK
def main(argv=sys.argv):
parser = argparse.ArgumentParser()
parser.add_argument("datafile")
parser.add_argument(
"--privacy", default="public",
choices=["public", "private", "unlisted"])
parser.add_argument("--section", default="")
asmyoutube.add_auth_args(parser)
args = parser.parse_args(argv[1:])
yt_service = asmyoutube.get_authenticated_service(args)
entry_data = asmmetadata.parse_file(open(args.datafile, "rb"))
result = os.EX_OK
sections = []
if args.section:
sections = [x.strip() for x in args.section.split(",")]
try:
update_youtube_playlists(
yt_service, entry_data, sections, args.privacy)
except KeyboardInterrupt:
result = os.DATAERR
print "Interrupted"
except Exception, e:
result = os.EX_SOFTWARE
print "EXCEPTION Unknown exception happened: %s" % e
def main(argv):
parser = argparse.ArgumentParser(description='Upload videos to Youtube.')
parser.add_argument('metadata_file', metavar="metadata-file")
parser.add_argument('files_root', metavar="files-root")
parser.add_argument('--video-postfix', default=".mp4")
parser.add_argument('--dry-run', action="store_true")
parser.add_argument('--media-vod-directory')
parser.add_argument(
'--privacy', default="public", choices=["public", "unlisted", "private"])
args = parser.parse_args(argv[1:])
files_root = args.files_root
video_postfix = args.video_postfix
media_vod_directory = args.media_vod_directory
privacy = args.privacy
sleep_function = time.sleep
if args.dry_run:
sleep_function = lambda x : None
call_and_capture_output = call_and_capture_output_fake
else:
call_and_capture_output = call_and_capture_output_real
metadata = asmmetadata.parse_file(open(args.metadata_file, "rb"))
state = State(
files_root=files_root,
media_vod_directory=media_vod_directory)
try:
for entry in metadata.entries:
handle_entry(
call_and_capture_output, sleep_function, privacy, state, entry)
except:
asmmetadata.print_metadata(
open(args.metadata_file, "wb"), metadata)
raise
asmmetadata.print_metadata(
open(args.metadata_file, "wb"), metadata)
if args.dry_run:
return 1
return os.EX_OK
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("datafile")
parser.add_argument("attribute_name", metavar="attribute-name")
parser.add_argument("value_prefix", metavar="value-prefix")
parser.add_argument("directory")
parser.add_argument("section", type=unicode)
args = parser.parse_args(argv[1:])
entry_data = asmmetadata.parse_file(open(args.datafile, "rb"))
section = entry_data.getSection(args.section)
for _, _, filenames in os.walk(args.directory):
filenames = [x.decode("utf-8") for x in filenames]
# Just get the filenames.
break
for entry in section["entries"]:
best_matches = select_best_candidates(entry, filenames)
not_used_matches = []
if len(best_matches) == 0:
sys.stderr.write("NO MATCH: %s\n" % entry["title"])
continue
elif len(best_matches) > 1:
best_match = select_bestest_match(entry, best_matches)
else:
best_match, = best_matches
not_used_matches = best_matches[:]
not_used_matches.remove(best_match)
print("%s -> %s" % (asmmetadata.get_entry_key(entry), best_match))
if len(not_used_matches) > 0:
print(" UNUSED: %s" % ", ".join(not_used_matches))
entry[args.attribute_name] = "%s:%s%s" % (
args.attribute_name, args.value_prefix, best_match)
for match in best_matches:
filenames.remove(match)
if len(filenames) > 0:
print("EXTRA: %s" % ", ".join(filenames))
asmmetadata.print_metadata(open(args.datafile, "wb"), entry_data)
import asmmetadata
import os
import os.path
import subprocess
import sys
target_directory = sys.argv[1]
if not os.path.exists(target_directory):
print "Target directory %s does not exist!" % target_directory
sys.exit(1)
entry_data = asmmetadata.parse_file(sys.stdin)
for entry in entry_data.entries:
if 'sceneorg' not in entry:
continue
sceneorg_path = entry['sceneorg']
section_directory = entry['section']['key'].replace("-", "_")
file_directory = asmmetadata.normalize_key("%s by %s" % (entry['title'], entry['author'])).replace("-", "_")
download_directory = os.path.join(
target_directory,
section_directory,
file_directory,
)
if not os.path.exists(download_directory):
os.makedirs(download_directory)
download_file = os.path.join(
download_directory,
os.path.basename(sceneorg_path)
)
download_url = "ftp://ftp.scene.org/pub%s" % sceneorg_path
entries = compo.getElementsByTagName("entry")
for entry in entries:
entry_id = entry.getAttribute("id")
entry_position_str = entry.getAttribute("place") or '0'
techniques = entry.getAttribute("techniques")
if len(techniques) == 0:
techniques = None
platform = entry.getAttribute("platform")
if len(platform) == 0:
platform = None
entry_position = int(entry_position_str) or None
iddata[entry_id] = (entry_position, techniques, platform)
import asmmetadata
parsed = asmmetadata.parse_file(open(args.datafile))
for entry in parsed.entries:
if 'pms-id' not in entry:
continue
_, _, pms_id = entry['pms-id'].split("/")
if pms_id not in iddata:
# This probably means that results of a category are not public.
continue
place, techniques, platform = iddata[pms_id]
entry['position'] = place
if techniques is not None:
# techniques = techniques.replace("\\", "\\\\")
# techniques = techniques.replace("\n", "\\n")
entry['techniques'] = techniques
if platform is not None:
import argparse
import asmmetadata
import requests
import sys
import xml.dom.minidom
parser = argparse.ArgumentParser()
parser.add_argument("metadata_file")
parser.add_argument("elaine_vods_url")
parser.add_argument("elaine_pms_vodlist_url")
args = parser.parse_args()
metadata_fp = open(args.metadata_file, "rb")
metadata = asmmetadata.parse_file(metadata_fp)
vodlist_result = requests.get(args.elaine_pms_vodlist_url)
if vodlist_result.status_code != 200:
sys.stderr.write(
"Vodlist request to %s failed\n" % args.elaine_pms_vodlist_url)
sys.exit(1)
vodlist = vodlist_result.text
elaine_pms_map = {}
for line in vodlist.split("\n"):
elaine_id, pms_id = (line.split(":", 1) + ["", ""])[:2]
if not pms_id:
continue
elaine_pms_map[elaine_id] = pms_id
vod_xml_result = requests.get(args.elaine_vods_url)
import argparse
import asmmetadata
import re
import shutil
import tempfile
import util
import xml.dom.minidom
parser = argparse.ArgumentParser()
parser.add_argument("asmdatafile", type=argparse.FileType("r+b"))
parser.add_argument("elainexml", type=util.argparseTypeUrlOpenable)
args = parser.parse_args()
doc = xml.dom.minidom.parse(args.elainexml)
metadata_filename = args.asmdatafile.name
event_data = asmmetadata.parse_file(args.asmdatafile)
args.asmdatafile.close()
items = doc.getElementsByTagName("item")
def get_languaged_tag(item, tagname):
nodes = item.getElementsByTagName(tagname)
values = {}
for node in nodes:
value = None
if node.firstChild is not None:
value = node.firstChild.nodeValue
language = node.getAttribute("xml:lang")
values[language] = value
return values
cut_region = (cut_left, cut_top, cut_left + cut_width, cut_top + cut_height)
cropped = inphoto.crop(cut_region)
scaled = cropped.resize((args.width, args.height), Image.ANTIALIAS)
full_title = "%s by %s" % (entry['title'], entry['author'])
section_name = asmmetadata.normalize_key(entry['section']['name'])
thumbnail_path = os.path.join(args.data_root, "thumbnails", "small", section_name)
basename = asmmetadata.normalize_key(full_title)
jpeg_file = os.path.join(thumbnail_path, basename + ".jpeg")
scaled.save(jpeg_file)
png_file = os.path.join(thumbnail_path, basename + ".png")
scaled.save(png_file)
entry_data = asmmetadata.parse_file(args.asmmetadata)
for entry in entry_data.entries:
section = asmmetadata.normalize_key( entry['section']['name'])
if "photos" not in section:
continue
section_name = asmmetadata.normalize_key(entry['section']['name'])
file_base = os.path.join(args.data_root, section_name)
full_title = "%s by %s" % (entry['title'], entry['author'])
basename = asmmetadata.normalize_key(full_title)
source_file = os.path.join(file_base, basename + ".jpeg")
if not os.path.isfile(source_file):
continue
create_small_thumbnail_file(args, source_file, entry)
