def main(): fips = pd.read_csv("./US_FIPS_Codes.csv", header=None) fips.columns = ['State', 'County', "State_FIPS", "County_FIPS"] fips['State_FIPS'] = fips['State_FIPS'].apply(lambda x: str(x).zfill(2)) fips['County_FIPS'] = fips['County_FIPS'].apply(lambda x: str(x).zfill(3)) fips['FIPS'] = fips['State_FIPS'] + fips['County_FIPS'] OW_county = [] fips_list = fips['FIPS'].tolist() file_path = "OW_result.csv" for item in fips_list: if int(item)>=39039: print("processing county:%s"%item) query_item = query_generator(item, "2021-01-09") server = sparql.SPARQLServer('http://128.111.106.227:7201/repositories/Covid-KG') result = server.query(query_item) result_list = extract_results(result) result_pd = pd.DataFrame(result_list, columns =['Model', 'Error']) if len(result_pd.index[result_pd['Model'] == 'OliverWyman-Navigator'].tolist())>0: OW_index = result_pd.index[result_pd['Model'] == 'OliverWyman-Navigator'].tolist()[0] OW_ratio = (OW_index+1)/len(result_pd) # index start from 0, so +1 with open(file_path, 'a') as f: writer = csv.writer(f) writer.writerow([item, OW_index+1, len(result_pd), OW_ratio]) else: with open(file_path, 'a') as f: writer = csv.writer(f) writer.writerow([item, '', '', ''])
def __init__(self, params_tsv=params_file, return_param_name=False) -> None: self.df_params = read_csv(params_tsv, sep='\t') self.df_params = self.df_params[ self.df_params.is_auth_param == False] # Remove authentication parameters self.df_params['name'] = self.df_params['name'].apply( ParamUtils.normalize) self.values = {} self.pattern_values = {} self.wikidata_server = sparql.SPARQLServer( 'http://localhost:9999/bigdata/namespace/wdq/sparql') self.return_param_name = return_param_name for index, row in self.df_params.iterrows(): name, pattern, example, typ, count = row['name'], row[ 'pattern'], row['example'], row['type'], row['count'] if example == 'None': continue if (name, typ) not in self.values: self.values[(name, typ)] = Counter() self.values[(name, typ)].update({example: count}) if pattern == 'None': continue if pattern not in self.pattern_values: self.pattern_values[pattern] = Counter() self.pattern_values[pattern].update({example: count})
def getIncludedFromExcluded(to_exclude,endpoint): server = sparql.SPARQLServer(endpoint) result = server.query('select distinct ?p where {?s ?p ?o}') to_include = [b['p']['value'] for b in result['results']['bindings']] for element in to_exclude: to_include.remove(element) to_include = [(p,'') for p in to_include] return to_include
def reset(): ts = sparql.SPARQLServer("http://localhost:9999/blazegraph/sparql") ts.update('delete{?x ?y ?z} where{?x ?y ?z}') shutil.rmtree("meta\\demo\\dumontier\\corpus\\", ignore_errors=True) shutil.rmtree("meta\\demo\\dumontier\\CSVe\\", ignore_errors=True) with open(patha("meta\\DEMO\\Dumontier\\auxiliary\\auxiliary.txt"), 'w') as br: br.write('') br.close()
def work(identification, graph_name, step_to_do, redis_fn): global redis_connection, strict_redis_connection, sparql_server, step, step_graph step = step_to_do log('work ' + '[' + str(step) + ']') #for Collections step_graph = ConjunctiveGraph(sparqlstore.SPARQLStore(sparql_uri), graph_name) sparql_server = sparql.SPARQLServer(sparql_uri) redis_connection = redislite.Redis(redis_fn) strict_redis_connection = redislite.StrictRedis(redis_fn) gv_output_file_name = identification + '_' + str(step).zfill(7) + '.gv' if list(subjects(RDF.type, kbdbg.frame)) == []: log('no frames.' + '[' + str(step) + ']') put_last_bindings(step, []) return if (step == global_start - 1): gv_output_file_name = 'dummy' try: os.unlink(gv_output_file_name) except FileNotFoundError: pass gv_output_file = open(gv_output_file_name, 'w') e = Emitter(gv_output_file, step) e.generate_gv_image() gv_output_file.close() if (step == global_start - 1): return log('convert..' + '[' + str(step) + ']') #cmd, args = subprocess.check_output, ("convert", '-regard-warnings', "-extent", '6000x3000', gv_output_file_name, '-gravity', 'NorthWest', '-background', 'white', gv_output_file_name + '.svg') cmd, args = subprocess.check_output, ("dot", '-Tsvg', gv_output_file_name, '-O') try: r = cmd(args, stderr=subprocess.STDOUT) if r != b"": raise RuntimeError('[' + str(step) + '] ' + str(r)) except subprocess.CalledProcessError as e: log('[' + str(step) + ']' + e.output) log('convert done.' + '[' + str(step) + ']') if len(stats): print('stats:') for i in stats: print(i) #stats.clear() redis_connection._cleanup() strict_redis_connection._cleanup()
def query_from_files(kb, goal, nokbdbg, nolog, visualize, sparql_uri, identification, base): global server, this pyin.kbdbg_file_name, pyin._rules_file_name, identification, base, this, runs_path = set_up( identification, base) pyin.this = this pyin.nolog = nolog common.nolog = nolog pyin.init_logging() common.log = pyin.log if sparql_uri != '': pyin.pool = ThreadPoolExecutor( ) #max_workers = , thread_name_prefix='sparql_updater' server = sparql.SPARQLServer(sparql_uri) server.update("""CLEAR GRAPHS""") pyin.server = server if sparql_uri != '': new = """kbdbg:latest kbdbg:is <""" + this + ">" pyin.kbdbg(new, default=True) uuu = ( pyin.prefixes + #WITH """ + default_graph + """ """DELETE {kbdbg:latest kbdbg:is ?x} WHERE {kbdbg:latest kbdbg:is ?x}""" ) server.update(uuu) pyin.kbdbg_text('#' + uuu) if identification != "": nolog or pyin.kbdbg( '<' + this + "> kbdbg:has_run_identification " + rdflib.Literal(identification).n3(), True) rules, query_rule, goal_graph = pyin.load(kb, goal, identification, base) for result in query(rules, query_rule, goal_graph): print() r = '' for triple in result: r += triple.str() print(' RESULT : ' + r) print(' step :' + str(pyin.global_step_counter)) sys.stdout.flush() nolog or pyin.kbdbg_text('#result: ' + r) print(' steps :' + str(pyin.global_step_counter)) if sparql_uri != '': pyin.kbdbg("<" + this + "> kbdbg:is kbdbg:done", default=True) pyin.flush_sparql_updates() if sparql_uri != '': pyin.pool.shutdown()
def requestSPARQL(gene, drug, verbose=True): """ Return result of query based on gene and drug in param """ server = sparql.SPARQLServer(ADDRESS) q = query % {'gene': gene, 'drug': drug} print q res = server.query(q) print res # Loading data to Blazegraph # server.update('load <file:///tmp/data.n3>') # Executing query # for b in result['results']['bindings']: # print "%s %s" (b['p']['value'], b['o']['value']
def foo(): global embeddings global args data = request.json if 'query' not in data: return {"status": "error"} response = json.dumps(processor.search( query = data['query'], fix_misspellings = data['fix-misspellings'] if 'fix-misspellings' in data else False, use_embeddings = data['use-embeddings'] if 'use-embeddings' in data else False, w2v = embeddings[data['embeddings'] if 'embeddings' in data else W2V_EMBEDDINGS], similar_tokens_score_weight = data['similar-tokens-score-weight'] if 'similar-tokens-score-weight' in data else 0.5, similar_tokens_quantity = data['similar-tokens-quantity'] if 'similar-tokens-quantity' in data else 2, products_quantity = data['products-quantity'] if 'products-quantity' in data else 5, similar_products_quantity = data['similar-products-quantity'] if 'similar-products-quantity' in data else 5, verbose = args.verbose, min_word_difference_ratio = data['min-word-difference-ratio'] if 'min-word-difference-ratio' in data else 50, sparql_server = sparql.SPARQLServer(f'http://{args.sparql_host}:9999/bigdata/sparql'), enable_good_type_diversity = data['enable-good-type-diversity'] if 'enable-good-type-diversity' in data else False, enable_product_type_diversity = data['enable-product-type-diversity'] if 'enable-product-type-diversity' in data else False, enable_developer_diversity = data['enable-developer-diversity'] if 'enable-developer-diversity' in data else False, enable_transliteration = data['enable-transliteration'] if 'enable-transliteration' in data else False )).encode().decode("utf-8") return response, 200, {'Content-Type': 'application/json; charset=utf-8'}
PREFIX dbpedia: <http://dbpedia.org/resource/> INSERT { ?s a dbpedia:Human . } WHERE { ?s a foaf:Person . } """) print("After the UPDATE, there are {} triples in the graph".format(len(g))) g.add((rdflib.URIRef("http://sib/person/serguei"), FOAF.givenName, rdflib.Literal("Serguei", datatype=XSD.string))) for row in g.query("SELECT ?s WHERE { [] foaf:knows ?s .}"): print(row.s) print("After the UPDATE, there are {} triples in the graph".format(len(g))) from pymantic import sparql server = sparql.SPARQLServer( 'http://HOST:PORT/blazegraph/namespace/NS_NAME/sparql') # Loading data to Blazegraph server.update( 'load <file:///opt/semantics-information-broker/data/blazegraph_prefix.n3>' ) # Executing query result = server.query( 'select * where { <http://blazegraph.com/blazegraph> ?p ?o }')
def connect_to_server(self): return sparql.SPARQLServer(self.blaze_graph_server)
# prefix cnt: <http://www.w3.org/2011/content#> # prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> # select DISTINCT ?query ?path ?chars ?method ?headerName ?headerValue # { # ?query a http:Request. # ?query http:absolutePath ?path. # ?query http:methodName ?method. # ?query http:body ?body. # ?body cnt:chars ?chars. # ?query http:headers/(rdf:first|rdf:rest)* ?header. # ?header http:fieldName ?headerName. # ?header http:fieldValue ?headerValue. # filter (?query = <http://voice.iot/request/get_device_state>)} # ''') # for b in result['results']['bindings']: # print(f"{b['p']['value']}, {b['o']['value']}") from pymantic import sparql server = sparql.SPARQLServer('http://25.29.130.188:9999/blazegraph/sparql') # Loading data to Blazegraph #server.update('load <file:///tmp/data.n3>') # Executing query result = server.query('select * where { <http://blazegraph.com/blazegraph> ?p ?o }') for b in result['results']['bindings']: print(b['p']['value'], b['o']['value'])
def __init__(self, url): self.server = sparql.SPARQLServer(url) self.prefixes = {}
from pymantic import sparql import csv, json server = sparql.SPARQLServer('http://127.0.0.1:9999/blazegraph/sparql') geo_file = open('edhGeographicData.json') geo_str = geo_file.read() geo_data = json.loads(geo_str)["features"] # Executing query result = server.query( 'PREFIX dcterms: <http://purl.org/dc/terms/> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX skos: <http://www.w3.org/2004/02/skos/core#> PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> PREFIX nmo: <http://nomisma.org/ontology#> PREFIX epi: <http://edh-www.adw.uni-heidelberg.de/edh/ontology#> PREFIX dc: <http://purl.org/dc/terms/> PREFIX lawd: <http://lawd.info/ontology/> PREFIX foaf: <http://xmlns.com/foaf/0.1/> PREFIX geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> SELECT distinct ?epigraph ?text ?place ?start ?end WHERE { ?epigraph epi:hasEditionText ?text. ?epigraph lawd:foundAt ?place. ?epigraph nmo:hasStartDate ?start. ?epigraph nmo:hasEndDate ?end . }' ) data = list() count = 0 for b in result['results']['bindings']: count += 1 print(count) dictio = dict() dictio["epigraph"] = b["epigraph"]["value"] dictio["text"] = b["text"]["value"] dictio["place"] = b["place"]["value"] dictio["start"] = b["start"]["value"] dictio["end"] = b["end"]["value"] dictio["id"] = b["epigraph"]["value"].replace( "http://edh-www.adw.uni-heidelberg.de/edh/inschrift/", "") for place in geo_data: if str(place["properties"]["uri"]).replace("https", "http") == str( b["place"]["value"]): dictio["lat"] = place["geometry"]["coordinates"][0] dictio["lng"] = place["geometry"]["coordinates"][1]
def __init__(self, ts_url): self.ts = sparql.SPARQLServer(ts_url)
from pymantic import sparql server = sparql.SPARQLServer('https://tender-hack-spb-manaslu.aa13q.ru/bigdata/sparql') # Loading data to Blazegraph server.update('load <file:///tmp/data.ttl>') # Executing query result = server.query('select * where { ?s ?p ?o }') for b in result['results']['bindings']: print(b['s']['value'], b['p']['value'], b['o']['value'])
def run(quiet, start, end, workers): global global_start, graphs_name_start, sparql_server, start_time, graphviz_pool if start: raise Exception("--start functionality needs updating") global_start = start if quiet: logger.setLevel(logging.INFO) sparql_server = sparql.SPARQLServer(sparql_uri) redis_fn = redislite.Redis().db info('redis is ' + redis_fn) if workers: worker_pool = ProcessPoolExecutor(max_workers=workers) graphviz_pool = ProcessPoolExecutor(max_workers=128) graphs_name_start = query_one('x', "{kbdbg:latest kbdbg:is ?x}") identification0 = query_one( 'y', "{<" + graphs_name_start + "> kbdbg:has_run_identification ?y}") path = 'runs/' + fix_up_identification(identification0) info('output path:' + path) os.system('mkdir -p ' + path) identification = path + '/' + fix_up_identification(graphs_name_start) graph_list_position = graphs_name_start step_to_submit = -1 done = False range_start = None start_time = time.perf_counter() range_size = 200000 while not done: step_to_submit += 1 if step_to_submit < start - 1: info("skipping [" + str(step_to_submit) + ']') continue if range_start == None: range_start = step_to_submit range_end = step_to_submit if range_end - range_start == range_size or (range_end >= end and end != -1): args = (identification, 'step_graph_uri', range_start, range_end, redis_fn) if not workers: work(*args) else: if check_futures() == 'end': info("ending") done = True break while len(futures) > workers + 1: info('sleeping') time.sleep(10) if check_futures() == 'end': info("ending") done = True break info('submit ' + str(range_start) + '-' + str(range_end) + ' (queue size: ' + str(len(futures)) + ')') fut = worker_pool.submit(work, *args) fut.step = step_to_submit futures.append(fut) log('submitted ') time.sleep(secs_per_frame) if check_futures() == 'end': info("ending") done = True break range_start = range_end + 1 range_size = range_size * 5 if range_size >= 100000: range_size = 100000 if range_start > end and end != -1: info("ending") done = True break log('loop' + str(step_to_submit)) if workers: while len(futures) != 0: check_futures() info('waiting for workers to end') time.sleep(10) worker_pool.shutdown() check_futures() while len(graphviz_futures) != 0: check_futures2(graphviz_futures) info('waiting for graphviz workers to end') time.sleep(2) graphviz_pool.shutdown()
def work(identification, graph_name, _range_start, _range_end, redis_fn): global redis_connection, strict_redis_connection, sparql_server, current_step, range_start, range_end, ss, just_unbound_bindings, frames_done_count, frame_templates, bnode_strings range_start, range_end = _range_start, _range_end sparql_server = sparql.SPARQLServer(sparql_uri) redis_connection = redislite.Redis(redis_fn) strict_redis_connection = redislite.StrictRedis(redis_fn) frame_templates = redis_collections.Dict(key='frames', redis=strict_redis_connection, writeback=True) bnode_strings = redis_collections.Dict(key='bnodes', redis=strict_redis_connection, writeback=True) raw = defaultdict(list) #todo limit queries with range_start, then uncomment this #if range_start != 0: # raw = redis_load('checkpoint'+str(range_start - 1)) raw['frames'] += list( query(('frame', 'parent', 'is_for_rule', 'step_finished', 'step_created'), """WHERE { """ + frame_query() + """ OPTIONAL {?frame kbdbg:has_parent ?parent}. ?frame kbdbg:is_for_rule ?is_for_rule. }""")) raw['bnodes'] += list( query(('bnode', 'frame', 'items', 'step_created', 'step_finished'), """WHERE { ?bnode kbdbg:has_items ?items. ?bnode kbdbg:has_parent ?frame. GRAPH ?g_created {?bnode rdf:type kbdbg:bnode}. """ + step_magic('_created') + """ OPTIONAL { GRAPH ?g_finished{?frame kbdbg:is_finished true}. """ + step_bind('_finished') + """ } }""")) raw['results'] += list( query(('uri', 'value', 'step_unbound'), """WHERE {GRAPH ?g_created { ?uri rdf:type kbdbg:result. ?uri rdf:value ?value. }.""" + step_magic('_created') + """ OPTIONAL {GRAPH ?g_unbound {?uri kbdbg:was_ubound true}.}.""" + step_bind('_unbound') + '}')) raw['bindings'] += list( query(('x', 'source', 'target', 'source_frame', 'target_frame', 'source_is_bnode', 'target_is_bnode', 'source_term_idx', 'target_term_idx', 'source_is_in_head', 'target_is_in_head', 'source_arg_idx', 'target_arg_idx', 'stepbinding_unbound', 'stepbinding_failed', 'stepbinding_created'), """WHERE { GRAPH ?gbinding_created {?x rdf:type kbdbg:binding.}. """ + step_magic('binding_created') + """ OPTIONAL {GRAPH ?gbinding_unbound {?x kbdbg:was_unbound true}. """ + step_bind('binding_unbound') + """ }. OPTIONAL {GRAPH ?gbinding_failed {?x kbdbg:failed true}. """ + step_bind('binding_failed') + """ }. ?x kbdbg:has_source ?source. ?x kbdbg:has_target ?target. ?source kbdbg:has_frame ?source_frame. ?target kbdbg:has_frame ?target_frame. OPTIONAL {?source kbdbg:is_bnode ?source_is_bnode.}. OPTIONAL {?target kbdbg:is_bnode ?target_is_bnode.}. ?source kbdbg:term_idx ?source_term_idx. ?target kbdbg:term_idx ?target_term_idx. OPTIONAL {?source kbdbg:is_in_head ?source_is_in_head.}. OPTIONAL {?target kbdbg:is_in_head ?target_is_in_head.}. OPTIONAL {?source kbdbg:arg_idx ?source_arg_idx.}. OPTIONAL {?target kbdbg:arg_idx ?target_arg_idx.}. }""")) current_step = range_end redis_save('checkpoint' + str(range_end), filter_out_irrelevant_stuff(raw)) current_step = '666' last_bindings = raw['bindings'][:] for i in range(range_start, range_end + 1): current_step = i ss = '[' + str(current_step) + ']' info('work ' + ss) state = filter_out_irrelevant_stuff(raw) if len(state['frames']) == 0: info('no frames.' + ss) continue #wont work with euler-style steps #if last_bindings == state['bindings']: # return 'end' #todo make emitter save data to output, not to file e = Emitter() e.gv("digraph frame" + str(current_step) + "{ ") #splines=ortho;#gv("pack=true") e.do_frames(state['frames']) e.do_bnodes(state['bnodes']) e.do_results(state['results']) e.do_bindings(state['bindings']) e.gv("}") info('}..' + ss) args = (ss, identification + '_' + str(current_step).zfill(7) + '.gv', e.output) while len(graphviz_futures) > 10000: info('sleeping') time.sleep(10) check_futures2(graphviz_futures) graphviz_futures.append(graphviz_pool.submit(output, *args)) check_futures2(graphviz_futures) #print_stats() redis_connection._cleanup() strict_redis_connection._cleanup()
?b4 kbdbg:has_source ?s4. ?s4 kbdbg:has_frame ?f5. ?f5 kbdbg:is_for_rule :Rule8. ?b4 kbdbg:has_target ?t4. ?t4 kbdbg:has_frame ?f0. ?b5 rdf:type kbdbg:binding. MINUS {?b5 kbdbg:failed true}. MINUS {?b5 kbdbg:was_unbound true}. ?b5 kbdbg:has_source ?s5. ?s5 kbdbg:has_frame ?f0. ?b5 kbdbg:has_target ?t5. ?t5 kbdbg:has_frame ?f6. ?f6 kbdbg:is_for_rule :Rule2. ?b6 rdf:type kbdbg:binding. MINUS {?b6 kbdbg:failed true}. MINUS {?b6 kbdbg:was_unbound true}. ?b6 kbdbg:has_source ?s6. ?s5 kbdbg:has_frame ?f6. ?b6 kbdbg:has_target ?t6. ?t5 kbdbg:has_frame ?f7. ?f7 kbdbg:is_for_rule :Rule10. """.strip().splitlines() sp = 'http://192.168.122.108:9999/blazegraph/sparql' server = sparql.SPARQLServer(sp) server.post_directly = True r = server.query(""" PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX kbdbg: <http://kbd.bg/#> PREFIX : <file:///#> SELECT ?this WHERE {kbdbg:latest kbdbg:is ?this}""") r = (r['results']['bindings']) if not len(r): print("no kbdbg:latest") exit() latest = URIRef(r[0]['this']['value']) print('latest is ' + latest.n3()) r = server.query(""" PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
from pymantic import sparql import os from glob import glob server = sparql.SPARQLServer( 'http://stko-roy.geog.ucsb.edu:9999/blazegraph/namespace/covid19-prediction/sparql' ) progress_file_list = [] progress_file = 'triple_progress_file.csv' if os.path.isfile(progress_file): with open(progress_file, newline='') as fr: for line in fr: progress_file_list.append(line.strip().replace('\n', '')) ##### Import the main part of the data ######### PATH = './output' EXT = "*.ttl" file_names = [ file for path, subdir, files in os.walk(PATH) for file in glob(os.path.join(path, EXT)) ] for file_name in file_names: if (file_name not in progress_file_list) and ( 'LICENSE' not in file_name) and ('README' not in file_name): file_command = 'load <file://' + os.path.abspath(file_name) + '>' print('loading %s' % (file_command)) server.update(file_command) with open(progress_file, 'a') as fa: fa.write(file_name + '\n')
from rdflib import URIRef, XSD, Namespace, Literal from rdflib.namespace import OWL, DC, DCTERMS, RDF, RDFS from rdflib.plugins.sparql import prepareQuery from SPARQLWrapper import SPARQLWrapper, JSON from web import form from pymantic import sparql WD = Namespace("http://www.wikidata.org/entity/") WDP = Namespace("http://www.wikidata.org/wiki/Property:") OL = Namespace("http://openlibrary.org/works/") ULAN = Namespace("http://vocab.getty.edu/ulan/") AAT = Namespace("http://vocab.getty.edu/aat/") PROV = Namespace("http://www.w3.org/ns/prov#") base = 'https://w3id.org/artchives/' server = sparql.SPARQLServer(conf.artchivesEndpoint) dir_path = os.path.dirname(os.path.realpath(__file__)) def clean_to_uri(stringa): """ given a string return a partial URI""" uri = re.sub('ä', 'a', stringa.strip().lower()) uri = re.sub('à', 'a', uri) uri = re.sub('è', 'e', uri) uri = re.sub('é', 'e', uri) uri = re.sub('ì', 'i', uri) uri = re.sub('ò', 'o', uri) uri = re.sub('ù', 'u', uri) uri = re.sub('[^a-zA-Z\s]', '', uri) uri = re.sub('\s', '-', uri) return uri
import os import time import sparql as SQ import requests import json from pymantic import sparql from SPARQLWrapper import SPARQLWrapper, JSON if __name__ == "__main__": q = 'ASK { ?s ?p ?o }' print 'bootstrapping provesense... - ', q endpoint = os.getenv('SPARQL_ENDPOINT', 'http://blazegraph:9999/blazegraph/sparql') while True: try: bootstrapped = SQ.query(endpoint, q) server = sparql.SPARQLServer(endpoint) if not bootstrapped.hasresult(): server.update('load <file:///tmp/bootstrap/prov-o.ttl>') server.update('load <file:///tmp/bootstrap/ssn.ttl>') server.update('load <file:///tmp/bootstrap/time.ttl>') server.update( 'load <file:///tmp/bootstrap/provesense-bootstrap.ttl>') # server.update('load <file:///tmp/blazegraph/sao.ttl>') break except: pass time.sleep(2)