def set_lo_properties(self, n, *properties):
for props in properties:
assert isinstance(props, dict)
for ref in props.get('referred_to_by', []):
if isinstance(ref, dict):
if 'uri' in ref:
l = model.LinguisticObject(ident=ref['uri'])
elif 'uuid' in data:
l = model.LinguisticObject(ident="urn:uuid:%s" %
ref['uuid'])
else:
raise Exception(
f'MakeLinkedArtRecord call attempt to set name {name} with a non-identified reference: {ref}'
)
elif isinstance(ref, object):
l = ref
else:
raise Exception(
f'MakeLinkedArtRecord call attempt to set name {name} with an unrecognized reference type: {ref}'
)
n.referred_to_by = l
def test_ordering(self):
p = model.Person(label="Person")
p.classified_as = model.Type(ident="type-uri")
p.referred_to_by = model.LinguisticObject(content="text")
p.dimension = model.Dimension(value=1)
outstr = model.factory.toString(p)
lbl = outstr.index("_label")
clsf = outstr.index("classified_as")
r2b = outstr.index("referred_to_by")
dim = outstr.index("dimension")
self.assertTrue(lbl < clsf)
self.assertTrue(clsf < r2b)
self.assertTrue(r2b < dim)
def __call__(self, data, non_auctions, event_properties,
problematic_records, transaction_types):
'''Add modeling data for the auction of a lot of objects.'''
self.helper.copy_source_information(data['_object'], data)
auction_houses_data = event_properties['auction_houses']
auction_locations = event_properties['auction_locations']
auction_data = data['auction_of_lot']
try:
lot_object_key = object_key(auction_data)
except Exception as e:
warnings.warn(
f'Failed to compute lot object key from data {auction_data} ({e})'
)
pprint.pprint({k: v
for k, v in data.items() if v != ''},
stream=sys.stderr)
raise
cno, lno, date = lot_object_key
sale_type = non_auctions.get(cno, 'Auction')
ask_price = data.get('ask_price', {}).get('ask_price')
if ask_price:
# if there is an asking price/currency, it's a direct sale, not an auction;
# filter these out from subsequent modeling of auction lots.
warnings.warn(
f'Skipping {cno} {lno} because it asserts an asking price')
return
if sale_type != 'Auction':
# the records in this sales catalog do not represent auction sales, so the
# price data should not be asserted as a sale price, but instead as an
# asking price.
with suppress(KeyError):
prices = data['price']
del data['price']
if prices:
price_data = prices[0]
price = get_crom_object(price_data)
if price:
ma = vocab.add_classification(price, vocab.AskingPrice)
data['ask_price'] = add_crom_data(price_data, ma)
shared_lot_number = self.helper.shared_lot_number_from_lno(lno)
uid, uri = self.helper.shared_lot_number_ids(cno, lno, date)
sale_data = {'uid': uid, 'uri': uri}
lot = self.helper.sale_for_sale_type(sale_type, lot_object_key)
data['lot_object_id'] = f'{cno} {lno} ({date})'
if 'link_to_pdf' in auction_data:
url = auction_data['link_to_pdf']
page = vocab.WebPage(ident=url, label=url)
lot.referred_to_by = page
for problem_key, problem in problematic_records.get('lots', []):
# TODO: this is inefficient, but will probably be OK so long as the number
# of problematic records is small. We do it this way because we can't
# represent a tuple directly as a JSON dict key, and we don't want to
# have to do post-processing on the services JSON files after loading.
if tuple(problem_key) == lot_object_key:
note = model.LinguisticObject(ident='', content=problem)
problem_classification = model.Type(
ident=self.helper.problematic_record_uri,
label='Problematic Record')
problem_classification.classified_as = vocab.instances[
"brief text"]
note.classified_as = problem_classification
lot.referred_to_by = note
cite_content = []
if data.get('transaction_so'):
cite_content.append(data['transaction_so'])
if data.get('transaction_cite'):
cite_content.append(data['transaction_cite'])
if cite_content:
content = ', '.join(cite_content)
cite = vocab.BibliographyStatement(
ident='', content=content, label='Source of transaction type')
cite.identified_by = model.Name(
ident='', content='Source of transaction type')
lot.referred_to_by = cite
transaction = data.get('transaction')
SOLD = transaction_types['sold']
WITHDRAWN = transaction_types['withdrawn']
self.set_lot_objects(lot, cno, lno, sale_data['uri'], data, sale_type)
auction, _, _ = self.helper.sale_event_for_catalog_number(
cno, sale_type)
if transaction not in WITHDRAWN:
lot.part_of = auction
event_dates = event_properties['auction_dates'].get(cno)
auction_houses = [
get_crom_object(self.helper.add_auction_house_data(h.copy()))
for h in auction_houses_data.get(cno, [])
]
self.set_lot_auction_houses(lot, cno, auction_houses)
self.set_lot_location(lot, cno, auction_locations)
self.set_lot_date(lot, auction_data, event_dates)
self.set_lot_notes(lot, auction_data, sale_type)
tx_uri = self.helper.transaction_uri_for_lot(auction_data, data)
lots = self.helper.lots_in_transaction(auction_data, data)
tx = vocab.ProvenanceEntry(ident=tx_uri)
tx_label = prov_entry_label(self.helper, sale_type, transaction,
'of', cno, lots, date)
tx._label = tx_label
tx.identified_by = model.Name(ident='', content=tx_label)
tx.caused_by = lot
tx_data = {'uri': tx_uri}
if transaction in SOLD:
if sale_type == 'Auction':
# the records in this sales catalog represent auction sales, so the
# price data for a sale should be asserted as a hammer price.
with suppress(KeyError):
prices = data['price']
if prices:
price_data = prices[0]
price = get_crom_object(price_data)
if price:
vocab.add_classification(
price, vocab.HammerPrice)
multi = self.helper.transaction_contains_multiple_lots(
auction_data, data)
if multi:
tx_data['multi_lot_tx'] = lots
with suppress(AttributeError):
tx_data['_date'] = lot.timespan
data['_prov_entry_data'] = add_crom_data(data=tx_data, what=tx)
data['_event_causing_prov_entry'] = add_crom_data(data=sale_data,
what=lot)
yield data