def createGui(self):
		# self.chatBox = self.createChatBox()
		self.messageWindow = self.createMessageWindow()
		headerDiv = Div(text="<link rel='stylesheet' type='text/css' href='templates/styles.css'>")

		self.createKeyboardCoordinates()

		self.englishInput = AutocompleteInput(value = "",title = "English:",completions = ["bath","bathtub"])
		self.englishInput.on_change("value",self.englishBoxCallback)

		self.text_input = TextInput(value="", title="Message:",width = self.keyboardWidth - 300)
		self.text_input.on_change("value",self.textBoxcallback)

		sendButton = Button(label="↩",button_type = "primary")
		sendButton.on_click(self.sendMessage)
		self.suggestedCategoryRow = self.createEmojiFigure("Row","Suggested")
		self.suggestedCategoryRow.on_event(Tap,self.suggestedSelectCallback)

		self.suggestedCategoryRow.title.text = "💡"
		self.suggestedCategoryRow.title.text_font_size = "20pt"

		mainCategoryFigure = self.createEmojiFigure("Column","Main")
		mainCategoryFigure.title.text = "🐘📦"
		mainCategoryFigure.title.text_font_size = "30pt"
		mainCategoryFigure.on_event(Tap,self.mainCategorySelectCallback)
		mainCategoryFigure.js_on_event(DoubleTap,self.playSound)

		subCategoryFigure = self.createEmojiFigure("Column","Sub")
		subCategoryFigure.title.text = "🥖📦"
		subCategoryFigure.title.text_font_size = "30pt"
		subCategoryFigure.name = "sub"
		subCategoryFigure.on_event(Tap,self.subCategorySelectCallback)

		self.emojiKeyboard = self.createMainEmojiWindow()
		self.emojiKeyboard.title.text = "⌨"
		self.emojiKeyboard.title.text_font_size = "30pt"
		self.gui = column(
			headerDiv,
			self.messageWindow,
			row(self.englishInput,self.text_input,sendButton),
			self.suggestedCategoryRow,
			row(self.emojiKeyboard,subCategoryFigure,mainCategoryFigure)
		)
示例#2
0
split = Dropdown(label="Split button", button_type="danger", menu=split_menu)

checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
                               active=[0, 1])

radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)

checkbox_button_group = CheckboxButtonGroup(
    labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])

radio_button_group = RadioButtonGroup(
    labels=["Option 1", "Option 2", "Option 3"], active=0)

text_input = TextInput(placeholder="Enter value ...")

autocomplete_input = AutocompleteInput()

select = Select(options=["Option 1", "Option 2", "Option 3"])

multi_select = MultiSelect(options=["Option %d" % (i + 1) for i in range(16)],
                           size=6)

slider = Slider(value=10, start=0, end=100)

range_slider = RangeSlider()

#date_range_slider = DateRangeSlider(value=(date(2016, 1, 1), date(2016, 12, 31)))

date_picker = DatePicker()

paragraph = Paragraph(text="some text")
示例#3
0
    RadioButtonGroup(
        labels=["Radio Option 1", "Radio Option 2", "Radio Option 3"],
        button_type="default",
        active=0),
    RadioButtonGroup(
        labels=["Radio Option 4", "Radio Option 5", "Radio Option 6"],
        button_type="primary",
        active=1),
    RadioButtonGroup(
        labels=["Radio Option 7", "Radio Option 8", "Radio Option 9"],
        button_type="success",
        active=2),
    TextInput(placeholder="TextInput 1"),
    TextInput(placeholder="TextInput 2"),
    TextInput(placeholder="TextInput 3"),
    AutocompleteInput(placeholder="AutocompleteInput 1 ...",
                      completions=["aaa", "aab", "aac", "baa", "caa"]),
    AutocompleteInput(placeholder="AutocompleteInput 2 ...",
                      completions=["AAA", "AAB", "AAC", "BAA", "CAA"]),
    AutocompleteInput(placeholder="AutocompleteInput 3 ...",
                      completions=["000", "001", "002", "100", "200"]),
    DatePicker(value=date(2018, 9, 1)),
    DatePicker(value=date(2018, 9, 2)),
    DatePicker(value=date(2018, 9, 3)),
)

#Slider(value=10, start=0, end=100, step=0.5),
#RangeSlider(value=[20, 30], start=0, end=100, step=0.5),
#DateSlider(value=date(2018, 9, 1), start=date(2018, 1, 1), end=date(2018, 12, 31)),
#DateRangeSlider(value=(date(2018, 9, 1), date(2018, 9, 30)), start=date(2018, 1, 1), end=date(2018, 12, 31)),

#CheckboxGroup(labels=["Checkbox Option 1", "Checkbox Option 2", "Checkbox Option 3"], active=[0, 1]),
def mapping_sentences_words(input_file):
    output_file(filename="../dashboards/sentences_words.html", title="Intermediate representations")

    ###################################################
    # PREPARING DATA
    ###################################################

    index = 0
    id_sentence = list()
    id_word = list()
    x = list()
    y = list()
    sentences = list()
    language_sentence = list()
    language_word = list()
    words = list()
    x_words = list()
    y_words = list()
    links = dict()
    with open(input_file, 'r') as file:
        array = json.load(file)
        data = array['content']
        for idx, translations in data.items():
            nbr_lang = len(translations)
            for lang, info in translations.items():
                id_sentence.append(idx)
                language_sentence.append(lang)
                sentences.append(info['sentence'])
                x.append(info['embedding'][0])
                y.append(info['embedding'][1])
                for word, emb in info['words'].items():
                    id_word.append(idx)
                    language_word.append(lang)
                    words.append(word)
                    x_words.append(emb[0])
                    y_words.append(emb[1])
            for i in range(nbr_lang):
                links[index + i] = [index + j for j in range(nbr_lang) if j != i]
            index += nbr_lang

        source_sentence_dict = {
            "id": id_sentence,
            "x": x,
            "y": y,
            "lang": language_sentence,
            "sentence": sentences
        }

        source_word_dict = {
            "id": id_word,
            "x": x_words,
            "y": y_words,
            "lang": language_word,
            "word": words
        }

    source_sentences = ColumnDataSource(source_sentence_dict)
    source_words = ColumnDataSource(source_word_dict)
    source_words_visible = ColumnDataSource(source_word_dict)

    ###################################################
    # SET UP SENTENCE FIGURE
    ###################################################

    tools = "hover, tap, box_select, reset, help"
    p = figure(plot_width=800, plot_height=700, tools=tools, title='Intermediate representations')

    cr = p.circle('x', 'y',
                  size=6, alpha=0.6,
                  hover_color='yellow', hover_alpha=1.0,
                  source=source_sentences,
                  color=factor_cmap('lang',
                                    palette=['red', 'blue', 'green'],
                                    factors=['en', 'fr', 'es']),
                  legend='lang',
                  name="sentences")

    ###################################################
    # SET UP LINKS BETWEEN TRANSLATIONS
    ###################################################

    source = ColumnDataSource({'x0': [], 'y0': [], 'x1': [], 'y1': []})
    sr = p.segment(x0='x0', y0='y0', x1='x1', y1='y1', color='black', alpha=0.6, line_width=1, source=source)

    code = """
    var links = %s;
    var data = {'x0': [], 'y0': [], 'x1': [], 'y1': []};
    var cdata = circle.data;
    var indices = cb_data.index['1d'].indices;
    for (var i = 0; i < indices.length; i++) {
        var ind0 = indices[i]
        for (var j = 0; j < links[ind0].length; j++) {
            var ind1 = links[ind0][j];
            data['x0'].push(cdata.x[ind0]);
            data['y0'].push(cdata.y[ind0]);
            data['x1'].push(cdata.x[ind1]);
            data['y1'].push(cdata.y[ind1]);
        }
    }
    segment.data = data;
    """ % links

    ###################################################
    # ADD LINKS IN HOVERTOOL
    ###################################################

    callback = CustomJS(args={'circle': cr.data_source,
                              'segment': sr.data_source}, code=code)
    p.add_tools(HoverTool(callback=callback, renderers=[cr]))
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = [
        ("sentence", "@sentence"),
    ]
    hover.names = [
        "sentences"
    ]

    ###################################################
    # SET UP WORD FIGURE
    ###################################################

    p_w = figure(title='Words', tools="reset")
    p_w.circle('x', 'y',
               size=6, alpha=0.6,
               hover_color='yellow', hover_alpha=1.0,
               selection_color='yellow',
               nonselection_color='white',
               source=source_words_visible,
               color=factor_cmap('lang',
                                 palette=['red', 'blue', 'green'],
                                 factors=['en', 'fr', 'es']),
               legend='lang',
               name="words")

    hover_word = HoverTool(tooltips=[('word', '@word')],
                           names=['words'])
    p_w.add_tools(hover_word)

    source_sentences.selected.js_on_change('indices', CustomJS(args=dict(sentences=source_sentences,
                                                                         words=source_words,
                                                                         words_visible=source_words_visible),
                                                               code="""
            var inds = cb_obj.indices;
            var sentences = sentences.data;
            var words = words.data;
            var words_visible = words_visible.data
            
            words_visible.id = []
            words_visible.x = []
            words_visible.y = []
            words_visible.lang = []
            words_visible.word = []
            
            console.log(sentences.id[inds])
            for (var i = 0; i < words.x.length; i++) {
                if (words.id[i] == sentences.id[inds]) {
                    words_visible.id.push(words.id[i])
                    words_visible.x.push(words.x[i])
                    words_visible.y.push(words.y[i])
                    words_visible.lang.push(words.lang[i])
                    words_visible.word.push(words.word[i])
                }
            }
            words_visible.change.emit();
        """)
                                           )

    text_input = AutocompleteInput(title='Search a sentence', completions=sentences)

    ###################################################
    # CREATION OF THE LAYOUT
    ###################################################

    # window = layout([p, words], sizing_mode='stretch_both')
    window = row(p, column(p_w, text_input))
    show(window)
                source_words_visible_dict['lang'].append(
                    source_words.data['lang'][idx])
                source_words_visible_dict['word'].append(
                    source_words.data['word'][idx])
    source_words_visible.data = source_words_visible_dict

    # source_words_visible.selected.indices = indices


source_sentences.selected.on_change('indices', update_words)

###################################################
# ADD TEXT INPUT
###################################################

text_input = AutocompleteInput(title='Select a sentence',
                               completions=sentences)


def update_sentences(attr, old, new):
    sentence = text_input.value
    ind = [
        j for j, sent in enumerate(source_sentences.data['sentence'])
        if sent == sentence
    ]
    source_sentences.selected.indices = ind


text_input.on_change('value', update_sentences)

###################################################
# ADD RESET BUTTON
    of "minus line" will be returned first. Result will be used for unpacking values to line figures.
    :param provider: str in ["emhi", "yrno"]
    :return: [{"y": ..., "x": ..., "source": ..., "color": ...}, same]
    """
    global source
    defaults = {"x": "start", "source": source}
    y_and_color_based_on_plus_dominance = {
        True: {"1y": "minus", "1c": "#48AFE8", "2y": "plus", "2c": "firebrick"},  # True if plus dominates
        False: {"1y": "plus", "1c": "firebrick", "2y": "minus", "2c": "#48AFE8"},  # False if plus does not dominate
    }
    vmap = y_and_color_based_on_plus_dominance[temp_plus_dominates[provider]]
    return [{"y": "temp_{}_{}".format(provider, vmap["1y"]), "color": vmap["1c"], **defaults},
            {"y": "temp_{}_{}".format(provider, vmap["2y"]), "color": vmap["2c"], **defaults}]


city_picker = AutocompleteInput(value="Tartu", title="\n",
                                completions=list(CITY_MAP))
city_picker.on_change("value", lambda attr, old, new: update())

source = ColumnDataSource(
    data=dict(
        start=[],  # Python datetime objects
        temp_emhi=[],  # All EMHI temperatures - needed for the positioning of cloud-symbols.
        temp_emhi_plus=[],  # EMHI temperatures above 0.
        temp_emhi_minus=[],  # EMHI temperatures below 0.
        precipitation_emhi=[],
        temp_yrno=[],
        temp_yrno_plus=[],
        temp_yrno_minus=[],
        precipitation_yrno=[],
        symbol_yrno=[],  # Cloud-symbols
        symbol_emhi=[]
class emojiPicker:

	def __init__(self):
		self.setupVariables()
		self.createGui()

		self.loadEmojis()

	def setupVariables(self):
		self.keyboardHeight = 650
		self.keyboardWidth = 1200

		self.categoryClickIndex = 0

		self.colWidth = 100
		self.colHeight = self.keyboardHeight
		self.rowHeight = 120

		self.rowWidth = self.keyboardWidth + 2 * self.colWidth

		#keyboard spacing variables
		self.midRowXOffset = .2
		self.keyboardYOffset = .5

		self.keyboardYSpacing = 1
		self.keyBoardXSpacing = 1

		self.TOOLTIPS = """<div>@names</div>"""
		self.TOOLTIPS =  """<div class="btn-group">
			  <button>@names 🔊</button>
			  <button>Schadenfreude 🔊</button>
			  <button>⻄⻇ 🔊</button>
			</div> """

		# var audio = new Audio('emojiMessenger/static/audio.mp3');
		self.filename = "audio.mp3"
		self.playSound = CustomJS(args=dict(filename = self.filename), code = 
			"""
			var audio = new Audio('emojiMessenger/static/'.concat(filename));
			audio.play();
			"""
			)

	def loadEmojis(self):
		self.sessionId = emojiDber.getSessionId()
		self.friendId = emojiDber.checkForUnmatchedFriendId(self.sessionId)

		#main category
		self.mainCategoryNames = emojiDber.getMasterCategories()[1:]
		mainCategoryIcons = emojiDber.getSubCategoriesIcons("MASTER",self.mainCategoryNames)
		self.updateEmojiFigure("Main","Column",mainCategoryIcons)

		#pick the first main category
		self.activeMainCategory = self.mainCategoryNames[0]
		subCategories = emojiDber.getSubCategories(self.activeMainCategory)
		subCategoryIcons = emojiDber.getSubCategoriesIcons(self.activeMainCategory,subCategories)
		self.updateEmojiFigure("Sub","Column",subCategoryIcons)

		#pick the first subcategory
		self.activeSubCategory = subCategories[0]

		#get suggested emojis
		suggestedEmojis = emojiDber.getRelevantEmojis(self.activeMainCategory)
		self.updateEmojiFigure("Suggested","Row",suggestedEmojis)

		#get emojis to display on the keyboars
		subCategoryEmojis = emojiDber.getCategoryTopEmojis(self.activeSubCategory)

		#fill in the difference with main cateogry emojis
		numSubEmojis = len(subCategoryEmojis)
		mainCategoryEmojies = emojiDber.getCategoryTopEmojis(self.activeMainCategory,NUM_TO_GET = 26 - numSubEmojis)
		keyboardEmojisDict = {**subCategoryEmojis,**mainCategoryEmojies}

		self.updateKeyboardFigure(keyboardEmojisDict)

	def updateEmojiFigure(self,figureName,figureType,emojisDict):
		newData = self.createCategoryGlyphSource(emojisDict,figureType)
		self.gui.select_one({"name":figureName}).data = newData

	def updateKeyboardFigure(self,emojisDict):
		newNames = list(emojisDict.keys())
		newEmojis = list(emojisDict.values())

		numEmojis = len(newNames)
		if numEmojis < 26:
			diff = 26 - numEmojis
			newNames += [""] * diff
			newEmojis += [""] * diff

		keyboardSourceDict = (self.emojiKeyboard.select_one({"name":"emojis"})).data_source.data
		keyboardSourceDict["names"] = newNames
		keyboardSourceDict["text"] = newEmojis
		(self.emojiKeyboard.select_one({"name":"emojis"})).data_source.data = keyboardSourceDict

	def createCategoryGlyphSource(self,categoriesDict,figureType):
		categoryEmojies = list(categoriesDict.values())
		categoryNames = list(categoriesDict.keys())
		numCategories = len(categoriesDict.keys())
		indices = range(1,1+numCategories)

		categoryFills = [0] * numCategories

		categoryXs = [0] * numCategories
		categoryYs = range(numCategories)
		if figureType == "Row":
			categoryXs, categoryYs = categoryYs,categoryXs
		else:
			categoryFills[-1] = 1

		categoryGlyphSourceDict = dict(x=categoryXs, y=categoryYs, text=categoryEmojies,names = categoryNames,fills = categoryFills,indices=indices)
		return categoryGlyphSourceDict

	def createEmojiFigure(self,figureType,name):
		#creates either a row or column to display emojies in
		numCategories = 10
		if figureType == "Column":
			height = self.colHeight
			width = self.colWidth
			xRange = (-.5,.5)
			yRange = (-.5,numCategories-.5)
			yOffset = 20

		else:
			height = self.rowHeight
			width = self.rowWidth
			xRange = (-.5,numCategories-.5)
			yRange = (-.4,.6)
			yOffset = 20

		categoriesFigure = figure(title = "Title",
			plot_height = height, plot_width = width,
			x_range=xRange,y_range=yRange,
			toolbar_location = None,tools = "")

		categoriesFigure.axis.visible = False
		categoriesFigure.grid.visible = False

		categorySourceDict = dict(x=[], y=[], text=[],names = [],fills = [],indices=[])

		# categorySourceDict = self.createCategoryGlyphSource(categoriesDict,figureType)
		categorySource = ColumnDataSource(categorySourceDict,name = name)

		#text glyph to display emojies
		categoriesGlyph = Text(x="x", y="y", text="text", angle=0,y_offset=yOffset,
			text_color="black",text_alpha = 1,
			text_font_size='35pt',text_align = "center")

		categoriesFigure.add_glyph(categorySource, categoriesGlyph)

		if figureType == "Row":
			categoryIndexText =  Text(x="x", y="y", text="indices", angle=0,y_offset=-10,x_offset= -50,
				text_color="black",text_alpha = 1,
				text_font_size='20pt',text_align = "center")
			categoriesFigure.add_glyph(categorySource,categoryIndexText)

		#hidden circle glyph used to allow hovertool to work to show tooltips
		categoryCircleGlyph = Circle(x="x", y="y",radius=.45,fill_alpha = 0,line_alpha = "fills")
		circleGlyph = categoriesFigure.add_glyph(categorySource, categoryCircleGlyph, name = "circles")
		#create hover tool and add it to figure
		categoryHoverer = HoverTool(renderers=[circleGlyph], tooltips=self.TOOLTIPS)
		categoriesFigure.add_tools(categoryHoverer)

		return categoriesFigure

	def mainCategorySelectCallback(self,event):
		self.categoryClickIndex += 1
		x,y = (event.x, event.y)
		index = int(y)

		selectedCategory = self.mainCategoryNames[index]
		self.activeMainCategory = selectedCategory

		#update the selected category indicator		
		newFills = [0] * len(self.mainCategoryNames)
		newFills[index] = 1
		self.gui.select_one({"name":"Main"}).data["fills"] = newFills

		#update sub categories
		subCategories = emojiDber.getSubCategories(self.activeMainCategory)
		subCategoryIcons = emojiDber.getSubCategoriesIcons(selectedCategory,subCategories)
		self.updateEmojiFigure("Sub","Column",subCategoryIcons)

		#pick the first new subcategory
		self.activeSubCategory = subCategories[0]
		subCategoryEmojis = emojiDber.getCategoryTopEmojis(self.activeSubCategory)

		#fill in the difference with main cateogry emojis
		numSubEmojis = len(subCategoryEmojis)
		mainCategoryEmojies = emojiDber.getCategoryTopEmojis(self.activeMainCategory,NUM_TO_GET = 26 - numSubEmojis)
		keyboardEmojisDict = {**subCategoryEmojis,**mainCategoryEmojies}

		self.updateKeyboardFigure(keyboardEmojisDict)

	def subCategorySelectCallback(self,event):
		#keep track of how many categories clicked throiugh until an answer found
		self.categoryClickIndex += 1

		x,y = (event.x, event.y)
		index = int(y)
		subCategoryDict = self.gui.select_one({"name":"Sub"}).data

		#update the selected category indicator		
		newFills = [0] * len(subCategoryDict["fills"])
		newFills[index] = 1
		self.gui.select_one({"name":"Sub"}).data["fills"] = newFills

		#change the active categroy abd get the emojis belonging to it
		self.activeSubCategory = subCategoryDict["names"][index]
		subCategoryEmojis = emojiDber.getCategoryTopEmojis(self.activeSubCategory)

		numSubEmojis = len(subCategoryEmojis.keys())

		mainCategoryEmojies = emojiDber.getCategoryTopEmojis(self.activeMainCategory,NUM_TO_GET = 26 - numSubEmojis)
		keyboardEmojisDict = {**subCategoryEmojis,**mainCategoryEmojies}

		self.updateKeyboardFigure(keyboardEmojisDict)

	def suggestedSelectCallback(self,event):
		x,y = (event.x, event.y)
		index = int(x)
		suggestedEmojis = self.gui.select_one({"name":"Suggested"}).data["text"]

		clickedEmoji = suggestedEmojis[index]

		self.text_input.remove_on_change("value",self.textBoxcallback)
		self.text_input.value += (clickedEmoji)
		self.text_input.on_change("value",self.textBoxcallback)

		self.analyzeNgram(self.text_input.value,"tapped")

	def xyCoordsToKeyboardKey(self,x,y):
		"""given an (X,Y) cooridnate, returns the key pressed
		on a qwerty keyboard"""

		rowIndex = int(y/(self.keyboardYSpacing))
		colIndex = (x-(rowIndex*self.midRowXOffset))/self.keyBoardXSpacing
		clickedLetter = self.letters[int(rowIndex)][int(colIndex)]
		return clickedLetter


	def emojiDoubleTapCallback(self,event):
		#called when an emoji keyboard is double tapped
		#updates the suggested categories, but doesn't add it to the textbox
		print (1)

	def emojiTapCallback(self,event):
		#called when an emoji on the keyboard window is single tapped
		x,y = (event.x, event.y)
		index = int(x) + int(y)
		selectedChar = self.xyCoordsToKeyboardKey(x,y)

		emojiSourceData = (self.emojiKeyboard.select_one({"name":"emojis"})).data_source.data
		letterIndex = emojiSourceData["letters"].index(selectedChar)
		selectedEmoji = emojiSourceData["text"][letterIndex]

		self.text_input.remove_on_change("value",self.textBoxcallback)
		self.text_input.value += (selectedEmoji)
		self.text_input.on_change("value",self.textBoxcallback)

		self.filename = "cats.wav"

		self.analyzeNgram(self.text_input.value,"tapped")


	def analyzeNgram(self,ngram,methodOfEntry):
		#get the current category structure
		heirarchy = [self.activeMainCategory,self.activeSubCategory]

		emojiDber.addEnteredString(
			ENTERED_STRING = ngram,
			ENTRY_METHOD = methodOfEntry,
			CLICK_INDEX = self.categoryClickIndex,
			CATEGORY_STRUCTURE = heirarchy,
			SESSION_ID = self.sessionId)

		#reset category click index
		self.categoryClickIndex = 0

		#get new suggestions
		#split the currently entered string
		splitNgram = list(ngram)
		newSuggestionsDict = {}
		for emoji in splitNgram:
			suggestions = emojiDber.getRelevantEmojisFromEmoji(emoji)
			newSuggestionsDict = {**newSuggestionsDict,**suggestions}

		#get suggested emojis
		self.updateEmojiFigure("Suggested","Row",newSuggestionsDict)

	def createMainEmojiWindow(self):
		plot = figure(title="", plot_width=self.keyboardWidth, plot_height=self.keyboardHeight,
			x_range= (-.5,10-.5),y_range = (0,3*self.keyboardYSpacing),
		    h_symmetry=False, v_symmetry=False, min_border=0,
		    toolbar_location=None,tools = "")

		plot.grid.visible = False
		plot.axis.visible = False

		emojiGlyph = Text(x="x", y="y", text="text", angle=0, 
			text_color="black",text_alpha = 1,text_font_size='65pt',text_align = "center")

		source = self.createKeyboardCoordinates()

		plot.add_glyph(source, emojiGlyph,name = "emojis")

		circleGlyph = Circle(x="x", y="y",radius=.5,fill_alpha = 0,line_alpha = 0)
		circGlypher = plot.add_glyph(source, circleGlyph)

		emojiLetterText =  Text(x="x", y="y", text="letters", angle=0,y_offset=-80,x_offset= -40,
			text_color="black",text_alpha = 1,
			text_font_size='20pt',text_align = "center")
		plot.add_glyph(source,emojiLetterText)

		hoverer = HoverTool(renderers=[circGlypher], tooltips=self.TOOLTIPS)
		plot.add_tools(hoverer)

		plot.on_event(Tap,self.emojiTapCallback)
		# plot.on_event(DoubleTap,self.emojiDoubleTapCallback)

		return plot

	def englishBoxCallback(self,attr,old,new):
		#called when someone types something into the english box,
		#gets the suggested emojis and updates the list

		#check if the new value is drastically longer than the old one (indicating autocomplete)
		if (len(new) - len(old)) > 4:
			print ("CLICKED")
			clickedEmoji = new[-1]

			self.text_input.value += (clickedEmoji)
			self.englishInput.value = ""
			return

		suggestedEmojis = emojiDber.getRelevantEmojis(new)
		emojisList = []
		for name,emoji in suggestedEmojis.items():
			entry = name.replace("_"," ") + "   " + emoji
			emojisList.append(entry)

		self.englishInput.completions = emojisList

	def textBoxcallback(self,attr,old,new):
		if (len(old) > len(new)):
			return
		if not new:
			return

		newChar = new[-1]
		if newChar == " ":
			return

		if newChar.isdigit():
			newEmojiIndex = int(newChar)-1
			newEmoji = (self.gui.select_one({"name":"Suggested"})).data["text"][newEmojiIndex]
			self.text_input.remove_on_change("value",self.textBoxcallback)
			self.text_input.value = new[:-1] + newEmoji
			self.text_input.on_change("value",self.textBoxcallback)

		if newChar.isalpha():
			newCharStr = newChar.lower()
			emojiSourceData = (self.gui.select_one({"name":"emojis"})).data_source.data
			typedEmojiIndex = emojiSourceData["letters"].index(newCharStr)
			newEmoji = emojiSourceData["text"][typedEmojiIndex]
			self.text_input.remove_on_change("value",self.textBoxcallback)
			self.text_input.value = new[:-1] + newEmoji
			self.text_input.on_change("value",self.textBoxcallback)

		self.analyzeNgram(self.text_input.value,"typed")

	def createKeyboardCoordinates(self):
		#rectangle window

		topRowXs, topRowYs = list(range(10)),[2*self.keyboardYSpacing + self.keyboardYOffset]*10
		topRowLetters = ["q","w","e","r","t","y","u","i","o","p"]

		midRowXs, midRowYs = list(np.linspace(self.midRowXOffset,9-self.midRowXOffset,9)), [self.keyboardYSpacing + self.keyboardYOffset]*9
		midRowLetters = ["a","s","d","f","g","h","j","k","l"]

		lowRowXs, lowRowYs = list(np.linspace(2*self.midRowXOffset,7-3*self.midRowXOffset,7)),[self.keyboardYOffset]*7
		lowRowLetters = ["z","x","c","v","b","n","m"]
		self.letters = [lowRowLetters,midRowLetters,topRowLetters]
		xCoords = topRowXs + midRowXs + lowRowXs
		yCoords = topRowYs + midRowYs + lowRowYs
		letters = topRowLetters + midRowLetters + lowRowLetters

		self.numCoords = len(xCoords)

		emojis = [""] * self.numCoords
		names = [""] * self.numCoords
		source = ColumnDataSource(dict(x=xCoords, y=yCoords, text=emojis,names = names,letters = letters))
		return source

	###CHAT BOX 

	def createChatBox(self):
		#creates a datatable to show messages
		data = dict(sender=[],message=[])
		source = ColumnDataSource(data)

		columns = [
		        TableColumn(field="sender", title="From"),
		        TableColumn(field="message", title="Message"),
		    ]

		chatBox = DataTable(source=source, columns=columns,
			width=self.keyboardWidth, height=200)
		return chatBox

	def createMessageWindow(self):
		messageWindow = column([],css_classes=["message-box"],width = self.keyboardWidth - 300,height = 400)
		return messageWindow

	def sendMessage(self):
		#posts a message to the db and clears the text box, updates the chat window
		currentMessage = self.text_input.value

		emojiDber.postEnteredMessage(MESSAGE = currentMessage,SESSION_ID = self.sessionId)
		self.updateChatBox("You",currentMessage)

	def createSentDiv(self,message):
		return Div(text=message,height=30,width=self.keyboardWidth-400,css_classes = ["sent-speech-bubble"])

	def createReceivedDiv(self,message):
		return Div(text=message,height=30,width=self.keyboardWidth-400,css_classes = ["received-speech-bubble"])

	def updateChatBox(self,sender,newMessage):
		if sender == "You":
			newDiv = self.createSentDiv(newMessage)
		else:
			newDiv = self.createReceivedDiv(newMessage)

		self.messageWindow.children.append(newDiv)

		# chatBoxSource = self.chatBox.source.data
		# chatBoxSource["sender"].append(sender)
		# chatBoxSource["message"].append(newMessage)
		# self.chatBox.source.data = chatBoxSource



		self.text_input.value = ""



	def getReceivedMessages(self):
		#check if there's a friend id
		self.friendId = emojiDber.checkForUnmatchedFriendId(self.sessionId)

		#if its not found, return and try again later
		if not self.friendId: return

		unreadMessages = emojiDber.getUnreadMessages(SESSION_ID = self.friendId)

		for message in unreadMessages:
			messageText = message["MESSAGE"]
			messageTime = message["TIMESTAMP"]
			self.updateChatBox("Them",messageText)

			emojiDber.incrementMessageRead(SESSION_ID=self.friendId,TIMESTAMP = messageTime)

	def createGui(self):
		# self.chatBox = self.createChatBox()
		self.messageWindow = self.createMessageWindow()
		headerDiv = Div(text="<link rel='stylesheet' type='text/css' href='templates/styles.css'>")

		self.createKeyboardCoordinates()

		self.englishInput = AutocompleteInput(value = "",title = "English:",completions = ["bath","bathtub"])
		self.englishInput.on_change("value",self.englishBoxCallback)

		self.text_input = TextInput(value="", title="Message:",width = self.keyboardWidth - 300)
		self.text_input.on_change("value",self.textBoxcallback)

		sendButton = Button(label="↩",button_type = "primary")
		sendButton.on_click(self.sendMessage)
		self.suggestedCategoryRow = self.createEmojiFigure("Row","Suggested")
		self.suggestedCategoryRow.on_event(Tap,self.suggestedSelectCallback)

		self.suggestedCategoryRow.title.text = "💡"
		self.suggestedCategoryRow.title.text_font_size = "20pt"

		mainCategoryFigure = self.createEmojiFigure("Column","Main")
		mainCategoryFigure.title.text = "🐘📦"
		mainCategoryFigure.title.text_font_size = "30pt"
		mainCategoryFigure.on_event(Tap,self.mainCategorySelectCallback)
		mainCategoryFigure.js_on_event(DoubleTap,self.playSound)

		subCategoryFigure = self.createEmojiFigure("Column","Sub")
		subCategoryFigure.title.text = "🥖📦"
		subCategoryFigure.title.text_font_size = "30pt"
		subCategoryFigure.name = "sub"
		subCategoryFigure.on_event(Tap,self.subCategorySelectCallback)

		self.emojiKeyboard = self.createMainEmojiWindow()
		self.emojiKeyboard.title.text = "⌨"
		self.emojiKeyboard.title.text_font_size = "30pt"
		self.gui = column(
			headerDiv,
			self.messageWindow,
			row(self.englishInput,self.text_input,sendButton),
			self.suggestedCategoryRow,
			row(self.emojiKeyboard,subCategoryFigure,mainCategoryFigure)
		)

	def showGui(self):
		curdoc().add_root(self.gui)
		curdoc().add_periodic_callback(self.getReceivedMessages,1000)
		curdoc().on_session_destroyed(self.destroySession)
		curdoc().title = "Emoji Messenger"
		show(self.gui)

	def destroySession(self,session_context):
		emojiDber.deactivateSessionId(self.sessionId,self.friendId)
		print ("Session closed")
示例#8
0
    def create_widget(self, dim, holomap=None, editable=False):
        """"
        Given a Dimension creates bokeh widgets to select along that
        dimension. For numeric data a slider widget is created which
        may be either discrete, if a holomap is supplied or the
        Dimension.values are set, or a continuous widget for
        DynamicMaps. If the slider is discrete the returned mapping
        defines a mapping between values and labels making it possible
        sync the two slider and label widgets. For non-numeric data
        a simple dropdown selection widget is generated.
        """
        label, mapping = None, None
        if holomap is None:
            if dim.values:
                if dim.default is None:
                    default = dim.values[0]
                elif dim.default not in dim.values:
                    raise ValueError(
                        "%s dimension default %r is not in dimension values: %s"
                        % (dim, dim.default, dim.values))
                else:
                    default = dim.default
                value = dim.values.index(default)

                if all(isnumeric(v) for v in dim.values):
                    values = sorted(dim.values)
                    labels = [unicode(dim.pprint_value(v)) for v in values]
                    if editable:
                        label = AutocompleteInput(value=labels[value],
                                                  completions=labels,
                                                  title=dim.pprint_label)
                    else:
                        label = Div(text='<b>%s</b>' %
                                    dim.pprint_value_string(labels[value]))
                    widget = Slider(value=value,
                                    start=0,
                                    end=len(dim.values) - 1,
                                    title=None,
                                    step=1)
                    mapping = list(enumerate(zip(values, labels)))
                else:
                    values = [(v, dim.pprint_value(v)) for v in dim.values]
                    widget = Select(title=dim.pprint_label,
                                    value=values[value][0],
                                    options=values)
            else:
                start = dim.soft_range[0] if dim.soft_range[0] else dim.range[0]
                end = dim.soft_range[1] if dim.soft_range[1] else dim.range[1]
                dim_range = end - start
                int_type = isinstance(dim.type, type) and issubclass(
                    dim.type, int)
                if dim.step is not None:
                    step = dim.step
                elif isinstance(dim_range, int) or int_type:
                    step = 1
                else:
                    step = 10**((round(math.log10(dim_range)) - 3))

                if dim.default is None:
                    default = start
                elif (dim.default < start or dim.default > end):
                    raise ValueError(
                        "%s dimension default %r is not in the provided range: %s"
                        % (dim, dim.default, (start, end)))
                else:
                    default = dim.default

                if editable:
                    label = TextInput(value=str(default),
                                      title=dim.pprint_label)
                else:
                    label = Div(text='<b>%s</b>' %
                                dim.pprint_value_string(default))
                widget = Slider(value=default,
                                start=start,
                                end=end,
                                step=step,
                                title=None)
        else:
            values = (dim.values if dim.values else list(
                unique_array(holomap.dimension_values(dim.name))))
            if dim.default is None:
                default = values[0]
            elif dim.default not in values:
                raise ValueError(
                    "%s dimension default %r is not in dimension values: %s" %
                    (dim, dim.default, values))
            else:
                default = dim.default
            if isinstance(values[0], np.datetime64) or isnumeric(values[0]):
                values = sorted(values)
                labels = [dim.pprint_value(v) for v in values]
                value = values.index(default)
                if editable:
                    label = AutocompleteInput(value=labels[value],
                                              completions=labels,
                                              title=dim.pprint_label)
                else:
                    label = Div(text='<b>%s</b>' %
                                (dim.pprint_value_string(labels[value])))
                widget = Slider(value=value,
                                start=0,
                                end=len(values) - 1,
                                title=None,
                                step=1)
            else:
                labels = [dim.pprint_value(v) for v in values]
                widget = Select(title=dim.pprint_label,
                                value=default,
                                options=list(zip(values, labels)))
            mapping = list(enumerate(zip(values, labels)))
        return widget, label, mapping
示例#9
0
    "#c7c7c7",
    "#1CE6FF",
    "#336600",
]  # these last ones were added

# load data
anndat = load_h5ad()
#pca = anndat.obsm['X_pca']
pca = anndat.obsm['X_draw_graph_fa']
tsne = anndat.obsm['X_tsne']
umap = anndat.obsm['X_umap']

# set up widgets
#stats = PreText(text='', width=500)
symbol = AutocompleteInput(completions=anndat.var_names.tolist(),
                           title="Enter Gene Name (e.g. POU5F1 ):",
                           value="AFP")
select = Select(title="Legend:",
                value="stage_group",
                options=[
                    "clusters", "stage", "stage_group", "donor", "Donor",
                    "group", "res.0.6"
                ])  #options=anndat.obs_keys())
# message box
message = Div(text="""Input Gene Name:\n Legend Option: """,
              width=200,
              height=100)

## setup data
dd = select.value
umis = get_umi(anndat, symbol.value)
示例#10
0
groups = widgetbox(Paragraph(text="The bokeh groups"), checkbox_group, radio_group, checkbox_button_group, radio_button_group, sizing_mode=sizing_mode)

# Markups
div = Div(text="Some custom <strong>bold</strong> text")
paragraph = Paragraph(text="this is a paragraph")
pretext_1 = PreText(text="This is pre. I could put a bunch of code in here perhaps\nOr maybe something else")
pretext_2 = PreText(text="This is pre")
pretext_3 = PreText(text="This is pre it's a bit longer and i'm going to constrict it.", width=150)
markups = widgetbox(Paragraph(text="The bokeh markups"), div, paragraph, pretext_1, pretext_2, pretext_3, sizing_mode=sizing_mode)

# Inputs
#daterangeslider = DateRangeSlider()  # Known broken
slider = Slider(title="Slider", start=0, end=10, width=100)
multiselect = MultiSelect(options=['1', '2', '3'])
select = Select(options=['1', '2', '3'])
textinput = TextInput()
autocomplete = AutocompleteInput(completions=['one', 'two', 'three'])
#datepicker = DatePicker()
inputs = widgetbox(Paragraph(text="The bokeh inputs"), slider, multiselect, select, textinput, autocomplete, sizing_mode=sizing_mode)

plot = figure(sizing_mode=sizing_mode)
plot.circle(x=[1, 2], y=[2, 3])

l = layout([
    [buttons, groups],
    [markups, inputs],
    [plot],
], sizing_mode=sizing_mode)

show(l)
示例#11
0

def update_simulation_sample_size(attr, old, new):
    update()


# configure Bokeh Inputs, data sources, and plots
autocomplete_station_names = list(STATIONS_DF['Station Name'])
peak_source = ColumnDataSource(data=dict())
peak_flagged_source = ColumnDataSource(data=dict())
distribution_source = ColumnDataSource(data=dict())
qq_source = ColumnDataSource(data=dict())


station_name_input = AutocompleteInput(
    completions=autocomplete_station_names, title='Enter Station Name (ALL CAPS)',
    value=IDS_TO_NAMES['08MH016'], min_characters=3)

simulation_number_input = Spinner(
    high=1000, low=1, step=1, value=50, title="Number of Simulations",
)

sample_size_input = Spinner(
    high=200, low=2, step=1, value=10, title="Sample Size for Simulations"
)

ffa_info = Div(
    text="Mean of {} simulations of a sample size {}.".format('x', 'y'))

error_info = Div(text="", style={'color': 'red'})
示例#12
0
                options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['superkingdom']).most_common()],\
                width=200,height=70)
kms.on_change('value',lambda attr,old,new:kmsfunc())

sfms=MultiSelect(title='Subfams',\
                options=[x[0] for x in collections.Counter(ptree.leaf_cds.data['subfamstr']).most_common()],\
                width=150,height=70)
sfms.on_change('value',lambda attr,old,new:sfmsfunc())

tcb=Button(label='CalcTC',width=80,height=40)
tcb.on_click(tcbfunc)
#splist=list(set(ptree.leaf_cds.data['species']))
#splist.sorted(key=ptree.leaf_cds.data['species'])
#acw=AutocompleteInput(title='Organism name',completions=list(set(ptree.leaf_cds.data['species'])),width=200,height=50)
acw=AutocompleteInput(title='Organism name',\
    completions=[x[0] for x in collections.Counter(ptree.leaf_cds.data['species']).most_common()],\
    width=200,height=50)
acw.on_change('value',lambda attr,old,new:acfunc())

accacw=AutocompleteInput(title='Accession',\
    completions=ptree.leaf_cds.data['gbacc'][:],width=200,height=50)
accacw.on_change('value',lambda attr,old,new:accacfunc())


if len(sys.argv)>3:
    preselfpath=os.path.join(os.environ['SCIENCEDIR'],'GHSeqs',ghfam.upper(),sys.argv[3])
    with open(preselfpath,'r') as f:
        preselections=[x.strip() for x in f.readlines()]
        print(preselections)
else:
    preselections=[]
示例#13
0
def bokehGUI(ScoreBoard,
             MakerDictionary,
             offlineboard='None',
             curMeme="sustainability",
             curInfluencer='zbattiz',
             ApiRequest=False):

    MD = MakerDictionary
    SB = ScoreBoard
    if offlineboard: SB.import_board(offlineboard)
    BI = BokehControler(SB, MD)

    names = [k for k, v in SB.get_names().items()]
    category_codes = MD.categories.values()
    print(category_codes)

    # make this more generic:
    if not curInfluencer: curInfluencer = 'zbattiz'
    if not curMeme: curMeme = 'sustainability'

    BI.populateInfluencers(names, category_codes)
    BI.populateBoards(category_codes)
    BI.setActiveBoard(curMeme, BI.Boards.data.keys())
    BI.setActiveInfluencer(curInfluencer, BI.Influencers.data.keys())

    boards = BI.Boards
    board = BI.ActiveBoard
    influencers = BI.Influencers
    influencer = BI.ActiveInfluencer

    boardatr = ColumnDataSource(data=dict(legend=[curMeme]))
    influenceratr = ColumnDataSource(data=dict(legend=[curInfluencer]))

    #for k in BI.Boards.data.keys(): print(k, BI.Boards.data[k])

    # Drawing:::::::::::::

    ## Commom Tools::
    TOOLS = "tap,pan,wheel_zoom,reset,save"

    ## The Influencer Canvas::
    title = "Influencer"
    fig_influencer = figure(plot_width=700,
                            plot_height=500,
                            title=title,
                            tools=TOOLS,
                            toolbar_location="above",
                            toolbar_sticky=True,
                            active_drag="pan",
                            active_tap='tap',
                            active_scroll='wheel_zoom',
                            responsive=True)

    fig_influencer.axis.visible = False
    fig_influencer.border_fill_color = "whitesmoke"
    fig_influencer.border_fill_alpha = 0.3
    fig_influencer.min_border_top = 30
    fig_influencer.outline_line_width = 4
    fig_influencer.outline_line_alpha = 0.2
    fig_influencer.outline_line_color = "navy"
    fig_influencer.xgrid.visible = False
    fig_influencer.ygrid.visible = False

    ### Legend:::
    fig_influencer.circle(0,
                          0,
                          alpha=0.8,
                          color='olive',
                          legend='legend',
                          source=influenceratr)
    fig_influencer.legend.location = "top_left"
    fig_influencer.legend.label_text_font_size = "8pt"
    fig_influencer.legend.label_text_color = "red"

    ### Data:::
    fig_influencer.multi_line('xsegments',
                              'ysegments',
                              color="colors",
                              alpha=0.5,
                              line_width=2,
                              line_dash="dashed",
                              source=influencer)
    fig_influencer.circle('x',
                          'y',
                          color='colors',
                          size='sizes',
                          alpha=1,
                          source=influencer)
    labels = LabelSet(x='x',
                      y='y',
                      text='memes',
                      text_font_size='9pt',
                      level='glyph',
                      x_offset="offsets",
                      y_offset=0,
                      source=influencer,
                      render_mode='canvas')
    fig_influencer.add_layout(labels)

    ### Hover Tool:::
    infhover = HoverTool(
        tooltips=[("Score",
                   "@scores{0,0.000}"), ("Type",
                                         "per_tweet"), ("Ntweets", "@tweets")])
    fig_influencer.add_tools(infhover)

    ## The Board Canvas:::

    #for k in BI.ActiveBoard.data.keys(): print(k, BI.ActiveBoard.data[k])

    title_board = "Community Spirometer"
    fig_board = figure(plot_width=900,
                       plot_height=550,
                       title=title_board,
                       tools=TOOLS,
                       toolbar_location="above",
                       toolbar_sticky=True,
                       active_drag="pan",
                       active_tap='tap',
                       active_scroll='wheel_zoom',
                       responsive=True)
    fig_board.axis.visible = False
    fig_board.border_fill_color = "whitesmoke"
    fig_board.border_fill_alpha = 0.2
    fig_board.min_border_top = 30
    fig_board.outline_line_width = 6
    fig_board.outline_line_alpha = 0.2
    fig_board.outline_line_color = "navy"

    ### Legend:::
    fig_board.circle(0,
                     0,
                     alpha=0.8,
                     color='turquoise',
                     legend='legend',
                     source=boardatr)
    fig_board.legend.location = "top_left"
    fig_board.legend.label_text_font_size = "9pt"
    fig_board.legend.label_text_color = "red"

    ### Data:::
    fig_board.line('x',
                   'y',
                   alpha=0.4,
                   line_width=1,
                   line_dash="dashed",
                   source=board)
    fig_board.circle('x',
                     'y',
                     color='black',
                     size='levels',
                     alpha=1,
                     source=board)
    fig_board.circle('x',
                     'y',
                     color='colors',
                     size='sizes',
                     alpha=0.8,
                     source=board)
    labels = LabelSet(x='x',
                      y='y',
                      text='names',
                      text_font_size='7pt',
                      level='glyph',
                      x_offset='offsets',
                      y_offset=0,
                      source=board,
                      render_mode='canvas')
    fig_board.add_layout(labels)

    ### Hover Tool:::
    boardhover = HoverTool(tooltips=[("Name", "@names"), (
        "Phase",
        "@clusters"), ("Score",
                       "@scores{0,0.000}"), (
                           "Scoring type",
                           "per_tweet"), ("Number of tweets probed",
                                          "@tweets")])
    fig_board.add_tools(boardhover)

    # JavaScript Callbacks:::

    board.callback = CustomJS(args=dict(source=influencers,
                                        display=influencer,
                                        atr=influenceratr),
                              code="""
        var inds = cb_obj.selected['1d'].indices;
        var d1 = cb_obj.data;
        var d2 = source.data;
        var d3 = display.data;
        var d4 = atr.data;
        
        var ind = inds[0];
        console.log(ind);
        if (ind != null){
            d3['x'] = [];
            d3['y'] = [];
            d3['sizes'] = [];
            d3['scores'] = [];
            d3['names'] = [];
            d3['memes'] = [];
            d3['colors'] = [];
            d3['offsets'] = [];
            d3['xsegments'] = [];
            d3['ysegments'] = [];
            d3['tweets'] = [];
            d3_tags = [];
            
            var name = d1['names'][ind];
            console.log(name);
            d4['legend'] = [];
            d4['legend'].push(name);
            
            
            var start = d2['names'].indexOf(name);
            var end = d2['names'].lastIndexOf(name);
            
            console.log(start);
            console.log(end);

            for (var i = start; i <= end; i++) {
                d3['x'].push(d2['x'][i]);
                d3['y'].push(d2['y'][i]);
                d3['sizes'].push(d2['sizes'][i]);
                d3['scores'].push(d2['scores'][i]);
                d3['names'].push(d2['names'][i]);
                d3['memes'].push(d2['memes'][i]);
                d3['offsets'].push(d2['offsets'][i]);
                d3['colors'].push(d2['colors'][i]);
                d3['tweets'].push(d2['tweets'][i]);
                d3['xsegments'].push(d2['xsegments'][i]);
                d3['ysegments'].push(d2['ysegments'][i]);
            }
        }
        display.change.emit();
        atr.change.emit();
         """)

    influencer.callback = CustomJS(args=dict(source=boards,
                                             display=board,
                                             atr=boardatr),
                                   code="""
        var inds = cb_obj.selected['1d'].indices;
        var d1 = cb_obj.data;
        var d2 = source.data;
        var d3 = display.data;
        var d4 = atr.data;
        
        var ind = inds[0];
        console.log(ind)

        if (ind != null){
            d3['x'] = [];
            d3['y'] = [];
            d3['sizes'] = [];
            d3['scores'] = [];
            d3['levels'] = [];
            d3['clusters'] = [];
            d3['names'] = [];
            d3['memes'] = [];
            d3['offsets'] = [];
            d3['colors'] = [];
            d3['tweets'] = [];
            
            var meme = d1['memes'][ind];
            d4['legend'] = [];
            d4['legend'].push(meme)
            console.log(meme)
            
            var name = d1['names'][ind];
            var color = d1['colors'][ind]
            
            var start = d2['memes'].indexOf(meme);
            var end = d2['memes'].lastIndexOf(meme);
            
            console.log(start);
            console.log(end);
            
            for (var i = start; i <= end; i++) {
                d3['x'].push(d2['x'][i]);
                d3['y'].push(d2['y'][i]);
                d3['sizes'].push(d2['sizes'][i]);
                d3['scores'].push(d2['scores'][i]);
                d3['levels'].push(d2['levels'][i]);
                d3['clusters'].push(d2['clusters'][i]);
                d3['names'].push(d2['names'][i]);
                d3['memes'].push(d2['memes'][i]);
                d3['offsets'].push(d2['offsets'][i]);
                d3['tweets'].push(d2['tweets'][i]);
                if (d2['names'][i] == name){
                    d3['colors'].push(color);
                }
                else {
                    d3['colors'].push(d2['colors'][i]);
                }
            }
        }
        display.change.emit();
        atr.change.emit();
         """)

    # Adding additional Widgets and their events:::::

    ## Info Box::
    div_title = Div(text="""
                <h2> Sustainable Finance Spirometer</h2>
                <p><b>This Sprirometer infographics is one of the ways to observe opionion leaders and influencers,
                those who promote or debate on issues relevant to sustainable finance. </b>
                
                <p>Influential actors are placed rather outer branches of the spiral. See the lower interactive panel.
                An infleuncer's spiral profile, as of his/her contribution to the related debates,
                can be seen via the upper interactive panel.</p>
                
                <p>The data is collected from the tweets that are in the public domain.
                The latest tweets in English of an infleuncer is used for the analysis and visualizations. 
                The nodes on the spirometer (the lower panel) are resized according to the number of tweets
                by the corresponding influencer.</p>
                
                 <p>Influencers are clustered according to their sphere of influence. 
                 There are 4 or more distinct clusters/phases on each spiral.
                 Number of clusters and cluster membership is algorithmically generated from the data.
                 
                 The sequence of nodes with/without an inner circle denotes membership to the same cluster.
                <br/> <br/>
                </p> 
                """,
                    width=850,
                    height=220)
    title_box = widgetbox(div_title, sizing_mode='scale_both', responsive=True)

    ## Tips Box::
    div_tips = Div(text="""
            <p>Hover over the nodes in order to see the details. <b>Ntweets</b>
             denotes the number of tweeters collected for the profiling, <b>per_tweet</b>
             denotes that scores are computed per tweet.</p>
      
            <p>A new influencer can be added. Address bar can be used to query an influencer
            whose profile is not analyzed yet. Note that a twitter user name is the part after @ sign.
            For instance, the Twitter user <i>@bulentozel</i> can be added by appending <b>bulentozel</b> to the URL:
            <i>BASE_URL/gui/bulentozel</i>
            </p>
            <p>To query the users whose profiling has already been included, the search bar below can be used. </p>
            """,
                   width=200,
                   height=350)
    tips_box = widgetbox(div_tips, sizing_mode='scale_both', responsive=True)

    ## Query Box::

    callback_search = CustomJS(args=dict(boardWin=board,
                                         infList=influencers,
                                         infWin=influencer,
                                         atr=influenceratr),
                               code="""
        var bWin = boardWin.data;
        var iWin = infWin.data;
        var iL = infList.data;
        var query = cb_obj.value;
        var d4 = atr.data;
        
        console.log(query);
        
        var ind = iL['names'].indexOf(query);
        if (ind >= 0){
            var start = ind;
            var end = iL['names'].lastIndexOf(query);
            
            iWin['x'] = [];
            iWin['y'] = [];
            iWin['sizes'] = [];
            iWin['scores'] = [];
            iWin['names'] = [];
            iWin['memes'] = [];
            iWin['colors'] = [];
            iWin['offsets'] = [];
            iWin['xsegments'] = [];
            iWin['ysegments'] = [];
            iWin['tweets'] = [];
            
            for (var i = start; i <= end; i++) {
                iWin['x'].push(iL['x'][i]);
                iWin['y'].push(iL['y'][i]);
                iWin['sizes'].push(iL['sizes'][i]);
                iWin['scores'].push(iL['scores'][i]);
                iWin['names'].push(iL['names'][i]);
                iWin['memes'].push(iL['memes'][i]);
                iWin['offsets'].push(iL['offsets'][i]);
                iWin['colors'].push(iL['colors'][i]);
                iWin['tweets'].push(iL['tweets'][i]);
                iWin['xsegments'].push(iL['xsegments'][i]);
                iWin['ysegments'].push(iL['ysegments'][i]);
            }
            
            ind = bWin['names'].indexOf(query);
            if (ind > 0){
                var blength = bWin['colors'].length;
                bWin['colors'] = []
                for (i = 0; i < blength; i++) {
                    bWin['colors'].push('turquoise');
                }
                bWin['colors'][ind] = 'olive'
            }
            d4['legend'] = [];
            d4['legend'].push(query);
        }
        boardWin.change.emit();
        infWin.change.emit();
        atr.change.emit();
    """)
    text_input = AutocompleteInput(completions=names,
                                   title="Search an influencer:")
    text_input.js_on_change('value', callback_search)
    query_box = widgetbox(text_input,
                          sizing_mode='stretch_both',
                          responsive=True)

    # Tabular Data

    ## Info Box::
    div_scorebord_info = Div(text="""
                    <h3>Spirometer Details</h3>
                    <p>Tap to column names in order to sort accordingly.
                    </p>
                    """,
                             width=750,
                             height=50)
    title_table = widgetbox(div_scorebord_info,
                            sizing_mode='scale_both',
                            responsive=True)

    Nformatter = NumberFormatter()
    Nformatter.format = "0,0.000"
    columns = [
        TableColumn(field="names", title="Name"),
        TableColumn(field="memes", title="Category"),
        TableColumn(field="scores", title="Score", formatter=Nformatter),
        TableColumn(field="tweets", title="Number of Tweets")
    ]
    data_table = DataTable(source=boards,
                           columns=columns,
                           width=820,
                           height=500)
    table_box = widgetbox(data_table,
                          sizing_mode='stretch_both',
                          responsive=True)

    # Figures only layout::::
    if ApiRequest:
        layoutAPI = column(fig_influencer, fig_board)
        return (layoutAPI)

    # Overall Layout::::
    layout = column(title_box, row(fig_influencer,
                                   column(tips_box, query_box)), fig_board,
                    title_table, table_box)

    return (layout)
示例#14
0
def cHow():
    if byButton:
        return rs_update()
    else:
        return byRow(source.data['ID'].iloc[source.selected.indices[0]])
        
    

menu = [('Publication Paper', 'pub'), ('Dataset', 'data'), ('All', '')]
nmenu = RadioButtonGroup(labels=['Publication', 'Dataset', 'Keyword'], active=0)
how = ['Jaccard', 'Cosine', 'Hopcroft', 'Adamic-Adar']
nhow = RadioButtonGroup(labels=['Jaccard', 'Cosine', 'Hopcroft', 'Adamic-Adar'], active=0)
nhow.on_change('active', lambda attr, old, new: cHow())

search = TextInput(title="Search Archive")
rs_search = AutocompleteInput(title="Recommend by Keyword", completions=all_keywords)

button = Button(label="Search", button_type="warning")
button.on_event(ButtonClick, update)
rs_button = Button(label="Recommend", button_type="success")
rs_button.on_event(ButtonClick, rs_update)

columns = [
    TableColumn(field="ID", title="ID", width=20),
    TableColumn(field="title", title="Title", width=300, formatter=HTMLTemplateFormatter(template=template)),
    TableColumn(field="description", title="Description", width=200, formatter=HTMLTemplateFormatter(template=template))
]
data_table = DataTable(source=source, columns=columns, width=800)
rs_columns = [
    TableColumn(field="data_set_id", title="Data ID", width=20),
    TableColumn(field="rs_score", title="RS Score", width=20),
示例#15
0
def recommender_tab_simple(recommender):

    # create a list of divs
    def make_div_list(textlist, max_lines, fmt_str="""%s""", **attribs):
        """create a list of divs containing text to display"""
        divs = []
        for i in range(max_lines):
            if len(textlist) > i:
                divs.append(Div(text=fmt_str % (textlist[i]), **attribs))
            else:
                divs.append(Div(text=fmt_str % (' '), **attribs))
        return divs

    def make_rec_list(titles, max_lines):
        """create a recommendation list of games,
        with a thumbnail, game title, info and Amazon buy links"""
        global games_by_title
        fmt_str1 = """
            <div class="rec-post-container">                
                <div class="rec-post-thumb"><img src="%s" /></div>
                <div class="rec-post-content">
                    <h3 class="rec-post-title">%s<br>
                    <a href="%s" target="_blank">Info</a><span>&nbsp;&nbsp;</span>
                    <a href="%s" target="_blank">Buy on Amazon</a> </h3>
                </div>
            </div>"""
        fmt_str2 = """"""
        divs = []
        for i in range(max_lines):
            # there is a title available for this list slot
            if len(titles) > i:
                divs.append(
                    Div(text=fmt_str1 %
                        (games_by_title['pic_url'].loc[titles[i]], titles[i],
                         'https://boardgamegeek.com/boardgame/' +
                         str(games_by_title['id'].loc[titles[i]]),
                         'https://www.amazon.com/s?k=' +
                         titles[i].replace(' ', '+') + '&i=toys-and-games')))
            # there no title available for this list slot
            else:
                divs.append(Div(text=fmt_str2))
        return divs

    # update the 'liked games' list UI elements
    def update_liked_list(titlelist):
        global max_liked
        ctl_liked_games.children = make_div_list(titlelist,
                                                 max_liked,
                                                 fmt_str=liked_list_fmt,
                                                 render_as_text=False)

    # update the 'recommended games' list UI elements
    def update_recommended_list(titlelist):
        global n_recommendations
        ctl_recommended_games.children = make_rec_list(titlelist,
                                                       n_recommendations)

    def show_searching_message():
        ctl_recommended_games.children = [
            Div(text='<h1>Searching for recommendations...</h1>')
        ]

    # called when a control widget is changed
    def update_preflist(attr, old, new):
        global liked_games
        liked_games.append(ctl_game_entry.value)
        liked_games = list(filter(None, set(liked_games)))
        # get control values
        update_liked_list(liked_games)
        ctl_game_entry.value = ''

    # clear out the list of preferred games
    def reset_preferred_games():
        global liked_games
        liked_games = []
        update_liked_list(liked_games)

    # user wants some recommendations (clicked the rec button)
    def recommend_games():
        global liked_games, recommended_games
        global games_all, n_recommendations, title_list
        global title_list_lower

        # display a "Searching for recommendations..." message
        # Note: Bokeh doesn't do redraw while inside handlers
        show_searching_message()

        # get some default filter parameters:
        weight = []
        minrating = 6.5
        categories = ['Any category']
        mechanics = ['Any mechanism']
        for title in liked_games:
            idx = (np.array(title_list_lower) == title.lower()).nonzero()[0][0]
            info = games_all.iloc[idx, :]
            weight.append(info['weight'])
            categories += info['categories'].split(',')
            mechanics += info['mechanics'].split(',')

        # select a range of weights around the liked game weights
        weightrange = [
            max(1,
                np.min(weight) - 0.25),
            min(5,
                np.max(weight) + 0.25)
        ]

        # get game IDs for titles
        liked_ids = recommender.get_item_title_id(liked_games)

        # select games to search from based on filters:
        recommended_games = recommender.recommend_items_by_pref_list(
            liked_ids,
            num2rec=n_recommendations,
            weightrange=weightrange,
            minrating=minrating,
            categories_include=categories,
            categories_exclude=['Expansion for Base-game'],
            mechanics_include=mechanics,
            mechanics_exclude=[])

        update_recommended_list(recommended_games)

    # NOTE: I'm using globals because I'm running into variable scope
    #  problems with the bokeh handlers. Easiest to declare globals
    global liked_games, recommended_games, games_all
    global n_recommendations, max_liked, title_list, title_list_lower
    global games_by_title

    # layout params
    n_recommendations = 10
    max_liked = 8

    # Format to use for liked list.
    # This needs to be changed to work like rec list
    liked_list_fmt = """<div style="font-size : 14pt; line-height:14pt;">%s</div>"""

    # variables used by the tab
    liked_games = []
    recommended_games = []
    weight_range = [1, 5]
    games_all = recommender.item_data  # use all games for search
    games_by_title = recommender.item_data.set_index('name')

    # list of all game titles
    title_list = games_all['name']
    title_list_lower = [s.lower() for s in title_list]

    # preferred game entry text control
    ctl_game_entry = AutocompleteInput(completions=list(title_list) +
                                       list(title_list_lower),
                                       min_characters=1,
                                       title='Enter some game names you like:')
    ctl_game_entry.on_change('value', update_preflist)

    # reset liked game list button
    ctl_reset_prefs = Button(label='Reset game list',
                             width_policy='min',
                             align='end')
    ctl_reset_prefs.on_click(reset_preferred_games)

    # liked list title
    ctl_liked_list_title = Div(
        text=
        """<div style="font-size : 18pt; line-height:16pt;">Games you like:</div>"""
    )

    # liked game entries
    ctl_liked_games = WidgetBox(
        children=make_div_list(liked_games, max_liked, fmt_str=liked_list_fmt))

    # recommended list title
    ctl_recommended_list_title = Div(
        text=
        """<div style="font-size : 18pt; line-height:16pt;">Games we recommend:</div>"""
    )

    # recommended games list widget
    ctl_recommended_games = WidgetBox(
        children=make_rec_list(recommended_games, n_recommendations))

    # Recommend games button
    ctl_recommend = Button(label='Recommend some games!', width_policy='min')
    ctl_recommend.on_click(recommend_games)

    # controls to select preferred games
    pref_controls = WidgetBox(ctl_liked_list_title, ctl_liked_games,
                              Spacer(min_height=20),
                              ctl_game_entry, ctl_reset_prefs,
                              Spacer(min_height=40), ctl_recommend)

    # recommendation results
    results_controls = WidgetBox(ctl_recommended_list_title,
                                 ctl_recommended_games)

    # Create a row layout
    layout = row(pref_controls, results_controls)

    # Make a tab with the layout
    tab = Panel(child=layout, title='Simple Game Recommender')

    return tab
示例#16
0
def update_simulated_msmt_error(val):
    update()


# configure Bokeh Inputs, data sources, and plots
autocomplete_station_names = list(STATIONS_DF['Station Name'])
peak_source = ColumnDataSource(data=dict())
peak_flagged_source = ColumnDataSource(data=dict())
distribution_source = ColumnDataSource(data=dict())
qq_source = ColumnDataSource(data=dict())
datatable_source = ColumnDataSource(data=dict())
hist_source = ColumnDataSource(data=dict())

station_name_input = AutocompleteInput(
    completions=autocomplete_station_names,
    title='Enter Water Survey of Canada STATION NAME (USE ALL CAPS)',
    value=IDS_TO_NAMES['08MH016'],
    min_characters=3)

simulation_number_input = Spinner(
    high=5000,
    low=100,
    step=1,
    value=500,
    title="Number of Simulations",
)

sample_size_input = Spinner(high=200,
                            low=2,
                            step=1,
                            value=10,
示例#17
0
menu = [("Item 1", "item_1_value"), ("Item 2", "item_2_value"), None, ("Item 3", "item_3_value")]

dropdown = Dropdown(label="Dropdown button", button_type="warning", menu=menu)
dropdown_split = Dropdown(label="Split button", button_type="danger", menu=menu, split=True)

checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)

checkbox_button_group = CheckboxButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])
radio_button_group = RadioButtonGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)

text_input = TextInput(placeholder="Enter value ...")

completions = ["aaa", "aab", "aac", "baa", "caa"]
autocomplete_input = AutocompleteInput(placeholder="Enter value (auto-complete) ...", completions=completions)

select = Select(options=["Option 1", "Option 2", "Option 3"])

multi_select = MultiSelect(options=["Option %d" % (i+1) for i in range(16)], size=6)

slider = Slider(value=10, start=0, end=100, step=0.5)

range_slider = RangeSlider(value=[10, 90], start=0, end=100, step=0.5)

date_slider = DateSlider(value=date(2016, 1, 1), start=date(2015, 1, 1), end=date(2017, 12, 31))

date_range_slider = DateRangeSlider(value=(date(2016, 1, 1), date(2016, 12, 31)), start=date(2015, 1, 1), end=date(2017, 12, 31))

spinner = Spinner(value=100)
示例#18
0
index_select = Select(value='000001', title='指数代码', options=sorted(index_codes), height=50)
index_type_select = Select(value='牛熊股比', title='数据类型', options=sorted(index_type_list), height=50)
# DatePciekr
dt_pckr_start = DatePicker(title='开始日期', value = date.today() - timedelta(days = 200), min_date = date(2004,1,1), max_date = date.today())
dt_pckr_end = DatePicker(title='结束日期', value = date.today(), min_date = date(2004,1,1), max_date = date.today())

index_select_row = row(index_select, index_type_select, dt_pckr_start, dt_pckr_end)
index_layout = column(index_select_row, create_index_figure_column(index_select.value, index_type_select.value, dt_pckr_start.value, dt_pckr_end.value))

index_select.on_change('value', update_index)
index_type_select.on_change('value', update_index)
dt_pckr_start.on_change('value', update_index)
dt_pckr_end.on_change('value', update_index)

# Add Stock Analysis
stock_auto_input = AutocompleteInput(value = '601318', completions = initializer.update_code_list(), title = '股票代码')
# DatePciekr
stock_pckr_start = DatePicker(title='开始日期', value = date.today() - timedelta(days = 100), min_date = date(2000,1,1), max_date = date.today())
stock_pckr_end = DatePicker(title='股票日期', value = date.today(), min_date = date(2000,1,1), max_date = date.today())

stock_select_row = row(stock_auto_input, stock_pckr_start, stock_pckr_end)
stock_layout = column(stock_select_row, create_stock_figure_column(stock_auto_input.value, stock_pckr_start.value, stock_pckr_end.value))

stock_auto_input.on_change('value', update_stock)
stock_pckr_start.on_change('value', update_stock)
stock_pckr_end.on_change('value', update_stock)

# Market Data
# DatePciekr
market_title = Div(text="整体市场概况", width=120, height=40, margin=[25, 0, 0, 0], style={'font-size': '150%', 'color': 'blue'})
market_pckr_start = DatePicker(title='开始日期', value = date.today() - timedelta(days = 100), min_date = date(2000,1,1), max_date = date.today())
示例#19
0
def recommender_tab_advanced(recommender):
    def make_div_list(textlist, max_lines, fmt_str="""%s""", **attribs):
        """create a list of divs containing text to display"""
        divs = []
        for i in range(max_lines):
            if len(textlist) > i:
                divs.append(Div(text=fmt_str % (textlist[i]), **attribs))
            else:
                divs.append(Div(text=fmt_str % (' '), **attribs))
        return divs

    def make_rec_list(titles, max_lines):
        """create a recommendation list of games,
        with a thumbnail, game title, info and Amazon buy links"""
        global games_by_title
        fmt_str1 = """
            <div class="rec-post-container">                
                <div class="rec-post-thumb"><img src="%s" /></div>
                <div class="rec-post-content">
                    <h3 class="rec-post-title">%s<br>
                    <a href="%s" target="_blank">Info</a><span>&nbsp;&nbsp;</span>
                    <a href="%s" target="_blank">Buy on Amazon</a> </h3>
                </div>
            </div>"""
        fmt_str2 = """"""
        divs = []
        for i in range(max_lines):
            # there is a title available for this list slot
            if len(titles) > i:
                divs.append(
                    Div(text=fmt_str1 %
                        (games_by_title['pic_url'].loc[titles[i]], titles[i],
                         'https://boardgamegeek.com/boardgame/' +
                         str(games_by_title['id'].loc[titles[i]]),
                         'https://www.amazon.com/s?k=' +
                         titles[i].replace(' ', '+') + '&i=toys-and-games')))
            # no title, so fill with blank
            else:
                divs.append(Div(text=fmt_str2))
        return divs

    # update the 'liked games' list UI elements
    def update_liked_list(titlelist):
        global max_liked
        ctl_liked_games.children = make_div_list(titlelist,
                                                 max_liked,
                                                 fmt_str=liked_list_fmt,
                                                 render_as_text=False)

    # update the 'recommended games' list UI elements
    def update_recommended_list(titlelist):
        global n_recommendations
        ctl_recommended_games.children = make_rec_list(titlelist,
                                                       n_recommendations)

    # called when a control widget is changed
    def update_filters(attr, old, new):
        global category_includes, mechanics_includes
        global category_excludes, mechanics_excludes

        category_includes = [
            ctl_category_selection1.labels[i]
            for i in ctl_category_selection1.active
        ]
        category_includes += [
            ctl_category_selection2.labels[i]
            for i in ctl_category_selection2.active
        ]

        mechanics_includes = [
            ctl_mechanics_selection1.labels[i]
            for i in ctl_mechanics_selection1.active
        ]
        mechanics_includes += [
            ctl_mechanics_selection2.labels[i]
            for i in ctl_mechanics_selection2.active
        ]

        # NOTE: this will need to be changed if I ever implement exclude selections!
        if ctl_include_expansions.active:
            category_excludes = []
        else:
            category_excludes = ['Expansion for Base-game']

    # called when a control widget is changed
    def update_preflist(attr, old, new):
        global liked_games
        liked_games.append(ctl_game_entry.value)
        liked_games = list(filter(None, set(liked_games)))
        # get control values
        update_liked_list(liked_games)
        ctl_game_entry.value = ''

    # reset preferred games list
    def reset_preferred_games():
        global liked_games
        liked_games = []
        update_liked_list(liked_games)

    # recommend some games
    def recommend_games():
        global liked_games, recommended_games
        global games_all, n_recommendations, title_list
        global category_includes, mechanics_includes

        # get game IDs for titles
        liked_ids = recommender.get_item_title_id(liked_games)

        # select games to search from based on filters:
        recommended_games = recommender.recommend_items_by_pref_list(
            liked_ids,
            num2rec=n_recommendations,
            weightrange=ctl_game_weight.value,
            minrating=ctl_game_min_rating.value,
            categories_include=category_includes,
            categories_exclude=category_excludes,
            mechanics_include=mechanics_includes,
            mechanics_exclude=mechanics_excludes)

        # show the recommended games
        update_recommended_list(recommended_games)

    # NOTE: I'm using globals because I'm running into variable scope
    #  problems with the bokeh handlers. Easiest to declare globals
    global liked_games, recommended_games, games_all
    global n_recommendations, max_liked, title_list, title_list_lower
    global category_includes, mechanics_includes
    global category_excludes, mechanics_excludes
    global games_by_title

    # layout params
    n_recommendations = 10
    max_liked = 8
    num_check_options = 20

    # Format to use for liked list.
    # This needs to be changed to work like rec list
    liked_list_fmt = """<div style="font-size : 14pt; line-height:14pt;">%s</div>"""

    # variables used by the tab
    games_all = recommender.item_data  # use all games for search
    liked_games = []
    recommended_games = []
    weight_range = [1, 5]
    category_includes = []
    mechanics_includes = []
    category_excludes = []
    mechanics_excludes = []

    # list of all game titles
    title_list = games_all['name']
    title_list_lower = [s.lower() for s in title_list]
    games_by_title = recommender.item_data.set_index('name')

    # preferred game entry text control
    ctl_game_entry = AutocompleteInput(completions=list(title_list) +
                                       list(title_list_lower),
                                       min_characters=1,
                                       title='Enter some game names you like:')
    ctl_game_entry.on_change('value', update_preflist)

    # reset liked game list button
    ctl_reset_prefs = Button(label='Reset game list',
                             width_policy='min',
                             align='end')
    ctl_reset_prefs.on_click(reset_preferred_games)

    # liked list title
    ctl_liked_list_title = Div(
        text=
        """<div style="font-size : 18pt; line-height:16pt;">Games you like:</div>"""
    )

    # liked game entries
    ctl_liked_games = WidgetBox(
        children=make_div_list(liked_games, max_liked, fmt_str=liked_list_fmt))

    # recommended list title
    ctl_recommended_list_title = Div(
        text=
        """<div style="font-size : 18pt; line-height:16pt;">Games we recommend:</div>"""
    )

    # recommended games list widget
    ctl_recommended_games = WidgetBox(
        children=make_rec_list(recommended_games, n_recommendations))

    # Recommend games button
    ctl_recommend = Button(label='Recommend some games!',
                           width_policy='min',
                           align='center')
    ctl_recommend.on_click(recommend_games)

    # game weight slider
    ctl_game_weight = RangeSlider(
        start=1,
        end=5,
        value=(1, 5),
        step=.1,
        title='Game weight range',
        width_policy='min',
    )
    ctl_game_weight.on_change('value', update_filters)

    # min game rating slider
    ctl_game_min_rating = Slider(start=1,
                                 end=10,
                                 value=7,
                                 step=.1,
                                 title='Minimum average rating',
                                 width_policy='min')
    ctl_game_min_rating.on_change('value', update_filters)

    # collect all category and mechanics labels from recommender data
    categories, mechanics = recommender.get_categories_and_mechanics()

    # game category selection
    category_list = ['Any category'] + list(categories['tag'].values)
    ctl_category_selection1 = CheckboxGroup(
        labels=category_list[:int(num_check_options / 2)],
        width_policy='min',
        active=[0])
    ctl_category_selection1.on_change('active', update_filters)
    ctl_category_selection2 = CheckboxGroup(
        labels=category_list[int(num_check_options / 2):num_check_options],
        width_policy='min')
    ctl_category_selection2.on_change('active', update_filters)

    # game mechanism checkbox group
    mechanics_list = ['Any mechanism'] + list(mechanics['tag'].values)
    ctl_mechanics_selection1 = CheckboxGroup(
        labels=mechanics_list[:int(num_check_options / 2)],
        width_policy='min',
        active=[0])
    ctl_mechanics_selection1.on_change('active', update_filters)
    ctl_mechanics_selection2 = CheckboxGroup(
        labels=mechanics_list[int(num_check_options / 2):num_check_options],
        width_policy='min')
    ctl_mechanics_selection2.on_change('active', update_filters)

    # select whether to include expansions
    ctl_include_expansions = CheckboxGroup(labels=['Include game expansions'],
                                           width_policy='min')

    ctl_include_expansions.on_change('active', update_filters)
    # controls to select preferred games
    pref_controls = WidgetBox(
        ctl_liked_list_title,
        ctl_liked_games,
        Spacer(min_height=20),
        ctl_game_entry,
        ctl_reset_prefs,
        Spacer(min_height=5),
    )

    ctl_liked_list_title = Div(
        text=
        """<div style="font-size : 18pt; line-height:16pt;">Game Categories:</div>"""
    )

    filter_controls = WidgetBox(
        row(ctl_game_weight, Spacer(min_width=50), ctl_game_min_rating),
        row(ctl_include_expansions),
        column(
            row(
                Div(text=
                    """<div style="font-size : 18pt; line-height:16pt;">Game Categories:</div>"""
                    ), Spacer(min_width=50), ctl_recommend),
            row(ctl_category_selection1, ctl_category_selection2),
            Spacer(min_height=5),
            Div(text=
                """<div style="font-size : 18pt; line-height:16pt;">Game Mechanics:</div>"""
                ),
            row(ctl_mechanics_selection1, ctl_mechanics_selection2),
        ))

    # recommendation results
    results_controls = WidgetBox(
        ctl_recommended_list_title,
        ctl_recommended_games,
        Spacer(min_height=10),
    )

    # Create a row layout
    layout = row(column(pref_controls, filter_controls), Spacer(min_width=50),
                 results_controls)

    # Make a tab with the layout
    tab = Panel(child=layout, title='Advanced Game Recommender')

    return tab
示例#20
0
    plot_height=PLOT_HEIGHT,
    plot_width=PLOT_WIDTH,
    tools=TOOLS,
    x_range=[1, 50],
    y_range=[0, 1],
)
plot.yaxis.axis_label = "Transmission fraction"
plot.xaxis.axis_label = "Energy [keV]"
plot.line("x", "y", source=source, line_width=3, line_alpha=0.6)
plot.title.text = f"{response}"
plot.add_tools(custom_hover)
# Set up the inputs
ylog_checkbox = CheckboxGroup(labels=["y-log"], active=[0])

# materials in the path
material_input = AutocompleteInput(title="Material (lowercase)",
                                   value=DEFAULT_MATERIAL[0])
material_input.completions = all_materials
material_thickness_input = TextInput(title="thickness",
                                     value=str(DEFAULT_THICKNESS[0]))
material_density_input = TextInput(title="density",
                                   value=str(this_material.density.value))

air_thickness_input = TextInput(title="air path length",
                                value=str(DEFAULT_AIR_THICKNESS))
air_pressure_input = TextInput(title='air pressure',
                               value=str(DEFAULT_AIR_PRESSURE))
air_temperature_input = TextInput(title='air temperature',
                                  value=str(DEFAULT_AIR_TEMPERATURE))

detector_material_input = AutocompleteInput(title='Detector',
                                            value=DEFAULT_DETECTOR_MATERIAL)
示例#21
0
def beliebtheitsermittler(df,actorList, productionList , directorList, writersList, genreList,df_merged, ratingQuantile ):

    text =  "Füllen Sie die Felder aus und drücken auf den Start-Button um den Film zu bewerten."
    actorList = list(set(actorList))
    productionList = list(set(productionList))
    directorList = list(set(directorList))
    writersList = list(set(writersList))
    genreList = list(set(genreList))
    
    
    output_notebook()
    
    # Set up widgets
    actor1 = AutocompleteInput(completions=actorList, placeholder = 'Required',title='Schauspieler 1')
    actor2 = AutocompleteInput(completions=actorList, placeholder = 'Required',  title='Schauspieler 2')
    actor3 = AutocompleteInput(completions=actorList, placeholder = 'Required',  title='Schauspieler 3')
    actor4 = AutocompleteInput(completions=actorList, placeholder = 'Required',  title='Schauspieler 4')
    production = AutocompleteInput(completions=productionList, placeholder = 'Required', title='Production')
    director = AutocompleteInput(completions= directorList, placeholder = 'Required', title='Regie')
    autor = AutocompleteInput(completions= writersList, placeholder = 'Required', title='Autor')
    genre = Select(title = 'Auswahl des Hauptgenre',height = 50,value = 'Comedy',  options = genreList)
    
    select = Select(title = 'Auswahl der Metric',height = 50,value = 'Metascore',   options = ['Metascore', 'imdbRating', 'TomatoRating'])
    answer = Button(height = 100, width = 600,disabled = True,margin = [10,10,10,10],background = 'white', label = text)
    button = Button(margin = [23,0,0,200], width = 100, button_type = 'primary', label = 'Start')
    paragraph2 = Paragraph(margin = [40,0,0,10])
    paragraph2.text = "Ergebnis:"
    
    
    def doOnClick():
        metric = select.value
        columns = df_merged.columns.tolist()
        columns.remove('Category')
        
        if  (actor1.value in actorList) and (actor2.value in actorList) and (actor3.value in actorList) and (actor4.value in actorList) and (production.value in productionList) and (director.value in directorList) and (autor.value in writersList):
            filename = 'models/'+ metric + '_model.sav'
            
            model = pickle.load(open(filename, 'rb'))
            d = pd.DataFrame(0,index=np.arange(1), columns=columns)
            
            d['Actors_' + actor1.value] = 1
            d['Actors_' + actor2.value] = 1
            d['Actors_' + actor3.value] = 1
            d['Actors_' + actor4.value] = 1
            d['Genre_' + genre.value] = 1
            d['Director_' + director.value] = 1
            d['Writer_' + autor.value] = 1
            d['Production__'+ production.value]  = 1  
            
            result = model.predict(d)[0]

            if ('Gut' in result):
                answer.background = 'green'

            elif('Schlecht' in result):
                answer.background = 'red'
    
            else:
                answer.background = 'yellow'

             
            answer.label = result
        else:
            answer.label = text
            answer.background = 'white'
        
          
    button.on_click(doOnClick)
    
    
        
    layout = [row(widgetbox(actor1 , actor2, actor3, actor4, genre),
                  widgetbox( production, director,autor, select, button ))]
    
    def modify_doc(doc):

        doc.add_root(row(layout))
        doc.add_root(column(widgetbox(paragraph2,answer)))
    
    handler = FunctionHandler(modify_doc)
    app = Application(handler)
    show(app)