แแก แแ แแก แกแแแแแแแแแแแแแแ แกแขแแขแแแแแก แกแแ แแแก แแแแ แ แแแฌแแแ Python-แจแ แญแแแแแแ แแแแขแ แแฅแขแแแแก แจแแฅแแแแก แจแแกแแฎแแ Ontology blockchain แฅแกแแแจแ. แฌแแแ แกแขแแขแแแจแ แแแแแชแแแแ
แแฆแแก แแแแแแฎแแแแแ, แแฃ แ แแแแ แแแแแแแงแแแแ แแแแ แ แแแแฃแแโ แจแแแแฎแแแก API. Storage API-แก แแฅแแก แฎแฃแแ แแแแแแจแแ แแแฃแแ API, แ แแแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แแแแแขแแแแก, แฌแแจแแแก แแ แชแแแแแแแแแก แแแแแฉแแแแแ แแแแแแ แแแแขแ แแฅแขแแแจแ แแฃแแแแ แจแแแแฎแแแจแ.
แฅแแแแแ แแแชแแแฃแแแ แแ แฎแฃแแ API-แแก แแแแแ แแฆแฌแแ แ:
แแแแแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแแฎแแแแ, แแฃ แ แแแแ แแแแแแแงแแแแ แแก แฎแฃแแ API.
0. แแแแแ แจแแแฅแแแแ แแฎแแแ แแแแขแ แแฅแขแ
1. แ แแแแ แแแแแแแงแแแแ Storage API
GetContext แแ GetReadOnlyContext
GetContext ะธ GetReadOnlyContext แแแแฆแแ แแแแขแแฅแกแขแ, แ แแแแแจแแช แจแแกแ แฃแแแแฃแแแ แแแแแแแแ แ แญแแแแแแ แแแแขแ แแฅแขแ. แแแแ แฃแแแแแก แแแแจแแแแแแแ แแ แแก แแแแแแ แ แแแแขแ แแฅแขแแก แแแแแแแแ แ แฐแแจแแก แแแแแ แกแแ. แ แแแแ แช แกแแฎแแแ แแแแแแแแแแก, GetReadOnlyContext แแฆแแแก แแฎแแแแ แฌแแแแแฎแแแก แแแแขแแฅแกแขแก. แฅแแแแแ แแแชแแแฃแ แแแแแแแแจแ, แแแแ แฃแแแแแก แแแแจแแแแแแแ แแ แแก แแแแขแ แแฅแขแแก แฐแแจแแก แแแแแ แกแแ, แ แแแแแแช แแแฉแแแแแแแ แแแแ แแแ แฏแแแแ แแฃแแฎแแจแ.
แแแแ
แคแฃแแฅแชแแ แแแแ แแแกแฃแฎแแกแแแแแแแแ แแแแแฉแแแแแ แแแแแชแแแแแแก แแแฅแกแแแแแแก แกแแฎแแ แจแแแแฎแแแแ. แฒ แแแแ แช แแแฉแแแแแแแ, แแแแ แแฆแแแก แกแแ แแแ แแแแขแ แก. GetContext แแฆแแแก แแแแแแแ แแแจแแแแฃแแ แญแแแแแแ แแแแขแ แแฅแขแแก แแแแขแแฅแกแขแก, แแแกแแฆแแแ แแ แแก แแแกแแฆแแแแก แแแแจแแแแแแแ, แ แแแแแแช แกแแญแแ แแ แแแแแชแแแแแแก แจแแกแแแแฎแแ แแ แแแแจแแแแแแแ แแ แแก แแแแแชแแแแแแก แแแแจแแแแแแแ, แ แแแแแแช แฃแแแ แจแแแแแฎแแก. แแแแแแแแแกแฌแแแแ, แ แแ แแฃ แแแกแแฆแแแแก แแแแจแแแแแแแ แฃแแแ แแ แแก แแแฆแแแแแจแ, แคแฃแแฅแชแแ แแแแแแฎแแแแก แแแก แจแแกแแแแแแก แแแแจแแแแแแแแก.
แแแฆแแแ
แคแฃแแฅแชแแ แแแฆแแแ แแแกแฃแฎแแกแแแแแแแแ แแแแแชแแแแ แฌแแแแแฎแแแแ แแแแแแแแ แ แแแแแฉแแแแจแ แแแกแแฆแแแแก แแแแจแแแแแแแแก แแแจแแแแแแ. แฅแแแแแ แแแชแแแฃแ แแแแแแแแจแ แจแแแแซแแแแ แจแแแแกแแ แแแกแแฆแแแแก แแแแจแแแแแแแ แแแ แแแแขแ แแแแก แแแแแแจแ แแแ แฏแแแแ แคแฃแแฅแชแแแก แจแแกแแกแ แฃแแแแแแ แแ แฌแแแแแแฎแแ แแแแแฉแแแแจแ แแแกแแฆแแแแก แแแแจแแแแแแแแก แจแแกแแแแแแกแ แแแแแชแแแแแ.
แฌแแจแแ
แคแฃแแฅแชแแ แฌแแจแแ แแแกแฃแฎแแกแแแแแแแแ แแแแแฉแแแแจแ แแแแแชแแแแแแก แฌแแจแแแแ แแแกแแฆแแแแก แแแแจแแแแแแแแก แแแจแแแแแแ. แฅแแแแแ แแแชแแแฃแ แแแแแแแแจแ แจแแแแซแแแแ แจแแแแกแแ แคแฃแแฅแชแแแก แแแกแแฆแแแแก แแแแจแแแแแแแ แแคแชแแแแแก แแแแแแจแ แแแ แฏแแแแ แแ แฌแแจแแแแ แแแแแฉแแแแจแ แแแกแแฆแแแแก แแแแจแแแแแแแแก แจแแกแแแแแแกแ แแแแแชแแแแแ.
2. แจแแแแฎแแแก API แแแแแก แแแแแแแแ
แฅแแแแแ แแแชแแแฃแแ แแแแ แแซแแแแ แฎแฃแแ API-แแก แแแแแงแแแแแแก แแแขแแแฃแ แแแแแแแแก: GetContext, Get, Put, Delete แแ GetReadOnlyContext. แจแแแแซแแแแ แกแชแแแแ API แแแแแชแแแแแแก แแแจแแแแ
from ontology.interop.System.Storage import GetContext, Get, Put, Delete, GetReadOnlyContext
from ontology.interop.System.Runtime import Notify
def Main(operation,args):
if operation == 'get_sc':
return get_sc()
if operation == 'get_read_only_sc':
return get_read_only_sc()
if operation == 'get_data':
key=args[0]
return get_data(key)
if operation == 'save_data':
key=args[0]
value=args[1]
return save_data(key, value)
if operation == 'delete_data':
key=args[0]
return delete_data(key)
return False
def get_sc():
return GetContext()
def get_read_only_sc():
return GetReadOnlyContext()
def get_data(key):
sc=GetContext()
data=Get(sc,key)
return data
def save_data(key, value):
sc=GetContext()
Put(sc,key,value)
def delete_data(key):
sc=GetContext()
Delete(sc,key)
Afterword
แแแแแฉแแแแแก แกแแชแแแ แแ แแก แแแแแ แแแแแฉแแแแแก แกแแกแขแแแแก แแแ แแแ. Ontology Storage API แแ แแก แแแ แขแแแ แแแแแกแแงแแแแแแแ แแ แแแแแแแแแ แแแแกแแแแก แแแกแแฎแแ แฎแแแแแ.
แแแแ แแก แแฎแ แแ, แจแแแแฎแแ แแ แแก แฐแแแแ แฃแแ แแแแแแกแฎแแแแแก แคแแแฃแกแ, แ แแแแ แแชแแ แฃแกแแคแ แแฎแแแแแก แกแแคแ แแฎแ, แ แแแแแแช แแฆแแแแจแแแ แแ แ-แแ แ แฌแแแ แกแขแแขแแแจแ.
แจแแแแแ แกแขแแขแแแจแ แแแแแแฎแแแแแ แ แแแแ แแแแแแแงแแแแ Runtime API.
แกแขแแขแแ แแแ แแแแแก Hashrate&Shares-แแก แ แแแแฅแขแแ แแแแ แกแแแชแแแแฃแ แแ OntologyRussia-แกแแแแก.
แขแแ แแแ
แแแแแแแแแ แ แฎแแ ? แจแแฃแแ แแแแ แฉแแแแก แขแแฅแแแแฃแ แกแแแแแแแแแแแก
Ontology
แฌแงแแ แ: www.habr.com