def nn2():
	import nn

	wWorld,wRiver,wBank = 101,102,103
	uWorldBank,uRiver,uEarth = 201,202,203
	mynet = nn.searchnet("nn.db")
	print(mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth]))

def onclick():
  mynet=nn.searchnet('nn.db')
  wWorld,wRiver,wBank =101,102,103
  uWorldBank,uRiver,uEarth =201,202,203
  mynet.generatehiddennode([wWorld,wBank],[uWorldBank,uRiver,uEarth])
  for c in mynet.con.execute('select * from wordhidden'): print c
  for c in mynet.con.execute('select * from hiddenurl'): print c
  print mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])

 def __init__(self):
     self.net = nn.searchnet('gridwar.db')
     # self.net.maketables()
     self.oUP = 0
     self.oDown = 1
     self.oLeft = 2
     self.oRight = 3
     self.outputs = [self.oUP, self.oDown, self.oLeft, self.oRight]

def test_select():
    sys.stderr.write("testing create hiddennodes...\n")
    mynet=nn.searchnet('nn.db')
    mynet.maketables()
    wWorld,wRiver,wBank =101,102,103
    uWorldBank,uRiver,uEarth =201,202,203
    mynet.generatehiddennode([wWorld,wBank],[uWorldBank,uRiver,uEarth])
    sys.stderr.write("testing 'select * from wordhidden'...\n")
    for c in mynet.con.execute('select * from wordhidden'): print c
    sys.stderr.write("testing 'select * from hiddenurl'...\n")
    for c in mynet.con.execute('select * from hiddenurl'): print c

def test_trainqueries():
    sys.stderr.write("testing training queries...\n")
    mynet=nn.searchnet('nn.db')
    allurls=[uWorldBank,uRiver,uEarth]
    for i in range(30):
        mynet.trainquery([wWorld,wBank],allurls,uWorldBank)
        mynet.trainquery([wRiver,wBank],allurls,uRiver)
        mynet.trainquery([wWorld],allurls,uEarth)

    print mynet.getresult([wWorld,wBank],allurls)
    print mynet.getresult([wRiver,wBank],allurls)
    print mynet.getresult([wBank],allurls)

