Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
'value': self.value,
'type': 'string'
}
super(WDUrl, self).set_value(value=self.value)
@classmethod
@JsonParser
def from_json(cls, jsn):
if jsn['snaktype'] == 'novalue' or jsn['snaktype'] == 'somevalue':
return cls(value=None, prop_nr=jsn['property'], snak_type=jsn['snaktype'])
return cls(value=jsn['datavalue']['value'], prop_nr=jsn['property'])
class WDMonolingualText(WDBaseDataType):
"""
Implements the Wikidata data type for Monolingual Text strings
"""
DTYPE = 'monolingualtext'
def __init__(self, value, prop_nr, language='en', is_reference=False, is_qualifier=False, snak_type='value',
references=None, qualifiers=None, rank='normal', check_qualifier_equality=True):
"""
Constructor, calls the superclass WDBaseDataType
:param value: The language specific string to be used as the value
:type value: str
:param prop_nr: The WD item ID for this claim
:type prop_nr: str with a 'P' prefix followed by digits
:param language: Specifies the WD language the value belongs to
:type language: str
:param is_reference: Whether this snak is a reference
datetime.datetime.strptime(self.time, '+%Y-%m-%dT%H:%M:%SZ')
except ValueError as e:
raise ValueError('Wrong data format, date format must be +%Y-%m-%dT%H:%M:%SZ')
@classmethod
@JsonParser
def from_json(cls, jsn):
if jsn['snaktype'] == 'novalue' or jsn['snaktype'] == 'somevalue':
return cls(time=None, prop_nr=jsn['property'], snak_type=jsn['snaktype'])
value = jsn['datavalue']['value']
return cls(time=value['time'], prop_nr=jsn['property'], precision=value['precision'],
timezone=value['timezone'], calendarmodel=value['calendarmodel'])
class WDUrl(WDBaseDataType):
"""
Implements the Wikidata data type for URL strings
"""
DTYPE = 'url'
sparql_query = '''
SELECT * WHERE {{
?item_id p:{0}/ps:{0} <{1}> .
}}
'''
def __init__(self, value, prop_nr, is_reference=False, is_qualifier=False, snak_type='value', references=None,
qualifiers=None, rank='normal', check_qualifier_equality=True):
"""
Constructor, calls the superclass WDBaseDataType
:param value: The URL to be used as the value
:type value: str
for si in stated_in_value:
if si in new_ref_si_values:
keep_block[count] = False
refs = [x for c, x in enumerate(old_references) if keep_block[c]]
refs.extend(new_references)
old_item.set_references(refs)
# sort the incoming data according to the WD property number
self.data.sort(key=lambda z: z.get_prop_nr().lower())
# collect all statements which should be deleted
statements_for_deletion = []
for item in self.data:
if item.get_value() == '' and isinstance(item, WDBaseDataType):
statements_for_deletion.append(item.get_prop_nr())
if self.create_new_item:
self.statements = copy.copy(self.data)
else:
for stat in self.data:
prop_nr = stat.get_prop_nr()
prop_data = [x for x in self.statements if x.get_prop_nr() == prop_nr]
prop_pos = [x.get_prop_nr() == prop_nr for x in self.statements]
prop_pos.reverse()
insert_pos = len(prop_pos) - (prop_pos.index(True) if any(prop_pos) else 0)
# If value should be appended, check if values exists, if not, append
if prop_nr in self.append_value:
equal_items = [stat == x for x in prop_data]
self.json_representation['datavalue'] = {
'value': self.value,
'type': 'string'
}
super(WDMath, self).set_value(value=value)
@classmethod
@JsonParser
def from_json(cls, jsn):
if jsn['snaktype'] == 'novalue' or jsn['snaktype'] == 'somevalue':
return cls(value=None, prop_nr=jsn['property'], snak_type=jsn['snaktype'])
return cls(value=jsn['datavalue']['value'], prop_nr=jsn['property'])
class WDExternalID(WDBaseDataType):
"""
Implements the Wikidata data type 'external-id'
"""
DTYPE = 'external-id'
def __init__(self, value, prop_nr, is_reference=False, is_qualifier=False, snak_type='value', references=None,
qualifiers=None, rank='normal', check_qualifier_equality=True):
"""
Constructor, calls the superclass WDBaseDataType
:param value: The string to be used as the value
:type value: str
:param prop_nr: The WD item ID for this claim
:type prop_nr: str with a 'P' prefix followed by digits
:param is_reference: Whether this snak is a reference
:type is_reference: boolean
:param is_qualifier: Whether this snak is a qualifier
if not __debug__:
print('no matches')
return True
qid = matching_qids.pop()
self.current_qid = qid
reconstructed_statements = []
for prop_nr, dt in self.prop_data[qid].items():
all_uids = set([x['s2'] for x in dt])
q_props = set([x['pr'] for x in dt if 'pr' in x])
for q_prop in q_props:
if q_prop not in self.prop_dt_map:
self.prop_dt_map.update({q_prop: FastRunContainer.get_prop_datatype(prop_nr=q_prop)})
for uid in all_uids:
qualifiers = [[x for x in wdi_core.WDBaseDataType.__subclasses__() if x.DTYPE ==
self.prop_dt_map[y['pr']]][0](value=y['q'], prop_nr=y['pr'], is_qualifier=True)
for y in dt if y['s2'] == uid and 'q' in y]
stmts = [[x for x in wdi_core.WDBaseDataType.__subclasses__() if x.DTYPE ==
self.prop_dt_map[prop_nr]][0](value=y['v'], prop_nr=prop_nr, qualifiers=qualifiers)
for y in dt if y['s2'] == uid][0]
reconstructed_statements.append(stmts)
tmp_rs = copy.deepcopy(reconstructed_statements)
# handle append properties
for p in append_props:
app_data = [x for x in data if x.get_prop_nr() == p]
rec_app_data = [x for x in tmp_rs if x.get_prop_nr() == p]
comp = [True for x in app_data for y in rec_app_data if x == y]
self.json_representation['datavalue'] = {
'value': self.value,
'type': 'string'
}
super(WDMath, self).set_value(value=value)
@classmethod
@JsonParser
def from_json(cls, jsn):
if jsn['snaktype'] == 'novalue' or jsn['snaktype'] == 'somevalue':
return cls(value=None, prop_nr=jsn['property'], snak_type=jsn['snaktype'])
return cls(value=jsn['datavalue']['value'], prop_nr=jsn['property'])
class WDExternalID(WDBaseDataType):
"""
Implements the Wikidata data type 'external-id'
"""
DTYPE = 'external-id'
def __init__(self, value, prop_nr, is_reference=False, is_qualifier=False, snak_type='value', references=None,
qualifiers=None, rank='normal', check_qualifier_equality=True):
"""
Constructor, calls the superclass WDBaseDataType
:param value: The string to be used as the value
:type value: str
:param prop_nr: The WD item ID for this claim
:type prop_nr: str with a 'P' prefix followed by digits
:param is_reference: Whether this snak is a reference
:type is_reference: boolean
:param is_qualifier: Whether this snak is a qualifier
'id': 'Q{}'.format(self.value)
},
'type': 'wikibase-entityid'
}
super(WDItemID, self).set_value(value=value)
@classmethod
@JsonParser
def from_json(cls, jsn):
if jsn['snaktype'] == 'novalue' or jsn['snaktype'] == 'somevalue':
return cls(value=None, prop_nr=jsn['property'], snak_type=jsn['snaktype'])
return cls(value=jsn['datavalue']['value']['numeric-id'], prop_nr=jsn['property'])
class WDProperty(WDBaseDataType):
"""
Implements the Wikidata data type with value 'property'
"""
DTYPE = 'wikibase-property'
sparql_query = '''
SELECT * WHERE {{
?item_id p:{0}/ps:{0} wd:P{1} .
}}
'''
def __init__(self, value, prop_nr, is_reference=False, is_qualifier=False, snak_type='value', references=None,
qualifiers=None, rank='normal', check_qualifier_equality=True):
"""
Constructor, calls the superclass WDBaseDataType
:param value: The WD property number to serve as a value
:type value: str with a 'P' prefix, followed by several digits or only the digits without the 'P' prefix