+def convert_to_rdf_statements(attributes, name):
+ submission_uri = get_submission_uri(name)
+ subject = RDF.Node(submission_uri)
+
+ statements = []
+ for daf_key in attributes:
+ predicate = dafTermOntology[daf_key]
+ if daf_key == 'views':
+ statements.extend(_views_to_statements(name,
+ dafTermOntology,
+ attributes[daf_key]))
+ elif daf_key == 'variables':
+ #predicate = ddfNS['variables']
+ for var in attributes.get('variables', []):
+ obj = toTypedNode(var)
+ statements.append(RDF.Statement(subject, predicate, obj))
+ else:
+ value = attributes[daf_key]
+ obj = toTypedNode(value)
+ statements.append(RDF.Statement(subject,predicate,obj))
+
+ return statements
+
+def _views_to_statements(name, dafNS, views):
+ subject = RDF.Node(get_submission_uri(name))
+ viewNS = get_view_namespace(name)
+
+ statements = []
+ for view_name in views:
+ view_attributes = views[view_name]
+ viewSubject = viewNS[view_name]
+ statements.append(RDF.Statement(subject, dafNS['views'], viewSubject))
+ for view_attribute_name in view_attributes:
+ predicate = dafNS[view_attribute_name]
+ obj = toTypedNode(view_attributes[view_attribute_name])
+ statements.append(RDF.Statement(viewSubject, predicate, obj))
+
+ #statements.extend(convert_to_rdf_statements(view, viewNode))
+ return statements
+
+def add_to_model(model, attributes, name):
+ for statement in convert_to_rdf_statements(attributes, name):
+ model.add_statement(statement)
+
+def get_submission_uri(name):
+ return submissionLog[name].uri
+
+def get_view_namespace(name):
+ submission_uri = get_submission_uri(name)
+ viewNS = RDF.NS(str(submission_uri) + '/view/')
+ return viewNS
+
+class DAFMapper(object):
+ """Convert filenames to views in the UCSC Daf
+ """
+ def __init__(self, name, daf_file=None, model=None):
+ """Construct a RDF backed model of a UCSC DAF
+
+ :args:
+ name (str): the name of this submission (used to construct DAF url)
+ daf_file (str, stream, or None):
+ if str, use as filename
+ if stream, parse as stream
+ if none, don't attempt to load the DAF into our model
+ model (RDF.Model or None):
+ if None, construct a memory backed model
+ otherwise specifies model to use
+ """
+ if daf_file is None and model is None:
+ logger.error("We need a DAF or Model containing a DAF to work")
+
+ self.name = name
+ if model is not None:
+ self.model = model
+ else:
+ self.model = get_model()
+
+ if hasattr(daf_file, 'next'):
+ # its some kind of stream
+ fromstream_into_model(self.model, name, daf_file)
+ else:
+ # file
+ parse_into_model(self.model, name, daf_file)
+
+ self.libraryNS = RDF.NS('http://jumpgate.caltech.edu/library/')
+ self.submissionSet = get_submission_uri(self.name)
+ self.submissionSetNS = RDF.NS(str(self.submissionSet)+'/')
+ self.__view_map = None
+
+
+ def add_pattern(self, view_name, filename_pattern):
+ """Map a filename regular expression to a view name
+ """
+ viewNS = get_view_namespace(self.name)
+
+ obj = toTypedNode(filename_pattern)
+ self.model.add_statement(
+ RDF.Statement(viewNS[view_name],
+ dafTermOntology['filename_re'],
+ obj))
+
+
+ def import_submission_dir(self, submission_dir, library_id):
+ """Import a submission directories and update our model as needed
+ """
+ #attributes = get_filename_attribute_map(paired)
+ libNode = self.libraryNS[library_id + "/"]