def __init__( self, audio_file, file_ext, options ):
self.file = audio_file
self.filename = ""
self.directory = os.path.dirname( self.file.filename )
self.ext = file_ext
self.file_data = metadata.Metadata()
self.processed_data = metadata.Metadata()
self.release = None
self.ParseFileMetadata()
self.errors = False
self.matched_medium_track = None
def add(self, name, st, meta_ofs, hashgen = None):
endswith = name.endswith('/')
ename = pathsplit(name)
basename = ename[-1]
#log('add: %r %r\n' % (basename, name))
flags = IX_EXISTS
sha = None
if hashgen:
(gitmode, sha) = hashgen(name)
flags |= IX_HASHVALID
else:
(gitmode, sha) = (0, EMPTY_SHA)
if st:
isdir = stat.S_ISDIR(st.st_mode)
assert(isdir == endswith)
e = NewEntry(basename, name, self.tmax,
st.st_dev, st.st_ino, st.st_nlink,
st.st_ctime, st.st_mtime, st.st_atime,
st.st_uid, st.st_gid,
st.st_size, st.st_mode, gitmode, sha, flags,
meta_ofs, 0, 0)
else:
assert(endswith)
meta_ofs = self.metastore.store(metadata.Metadata())
e = BlankNewEntry(basename, meta_ofs, tmax)
e.gitmode = gitmode
e.sha = sha
e.flags = flags
self._add(ename, e)
def open_metadata(self, path=None):
if not path:
path = self.cache_path(os.path.basename(METADATA_DOWNLOAD_FILE))
path = self.cache.abspath(path)
if self.cache.exists(path):
return metadata.Metadata(self.pakfire, path)
def correctImages(inputPath, outputPath):
# Reads all tiff images in an input folder
# Correct the distortion
# Then writes the undistorted image to the output folder
# Also copies the metadata from the raw image to the undistorted image
image_list = []
for filename in glob.glob(inputPath + '/*.tif'):
image_list.append(filename)
for item in sorted(image_list):
print(item)
fileItem = os.path.basename(item)
print(fileItem)
print(outputPath + fileItem)
meta = metadata.Metadata(item)
flightImageRaw = cv2.imread(item,
cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
flightUndistorted = correct_lens_distortion(meta, flightImageRaw)
resultPath = outputPath + fileItem
tiff.imsave(resultPath, flightUndistorted)
copyMetadata(item, resultPath)
return
def id(self, pathname, name, parent):
stat = os.lstat(pathname)
size = stat.st_size
cached_info = self.file_db.find_one({'name': name, 'parent': parent})
cf = cached_file.CachedFile.FromStat(self, None, stat)
# hasChanged should be internal to file
# file should provide a method that returns file_info
# it should return cached if not hasChanged (and cache exists)
# it should take a filename and a cached value and say if the
# cached value is stale
if cached_info and not cf.hasChanged(cached_info):
return cached_info['_id']
if cf.isRegularFile:
mf = metadata.Metadata(pathname, size)
my_metadata = mf.metadata()
# the rest of this logic should be cachedFile updating
# the cache
try:
cf.digest = my_metadata['digest']
except KeyError:
pass
try:
cf.tags = pymongo.binary.Binary(
pickle.dumps(my_metadata['tags'], pickle.HIGHEST_PROTOCOL))
except KeyError:
pass
return self.add(cf, pathname)
def test_init(self):
"""
The metadata object appears to need to be created while CWD is
in the root of a git repo containing a file called '<name>.yml'
This file must contain a structure:
{'distgit': {'namespace': '<value>'}}
The metadata object requires:
a type string <image|rpm>
a Runtime object placeholder
"""
mt = 'image'
rt = MockRuntime(self.logger)
name = 'test.yml'
md = metadata.Metadata(mt, rt, name)
#
# Check the logs
#
logs = [l.rstrip() for l in open(self.test_file).readlines()]
expected = 6
actual = len(logs)
self.assertEqual(
expected, actual,
"logging lines - expected: {}, actual: {}".format(
expected, actual))
def merge_file_metadata(dup_dict, base_dir=''):
"""merge_file_metadata
given a dictionary of file_names and file metadata
of files that all have the same content
create a new file with that content and merged metadata
or raise an exception if there is a merge conflict
"""
metadatas = dup_dict.values()
old_file_name = dup_dict.keys()[0]
try:
merged_metadata_dict = merge(metadatas)
if merged_metadata_dict is None:
return None
except MergeConflict as exc:
print exc
return None
try:
old_file = metadata.Metadata(old_file_name)
new_file_name = os.path.join(base_dir, old_file.canonical_name)
except file_with_metadata.NoCanonicalName:
return
try:
os.makedirs(os.path.dirname(new_file_name))
except OSError:
pass
shutil.copy(old_file_name, new_file_name)
print "copying to ", new_file_name,
replace_metadata(new_file_name, merged_metadata_dict)
print " done."
def _golevel(level, f, ename, newentry, metastore, tmax):
# close nodes back up the tree
assert(level)
default_meta_ofs = metastore.store(metadata.Metadata())
while ename[:len(level.ename)] != level.ename:
n = BlankNewEntry(level.ename[-1], default_meta_ofs, tmax)
n.flags |= IX_EXISTS
(n.children_ofs,n.children_n) = level.write(f)
level.parent.list.append(n)
level = level.parent
# create nodes down the tree
while len(level.ename) < len(ename):
level = Level(ename[:len(level.ename)+1], level)
# are we in precisely the right place?
assert(ename == level.ename)
n = newentry or \
BlankNewEntry(ename and level.ename[-1] or None, default_meta_ofs, tmax)
(n.children_ofs,n.children_n) = level.write(f)
if level.parent:
level.parent.list.append(n)
level = level.parent
return level
def update_metadata(self, force=False, offline=False):
filename = os.path.join(METADATA_DOWNLOAD_PATH, METADATA_DOWNLOAD_FILE)
cache_filename = self.cache_path(os.path.basename(filename))
# Check if the metadata is already recent enough...
exists = self.cache.exists(cache_filename)
if not exists and offline:
raise OfflineModeError, _("No metadata available for repository %s. Cannot download any.") \
% self.name
elif exists and offline:
# Repository metadata exists. We cannot update anything because of the offline mode.
return
if not force and exists:
age = self.cache.age(cache_filename)
if age and age < TIME_10M:
log.debug(
"Metadata is recent enough. I don't download it again.")
return
# Going to download metada.
log.debug("Going to download repository metadata for %s..." %
self.name)
assert not offline
grabber = downloader.MetadataDownloader(self.pakfire)
grabber = self.mirrors.group(grabber)
while True:
try:
data = grabber.urlread(filename, limit=METADATA_DOWNLOAD_LIMIT)
except urlgrabber.grabber.URLGrabError, e:
if e.errno == 256:
raise DownloadError, _(
"Could not update metadata for %s from any mirror server"
) % self.name
grabber.increment_mirror(grabber)
continue
# Parse new metadata for comparison.
md = metadata.Metadata(self.pakfire, metadata=data)
if self.metadata and md < self.metadata:
log.warning(
_("The downloaded metadata was less recent than the current one."
))
grabber.increment_mirror(grabber)
continue
# If the download went well, we write the downloaded data to disk
# and break the loop.
f = self.cache.open(cache_filename, "w")
f.write(data)
f.close()
break
def __init__(self, parent):
self.parent = parent
self.phonon = self.parent.phonon
self.playlist = self.parent.playlist
self.media_object = self.parent.media_object
self.metadata = metadata.Metadata()
self.shuffle_mode = False
self.repeat_mode = False
self.mute = False
self._current_artist = ""
self._current_track = ""
def __init__(self, filepath=None):
self._version = 1
self.label = None
self.created_at = None
self.saved_at = None
self.units = None
self.metadata = metadata.Metadata()
self.values = None
self.kdtree = None
if filepath is not None:
self.load(filepath)
def metadata_error(self, error):
with patch('io.open',
mockOpen([id3v2_header, id3v1_trailer[:3],
'1234'])) as mock_open:
with patch('mutagen.File', Mock(side_effect=error)):
# with warnings.catch_warnings(record=True) as w:
# warnings.simplefilter("always")
try:
f = metadata.Metadata(
'test_file',
len(id3v2_header + id3v1_trailer[:3] + '1234'))
info = f.metadata
except TypeError:
print mock_open.mock_calls
def _initialize(self):
# Create state directory.
if not os.path.exists(K.STATE_DIR):
os.mkdir(K.STATE_DIR)
# Create upload thread (started in run() below).
self._uploader = uploader.Uploader(self._main_cq,
self._uploader_termination_event)
# Create data sources.
GPIO.setmode(GPIO.BCM) # required before Wind()
self._uploader.add_data_source(temperature.Temperature(), True)
self._uploader.add_data_source(metadata.Metadata(), False)
# Import modules only when enabled, since some again import optional libraries (e.g. DHT).
# In demo mode, enable all and import demo instances.
if True: # TODO: Make wind optional.
if C.DEMO_MODE_ENABLED():
import demo.demo_wind as wind # @UnusedImport
else:
import wind # @Reimport
self._uploader.add_data_source(wind.Wind(), True)
if C.DHT_ENABLED() or C.DEMO_MODE_ENABLED():
if C.DEMO_MODE_ENABLED():
import demo.demo_dht as dht # @UnusedImport
else:
import dht # @Reimport
self._uploader.add_data_source(dht.Dht(), True)
if C.ADC_ENABLED() or C.DEMO_MODE_ENABLED():
if C.DEMO_MODE_ENABLED():
import demo.demo_spi_adc as spi_adc # @UnusedImport
else:
import spi_adc # @Reimport
self._uploader.add_data_source(spi_adc.SpiAdc(), True)
if C.HUAWEI_ENABLED() or C.DEMO_MODE_ENABLED():
if C.DEMO_MODE_ENABLED():
import demo.demo_huawei_status as huawei_status # @UnusedImport
else:
import huawei_status # @Reimport
self._uploader.add_data_source(huawei_status.HuaweiStatus(), True)
if C.DOOR_ENABLED() or C.DEMO_MODE_ENABLED():
if C.DEMO_MODE_ENABLED():
import demo.demo_door as door # @UnusedImport
else:
import door # @Reimport
self._uploader.add_data_source(door.Door(), True)
if C.PILOTS_ENABLED() or C.DEMO_MODE_ENABLED():
if C.DEMO_MODE_ENABLED():
import demo.demo_pilot_count as pilot_count # @UnusedImport
else:
import pilot_count # @Reimport
self._uploader.add_data_source(pilot_count.PilotCount(), True)
def correctRaReDe(inputPath, outputPath):
# Reads all the tiff images in an input folder
# Converts each images to radiance
# Converts radiance to reflectance
# Converts reflectance to undistorted image
# Unfinished -- causes the undistorted image to be quite a bit darker
# Than it otherwise would be
#
image_list = []
for filename in glob.glob(inputPath + '/*.tif'):
image_list.append(filename)
for item in sorted(image_list):
print(item)
fileItem = os.path.basename(item)
print(fileItem)
print(outputPath + fileItem)
meta = metadata.Metadata(item)
flightImageRaw = cv2.imread(item,
cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
flightUndistorted = correct_lens_distortion(meta, flightImageRaw)
resultPath = outputPath + fileItem
tiff.imsave(resultPath, flightUndistorted)
copyMetadata(item, resultPath)
return
flightRadianceImage, _, _, _ = utils.raw_image_to_radiance(
meta, flightImageRaw)
plotutils.plotwithcolorbar(flightRadianceImage, 'Radiance Image')
radianceToReflectance = utils.radiance_to_reflectance(
meta.band_name(), flightRadianceImage, flightImageRaw)
print(radianceToReflectance)
flightReflectanceImage = flightRadianceImage * radianceToReflectance
plotutils.plotwithcolorbar(flightReflectanceImage, 'Reflectance converted')
flightUndistortedReflectance = utils.correct_lens_distortion(
meta, flightReflectanceImage)
fUR = flightUndistortedReflectance * 255
#flightUndistortedReflectance
#plt.imsave('Result.tiff', flightUndistortedReflectance)
#plt.imsave("Result.tiff", fUR)
plotutils.plotwithcolorbar(flightUndistortedReflectance,
'Reflectance converted and undistorted')
tiff.imsave('RadReflUndis.tif', flightUndistortedReflectance)
def __init__(self, id_):
self.songs = list()
self.fetched = False
self.valid = True
self.art = None
self.data = None
self.processed_data = metadata.Metadata()
self.fetch_attempts = 0
Release.num_loaded += 1
try:
uuid.UUID(id_)
except ValueError:
utils.safeprint(u"Corrupt UUID in file.")
self.valid = False
else:
self.id = id_
def _script_to_filename( self, format_string, options ):
# Do format script replacing here.
script_data = metadata.Metadata()
script_data.copy( self.processed_data )
filename = script.ScriptParser().eval( format_string, script_data, self )
filename = filename.replace( "\x00", "" ).replace( "\t", "" ).replace( "\n", "" )
# replace incompatible characters
if options["windows_compatible_filenames"] or sys.platform == "win32":
filename = utils.replace_win32_incompat( filename )
if options["ascii_filenames"]:
if isinstance( filename, unicode ):
filename = utils.unaccent( filename )
filename = utils.replace_non_ascii( filename )
return filename
def Parse(self, string):
"""Parse a Pack2 definition string."""
self.valid = True
self.metadata = metadata.Metadata()
self.errors = []
try:
self.parser.parse(string, tracking=True)
except IndexError as e:
# Due to a bug in PLY, an index error is caused if we raise a syntax
# error. If we've previously raised a syntax error, ignore it so that
# we can raise a ParseError instead.
if self.valid:
raise e
if not self.valid:
raise ParseError('Parse Error', self.errors)
return self.metadata
def __init__(self, config):
traverseLogger.info('Setting up service...')
global currentService
currentService = self
self.config = config
self.proxies = dict()
self.active = False
config['configuri'] = ('https' if config.get('usessl', True) else 'http') + '://' + config['targetip']
httpprox = config['httpproxy']
httpsprox = config['httpsproxy']
self.proxies['http'] = httpprox if httpprox != "" else None
self.proxies['https'] = httpsprox if httpsprox != "" else None
# Convert list of strings to dict
self.chkcertbundle = config['certificatebundle']
chkcertbundle = self.chkcertbundle
if chkcertbundle not in [None, ""] and config['certificatecheck']:
if not os.path.isfile(chkcertbundle) and not os.path.isdir(chkcertbundle):
self.chkcertbundle = None
traverseLogger.error('ChkCertBundle is not found, defaulting to None')
else:
config['certificatebundle'] = None
ChkCert = config['certificatecheck']
AuthType = config['authtype']
self.currentSession = None
if not config.get('usessl', True) and not config['forceauth']:
if config['username'] not in ['', None] or config['password'] not in ['', None]:
traverseLogger.warning('Attempting to authenticate on unchecked http/https protocol is insecure, if necessary please use ForceAuth option. Clearing auth credentials...')
config['username'] = ''
config['password'] = ''
if AuthType == 'Session':
certVal = chkcertbundle if ChkCert and chkcertbundle is not None else ChkCert
# no proxy for system under test
self.currentSession = rfSession(config['username'], config['password'], config['configuri'], None, certVal, self.proxies)
self.currentSession.startSession()
self.metadata = md.Metadata(traverseLogger)
self.active = True
def create(self, path, id, original_path):
"""
create a new image package at the targeted path
"""
real_path = validate_path(path, 'directory')
os.makedirs(
os.path.join(real_path, id, 'temp')
) # don't we need to destroy this when done? what is it for?
self.path = os.path.join(real_path, id)
self.id = id
self.manifest = manifest.Manifest(os.path.join(self.path,
'manifest-sha1.txt'),
create=True)
self.__import_original__(original_path)
self.master = self.__generate_master__()
self.original = os.path.basename(original_path)
self.make_derivatives()
self.metadata = metadata.Metadata(os.path.join(self.path, 'meta.xml'),
create=True,
exiftool_json=os.path.join(
self.path, 'original-exif.json'))
self.make_overview()
self.__append_event__(
'created package at {path}'.format(path=self.path))
def open(self, path):
"""
open an existing image package at the targeted path
"""
logger = logging.getLogger(sys._getframe().f_code.co_name)
self.path = validate_path(path, 'directory')
self.id = os.path.basename(self.path)
# verify original and master and metadata and checksums
# TBD
# open manifest and metadata
self.manifest = manifest.Manifest(
os.path.join(self.path, 'manifest-sha1.txt'))
try:
self.metadata = metadata.Metadata(
os.path.join(self.path, 'meta.xml'))
except IOError:
logger.warning(
"no meta.xml file was found in the package for this image ({0})"
.format(self.id))
raise
# see if there is an original file yet
filenames = self.manifest.get_all().keys()
for filename in filenames:
if 'original.' in filename:
front, extension = os.path.splitext(filename)
if 'sha1' not in extension:
self.original = filename
try:
o = self.original
except AttributeError:
logger.error(
"no original image file was found in the package for this image ({0})"
.format(self.id))
raise
self.make_overview()
import argparse
import metadata
parser = argparse.ArgumentParser(
description='Get metadata value of query parameters')
parser.add_argument('--dir_path',
type=str,
help='Path to the directory of the metadata file',
required=True)
parser.add_argument(
'--get',
type=str,
help=
'Query to execute. If query parameter is found,it return the value/dict of values'
)
args = parser.parse_args()
mtd = metadata.Metadata(args.dir_path)
mtd.get_cli(args.get)
def __init__(self, config, default_entries=[]):
traverseLogger.info('Setting up service...')
global currentService
currentService = self
self.config = config
self.proxies = dict()
self.active = False
config['configuri'] = ('https' if config.get('usessl', True) else
'http') + '://' + config['targetip']
httpprox = config['httpproxy']
httpsprox = config['httpsproxy']
self.proxies['http'] = httpprox if httpprox != "" else None
self.proxies['https'] = httpsprox if httpsprox != "" else None
# Convert list of strings to dict
self.chkcertbundle = config['certificatebundle']
chkcertbundle = self.chkcertbundle
if chkcertbundle not in [None, ""] and config['certificatecheck']:
if not os.path.isfile(chkcertbundle) and not os.path.isdir(
chkcertbundle):
self.chkcertbundle = None
traverseLogger.error(
'ChkCertBundle is not found, defaulting to None')
else:
config['certificatebundle'] = None
ChkCert = config['certificatecheck']
AuthType = config['authtype']
self.currentSession = None
if not config.get('usessl', True) and not config['forceauth']:
if config['username'] not in [
'', None
] or config['password'] not in ['', None]:
traverseLogger.warning(
'Attempting to authenticate on unchecked http/https protocol is insecure, if necessary please use ForceAuth option. Clearing auth credentials...'
)
config['username'] = ''
config['password'] = ''
if AuthType == 'Session':
certVal = chkcertbundle if ChkCert and chkcertbundle is not None else ChkCert
# no proxy for system under test
self.currentSession = rfSession(config['username'],
config['password'],
config['configuri'], None, certVal,
self.proxies)
self.currentSession.startSession()
self.metadata = md.Metadata(traverseLogger)
target_version = self.config.get('versioncheck')
# get Version
success, data, status, delay = self.callResourceURI('/redfish/v1')
if not success:
traverseLogger.warn('Could not get ServiceRoot')
elif target_version in [None, '']:
if 'RedfishVersion' not in data:
traverseLogger.warn(
'Could not get RedfishVersion from ServiceRoot')
else:
traverseLogger.info('Redfish Version of Service: {}'.format(
data['RedfishVersion']))
target_version = data['RedfishVersion']
# with Version, get default and compare to user defined values
default_config_target = defaultconfig_by_version.get(
target_version, dict())
override_with = {
k: default_config_target[k]
for k in default_config_target if k in default_entries
}
if len(override_with) > 0:
traverseLogger.info(
'CONFIG: RedfishVersion {} has augmented these tool defaults {}'
.format(target_version, override_with))
self.config.update(override_with)
self.active = True
def createReportJson(self):
c3dValObj = c3dValidation.c3dValidation(self.workingDirectory)
self.measurementNames = c3dValObj.getValidC3dList(True)
fileNames = c3dValObj.getValidC3dList(False)
self.null = None
if fileNames != []: # empty list means c3d does not contain Plugin-Gait created 'LAnkleAngles' or there are no events
self.frameRate, self.analogRate = getFrameAndAnalogRateFromC3D(
fileNames[0])
ts = self.getTimeseriesResults()
print "--------------------Timeseries OK--------------------------------"
mapProfile = map2.MAP(self.workingDirectory)
gvs = self.getGVSResults(mapProfile)
print "--------------------GVS OK--------------------------------"
gps = self.getGPSResults(mapProfile)
print "--------------------GPS OK--------------------------------"
emgExp = self.getEMGResults()
print "--------------------EMG--------------------------------"
# Events
ev = self.getEvents()
print "--------------------events OK--------------------------------"
# #MetaData
metaDataObj = metadata.Metadata(self.workingDirectory,
self.modelledC3dfilenames,
self.subjectMetadata,
self.creationDate)
md = metaDataObj.medatadaInfo()
print "--------------------metadata OK--------------------------------"
# Subject
sub = metaDataObj.subjectInfo()
print "--------------------subjectInfo OK--------------------------------"
# Project
proj = metaDataObj.projectInfo()
print "--------------------proj OK--------------------------------"
# TSP
tspObj = tsp.TSP(self.workingDirectory)
tsparams = tspObj.export()
print "--------------------TSP OK--------------------------------"
# Measurements
measObj = measurements.Measurements(self.workingDirectory)
mea = measObj.measurementInfo(self.extra_settings)
print "--------------------Measurements OK--------------------------------"
# Create json
root = {
"results": ts + gvs + gps + emgExp + tsparams,
"events": ev,
"metadata": md,
"measurements": mea,
"clientId": self.clientId,
"subject": sub,
"project": proj
}
return root
else:
root = {}
return root
def test_non_mp3_file_to_mp3_tags(self, mock_mutagen):
mock_mutagen.return_value = None
f = metadata.Metadata('test_file', 0)
mp3_tags = f.tags
self.assertEqual(mp3_tags, None)
def play(self):
self.emit("preplay")
self.player = gst.Pipeline("player")
self.queue_video = gst.element_factory_make("queue", "queue_video")
self.player.add(self.queue_video)
self.input_type = 0
# Source selection
self.source_pads = {}
self.audio_pads = {}
self.pip_pads = {}
self.output_bins = {}
type = 0
source_number = 0
pip_number = 0
self.pip = PictureInPicture()
self.player.add(self.pip)
for row in self.sources.get_store():
(name, source) = row
element = source.create()
self.player.add(element)
if element.does_audio():
if not self.input_type & MEDIA_AUDIO:
# The pipeline has audio sources, and this is the first
# audio source we add
if self.audio_source is None:
self.emit("error", "You need to select an audio source")
self.emit("stopped")
return
self.input_type |= MEDIA_AUDIO
self.input_selector = gst.element_factory_make(
"input-selector", "audio-selector"
)
self.player.add(self.input_selector)
audiobin = audioinputbin.AudioInputBin(source)
self.player.add(audiobin)
element.audio_pad.link(audiobin.get_static_pad("sink"))
self.audio_pads[name] = \
self.input_selector.get_request_pad("sink%d")
audiobin.src_pad.link(self.audio_pads[name])
if element.does_video():
self.input_type |= MEDIA_VIDEO
self.source_pads[name] = source_number
source_number = source_number + 1
# Thumbnail preview
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
element.video_pad.link(tee.sink_pads().next())
thumbnail_queue = gst.element_factory_make("queue", None)
self.player.add(thumbnail_queue)
self.thumbnails[name] = Preview(self)
self.player.add(self.thumbnails[name])
thumbnail_err = gst.element_link_many(
tee, thumbnail_queue, self.thumbnails[name]
)
if thumbnail_err == False:
self.emit("error", "Error conecting thumbnail preview.")
# Picture in Picture
self.pip_pads[name] = pip_number
pip_number = pip_number + 1
main_queue = gst.element_factory_make("queue", None)
self.player.add(main_queue)
pip_queue = gst.element_factory_make("queue", None)
self.player.add(pip_queue)
tee.link(main_queue)
tee.link(pip_queue)
main_queue.src_pads().next().link(self.pip.get_request_pad_A())
pip_queue.src_pads().next().link(self.pip.get_request_pad_B())
if name == self.video_source:
type |= element.get_type()
if name == self.audio_source:
type |= element.get_type()
self.watermark = gst.element_factory_make(
"cairoimageoverlay", "cairoimageoverlay"
)
self.player.add(self.watermark)
self.colorspace = gst.element_factory_make(
"ffmpegcolorspace", "colorspace-imageoverlay-videobalance"
)
self.player.add(self.colorspace)
self.videobalance = gst.element_factory_make(
"videobalance", "videobalance"
)
self.player.add(self.videobalance)
if self.videobalance_contrast:
self.videobalance.set_property(
"contrast", self.videobalance_contrast
)
if self.videobalance_brightness:
self.videobalance.set_property(
"brightness", self.videobalance_brightness
)
if self.videobalance_hue:
self.videobalance.set_property(
"hue", self.videobalance_hue
)
if self.videobalance_saturation:
self.videobalance.set_property(
"saturation", self.videobalance_saturation
)
gst.element_link_many(
self.pip, self.watermark, self.colorspace, self.videobalance,
self.queue_video
)
self._switch_source()
self._switch_pip()
if self.pip_position:
self.pip.set_property("position", self.pip_position)
self.effect[MEDIA_VIDEO] = effect.video_effect.VideoEffect(
self.effect_name[MEDIA_VIDEO]
)
self.player.add(self.effect[MEDIA_VIDEO])
self.overlay = gst.element_factory_make("textoverlay", "overlay")
self.overlay.set_property("font-desc", self.overlay_font)
self.overlay.set_property("halign", self.halign)
self.overlay.set_property("valign", self.valign)
self.player.add(self.overlay)
gst.element_link_many(
self.queue_video, self.effect[MEDIA_VIDEO], self.overlay
)
self.preview_tee = multeequeue.MulTeeQueue()
self.player.add(self.preview_tee)
self.overlay.link(self.preview_tee)
if self.input_type & MEDIA_AUDIO:
self.convert = gst.element_factory_make("audioconvert", "convert")
self.player.add(self.convert)
self.effect[MEDIA_AUDIO] = effect.audio_effect.AudioEffect(
self.effect_name[MEDIA_AUDIO]
)
self.player.add(self.effect[MEDIA_AUDIO])
self.audio_tee = gst.element_factory_make("tee", "audio_tee")
self.player.add(self.audio_tee)
self.volume = volume.Volume()
self.player.add(self.volume)
gst.element_link_many(
self.input_selector, self.volume,
self.effect[MEDIA_AUDIO], self.convert, self.audio_tee
)
self.input_selector.set_property(
"active-pad", self.audio_pads[self.audio_source]
)
added_encoders = {}
pip_width = 0
pip_height = 0
for row in self.outputs.get_store():
(name, output) = row
output_bin = outputbin.OutputBin(output)
self.output_bins[name] = output_bin
self.player.add(output_bin)
encoder_name = output.get_config()["parent"]
encoder_item = self.encoders.get_item(encoder_name)
if encoder_item is None:
self.emit("error", "Please, add an encoder.")
break
if added_encoders.has_key(encoder_name):
tee = added_encoders[encoder_name]
tee.link(output_bin)
else:
tee = gst.element_factory_make("tee", None)
self.player.add(tee)
converter_item = encoder_item.parent
converter = converter_item.create()
if converter_item.config["width"] > pip_width:
pip_width = converter_item.config["width"]
if converter_item.config["height"] > pip_height:
pip_height = converter_item.config["height"]
self.player.add(converter)
encoder = encoder_item.factory.create(type)
if encoder.vorbisenc:
self.metadata = metadata.Metadata(encoder.vorbisenc)
self.metadata.set_tags(self.taglist)
encoder.config(encoder_item.config)
self.player.add(encoder)
added_encoders[encoder_name] = tee
self.preview_tee.get_src_pad().link(
converter.sink_pads().next()
)
gst.element_link_many(
converter, encoder, tee, output_bin
)
if self.input_type & MEDIA_AUDIO:
audio_queue = gst.element_factory_make("queue", None)
self.player.add(audio_queue)
gst.element_link_many(self.audio_tee, audio_queue, encoder)
self.preview = Preview(self)
self.player.add(self.preview)
self.preview_tee.get_src_pad().link(self.preview.sink_pads().next())
if pip_width == 0:
pip_width = 320
pip_height = 240
self.pip.set_property("width", int(pip_width))
self.pip.set_property("height", int(pip_height))
self.video_width = int(pip_width)
self.video_height = int(pip_height)
self._set_watermark(self.video_width, self.video_height)
self.overlay.set_property("text", self.overlay_text)
if self.volume_value is not None:
self.volume.set_property("volume", self.volume_value)
self.emit("pipeline-ready")
bus = self.player.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect("message", self.on_message)
bus.connect("sync-message::element", self.on_sync_message)
cr = self.player.set_state(gst.STATE_PLAYING)
if cr == gst.STATE_CHANGE_SUCCESS:
self.emit("playing")
elif cr == gst.STATE_CHANGE_ASYNC:
self.pending_state = gst.STATE_PLAYING
def save(self, path=None, algo="xz"):
"""
This function saves the database and metadata to path so it can
be exported to a remote repository.
"""
if not path:
path = self.path
# Create filenames
metapath = os.path.join(path, METADATA_DOWNLOAD_PATH)
db_path = os.path.join(metapath, METADATA_DATABASE_FILE)
md_path = os.path.join(metapath, METADATA_DOWNLOAD_FILE)
# Remove all pre-existing metadata.
if os.path.exists(metapath):
util.rm(metapath)
# Create directory for metdadata.
os.makedirs(metapath)
# Save the database to path and get the filename.
self.index.write(db_path)
# Make a reference to the database file that it will get a unique name
# so we won't get into any trouble with caching proxies.
db_hash = util.calc_hash1(db_path)
db_path2 = os.path.join(os.path.dirname(db_path),
"%s-%s" % (db_hash, os.path.basename(db_path)))
# Compress the database.
if algo:
# Open input file and get filesize of input file.
f = open(db_path)
filesize = os.path.getsize(db_path)
# Make a nice progress bar.
p = util.make_progress(_("Compressing database..."), filesize)
# Create compressing file handler.
c = compress.compressobj(db_path2)
try:
size = 0
while True:
buf = f.read(BUFFER_SIZE)
if not buf:
break
if p:
size += len(buf)
p.update(size)
c.write(buf)
except:
# XXX catch compression errors
raise
finally:
f.close()
c.close()
p.finish()
# Remove old database.
os.unlink(db_path)
else:
shutil.move(db_path, db_path2)
# Create a new metadata object and add out information to it.
md = metadata.Metadata(self.pakfire)
# Save name of the hashed database to the metadata.
md.database = os.path.basename(db_path2)
md.database_hash1 = db_hash
md.database_compression = algo
# Save metdata to repository.
md.save(md_path)
def test_metadata_id3v1v2(self, mock_mutagen):
mock_mutagen.return_value = {'tag': 'value'}
f = metadata.Metadata('test_file',
len(id3v2_header + id3v1_trailer[:3] + '1234'))
info = f.metadata
self.assertEqual(info, {'digest': hash_1234, 'tags': {'tag': 'value'}})
def test_mp3_file_to_mp3_tags(self, mock_mutagen):
mock_mutagen.return_value = {'tag': 'value'}
f = metadata.Metadata('test_file', 0)
mp3_tags = f.tags
self.assertEqual(mp3_tags, {'tag': 'value'})
self.assertTrue(mock_mutagen.called)
def test_malformed_mp3_file_to_mp3_tags(self, mock_mutagen):
mock_mutagen.side_effect = mutagen.mp3.HeaderNotFoundError(
'test error')
f = metadata.Metadata('test_file', len(id3v1v2))
mp3_tags = f.tags
self.assertIsNone(mp3_tags)
def test_metadata_of_non_mp3_file(self, mock_mutagen):
mock_mutagen.return_value = None
f = metadata.Metadata('test_file', len('' + '' + '1234'))
info = f.metadata
self.assertEqual(info, {'digest': hash_1234})