def trainingTest():
  mynet=nn.searchnet('nn.db')
  wWorld,wRiver,wBank =101,102,103
  uWorldBank,uRiver,uEarth =201,202,203
  allurls=[uWorldBank,uRiver,uEarth]
  for i in range(30):
    mynet.trainquery([wWorld,wBank],allurls,uWorldBank)
    mynet.trainquery([wRiver,wBank],allurls,uRiver)
    mynet.trainquery([wWorld],allurls,uEarth)
  print mynet.getresult([wWorld,wBank],allurls)
  print mynet.getresult([wRiver,wBank],allurls)
  print mynet.getresult([wBank],allurls)
  '''

def nn():
	import nn
	mynet = nn.searchnet("nn.db")
	mynet.maketables()
	wWorld,wRiver,wBank = 101,102,103
	uWorldBank,uRiver,uEarth = 201,202,203
	mynet.generatehiddennode([wWorld,wBank],[uWorldBank,uRiver,uEarth])

	for c in mynet.con.execute("select * from wordhidden"):
		print(c)

	for c in mynet.con.execute("select * from hiddenurl"):
		print(c)

#!/Users/kawasakitaku/Documents/python-PVM/ln-python3.4/bin/python3.4

import searchengine as s
import nn
from flask import Flask
from flask import render_template, request
import os


mynet = nn.searchnet("nn.db")

tempate = os.path.join(os.getcwd(),'templates')
app = Flask(__name__,template_folder=tempate)

def makeindex(key):
  e = s.searcher('searchindex.db')
  result = e.query(key)
  List = []
  size = len(result)
  for i in range(size):
    for j in result[i]:
      List.append(e.geturlname(j))
  return List


@app.route('/',methods=['GET','POST'])
def index():
  if request.method == 'POST':
    keyword = request.form['keyword']
    res_list = makeindex(keyword)
    if keyword:

def test_trainquery():
    sys.stderr.write("testing training query...\n")
    mynet=nn.searchnet('nn.db')
    mynet.trainquery([wWorld,wBank],[uWorldBank,uRiver,uEarth],uWorldBank)
    print mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])

def test_feedforward():
    sys.stderr.write("testing feedforward (without training)...\n")
    mynet=nn.searchnet('nn.db')
    print mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])

import os
import re
import urllib2
import urlparse

from pysqlite2 import dbapi2 as sqlite
from BeautifulSoup import BeautifulSoup

import nn
net = nn.searchnet('nn.db')  # XXX: somehow train this from user clicks

ignorewords = set(['the', 'of', 'to', 'and', 'a', 'in', 'is', 'it'])


# XXX: the root page (amnoid.de) is indexed twice for some reason (e.g.
#   select * from links where toid = 2;
# shows the link 1->2 two times.
class crawler:

  def __init__(self, dbname):
    self.con = sqlite.connect(dbname)

  def __del__(self):
    self.con.close()

  def dbcommit(self):
    self.con.commit()

  def getentryid(self, table, field, value, createnew=True):
    """Returns an entry id and creates it if it is not present."""
    cur = self.con.execute('select rowid from %s where %s="%s"'

 #coding=utf-8
import nn
mynet=nn.searchnet('nn.db')#创建数据库
#mynet.maketables()#创建数据表
wWorld,wRiver,wBank=101,102,103
uWorldBank,uRiver,uEarth=201,202,203
mynet.generatehiddennode([wWorld,wBank],[uWorldBank,uRiver,uEarth])
for c in mynet.con.execute('select * from wordhidden'): print c
for c in mynet.con.execute('select * from hiddenurl'): print c

# crawler.createindextables()

crawler = searchengine.crawler("searchindex.db")
# crawler.createindextables()
# pages=['http://kiwitobes.com/wiki/Categorical_list_of_programming_languages.html']
# crawler.crawl(pages)


# crawler.calculatepagerank()

# search
# e=searchengine.searcher('searchindex.db')
# e.query('function programming')

import nn

mynn = nn.searchnet("nndb.db")
# mynn.maketables()
kaka1 = mynn.getstrength(0, 5, 0)
kaka1 = mynn.getstrength(0, 5, 1)

mynn.setstrength(0, 5, 0, 3)
mynn.setstrength(0, 5, 1, 2)


kaka1 = mynn.getstrength(0, 5, 0)
kaka1 = mynn.getstrength(0, 5, 1)


print("Hello World")

	def __init__(self,dbname):
		self.con=sqlite.connect(dbname)
		self.mynet=nn.searchnet('nn.db')

get_ipython().magic(u"logstart example.py append")
import nn

online, pharmacy = 1, 2
spam, notspam = 1, 2
possible = [spam, notspam]
neuralnet = nn.searchnet("nntest.db")
neuralnet.maketables()
neuralnet.trainquery([online], possible, notspam)
neuralnet.trainquery([online, pharmacy], possible, spam)
neuralnet.trainquery([pharmacy], possible, notspam)
neuralnet.getresult([online, pharmacy], possible)
neuralnet.getresult([online], possible)
neuralnet.trainquery([online], possible, notspam)
neuralnet.getresult([online], possible)
neuralnet.trainquery([online], possible, notspam)
neuralnet.getresult([online], possible)
quit()

def backpropagation():
  mynet=nn.searchnet('nn.db')
  wWorld,wRiver,wBank =101,102,103
  uWorldBank,uRiver,uEarth =201,202,203
  mynet.trainquery([wWorld,wBank],[uWorldBank,uRiver,uEarth],uWorldBank)
  print mynet.getresult([wWorld,wBank],[uWorldBank,uRiver,uEarth])

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import bottle
import searchengine
import nn
import beaker.middleware
import os

mynet = nn.searchnet()

session_opts = {
    'session.type': 'file',
    'session.data_dir': './session/',
    'session.auto': True,
}
app = beaker.middleware.SessionMiddleware(bottle.app(), session_opts)

@bottle.route('/') 
def querypage():
    return bottle.template('query')

@bottle.route('/resume')
def resumepage():
    return bottle.template('resume')

@bottle.route('/query', method='POST')
def queryhandler():
    e = searchengine.searcher()
    q = bottle.request.forms.get("query")
    mywords, myurls = e.query(q)

import urllib2
from BeautifulSoup import *
from urlparse import urljoin
from pysqlite2 import dbapi2 as sqlite
import nn
mynet=nn.searchnet('nn.db')

# Create a list of words to ignore
ignorewords={'the':1,'of':1,'to':1,'and':1,'a':1,'in':1,'is':1,'it':1}


class crawler:
  # Initialize the crawler with the name of database
  def __init__(self,dbname):
    self.con=sqlite.connect(dbname)

  def __del__(self):
    self.con.close()

  def dbcommit(self):
    self.con.commit()

  # Auxilliary function for getting an entry id and adding
  # it if it's not present
  def getentryid(self,table,field,value,createnew=True):
    cur=self.con.execute(
    "select rowid from %s where %s='%s'" % (table,field,value))
    res=cur.fetchone()
    if res==None:
      cur=self.con.execute(
      "insert into %s (%s) values ('%s')" % (table,field,value))

 def neural_network(self, rows, wordids):
     urlids = [urlid for urlid in set([row[0] for row in rows])]
     network_nel = nn.searchnet('nn.db')
     node_output = network_nel.getresult(wordids, urlids)
     net_score = dict([(urlids[i], node_output[i]) for i in range(len(urlids))])
     return self.normalizescores(net_score)