def test_nested(self):
alice = Knowledge('alice ')
bob = Knowledge()
@bob.simple("about time")
async def touch(message: str):
assert message == 'about time'
return 'time is nothing'
alice.prefix('ask bob ', bob) # make nested knowledge
reply = asyncio.get_event_loop().run_until_complete(alice('alice ask bob about time'))
print("reply", reply)
assert reply == 'time is nothing', 'nested knowledge'
def home_page(self):
self.GUI()
knowledge = Knowledge()
'''Location and time for home'''
time_json, str_time, str_day = knowledge.time_knowledge()
clock = tk.Label(self.window,
text=str_day,
font=('Arial', 17),
fg='white',
bg='black')
clock.place(relx=0.1, rely=0.1, anchor="center")
clock = tk.Label(self.window,
text=str_time,
font=('Arial', 30),
fg='white',
bg='black')
clock.place(relx=0.1, rely=0.05, anchor="center")
'''weather for home'''
weather_json = knowledge.weather_knowledge()
temp = weather_json['main']['temp']
print(temp)
#temp = float(5/9)*(float(temp)-32 )
temp = int(temp) - 273
print(temp)
self.display()
def learn_from_file(self):
''' It search for knowledge in directory, if exists it is loaded - Procura conhecimentos no diretório, se existir são carregados'''
log("charging knowledge from files")
import glob
files = glob.glob("./know/*")
for file in files:
data = open(file, "r")
data = data.readlines()
nome = data[1].replace("#", "").replace("\n", "")
print nome
topicos = data[2].replace("#", "").replace("\n", "")
descricao = data[3].replace("#", "").replace("\n", "")
modelo = data[4].replace("#", "").replace("\n", "")
endereco = file
atributos = data[6].replace("#", "").replace("\n", "").split()
dependencias = data[7].replace("#",
"").replace("\n",
"").replace(",",
"").split()
for dep in dependencias:
dep = dep.replace(",", "").replace(" ", "")
tipoDeTarefa = data[8].replace("#", "").replace("\n", "").split()
if len(tipoDeTarefa) > 0:
tipoDeTarefa = tipoDeTarefa.pop()
else:
tipoDeTarefa = "passive"
#print (type (tipoDeTarefa))
know = Knowledge(nome, topicos, descricao, modelo, endereco,
atributos, dependencias, tipoDeTarefa)
self.knowledge.append(know)
def __init__(self, verbose):
self._verbose = verbose
self.knowledge = Knowledge()
self.knowledge.add_to_memory(CS4635Context())
self.invalid_list = list()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.file = None
self.goal = None
self.log = None
self.setWindowTitle('Экспертная система')
self.ui.actionNew.triggered.connect(self.showDialogNew)
self.ui.actionOpen.triggered.connect(self.showDialogOpen)
self.ui.actionSaveAs.triggered.connect(self.showDialogSaveAs)
self.ui.actionSave.triggered.connect(self.saveKnowledge)
self.ui.actionDomains.triggered.connect(self.showDialogDomains)
self.ui.actionVariables.triggered.connect(self.showDialogVariables)
self.ui.actionViewOntology.triggered.connect(self.showDialogOntologyView)
self.ui.actionFacts.triggered.connect(self.showDialogFacts)
self.ui.actionStart.triggered.connect(self.showDialogRecommendation)
self.ui.action.triggered.connect(self.showDialogGoal)
self.ui.actionSolution.triggered.connect(self.showDialogSolution)
self.ui.buttonAdd.clicked.connect(self.showDialogAddRule)
self.ui.buttonEdit.clicked.connect(self.showDialogEditRule)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
self.ui.Rules.setDragDropMode(QAbstractItemView.InternalMove)
self.ui.Rules.itemSelectionChanged.connect(self.RefreshBoxes)
def receive_knowledge(self, knowledge):
''' Callback: It receives knowledges from topic and save it in files - Recebe conhecimento e o salva em arquivos'''
data = str(knowledge.data).split("\n")
if self.has(data[1].replace("#", "").replace("\n", "")):
#log ("I already have this knowledge: " + str(data[1]))
return
nome = data[1].replace("#", "").replace("\n", "")
topicos = data[2].replace("#", "").replace("\n", "")
descricao = data[3].replace("#", "").replace("\n", "")
modelo = data[4].replace("#", "").replace("\n", "")
endereco = data[5].replace("#", "").replace("\n", "")
atributos = data[6].replace("#", "").replace("\n", "").split()
dependencias = data[7].replace("#",
"").replace("\n",
"").replace(",",
"").split()
for dep in dependencias:
dep = dep.replace(",", "").replace(" ", "")
tipoDeTarefa = data[8].replace("#", "").replace("\n", "").split()
if len(tipoDeTarefa) > 0:
tipoDeTarefa = tipoDeTarefa.pop()
else:
tipoDeTarefa = "passive"
know = Knowledge(nome, topicos, descricao, modelo, endereco, atributos,
dependencias, tipoDeTarefa)
file = open(data[5].replace("#", "").replace("\n", ""), "wb")
for i in data:
file.write(i + "\n")
self.knowledge.append(know)
file.close()
print('\033[94m' + "I learn!" + str(data[1]))
self.addInLog("Learn " + str(data[1]))
def showDialogNew(self):
qm = QMessageBox()
qm.setWindowTitle('Создать новую базу знаний')
ret = qm.question(self,'', "Вы уверены?", qm.Yes | qm.No)
if ret == qm.Yes:
self.knowledge = Knowledge()
self.setWindowTitle('Экспертная система - БезНазвания' )
else:
pass
def create_rdf():
"""
Create SoftEng RDF file
"""
graph = Graph()
Knowledge(graph)
AcademicDomain(graph)
graph.serialize("ontology/RDF/softeng.rdf")
def initialize(self, id, num_players, k, board, deck_type, my_hand, hands,
discard_pile, deck_size):
"""
To be called once before the beginning.
"""
self.id = id
self.num_players = num_players
self.k = k # number of cards per hand
self.board = board
self.deck_type = deck_type
# store a copy of the full deck
self.full_deck = get_appearance(DECKS[deck_type]())
self.full_deck_composition = Counter(self.full_deck)
# hands
self.my_hand = my_hand # says in which positions there is actually a card
self.hands = hands
# discard pile
self.discard_pile = discard_pile
self.discard_pile_composition = Counter(discard_pile)
# deck size
self.deck_size = deck_size
# personal knowledge
self.personal_knowledge = Knowledge(self, Knowledge.PERSONAL, id)
# public knowledge
self.public_knowledge = [
Knowledge(self, Knowledge.PUBLIC, i) for i in range(num_players)
]
# all knowledge
self.all_knowledge = self.public_knowledge + [self.personal_knowledge]
# remove cards of other players from possibilities
self.update_knowledge()
# create hints manager
self.hints_manager = HintsManager(self)
def __init__(self, name=None, speech_input=False, facebook_input=False):
self.phrases = Phrases()
self.speech = Speech()
self.knowledge = Knowledge(weather_api_token=weather_api_token)
self.name = name
self.facebook_input = facebook_input
if self.facebook_input:
self.facebook_response = list()
self.speech_input = speech_input
self.witai = Wit("S73IKQDWJ22OJMOSD6AOT4CSJOWXIPX6")
self.fs = Fatsecret("90fe184a283449ed8a83e35790c04d65", "054e80b2be154337af191be2c9e11c28")
self.translator = Translator()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.ui.Domains.currentTextChanged.connect(self.refreshDomainValues)
self.ui.VarCategory.currentTextChanged.connect(self.refreshBlock)
self.ui.textQuestion.setReadOnly(True)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_dialog()
self.ui.setupUi(self)
self.ui.domainName.setPlaceholderText('Имя домена')
self.knowledge = Knowledge()
self.ui.buttonAdd.clicked.connect(self.click_buttonAdd)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
self.ui.domainName.setFocus()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.edit = None
self.ui.buttonAdd.clicked.connect(self.click_buttonAdd)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
self.ui.Facts.view().setFixedWidth(300)
def update_temp():
global temp1
global temp_
knowledge = Knowledge()
weather_json = knowledge.weather_knowledge()
location_json = knowledge.location_knowledge()
temp_ = weather_json['main']['temp']
location_temp = location_json['state_prov']
if temp1 != temp_:
temp1 = temp_
text = int(temp1 - 273)
temp.config(text=location_temp + "City\n%d oC" % text)
temp.after(50000, update_greeting)
def test_rule_4(self):
g = make_graph(4, [(0, 1), (1, 0), (0, 2), (2, 0), (0, 3), (3, 0),
(1, 2), (2, 3)])
k = Knowledge()
k.set_forbidden(1, 3)
meek = MeekRules(undirect_unforced_edges=False, knowledge=k)
meek.orient_implied_subset(g, [0])
assert len(g.edges()) == 7
assert has_dir_edge(g, 1, 2)
assert has_dir_edge(g, 2, 3)
assert has_dir_edge(g, 0, 3)
assert has_undir_edge(g, 0, 1)
assert has_undir_edge(g, 0, 2)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.ui.buttonAdd.clicked.connect(self.click_buttonAdd)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
self.ui.tableWidget.setColumnWidth(0, 120)
self.ui.tableWidget.setColumnWidth(1, 280)
self.ui.tableWidget.setSelectionBehavior(
self.ui.tableWidget.SelectRows)
self.ui.tableWidget.setSelectionMode(QAbstractItemView.SingleSelection)
def test_annotations(self):
brain = Knowledge('alice ', 'bob ')
@brain.simple('what time is it now?')
async def current_time(message: str):
return 'no time - no problem'
@brain.regexp(r'I am (?P<name>\w+)')
async def greet(message: str, name: str):
return f"Hello, {name}!"
@brain.simple("raise an error")
async def broken(message: str):
raise RuntimeError("test error")
@brain.simple("skip none")
async def skip_none(message: str):
return None
@brain.simple('multi')
@brain.simple('another')
@brain.regexp('.*?nano.*')
async def multi(message: str):
return 'ok'
@brain.default()
async def unknown(message: str):
return "WTF?"
@brain.simple('pass element')
async def params(message: str, custom_value=None):
assert custom_value is not None
return message
async def main():
assert await brain('bob what time is it now?') == 'no time - no problem', 'simple match'
assert await brain('alice I am Brayan!') == 'Hello, Brayan!', 'regexp named match'
assert await brain('nick I am Alice') is None, 'no trigger'
assert await brain('alice raise an error') == 'WTF?', 'suppress exception'
assert await brain('alice skip none') == 'WTF?', 'skip none result'
assert await brain('bob who are you?') == 'WTF?', 'default trigger'
assert await brain('alice multi') == 'ok', 'multi triggers over first simple'
assert await brain('alice another') == 'ok', 'multi triggers over second simple'
assert await brain('alice super nano multi') == 'ok', 'multi triggers over regexp'
assert await brain('alice pass element', custom_value=123) == 'pass element', 'pass element'
asyncio.get_event_loop().run_until_complete(main())
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.ui.tableWidget.setColumnWidth(0, 135)
self.ui.tableWidget.setColumnWidth(1, 60)
self.ui.tableWidget.setColumnWidth(2, 135)
self.ui.tableWidget.setSelectionBehavior(
self.ui.tableWidget.SelectRows)
self.ui.tableWidget.setSelectionMode(QAbstractItemView.SingleSelection)
self.ui.variables.currentTextChanged.connect(self.RefreshValues)
self.ui.buttonAdd.clicked.connect(self.click_buttonAdd)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
def __init__(self):
self.nlg = NLG(user_name=my_name)
self.nlg_vn = NLG(user_name=my_name_vn, language='vi')
self.speech = Speech(launch_phrase=launch_phrase,
debugger_enabled=debugger_enabled)
self.wit_client_vn = Wit(wit_ai_token_vn)
self.wit_client_en = Wit(wit_ai_token)
self.knowledge = Knowledge(weather_api_token,
google_cloud_api_key=google_cloud_api_key)
#self.vision = Vision(camera=camera)
self.bot_vn = 'ty'
subprocess.Popen([
"aplay", "/home/pi/AI-Smart-Mirror/sample-audio-files/Startup.wav"
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
time.sleep(4)
def initialize_objs_vars():
'''
Initializing all game objects (and some important vars) at the start of the run, namely:
Objects: Player, entities, god, game_map,
Important VARS: game_state, fov_map, key, mouse
'''
# OBJECTS
actor_comp = Actor(mental=pstats['mental'],
physical=pstats['physical'],
spiritual=pstats['spiritual'])
inventory_comp = Inventory(5)
knowledge_comp = Knowledge()
player = Entity(0,
0,
'@',
colors['player'],
'Hero',
blocks=True,
render_order=RenderOrder.ACTOR,
actor=actor_comp,
inventory=inventory_comp,
knowledge=knowledge_comp)
entities = [player]
god = God()
game_map = GameMap(const.get('map_width'), const.get('map_height'))
game_map.make_map(player, entities)
#Important vars
game_state = GameStates.PLAYERS_TURN
prev_game_state = game_state
fov_map = initialize_fov(game_map)
key = tcod.Key()
mouse = tcod.Mouse()
targeting_item = None
targeting_skill = None
#Message related stuff, in a near future, separate into combat, qests, chat, etc
msg_log = MessageLog(const['message_x'], const['message_width'],
const['message_height'])
return player, entities, god, game_map, game_state, prev_game_state, fov_map, msg_log, key, mouse, targeting_item, targeting_skill
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.knowledge = Knowledge()
self.ui.tableWidget.setColumnWidth(0, 120)
self.ui.tableWidget.setColumnWidth(1, 120)
self.ui.tableWidget.setColumnWidth(2, 190)
self.ui.tableWidget.setSelectionBehavior(
self.ui.tableWidget.SelectRows)
self.ui.tableWidget.setSelectionMode(QAbstractItemView.SingleSelection)
self.ui.buttonAdd.clicked.connect(self.showDialogVariableAdd)
self.ui.buttonDelete.clicked.connect(self.click_buttonDelete)
self.ui.buttonEdit.clicked.connect(self.click_buttonEdit)
self.ui.tableWidget.itemSelectionChanged.connect(
self.RefreshQuestionDomainBoxes)
def __init__(self, db_conn, db_name):
from pymongo import Connection
print "Opening MongoDB connection"
self.conn = Connection(host=db_conn)
self.db = self.conn[db_name]
# Open subcollections
self.knowledge = Knowledge(self)
self.frames = Frames(self)
#self.map = Map(self)
self.geo = Geo(self)
# Logging
from wifistalker import Log
header = 'DB'
self.log = Log(self, use_stdout=True, header=header)
# Log collection
self._log = self['log']
self._log.ensure_index('stamp_utc', expireAfterSeconds=60*60)
def transform(self):
"""
Convert original crash dump information into the target data format.
Returns:
Documents to be stored.
"""
documents = []
hash_value = set()
result = self.extract_qdb()
count, total = 0, len(result)
for row in result:
count += 1
test_id, time_stamp, url, bug_id = row
print(f"{test_id}, {count}/{total}")
try:
if requests.get(url, verify=False).status_code == 200:
dump = requests.get(url, verify=False).content.decode("utf-8")
processed = Process(dump).pre_process()
else:
dump = self.extract_cdb(test_id)
processed = Process(dump).internal_process()
except (IndexError, UnicodeDecodeError):
continue
cpnt_order, func_block = Knowledge(processed).add_knowledge()
if not cpnt_order or not func_block:
continue
data = dict()
data["test_id"] = test_id
data["time_stamp"] = int(datetime.timestamp(time_stamp))
data["cpnt_order"] = cpnt_order
data["func_block"] = func_block
data["bug_id"] = bug_id
data["md5sum"] = hashlib.md5("".join("".join(i) for i in func_block).encode("utf-8")).hexdigest()
# deduplication via set
if data["md5sum"] in hash_value:
continue
hash_value.add(data["md5sum"])
documents.append(data)
return documents
def detect_sim(self):
"""
Detect crash dump similarity and output the comparison result.
"""
message = []
order_pair, block_pair = [], []
for param in self.params:
# parameter is test_id
if re.match(r"^\d{9,}$", param):
dump = ETL().extract_cdb(param)
processed = Process(dump).internal_process()
# parameter is dump_path
else:
with open(param, "r", encoding="utf-8") as fp:
dump = fp.read()
processed = Process(dump).pre_process()
cpnt_order, func_block = Knowledge(processed).add_knowledge()
message.extend([cpnt_order, func_block])
order_pair.append(cpnt_order)
block_pair.append(func_block)
# output dump comparison
Log().dump_print(message)
Calculate(order_pair, block_pair).calculate_sim(debug=True)
def __init__(self, game, x, y):
self.groups = game.all_sprites
pg.sprite.Sprite.__init__(self, self.groups)
self.game = game
self.images = {'normal': pg.image.load(path.join(game.img_folder, "apple_64px.png")).convert_alpha(), \
'blink': pg.image.load(path.join(game.img_folder, "apple_64px_blink.png")).convert_alpha(), \
'wink': pg.image.load(path.join(game.img_folder, "apple_64px_wink.png")).convert_alpha()}
self.blinks = False
self.blink_time = .25
self.staring_time = 3
self.start_time = time.time()
self.image = self.images['normal']
self.rect = self.image.get_rect()
self.rect.center = (x, y)
self.hit_rect = self.rect
self.hit_rect.center = self.rect.center
self.vel = vec(0, 0)
self.position = vec(x, y)
self.dest = vec_dest(x, y)
self.previous_pos = vec_prev(x, y)
self.instruction = ""
self.orientation = "front" # left, right, front, back
self.name = "Young Apple"
self.silence_responses = ["can you please say that again?", "oops, I missed that. say again?", "I heard *silence*", "repeat again, please?", "could you say again?", "I didn't hear that, try again?", "I heard *silence*"]
self.knowledge = Knowledge(self)
self.transcript = Transcript()
# Working memory properties
self.recognized = []
self.actions = [] # current, complete list of action sequences e.g. [[1],[[0],[2]]]
self.input_to_actions = []
self.action_queue = [] # remaining actions to be completed
self.current_action = []
self.key_used = ""
#self.responses = []
self.response = ""
def __init__(self):
self.nlg = NLG(user_name=my_name)
self.speech = Speech(launch_phrase=launch_phrase, debugger_enabled=debugger_enabled)
self.knowledge = Knowledge(weather_api_token)
self.vision = Vision(camera=camera)
from knowledge import Knowledge
root = Knowledge('сая ')
def __init__(self, **kwargs):
self.knowledge = Knowledge(**kwargs)
self.encoder = Encoder()
self.decoder = Decoder()
def rewrite(self):
return Negation(
lhs=Knowledge(agent=self.agent, lhs=Negation(lhs=self.lhs)))
default=False,
help='If notify is defined, then errors will be sent by email',
required=False)
flags = parser.parse_args()
args = vars(flags)
except ImportError:
flags = None
sheet = args['sheet_id'] or None
notify = args['notify'] or False
logging_level = args['logging_level'] or 'ERROR'
logger = logger_builder.initLogger(logging_level)
config = Config()
spreadsheet_api = Spreadsheet(flags)
knowledge = Knowledge(config)
project = Project(config)
gmail = GMail(flags)
def load_knowledge_map(sheet=None, notify=False):
"""Load data from spreadsheet api and save on knowledge database."""
# authenticate and get service API for spreadsheet
service = spreadsheet_api.get_service_spreadsheets()
spreadsheets = project.find_by_sheet_id(sheet)
total_hits = spreadsheets['hits']['total']
logger.info('total %s sheets' % total_hits)
total_errs = 0
for item in spreadsheets['hits']['hits']:
