def build(self): if self.start_date_bound is not None and self.end_date_bound is not None: self.dates.append( Date.Builder() .setEarliestDate(self.start_date_bound) .setLatestDate(self.end_date_bound) .setType(DateType.CREATION) .build() ) if len(self.agents) > 0: self._object_builder.setAgents(AgentSet.Builder().setElements(ImmutableList.copyOf(self.agents)).build()) if len(self.dates) > 0: self._object_builder.setDates(DateSet.Builder().setElements(ImmutableList.copyOf(self.dates)).build()) if len(self.descriptions) > 0: self._object_builder.setDescriptions(DescriptionSet.Builder().setElements(ImmutableList.copyOf(self.descriptions)).build()) if len(self.images) > 0: self._object_builder.setImages(ImmutableList.copyOf(self.images)) if len(self.locations) > 0: self._object_builder.setLocations(LocationSet.Builder().setElements(ImmutableList.copyOf(self.locations)).build()) if len(self.rights) > 0: self._object_builder.setRights(RightsSet.Builder().setElements(ImmutableList.copyOf(self.rights)).build()) if len(self.subjects) > 0: self._object_builder.setSubjects(SubjectSet.Builder().setElements(ImmutableList.copyOf(self.subjects)).build()) if len(self.textrefs) > 0: self._object_builder.setTextrefs(TextrefSet.Builder().setElements(ImmutableList.copyOf(self.textrefs)).build()) if len(self.titles) > 0: self._object_builder.setTitles(TitleSet.Builder().setElements(ImmutableList.copyOf(self.titles)).build()) if len(self.work_types) > 0: self._object_builder.setWorkTypes(WorkTypeSet.Builder().setElements(ImmutableList.copyOf(self.work_types)).build()) return self._object_builder.build()
def __init__(self, form, trueSentences): """ generated source for method __init__ """ super(FunctionInfoImpl, self).__init__() self.form = form numSlots = form.getTupleSize() i = 0 while i < numSlots: # We want to establish whether or not this is a constant... for sentence in trueSentences: ConcurrencyUtils.checkForInterruption() tuplePart.addAll(tuple_.subList(0, i)) tuplePart.addAll(tuple_.subList(i + 1, len(tuple_))) if functionMap.containsKey(tuplePart): # We have two tuples with different values in just this slot functional = False break # Otherwise, we record it functionMap.put(ImmutableList.copyOf(tuplePart), tuple_.get(i)) if functional: # Record the function self.dependentSlots.add(True) self.valueMaps.add(functionMap) else: # Forget it self.dependentSlots.add(False) self.valueMaps.add(None) i += 1
def addOrMergeStratumAndAncestors(cls, curStratum, ordering, toAdd, strataDependencyGraph, downstreamStrata): """ generated source for method addOrMergeStratumAndAncestors """ if downstreamStrata.contains(curStratum): mergeStrata(Sets.newHashSet(toMerge), toAdd, strataDependencyGraph) return downstreamStrata.add(curStratum) for parent in ImmutableList.copyOf(strataDependencyGraph.get(curStratum)): # We could merge away the parent here, so we protect against CMEs and # make sure the parent is still in toAdd before recursing. if toAdd.contains(parent): cls.addOrMergeStratumAndAncestors(parent, ordering, toAdd, strataDependencyGraph, downstreamStrata) downstreamStrata.remove(curStratum) # - If we've added all our parents, we will still be in toAdd # and none of our dependencies will be in toAdd. Add to the ordering. # - If there was a merge upstream that we weren't involved in, # we will still be in toAdd, but we will have (possibly new) # dependencies that are still in toAdd. Do nothing. # - If there was a merge upstream that we were involved in, # we won't be in toAdd anymore. Do nothing. if not toAdd.contains(curStratum): return for parent in strataDependencyGraph.get(curStratum): if toAdd.contains(parent): return ordering.add(curStratum) toAdd.remove(curStratum)
def create(cls, description): """ generated source for method create """ gameRules = ImmutableList.copyOf(description) sentenceForms = getSentenceForms(gameRules) rulesByForm = getRulesByForm(gameRules, sentenceForms) trueSentencesByForm = getTrueSentencesByForm(gameRules, sentenceForms) dependencyGraph = getDependencyGraph(sentenceForms, rulesByForm) constantSentenceForms = getConstantSentenceForms(sentenceForms, dependencyGraph) independentSentenceForms = getIndependentSentenceForms(sentenceForms, dependencyGraph) return ImmutableSentenceFormModel(gameRules, sentenceForms, constantSentenceForms, independentSentenceForms, dependencyGraph, rulesByForm, trueSentencesByForm)
def getObjectsByCollectionId(self, collection_id, logger, log_marker): objects = [] for root_dir_path, _, file_names in os.walk(os.path.join(self.__data_dir_path, "record")): for file_name in file_names: file_path = os.path.join(root_dir_path, file_name) if not file_path.endswith(".xml"): os.rename(file_path, file_path + ".xml") file_path = file_path + ".xml" objects.append(self.__map_oai_pmh_record(collection_id=collection_id, file_path=file_path)) return ImmutableList.copyOf(objects)
def _map_omeka_collections(self, institution_id, omeka_collections): collections = [] for omeka_collection in omeka_collections: collection = \ self._map_omeka_collection( institution_id=institution_id, omeka_collection=omeka_collection, ) if collection is not None: collections.append(collection) return ImmutableList.copyOf(collections)
def copyOf(cls, other): """ generated source for method copyOf """ if isinstance(other, (ImmutableSentenceDomainModel, )): return cls.copyOf((other).getFormModel()) elif isinstance(other, (ImmutableSentenceFormModel, )): return other rulesByForm = ImmutableSetMultimap.builder() trueSentencesByForm = ImmutableSetMultimap.builder() for form in other.getSentenceForms(): rulesByForm.putAll(form, other.getRules(form)) trueSentencesByForm.putAll(form, other.getSentencesListedAsTrue(form)) return ImmutableSentenceFormModel(ImmutableList.copyOf(other.getDescription()), ImmutableSet.copyOf(other.getSentenceForms()), ImmutableSet.copyOf(other.getConstantSentenceForms()), ImmutableSet.copyOf(other.getIndependentSentenceForms()), ImmutableSetMultimap.copyOf(other.getDependencyGraph()), rulesByForm.build(), trueSentencesByForm.build())
def getObjectsByCollectionId(self, collection_id, logger, log_marker): objects = [] omeka_items = self.__api_client.get_all_items(collection=int(collection_id.getUnqualifiedCollectionId())) for omeka_item in omeka_items: objects.append( self._map_omeka_item( collection_id=collection_id, omeka_item=omeka_item, omeka_item_files=self.__api_client.get_all_files(item=omeka_item.id), ) ) return ImmutableList.copyOf(objects)
def build(self): if len(self.closure_placements) > 0 and len(self.closure_types) > 0: closures = [] if len(self.closure_placements) == len(self.closure_types): for closure_placement, closure_type in zip(self.closure_placements, self.closure_types): closures.append( Closure.builder() .setPlacement(closure_placement) .setType(closure_type) .build() ) elif len(self.closure_placements) == 1: for closure_type in self.closure_types: closures.append( Closure.builder() .setPlacement(self.closure_placements[0]) .setType(closure_type) .build() ) elif len(self.closure_types) == 1: for closure_placement in self.closure_placements: closures.append( Closure.builder() .setPlacement(closure_placement) .setType(self.closure_types[0]) .build() ) else: self.__logger.warn("item %d has different numbers of closure placements and closure types: %d vs. %d", self.omeka_item.id, len(self.closure_placements), len(self.closure_types)) if len(closures) > 0: self._object_builder.setClosures(ClosureSet.builder().setElements(ImmutableList.copyOf(closures)).build()) if len(self.component_builders_by_letter) > 0: components = [] for letter, component_builder in self.component_builders_by_letter.iteritems(): structures = self.structures_by_component_letter.pop(letter, []) structures.extend(self.structures_by_extent.pop(component_builder.term.text, [])) if len(structures) > 0: component_builder.setStructures(StructureSet.builder().setElements(ImmutableList.copyOf(structures)).build()) component = component_builder.build() components.append(component) for letter in self.structures_by_component_letter.iterkeys(): self.__logger.warn("structure(s) specified for unknown component %s on item %d", letter, self.omeka_item.id) for letter in self.structures_by_extent.iterkeys(): self.__logger.warn("structure(s) specified for unknown extent %s on item %d", letter, self.omeka_item.id) self._object_builder.setComponents(ComponentSet.builder().setElements(ImmutableList.copyOf(components)).build()) if len(self.colors) > 0: self._object_builder.setColors(ColorSet.builder().setElements(ImmutableList.copyOf(self.colors)).build()) if len(self.structures) > 0: self._object_builder.setStructures(StructureSet.builder().setElements(ImmutableList.copyOf(self.structures)).build()) return OmekaResourceMapper._ObjectBuilder.build(self)
def mergeStrata(cls, toMerge, toAdd, strataDependencyGraph): """ generated source for method mergeStrata """ newStratum = ImmutableSet.copyOf(Iterables.concat(toMerge)) for oldStratum in toMerge: toAdd.remove(oldStratum) toAdd.add(newStratum) # Change the keys for oldStratum in toMerge: strataDependencyGraph.putAll(newStratum, parents) strataDependencyGraph.removeAll(oldStratum) # Change the values for entry in ImmutableList.copyOf(strataDependencyGraph.entries()): if toMerge.contains(entry.getValue()): strataDependencyGraph.remove(entry.getKey(), entry.getValue()) strataDependencyGraph.put(entry.getKey(), newStratum)
def create(cls, form, domain): """ generated source for method create """ domainsForSlotsBuilder = Lists.newArrayList() i = 0 while i < form.getTupleSize(): domainsForSlotsBuilder.add(ImmutableSet.builder()) i += 1 for sentence in domain: assert form.matches(sentence) if len(tuple_) != form.getTupleSize(): raise IllegalArgumentException() while i < len(tuple_): domainsForSlotsBuilder.get(i).add(constant) i += 1 domainsForSlots = ImmutableList.builder() for builder in domainsForSlotsBuilder: domainsForSlots.add(builder.build()) return FullSentenceFormDomain(form, ImmutableList.copyOf(domain), domainsForSlots.build())
def create(cls, conjunct, functionInfo, rightmostVar, varOrder, preassignment): """ generated source for method create """ # We have to set up the things mentioned above... internalFunctions = ArrayList() # We can traverse the conjunct for the list of variables/constants... terms = ArrayList() gatherVars(conjunct.getBody(), terms) # Note that we assume here that the var of interest only # appears once in the relation... varIndex = terms.indexOf(rightmostVar) if varIndex == -1: print "conjunct is: " + conjunct print "terms are: " + terms print "righmostVar is: " + rightmostVar terms.remove(rightmostVar) function_ = functionInfo.getValueMap(varIndex) # Set up inputs and such, using terms querySize = len(terms) isInputConstant = ArrayList(len(terms)) queryConstants = Maps.newHashMap() queryInputIndices = ArrayList(len(terms)) i = 0 while i < len(terms): if isinstance(term, (GdlConstant, )): isInputConstant.add(True) queryConstants.put(i, term) queryInputIndices.add(-1) elif isinstance(term, (GdlVariable, )): # Is it in the head assignment? if preassignment.containsKey(term): isInputConstant.add(True) queryConstants.put(i, preassignment.get(term)) queryInputIndices.add(-1) else: isInputConstant.add(False) # queryConstants.add(null); # What value do we put here? # We want to grab some value out of the # input tuple, which uses functional ordering # Index of the relevant variable, by the # assignment's ordering queryInputIndices.add(varOrder.indexOf(term)) i += 1 return AssignmentFunction(ImmutableList.copyOf(internalFunctions), querySize, ImmutableList.copyOf(isInputConstant), ImmutableMap.copyOf(queryConstants), ImmutableList.copyOf(queryInputIndices), ImmutableMap.copyOf(function_))
def addTuple(self, sentenceTuple): """ generated source for method addTuple """ if len(sentenceTuple) != self.form.getTupleSize(): raise IllegalArgumentException() # For each slot... i = 0 while i < len(sentenceTuple): if self.dependentSlots.get(i): # Either add to that entry, or invalidate the slot lookupTuple.remove(i) if curValue == None: # Just add to the map valueMap.put(ImmutableList.copyOf(lookupTuple), newValue) else: # If this isn't the existing sentence, invalidate this slot if curValue != newValue: self.dependentSlots.set(i, False) self.valueMaps.set(i, ImmutableMap.of()) i += 1
def __init__(self, headAssignment, rule, varDomains, functionInfoMap, completedSentenceFormValues): """ generated source for method __init__ """ super(AssignmentsImpl, self).__init__() self.empty = False self.headAssignment = headAssignment # We first have to find the remaining variables in the body self.varsToAssign = GdlUtils.getVariables(rule) # Remove all the duplicates; we do, however, want to keep the ordering newVarsToAssign = ArrayList() for v in varsToAssign: if not newVarsToAssign.contains(v): newVarsToAssign.add(v) self.varsToAssign = newVarsToAssign self.varsToAssign.removeAll(headAssignment.keySet()) # varsToAssign is set at this point # We see if iterating over entire tuples will give us a # better result, and we look for the best way of doing that. # Let's get the domains of the variables # Map<GdlVariable, Set<GdlConstant>> varDomains = model.getVarDomains(rule); # Since we're looking at a particular rule, we can do this one step better # by looking at the domain of the head, which may be more restrictive # and taking the intersections of the two domains where applicable # Map<GdlVariable, Set<GdlConstant>> headVarDomains = model.getVarDomainsInSentence(rule.getHead()); # We can run the A* search for a good set of source conjuncts # at this point, then use the result to build the rest. completedSentenceFormSizes = HashMap() if completedSentenceFormValues != None: for form in completedSentenceFormValues.keySet(): completedSentenceFormSizes.put(form, completedSentenceFormValues.get(form).size()) varDomainSizes = HashMap() for var in varDomains.keySet(): varDomainSizes.put(var, varDomains.get(var).size()) bestOrdering = IterationOrderCandidate() bestOrdering = getBestIterationOrderCandidate(rule, varDomains, functionInfoMap, completedSentenceFormSizes, headAssignment, False)# model, # TODO: True here? # Want to replace next few things with order # Need a few extra things to handle the use of iteration over existing tuples self.varsToAssign = bestOrdering.getVariableOrdering() # For each of these vars, we have to find one or the other. # Let's start by finding all the domains, a task already done. self.valuesToIterate = Lists.newArrayListWithCapacity(len(self.varsToAssign)) for var in varsToAssign: if varDomains.containsKey(var): if not varDomains.get(var).isEmpty(): self.valuesToIterate.add(ImmutableList.copyOf(varDomains.get(var))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) else: self.valuesToIterate.add(ImmutableList.of(GdlPool.getConstant("0"))) # Okay, the iteration-over-domain is done. # Now let's look at sourced iteration. self.sourceDefiningSlot = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): self.sourceDefiningSlot.add(-1) i += 1 # We also need to convert values into tuples # We should do so while constraining to any constants in the conjunct # Let's convert the conjuncts sourceConjuncts = bestOrdering.getSourceConjuncts() self.tuplesBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<List<GdlConstant>>>(len(sourceConjuncts)); self.varsChosenBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Integer>>(len(sourceConjuncts)); self.putDontCheckBySource = Lists.newArrayListWithCapacity(len(sourceConjuncts)) # new ArrayList<List<Boolean>>(len(sourceConjuncts)); j = 0 while j < len(sourceConjuncts): # flatten into a tuple # Go through the vars/constants in the tuple while i < len(conjunctTuple): if isinstance(term, (GdlConstant, )): constraintSlots.add(i) constraintValues.add(term) # TODO: What if tuple size ends up being 0? # Need to keep that in mind elif isinstance(term, (GdlVariable, )): varsChosen.add(varIndex) if self.sourceDefiningSlot.get(varIndex) == -1: # We define it self.sourceDefiningSlot.set(varIndex, j) putDontCheck.add(True) else: # It's an overlap; we just check for consistency putDontCheck.add(False) else: raise RuntimeException("Function returned in tuple") i += 1 self.varsChosenBySource.add(ImmutableList.copyOf(varsChosen)) self.putDontCheckBySource.add(ImmutableList.copyOf(putDontCheck)) # Now we put the tuples together # We use constraintSlots and constraintValues to check that the # tuples have compatible values for sentence in sentences: # Check that it doesn't conflict with our headAssignment if not headAssignment.isEmpty(): for var in headAssignment.keySet(): if tupleAssignment.containsKey(var) and tupleAssignment.get(var) != headAssignment.get(var): continue while c < len(constraintSlots): if not longTuple.get(slot) == value: continue c += 1 while s < len(longTuple): # constraintSlots is sorted in ascending order if c < len(constraintSlots) and constraintSlots.get(c) == s: c += 1 else: shortTuple.add(longTuple.get(s)) s += 1 # The tuple fits the source conjunct tuples.add(ImmutableList.copyOf(shortTuple)) # sortTuples(tuples); //Needed? Useful? Not sure. Probably not? self.tuplesBySource.add(ImmutableList.copyOf(tuples)) j += 1 # We now want to see which we can give assignment functions to self.valuesToCompute = ArrayList(len(self.varsToAssign)) for var in varsToAssign: self.valuesToCompute.add(None) self.indicesToChangeWhenNull = ArrayList(len(self.varsToAssign)) i = 0 while i < len(self.varsToAssign): # Change itself, why not? # Actually, instead let's try -1, to catch bugs better self.indicesToChangeWhenNull.add(-1) i += 1 # Now we have our functions already selected by the ordering # bestOrdering.functionalConjunctIndices; # Make AssignmentFunctions out of the ordering functionalConjuncts = bestOrdering.getFunctionalConjuncts() # print "functionalConjuncts: " + functionalConjuncts; i = 0 while i < len(functionalConjuncts): if functionalConjunct != None: # These are the only ones that could be constant functions if functionInfoMap != None: functionInfo = functionInfoMap.get(conjForm) if functionInfo != None: # Now we need to figure out which variables are involved # and which are suitable as functional outputs. # 1) Which vars are in this conjunct? # 2) Of these vars, which is "rightmost"? # 3) Is it only used once in the relation? if Collections.frequency(varsInSentence, rightmostVar) != 1: continue # Can't use it # 4) Which slot is it used in in the relation? # 5) Build an AssignmentFunction if appropriate. # This should be able to translate from values of # the other variables to the value of the wanted # variable. # We don't guarantee that this works until we check if not function_.functional(): continue self.valuesToCompute.set(index, function_) remainingVarsInSentence.remove(rightmostVar) self.indicesToChangeWhenNull.set(index, self.varsToAssign.indexOf(nextRightmostVar)) i += 1 # We now have the remainingVars also assigned their domains # We also cover the distincts here # Assume these are just variables and constants self.distincts = ArrayList() for literal in rule.getBody(): if isinstance(literal, (GdlDistinct, )): self.distincts.add(literal) computeVarsToChangePerDistinct() # Need to add "distinct" restrictions to head assignment, too... checkDistinctsAgainstHead()
def build(self): if len(self.agents) > 0: self._object_builder.setAgents(AgentSet.builder().setElements(ImmutableList.copyOf(self.agents)).build()) if len(self.categories) > 0: self._object_builder.setCategories(ImmutableList.copyOf(set(self.categories))) if len(self.cultural_contexts) > 0: self._object_builder.setCulturalContexts(CulturalContextSet.builder().setElements(ImmutableList.copyOf(self.cultural_contexts)).build()) if self.dc_date_builder.getEarliestDate() is not None and self.dc_date_builder.getLatestDate() is not None: if self.dc_date_certainty is not None: assert self.dc_date_certainty == 'circa' self.dc_date_builder.setEarliestDate( DateBound.builder(self.dc_date_builder.earliestDate)\ .setCirca(True)\ .build() ) self.dc_date_builder.setLatestDate( DateBound.builder(self.dc_date_builder.latestDate)\ .setCirca(True)\ .build() ) self.dates.append(self.dc_date_builder.build()) if len(self.dates) > 0: self._object_builder.setDates(DateSet.builder().setElements(ImmutableList.copyOf(self.dates)).build()) if len(self.descriptions) > 0: description_texts = {} description_i = 0 while description_i < len(self.descriptions): description = self.descriptions[description_i] if description.text in description_texts: del self.descriptions[description_i] else: description_texts[description.text] = None description_i = description_i + 1 self._object_builder.setDescriptions(DescriptionSet.builder().setElements(ImmutableList.copyOf(self.descriptions)).build()) for identifier in self.identifiers: self.textrefs.append( Textref.builder() .setName( TextrefName.builder() .setText("Identifier") .setType(TextrefNameType.CATALOG) .build() ) .setRefid( TextrefRefid.builder() .setText(identifier) .setType(TextrefRefidType.OTHER) .build() ) .build() ) if len(self.images) > 0: self._object_builder.setImages(ImmutableList.copyOf(self.images)) if len(self.inscriptions) > 0: self._object_builder.setInscriptions(InscriptionSet.builder().setElements(ImmutableList.copyOf(self.inscriptions)).build()) if len(self.locations) > 0: self._object_builder.setLocations(LocationSet.builder().setElements(ImmutableList.copyOf(self.locations)).build()) if len(self.materials) > 0: self._object_builder.setMaterials(MaterialSet.builder().setElements(ImmutableList.copyOf(self.materials)).build()) if len(self.measurements) > 0: self._object_builder.setMeasurements(MeasurementsSet.builder().setElements(ImmutableList.copyOf(self.measurements)).build()) if len(self.relation_builders) > 0: unique_relation_builders_by_text = {} for relation_builder in self.relation_builders: assert relation_builder.text is not None existing_relation_builders = unique_relation_builders_by_text.setdefault(relation_builder.text, []) unique = True for existing_relation_builder in existing_relation_builders: if existing_relation_builder.type == relation_builder.type: unique = False break if unique: existing_relation_builders.append(relation_builder) else: self.__logger.warn("item %d has duplicate relation type=%s, text=%s", self.__omeka_item.id, relation_builder.type, relation_builder.text) unique_relation_builders = [] for relation_builders in unique_relation_builders_by_text.values(): unique_relation_builders.extend(relation_builders) self._object_builder.setRelations( RelationSet.builder() .setElements(ImmutableList.copyOf(relation_builder.build() for relation_builder in unique_relation_builders)) .build()) if len(self.subjects) > 0: self._object_builder.setSubjects(SubjectSet.builder().setElements(ImmutableList.copyOf(self.subjects)).build()) if len(self.techniques) > 0: self._object_builder.setTechniques(TechniqueSet.builder().setElements(ImmutableList.copyOf(self.techniques)).build()) if len(self.textrefs) > 0: self._object_builder.setTextrefs(TextrefSet.builder().setElements(ImmutableList.copyOf(self.textrefs)).build()) if len(self.titles) > 0: self._object_builder.setTitles(TitleSet.builder().setElements(ImmutableList.copyOf(self.titles)).build()) else: raise ValueError('no titles') if len(self.work_types) > 0: self._object_builder.setWorkTypes(WorkTypeSet.builder().setElements(ImmutableList.copyOf(self.work_types)).build()) else: raise ValueError('no work types') return self._object_builder.build()
def map_omeka_item(self, collection_id, endpoint_url, omeka_item, omeka_item_files, square_thumbnail_height_px, square_thumbnail_width_px): object_id = ObjectId.parse(str(collection_id) + '/' + str(omeka_item.id)) vocab_ref = VocabRef.Builder().setVocab(Vocab.COSTUME_CORE).build() feature_name = None omeka_collection_id = int(collection_id.getUnqualifiedCollectionId()) for item in self.OMEKA_COLLECTIONS.iteritems(): if item[1] == omeka_collection_id: feature_name = item[0] break assert feature_name is not None feature_value = None item_image_credit_line = item_image_license = None for element_text in omeka_item.element_texts: if len(element_text.text) == 0: continue if element_text.element_set.name == 'Dublin Core': if element_text.element.name == 'Title': if feature_value is None: feature_value = element_text.text elif element_text.element_set.name == 'Item Type Metadata': if element_text.element.name == 'Image Creator': item_image_credit_line = element_text.text elif element_text.element.name == 'Image License': item_image_license = element_text.text else: self._logger.warn("Omeka item %d has unknown element set name '%s'", omeka_item.id, element_text.element_set.name) object_builder = \ Object.Builder()\ .setCollectionId(collection_id)\ .setHidden(True)\ .setInstitutionId(collection_id.getInstitutionId())\ .setStructures(\ StructureSet.Builder().setElements(ImmutableList.of( Structure.Builder() .setText(feature_value) .setType( StructureType.Builder() .setText(feature_name) .setVocabRef(vocab_ref) .build() ) .build() )) .build() )\ .setTitles( TitleSet.Builder().setElements(ImmutableList.of( Title.Builder() .setText("%(feature_value)s" % locals()) .setType(TitleType.DESCRIPTIVE) .build() )) .build() )\ .setViewType(ViewType.DETAIL) images = [] for file_ in omeka_item_files: if not file_.mime_type.startswith('image/'): continue image_credit_line = item_image_credit_line image_license = item_image_license for element_text in file_.element_texts: if element_text.element_set.name == 'Dublin Core': if element_text.element.name == 'License': image_license = element_text.text elif element_text.element.name == 'Provenance': image_credit_line = element_text.text if image_credit_line is None or len(image_credit_line) == 0: self._logger.warn("Omeka item %d has a file %d missing a Provenance", omeka_item.id, file_.id) continue if image_license is None or len(image_license) == 0: self._logger.warn("Omeka item %d has a file %d missing a License", omeka_item.id, file_.id) continue license_vocab_ref = None if image_license.lower() == 'public domain': rights_type = RightsType.PUBLIC_DOMAIN elif image_license == 'CC0': rights_type = RightsType.LICENSED license_vocab_ref = \ VocabRef.Builder()\ .setVocab(Vocab.CREATIVE_COMMONS)\ .setUri(Uri.parse('https://creativecommons.org/publicdomain/zero/1.0/'))\ .build() elif image_license.startswith('CC BY-SA '): rights_type = RightsType.LICENSED version = image_license[len('CC BY-SA '):] float(version) license_vocab_ref = \ VocabRef.Builder()\ .setVocab(Vocab.CREATIVE_COMMONS)\ .setUri(Uri.parse("https://creativecommons.org/licenses/by-sa/%s/" % version))\ .build() else: rights_type = RightsType.LICENSED image_builder = Image.Builder() # @UndefinedVariable file_urls = file_.file_urls image_builder.setOriginal(ImageVersion.Builder().setUrl(Url.parse(file_urls.original)).build()) image_builder.setRights( RightsSet.Builder().setElements(ImmutableList.of( Rights.Builder() .setLicenseVocabRef(Optional.fromNullable(license_vocab_ref)) .setRightsHolder(image_credit_line) .setText(image_license) .setType(rights_type) .build() )) .build() ) if file_urls.square_thumbnail is None: self._logger.warn("Omeka item %d has a file %d missing a square thumbnail", omeka_item.id, file_.id) continue image_builder.setSquareThumbnail( ImageVersion.Builder() .setHeightPx(UnsignedInteger.valueOf(square_thumbnail_height_px)) .setUrl(Url.parse(file_urls.square_thumbnail)) .setWidthPx(UnsignedInteger.valueOf(square_thumbnail_width_px)) .build() ) images.append(image_builder.build()) if len(images) > 0: object_builder.setImages(ImmutableList.copyOf(images)) else: self._logger.warn("Omeka item %d has no valid images", omeka_item.id) object_ = object_builder.build() object_id = ObjectId.parse(str(collection_id) + '/' + urllib.quote(feature_value, '')) return ObjectEntry(object_id, object_)
def create(cls, varsToAssign, tuplesBySource, headAssignment, indicesToChangeWhenNull, distincts, varsToChangePerDistinct, valuesToCompute, sourceDefiningSlot, valuesToIterate, varsChosenBySource, putDontCheckBySource, empty, allDone): """ generated source for method create """ if empty: return cls.EMPTY_ITERATION_PLAN return AssignmentIterationPlan(ImmutableList.copyOf(varsToAssign), ImmutableList.copyOf(tuplesBySource), ImmutableMap.copyOf(headAssignment), ImmutableList.copyOf(indicesToChangeWhenNull), ImmutableList.copyOf(distincts), fromNullableList(varsToChangePerDistinct), fromNullableList(valuesToCompute), ImmutableList.copyOf(sourceDefiningSlot), ImmutableList.copyOf(valuesToIterate), ImmutableList.copyOf(varsChosenBySource), ImmutableList.copyOf(putDontCheckBySource), empty, allDone)
def cleanUpIrrelevantRules(cls, expandedRules): """ generated source for method cleanUpIrrelevantRules """ model = SentenceFormModelFactory.create(expandedRules) return ImmutableList.copyOf(Collections2.filter(expandedRules, Predicate()))
def _parse_record_metadata_coverage_element(self, element, object_builder): text = element.text.strip() if len(text) == 0: return qualifier = element.attrib.get('qualifier', None) if qualifier is None: self._logger.warn("coverage element without qualifier on record %s", object_builder.record_identifier) return if qualifier == 'date': pass # Same as date element elif qualifier == 'eDate': if object_builder.end_date_bound is not None: self._logger.warn("record %s has multiple eDate's", object_builder.record_identifier) earliest_date, latest_date = self.__parse_date_range(text) if earliest_date != latest_date: self._logger.warn("record %s has a eDate range: %s", object_builder.record_identifier, text) object_builder.end_date_bound = latest_date elif qualifier == 'placeName': text_parts = [text_part.strip() for text_part in text.split(' - ')] self._logger.debug('place name from record %s: %s', object_builder.record_identifier, text) location_names_by_extent = {} location_names_by_extent['nation'] = nation = text_parts.pop(0) if len(text_parts) > 0: text_part = text_parts.pop(0) if nation == 'United States': extent = 'state' else: extent = 'region (geographic)' location_names_by_extent[extent] = text_part if len(text_parts) >= 2: text_part = text_parts.pop(0) if nation == 'United States': extent = 'county' else: extent = 'province' location_names_by_extent[extent] = text_part if len(text_parts) == 2: # 'Millburn Township', "Short Hills' # 'New York City', 'Brooklyn Borough' text_part = text_parts.pop(0) assert nation == 'United States', text_parts location_names_by_extent['township'] = text_part if len(text_parts) > 0: location_names_by_extent['inhabited place'] = text_parts.pop(0) assert len(text_parts) == 0, text for extent, text in location_names_by_extent.iteritems(): location_names_temp = self.__location_names_by_extent.setdefault(extent, []) if not text in location_names_temp: location_names_temp.append(text) object_builder.locations.append( Location.Builder() .setNames(ImmutableList.copyOf( LocationName.Builder() .setExtent(extent) .setText(text) .setType(LocationNameType.GEOGRAPHIC) .build() for extent, text in location_names_by_extent.iteritems() )) .setType(LocationType.OTHER) .build() ) elif qualifier == 'sDate': if object_builder.start_date_bound is not None: self._logger.warn("record %s has multiple sDate's", object_builder.record_identifier) earliest_date, latest_date = self.__parse_date_range(text) if earliest_date != latest_date: self._logger.warn("record %s has a sDate range: %s", object_builder.record_identifier, text) object_builder.start_date_bound = earliest_date else: self._logger.warn("unknown coverage qualifier '%s' on record %s", qualifier, object_builder.record_identifier)
def create(cls, form, domainsForSlots): """ generated source for method create """ return CartesianSentenceFormDomain(form, ImmutableList.copyOf(Lists.transform(domainsForSlots, Function())))