Esempio n. 1
0
def subplots(*args, **kwargs):
    fig, axs = matplotlib.pyplot.subplots(*args, **kwargs)
    yield fig, axs
    try:
        display(fig)
    finally:
        matplotlib.pyplot.close(fig)
Esempio n. 2
0
def figure(*args, **kwargs):
    fig = matplotlib.pyplot.figure(*args, **kwargs)
    yield(fig)
    try:
        display(fig)
    finally:
        matplotlib.pyplot.close(fig)
Esempio n. 3
0
    def plot(self, positions, dt=0.1):
        '''
        
        This function animates the motion of the particles.
        
        It is only meant as a demonstration for small N, to check that things are working as we expect.
        
        It takes in a list of calculated positions, and displays where they were at
        a specified regular time interval.
        
        
        '''

        skip = dt / self.timestep

        for i in np.arange(0, len(positions), skip):
            i = int(i)
            fig = plt.figure(figsize=(8, 8))
            ax = fig.add_subplot(111, projection='3d')

            pos = positions[i]

            for j in range(len(pos)):
                ax.scatter(pos[j][0], pos[j][1], pos[j][2], color="blue")
            ax.set_xlim([-1, self.size[0] + 1])
            ax.set_ylim([-1, self.size[1] + 1])
            ax.set_zlim([-1, self.size[2] + 1])
            plt.grid()
            clear_output(wait=True)
            display(fig)
            fig.clear()
        plt.close()
    def print_topics(cls, model, num_words: int = 10) -> None:
        """Print all of the latent topics and top tokens associated with each topic.

        Args:
            model:
                The gensim model for which to calculate the coherence.
            num_words:
                Optional; The amount of words related to each topic to print. The default
                behaviors is to print the top 10 words related to each latent topic.
        """
        topics = TopicModeler.get_topics(model, num_words=num_words)
        topics_dict = []

        for t in topics:
            topics = t[1].replace('"', "").replace('+', "\n").split('\n')
            topics = [topic.strip().split('*') for topic in topics]
            keyphrases = ", ".join([key for _, key in topics])
            topics_dict.append([t[0] + 1, keyphrases])

        df = pd.DataFrame(topics_dict, columns=["Topic #", "Top keywords"])
        df = df.style.set_properties(**{
            "text-align": "left",
            "colheader-align": "left"
        })
        display(df)
Esempio n. 5
0
def bodePlot(H_s, w_range=(0, 8), points=800):
    """Plot the magnitude and phase of H_s over the given range of frequencies."""

    w = logspace(*w_range, points)
    h_s = lambdify(s, H_s, 'numpy')
    H_jw = h_s(1j * w)

    # find mag and phase
    mag = 20 * np.log10(np.abs(H_jw))
    phase = angle(H_jw, deg=True)

    eqn = Eq(H, simplify(H_s))
    display(eqn)

    fig, axes = plt.subplots(1, 2, figsize=(18, 6))
    ax1, ax2 = axes[0], axes[1]

    # mag plot
    ax1.set_xscale('log')
    ax1.set_ylabel('Magntiude in dB')
    ax1.set_xlabel('$\omega$ in rad/s')
    ax1.plot(w, mag)
    ax1.grid()
    ax1.set_title("Magnitude of $H(j \omega)$")

    # phase plot
    ax2.set_ylabel('Phase in degrees')
    ax2.set_xlabel('$\omega$ in rad/s')
    ax2.set_xscale('log')
    ax2.plot(w, phase)
    ax2.grid()
    ax2.set_title("Phase of $H(j \omega)$")

    plt.show()
Esempio n. 6
0
def draw_strokes(data, factor=0.2, svg_filename = '/tmp/sketch_rnn/svg/sample.svg'):
  os.makedirs(os.path.dirname(svg_filename), exist_ok=True)
  min_x, max_x, min_y, max_y = get_bounds(data, factor)
  dims = (50 + max_x - min_x, 50 + max_y - min_y)
  dwg = svgwrite.Drawing(svg_filename, size=dims)
  dwg.add(dwg.rect(insert=(0, 0), size=dims,fill='white'))
  lift_pen = 1
  abs_x = 25 - min_x 
  abs_y = 25 - min_y
  p = "M%s,%s " % (abs_x, abs_y)
  command = "m"
  for i in range(len(data)):
    if (lift_pen == 1):
      command = "m"
    elif (command != "l"):
      command = "l"
    else:
      command = ""
    x = float(data[i,0])/factor
    y = float(data[i,1])/factor
    lift_pen = data[i, 2]
    p += command+str(x)+","+str(y)+" "
  the_color = "black"
  stroke_width = 1
  dwg.add(dwg.path(p).stroke(the_color,stroke_width).fill("none"))
  dwg.save()
  display(SVG(dwg.tostring()))
Esempio n. 7
0
def load_graph(num):
    global G

    while num < 1 or num > 5:
        num = input("Invalid Graph number, please enter a new one:  ")
        num = int(num)

    fileName = ""

    if num == 1:
        # set the file name
        fileName = "simpleG.jpg"
        G.create_simple()
    elif num == 2:
        # set the file name
        fileName = "simp_diff_len.jpg"
        G.create_simple_different_road_lengths()
    elif num == 3:
        # set the file name
        fileName = "simp_diff_ang.jpg"
        G.create_simple_different_angles()
    elif num == 4:
        # set the file name
        fileName = "mystery.jpg"
        G.mystery_graph()
    elif num == 5:
        # set the file name
        fileName = "complex.jpg"
        G.create_complex()

        # display the image here
    display(
        Image(filename=('/home/pi/Dashboard/user/jason/MyImages/' + fileName),
              width=300,
              height=200))
Esempio n. 8
0
    def load(self, *_):
        try:
            self.set_buzy(True, "⌛ Loading data...")

            if self._output:
                with pd.option_context('display.precision', 2,
                                       'display.max_columns', 300):
                    pd.options.display.max_columns = 300
                    self._output.clear_output()
                    style_dict = [{
                        'selector':
                        'thead th',
                        'props': [('position', 'sticky'), ('top', '0'),
                                  ('background-color', 'grey')],
                    }]
                    with self._output:  # pylint: disable=not-context-manager
                        df: pd.DataFrame = (self.data.style.format({
                            'H':
                            "{:.2%}"
                        }).set_table_styles(style_dict).hide_index())
                        display(HTML(df.style.render()))

            if self._table is not None:
                self._table.clear()
                self._table.load(self.data)

            self.set_buzy(False, "✔")

        except Exception as ex:
            self.set_buzy(False, f"😮 {str(ex)}")
def display_vctk_sample(vctk_speaker_id, sample_id):
    speaker_info = get_vctk_speaker_info()

    # raw .wav file
    wav_file = os.path.join(
        vctk_raw_folder,
        'wav48/p' + str(vctk_speaker_id) + '/p' + str(vctk_speaker_id) + '_' +
        '{num:03d}'.format(num=sample_id) + '.wav')

    # print speaker info
    display(speaker_info[speaker_info['id'] == vctk_speaker_id])

    # print text
    txt_file = wav_file.replace("wav48", "txt").replace(".wav", ".txt")
    f = open(txt_file, 'r')
    print(f.read())
    f.close()

    # play sample
    rate, wav_data = wavfile.read(wav_file)
    display(IPython.display.Audio(data=wav_data, rate=rate, autoplay=True))

    # plot waveform
    plt.figure(figsize=(15, 4))
    plt.plot(wav_data)
    plt.grid(True)
    plt.xlim(0, len(wav_data))
    plt.xticks(range(0, len(wav_data), 48000),
               range(0, np.int(np.ceil(1.0 * len(wav_data) / 48000))))

    # plot spectrogram
    plot_spectrogram(wav_data, rate)
def tune_hyper_parameter(stock_name, df, config):
    # Get last 365 day for tuning
    df = df[-365:]
    bayer_max_evals = config.get('bayer_max_evals', 1000)
    param_grid = config.get('param_grid')

    # Hyperparameter grid
    bayes_trials = Trials()

    # Create the algorithm
    bayes_algo = tpe.suggest

    fmin_objective = partial(objective, df=df)

    bayes_best = fmin(fn=fmin_objective,
                      space=param_grid,
                      algo=bayes_algo,
                      trials=bayes_trials,
                      max_evals=bayer_max_evals)

    param_file_path = os.path.join(config['model_dir'],
                                   '%s_param.txt' % (stock_name))
    with open(param_file_path, 'w') as outfile:
        json.dump(bayes_best, outfile)

    display(bayes_best)
Esempio n. 11
0
def display_img_df(
    df,
    txt_fields=None,
    img_fields=["thumbnail"],
    link_fields=[],
    use_api=True,
    img_first=True,
    docid_name="dsid",
    script_func_name=None,
    script_name=None,
    **kwargs
):
    """ image display를 위해서 html로 변환하여 화면에 표시

    img_fields에 정의된 필드는 excaping하지 않는다. 
    use_api : dsid(docimgdsid) 필드가 있으면 가 있으면 
              api로 필요한 데이터를 가져온다. 
    """

    if len(df) == 0:
        return

    df = _complete_img_df(df, txt_fields, img_fields, link_fields, use_api, img_first, docid_name=docid_name, **kwargs)
    html = df.to_html(escape=False)
    df_name = kwargs.get("script_df_name", "None")
    if script_func_name is not None:
        if script_name is None:
            script_name = script_func_name
        html = add_script(script_func_name, script_func_name, html, df_name=df_name)
    display(HTML(html))
Esempio n. 12
0
 def fromTHnArray(cls, tHnArray, inputProjectionList, figureOptions,
                  graphOptions):
     """
     initialize bokehDrawHisto from histogramArray and inputProjectionArray
     :param tHnArray:                 TContainer with histograms
     :param inputProjectionList:
     :param graphOptions:
     :param figureOptions:
     :return:
     """
     self: bokehDrawHisto = cls()
     self.figureOptions.update(figureOptions)
     self.graphOptions.update(graphOptions)
     self.projectionList = inputProjectionList
     self.histogramList = {}
     for his in tHnArray:
         try:
             # check if root THn - otherwise assume
             ddHis = thnToNumpyDD(his)
             logging.info("Processing histogram %s", his.GetName())
         except:
             #logging.error("non compatible object %s\t%s", his.GetName(), his.__class__)
             ddHis = his
         logging.info("Processing histogram %s", ddHis['name'])
         self.histogramList[ddHis['name']] = ddHis
     self.__processSliders()
     self.sliderWidgets = widgets.VBox(self.sliderList)
     self.__processProjections()
     isNotebook = get_ipython().__class__.__name__ == 'ZMQInteractiveShell'
     #self.handle = show(self.sliderWidgets, notebook_handle=isNotebook)
     display(self.sliderWidgets)
     return self
Esempio n. 13
0
def protect (author=None):
    """Makes current notebook protected with the given author name. Protected notebooks won't be saved
    unless the user matches the author."""
    author = author or os.environ['USER']
    display(Javascript("document.radiopadre.protect('%s')"%author))
    display(HTML(render_status_message("""This notebook is now protected, author is "%s".
        All other users will have to treat this notebook as read-only.""" % author)))
Esempio n. 14
0
def show(close=None, block=None):
    """Show all figures as SVG/PNG payloads sent to the IPython clients.

    Parameters
    ----------
    close : bool, optional
      If true, a ``plt.close('all')`` call is automatically issued after
      sending all the figures. If this is set, the figures will entirely
      removed from the internal list of figures.
    block : Not used.
      The `block` parameter is a Matplotlib experimental parameter.
      We accept it in the function signature for compatibility with other
      backends.
    """
    if close is None:
        close = InlineBackend.instance().close_figures
    try:
        for figure_manager in Gcf.get_all_fig_managers():
            display(figure_manager.canvas.figure)
    finally:
        show._to_draw = []
        # only call close('all') if any to close
        # close triggers gc.collect, which can be slow
        if close and Gcf.get_all_fig_managers():
            matplotlib.pyplot.close('all')
Esempio n. 15
0
def rank_features_by_logreg_coefficients(X_train, logreg, abs_threshold=0.5):

    fi = {
        'Features': X_train.columns.tolist(),
        'Importance': np.transpose(logreg.coef_[0])
    }

    importance = pd.DataFrame(fi, index=None).sort_values(
        'Importance',
        ascending=False).set_index('Features').sort_values(by='Importance',
                                                           ascending=False)

    mask = abs(importance['Importance']) > abs_threshold

    with pd.option_context('display.max_rows', len(importance)):
        display(importance[mask])

    # Creating graph title
    titles = [
        'The most important features in predicting survival on the Titanic: Logistic Regression'
    ]

    # Plotting graph
    importance_plotting(importance.reset_index(), 'Importance', 'Features',
                        'Reds_r', titles)

    important_features = importance[mask].index.tolist()
    unimportant_features = importance[~mask].index.tolist()
    return important_features, unimportant_features
Esempio n. 16
0
    def tikz_to_plot(
        cls,
        code,
        x='1em',
        y='1em',
        scale='1',
        svg_scale=2,
        raw=False,
        **kwargs,
    ):
        code = cls.tikz_to_tex(code, x=x, y=y, scale=scale, raw=raw, **kwargs)
        try:
            with tempfile.TemporaryDirectory() as tmpdir:
                tmpdir = Path(tmpdir)

                main_tex = (tmpdir / 'main.tex')
                main_tex.write_text(code)

                run_process(['pdflatex', 'main.tex'], cwd=tmpdir)

                run_process([
                    'inkscape',
                    '--without-gui',
                    '--file=main.pdf',
                    '--export-plain-svg=main.svg',
                ],
                            cwd=tmpdir)
                res_svg = Path(tmpdir / 'main.svg').read_text()
            return SVG(resize_svg_code(res_svg, factor=svg_scale,
                                       method='bs4'))
        except Exception as e:
            display(Code(code, language='tex'))
            raise
Esempio n. 17
0
def show_style():
    html = HTML('''<style>
                    .right_aligned_df td { text-align: right; }
                    .left_aligned_df td { text-align: right; }
                    .pink_df { background-color: pink; }
                </style>''')
    display(html)
Esempio n. 18
0
def nb_raw_input(prompt, name="raw_input_reply"):
    display(
        Javascript(
            """
var dialog = $('<div/>').append(
    $('<input/>')
    .attr('id', 'theinput')
    .attr('value', '')
);
$(document).append(dialog);
dialog.dialog({
    resizable: false,
    modal: true,
    title: "%s",
    closeText: '',
    buttons : {
        "Okay": function () {
            IPython.notebook.kernel.execute(
                "%s = '" + $("input#theinput").attr('value') + "'"
            );
            $(this).dialog('close');
            dialog.remove();
        },
        "Cancel": function () {
            $(this).dialog('close');
            dialog.remove();
        }
    }
});
"""
            % (prompt, name)
        ),
        include=["application/javascript"],
    )
Esempio n. 19
0
 def set_data(self,
              data_dict,
              download=False,
              load_transform=None,
              **kwargs):
     # get data from urls in data_dict
     if download:
         data = []
         for i, (id, url) in enumerate(data_dict.items()):
             clear_output(wait=True)
             display('downloading data')
             display('progress: %g%%' % (100. * (i + 1) / len(data_dict)))
             d = self.download_image(url, id, download)
             if d is None:
                 continue
             d = functions.kwarg_fn(
                 [self, functions, list, dict, __builtins__, np, torch], d,
                 **kwargs)
             if load_transform:
                 d = load_transform(d)
             data.append(d)
         if np.all([
                 type(d) is torch.Tensor and d.ndimension() == 4
                 for d in data
         ]):
             self.data = torch.cat(data)
         else:
             self.data = data
     else:
         self.data = data_dict.copy()
Esempio n. 20
0
    def _show_thumbs(images, width=None, ncol=None, maxwidth=None, mincol=None,
                     external_thumbs=None,
                     maxcol=None, title=None, **kw):

        if not images:
            return None
        nrow, ncol, width = radiopadre.file.compute_thumb_geometry(
            len(images), ncol, mincol, maxcol, width, maxwidth)
        npix = int(radiopadre.DPI * width)

        # make list of basename, filename  tuples
        filelist = sorted(
            [(os.path.basename(img.fullpath), img.fullpath) for img in images])

        # keep track of thumbnail fails
        nfail = 0

        html = render_preamble() + render_title(title) + \
            """<br>
                   <table style="border: 0px; text-align: left">\n
                   """
        for row in range(nrow):
            html += """<tr style="border: 0px; text-align: left">\n"""
            filelist_row = filelist[row * ncol:(row + 1) * ncol]
            for name, image in filelist_row:
                html += """<td style="border: 0px; text-align: center">"""
                html += "<a href=%s target='_blank'>%s</a>" % (render_url(image), name)
                html += "</td>\n"
            html += """</tr><tr style="border: 0px; text-align: left">\n"""
            for _, image in filelist_row:
                if external_thumbs is False:
                    thumb = None
                # make thumbnail and record exceptions. Print the first one, as
                # they really shouldn't happen
                else:
                    try:
                        thumb = _make_thumbnail(image, npix)
                        if not thumb and external_thumbs:
                            nfail += 1
                    except:
                        if not nfail:
                            traceback.print_exc()
                        nfail += 1
                        thumb = None
                html += """<td style="border: 0px; text-align: left">"""
                if thumb:
                    html += "<a href=%s target='_blank'><img src=%s alt='?'></a>" % (
                        render_url(image), render_url(thumb))
                else:
                    html += "<a href=%s target='_blank'><img src=%s width=%d alt='?'></a>" % (
                        render_url(image), render_url(image), npix)
                html += "</td>\n"
            html += "</tr>\n"
        html += "</table>"

        if nfail:
            html += "(WARNING: %d thumbnails unexpectedly failed to generate, check console for errors)<br>\n" % nfail

        display(HTML(html))
Esempio n. 21
0
def transform():
    global file_name
    imageLocation = 'photo/zumi.png'

    if (file_name != ''):
        imageLocation = 'photo/' + file_name + ".png"

    #RotaionRatio = 0.5  #  회전시 잘리는 경우 1을 입력

    RotaionRatio = 1  #  회전시 잘리는 경우 1을 입력

    wImagR = widgets.Image(
        layout=Layout(border="solid"),
        width=300,
        height=400  # 이미지 크기
    )

    wRadioR = widgets.RadioButtons(
        options=['원위치', '왼쪽으로 90도 회전', '오른쪽으로 90도 회전', '좌우 반전', '상하 반전'],
        description='Rotate:',
        disabled=False)

    def on_Rotate_change(change):
        ImageRotate(change['new'])

    def ImageRotate(direction):

        image = cv2.imread(imageLocation)  # 이미지 읽기

        (height, width) = image.shape[:2]
        (center_height, center_width) = (height / 2.0, width / 2.0)

        if (direction == '왼쪽으로 90도 회전'):
            angle = 90
            M = cv2.getRotationMatrix2D((center_width, center_height), angle,
                                        RotaionRatio)
            image = cv2.warpAffine(image, M, (width, height))

        elif (direction == '오른쪽으로 90도 회전'):
            angle = -90
            M = cv2.getRotationMatrix2D((center_width, center_height), angle,
                                        RotaionRatio)
            image = cv2.warpAffine(image, M, (width, height))

        elif (direction == '좌우 반전'):
            image = cv2.flip(image, 1)

        elif (direction == '상하 반전'):
            image = cv2.flip(image, 0)

        originalImg = cv2.imencode(".png", image)[1].tostring()
        wImagR.value = originalImg

    ImageRotate('원위치')

    wRadioR.observe(on_Rotate_change, names='value')

    BOX_NEW = widgets.Box([wImagR, wRadioR])
    display(BOX_NEW)
Esempio n. 22
0
 def _pngDisplay(self):
     ofile = tempfile.NamedTemporaryFile(suffix=".png")
     with _setIgnoreLevel(ROOT.kError):
         self.canvas.SaveAs(ofile.name)
     img = IPython.display.Image(filename=ofile.name,
                                 format='png',
                                 embed=True)
     display(img)
Esempio n. 23
0
def csnap(orig_df, fn=lambda x: x.shape, msg=None):
    """ Custom Help function to print things in method chaining.
        Returns back the df to further use in chaining.
    """
    if msg:
        print(msg)
    display(fn(orig_df))
    return orig_df
Esempio n. 24
0
 def progresser(x,y,z):
   if len(apsc.history())<10:
     plt.xlim(1,10)
   else:
     plt.xlim(1,len(apsc.history()))
   plt.plot(scale(apsc.history()), 'g')
   clear_output(True)
   display(f)
Esempio n. 25
0
def interact_h(_interact_f, *args, **kwargs):
    '''Similar to IPython's interact function, but with widgets
    packed horizontally.'''
    f = _interact_f
    w = widgets.interactive(f, *args, **kwargs)
    f.widget = w
    # Weirdly enough, be sure to display before changing the class.
    display(w)
    return f
Esempio n. 26
0
 def summary(self, **kw):
     kw.setdefault('title', self._title)
     kw.setdefault('showpath', self._showpath)
     summary = getattr(self._classobj, "_show_summary", None)
     if summary:
         display(HTML(render_refresh_button(full=self._parent and self._parent.is_updated())))
         return summary(self, **kw)  
     else:
         return self.list(**kw)
Esempio n. 27
0
 def show(self):
     from IPython.display import display
     if self.tool_bar_state:
         self._configure_tool_bar()
     self.figure.display = self.plotter.show(use_ipyvtk=True,
                                             return_viewer=True)
     self.figure.display.layout.width = None  # unlock the fixed layout
     display(self.figure.display)
     return self.scene()
def Model_prediction(dataset=None, num=1):
    if dataset:
        for image, mask in dataset.take(num):
            pred_mask = model.predict(image)
            display([image[0], mask[0], create_mask(pred_mask)])
    else:
        display([
            sample_image, sample_mask,
            create_mask(model.predict(sample_image[tf.newaxis, ...]))
        ])
Esempio n. 29
0
 def update_output_slider(self, value):
     self.out.clear_output(wait=True)
     plt.plot(self.time, self.dt[self.select.value])
     plt.xlabel("t (ps)")
     plt.ylabel(self.select.value)
     plt.xlim([0, self.slider.value])
     plt.grid()
     with self.out:
         display(plt.gcf())
     plt.close()
Esempio n. 30
0
def display_table_info(table_name, job_name=None, args_str="", n=10, local=False, use_all=True, html_n=0, **kwargs):
    A = test_anal.head_table(
        table_name, job_name=job_name, args_str=args_str, n=n, local=local, use_all=use_all, **kwargs
    )
    display(A)

    if html_n > 0:
        display(HTML(A.head(html_n).to_html()))

    return A
Esempio n. 31
0
def display_or_return_df(df, return_df, style_class=None, formatters=None):
    if return_df:
        return df
    else:
        # style 을 사용하기 위해서는 show_style() 을 실행한 cell이 하나 있어야 함.
        html = df.to_html(escape=False,
                          classes=style_class,
                          formatters=formatters)
        display(HTML(html))
        return None
Esempio n. 32
0
 def display_interactive(*args):
     display(fig)
     #clear up figure so it isn't displayed at end of execution
     try:
         show._to_draw.remove(fig)
     except ValueError:
         pass
     show._draw_called = False
     matplotlib.pyplot.close(fig)
     return
Esempio n. 33
0
def display_df(df, html=False, **kwargs):
    print "total : %s" % len(df)

    df = _get_df_part(df, **kwargs)

    # html (충분히 길고 넓은 데이터를 보여줄 수 있음, image 표현 가능)
    if html:
        display(HTML(df.to_html()))
    else:
        display(df)
Esempio n. 34
0
    def _show_thumbs(images,
                     width=None,
                     ncol=None,
                     maxwidth=None,
                     mincol=None, 
                     maxcol=None, 
                     title=None,
                     **kw):

        if not images:
            return None
        nrow, ncol, width = rv.File.compute_thumb_geometry(len(images), ncol, mincol, maxcol, width, maxwidth)
        npix = int(rv.DPI*width)

        # make list of thumbnail,filename pairs
        filelist = [ (os.path.basename(img.fullpath),
                      "%s/thumbnails/%d.%s"%(os.path.dirname(img.fullpath),
                                        npix,os.path.basename(img.fullpath)),
                      img.fullpath)
                    for img in images ]
        filelist.sort()

        # (re)generate thumbs if needed
        fails = 0
        for _, thumb, image in filelist:
            if not os.path.exists(os.path.dirname(thumb)):
                if os.system("mkdir %s"%os.path.dirname(thumb)):
                    fails += 1
            if not os.path.exists(thumb) or os.path.getmtime(thumb) < os.path.getmtime(image):
                if os.system("convert -thumbnail %d %s %s"%(npix,image,thumb)):
                    fails += 1

        html = rv.renderTitle(title) + \
            """<br>
            <table style="border: 0px; text-align: left">\n
            """
        if fails:
            html += "(WARNING: %d thumbnails failed to generate, check console for errors)<br>\n"%fails

        for row in range(nrow):
            html += """<tr style="border: 0px; text-align: left">\n"""
            filelist_row = filelist[row*ncol:(row+1)*ncol]
            for _, thumb, image in filelist_row:
                html += """<td style="border: 0px; text-align: center">"""
                html += os.path.basename(image)
                html += "</td>\n"
            html += """</tr><tr style="border: 0px; text-align: left">\n"""
            for _, thumb, image in filelist_row:
                html += """<td style="border: 0px; text-align: left">"""
                html += "<a href=%s><img src=%s alt='?'></a>"%(image,thumb)
                html += "</td>\n"
            html += "</tr>\n"
        html += "</table>"

        display(HTML(html))
def log_progress(sequence, every=1, size=None, name='Items'):
    from ipywidgets import IntProgress, HTML, VBox
    from IPython.display import display

    is_iterator = False
    if size is None:
        try:
            size = len(sequence)
        except TypeError:
            is_iterator = True
    if size is not None:
        if every is None:
            if size <= 200:
                every = 1
            else:
                every = int(size / 200)     # every 0.5%
    else:
        assert every is not None, 'sequence is iterator, set every'

    if is_iterator:
        progress = IntProgress(min=0, max=1, value=1)
        progress.bar_style = 'info'
    else:
        progress = IntProgress(min=0, max=size, value=0)
    label = HTML()
    box = VBox(children=[label, progress])
    display(box)

    index = 0
    try:
        for index, record in enumerate(sequence, 1):
            if index == 1 or index % every == 0:
                if is_iterator:
                    label.value = '{name}: {index} / ?'.format(
                        name=name,
                        index=index
                    )
                else:
                    progress.value = index
                    label.value = u'{name}: {index} / {size}'.format(
                        name=name,
                        index=index,
                        size=size
                    )
            yield record
    except:
        progress.bar_style = 'danger'
        raise
    else:
        progress.bar_style = 'success'
        progress.value = index
        label.value = "{name}: {index}".format(
            name=name,
            index=str(index or '?')
        )
Esempio n. 36
0
def test_check_renderer_options():
    # this test should pass
    with check_render_options():
        from IPython.display import display
        display(None)

    # check that an error is appropriately raised if the test fails
    with pytest.raises(AssertionError):
        with check_render_options(foo='bar'):
            from IPython.display import display
            display(None)
Esempio n. 37
0
def _init_js_side ():
    """Checks that Javascript components of radiopadre are initialized"""
    try:
        get_ipython
    except:
        return None
    get_ipython().magic("matplotlib inline")
    # load radiopadre/js/init.js and init controls
    initjs = os.path.join(os.path.dirname(__file__),"js","init.js")
    display(Javascript(open(initjs).read()))
    display(Javascript("document.radiopadre.init_controls('%s')"%os.environ['USER']))
Esempio n. 38
0
    def reveal_figure(b):
        global controls

        record_action('predict', b.description)
        controls.close()

        descr = describe_and_show_figure(current_figure)
        descr += '<br/><br/>Actual chart form:'
        controls = widgets.VBox(
            [widgets.HTML(descr),
             widgets.HBox(confirm_buttons)])
        display(controls)
Esempio n. 39
0
def pathfindAndDisplay(x, y, w, h, grid, pathfinder, maxItr=float("inf")):
    ipgrid = IPGrid(w, h, 440 / w)
    ipgrid.renderGrid(grid, x, y, pathfinder=pathfinder)

    result = pathfinder.findPath(maxItr)

    if(result["failed"]):
        print("Failed after " + str(result["iterations"]) + " iterations!")
    else:
        print("Finished after " + str(result["iterations"]) + " iterations:")
        ipgrid.renderGrid(grid, x, y, pathfinder=pathfinder, path=result["pathCoords"])
        
    display(ipgrid)
Esempio n. 40
0
    def update_plot(self, value):
        self.out.clear_output(wait=True)
        omffile = self.find_omf_file()
        field = df.read_oommf_file(omffile)

        slice_index = {"x": 0, "y": 1, "z": 2}[self.select.value]
        point = field.mesh.pmin[
            slice_index] + self.slice_slider.value * field.mesh.l[slice_index]

        field.plot_slice(self.select.value, point, xsize=10)
        with self.out:
            display(plt.gcf())
        plt.close()
Esempio n. 41
0
def plot_log_odds(target, feature, bins, f_range=None, M=10, figsize=(10, 3), display_head=False, normed=True):
    LO, base = get_log_odds(target, feature, bins, f_range=f_range, M=M, display_head=display_head)
    fig, axs = plt.subplots(2, 1, figsize=figsize)
    ax = axs[0]
    feature[target == 1].hist(bins=bins, alpha=0.4, color="red", normed=normed, range=f_range, ax=ax)
    ax = axs[0]
    feature[target == 0].hist(bins=bins, alpha=0.4, color="blue", normed=normed, range=f_range, ax=ax)
    ax.set_xlabel(feature.name)

    ax = axs[1]
    LO.plot(ax=ax)
    ax.set_xlabel("%s_cut" % feature.name)
    ax.set_ylabel(r"$log(P(good) / P(bad))$")
    ax.axhline(base)
    display(LO)
Esempio n. 42
0
def py_oauth_dance():
    
    _twitter=twitter.Twitter(auth=twitter.OAuth('','',CONSUMER_KEY, CONSUMET_SECRET), format='', api_version=None)
    
    oauth_token, oauth_token_secret = parse_oauth_tokens(_twitter.oauth.request_token(oauth_callback=oauth_callback))
    
    # Se nececitan escribir estos valores en un archivo para de ahi recojer la 
    # llamada de Twitter que es manejada del web server en /oauth_helper
    
    write_token_file(OAUTH_FILE,oauth_token, oauth_token_secret)
    
    oauth_url=('http://api.twitter.com/oauth/authorize?oauth_token='+oauth_token)
    
    #Utilizamos el browser para abrir una nueva ventana y asi accesar al web 
    #server y obtener la autorizacion del usuario
    display(JS("windows.open('%s')" % oauth_url))
Esempio n. 43
0
    def _jsDisplay(self):
        # Workaround to have ConvertToJSON work
        json = ROOT.TBufferJSON.ConvertToJSON(self.canvas, 3)
        #print "JSON:",json

        # Here we could optimise the string manipulation
        divId = 'root_plot_' + str(self._getUID())
        thisJsCode = _jsCode.format(jsCanvasWidth = _jsCanvasWidth,
                                    jsCanvasHeight = _jsCanvasHeight,
                                    jsROOTSourceDir = _jsROOTSourceDir,
                                    jsonContent=json.Data(),
                                    jsDrawOptions="",
                                    jsDivId = divId)

        # display is the key point of this hook
        display(HTML(thisJsCode))
Esempio n. 44
0
 def _show_thumbs(fits_files,
                  width=None,
                  ncol=None,
                  maxwidth=None,
                  mincol=None,
                  maxcol=None,
                  title=None,
                  fs='small',
                  **kw):
     if not fits_files:
         return None
     if title:
       display(HTML(rv.renderTitle(title)))
     nrow, ncol, width = rv.File.compute_thumb_geometry(len(fits_files), ncol, mincol, maxcol, width, maxwidth)
     fig = plt.figure(figsize=(width * ncol, width * nrow), dpi=rv.DPI)
     for iplot, ff in enumerate(fits_files):
         ax = plt.subplot(nrow, ncol, iplot + 1)
         ax.tick_params(labelsize=kw.get('fs_axis',fs))
         ff.show(index=[0] * 10,
                 unroll=None,
                 filename_in_title=True,
                 make_figure=False,
                 fs_title='small', **kw)
Esempio n. 45
0
 def thumbs(self, **kw):
     display(HTML(render_refresh_button(full=self._parent and self._parent.is_updated())))
     if not self:
         display(HTML("<p>0 files</p>"))
         return None
     kw.setdefault('title', self._title + " (%d file%s)" % (len(self), "s" if len(self) > 1 else ""))
     kw.setdefault('showpath', self._showpath)
     thumbs = getattr(self._classobj, "_show_thumbs", None)
     if thumbs:
         return thumbs(self, **kw) 
     display(HTML("<p>%d files. Don't know how to make thumbnails for this collection.</p>" % len(self)))
Esempio n. 46
0
def display_full(df):
    """
    truncation view로 들어가지 않고, df를 모두 출력한다.
    """
    with pd.option_context("display.max_rows", len(df)), pd.option_context("display.max_columns", len(df.columns)):
        display(df)
Esempio n. 47
0
from IPython import display

t_minus = range(10,0,-1)

def lazy_iterator(name):
    seq = eval(name)
    it = iter(seq)
    while True:
        try:
            yield it.next()
        # this looks silly locally, but it will be useful for the remote version:
        except StopIteration:
            raise StopIteration

lzit = lazy_iterator('t_minus')
display(lzit)
list(lzit)
Esempio n. 48
0
 def subdirectory_catalog (self, basename="results", dirs="dirs", root="root", **kw):
     return display(HTML(self._repr_html_(copy_filename=basename,copy_dirs=dirs,copy_root=root,**kw)))
Esempio n. 49
0
 def list(self, **kw):
     return display(HTML(self._repr_html_(**kw)))
Esempio n. 50
0
 def show_all(self,*args,**kw):
     display(HTML(render_refresh_button(full=self._parent and self._parent.is_updated())))
     if not self:
         display(HTML("<p>0 files</p>"))
     for f in self:
         f.show(*args,**kw)
def PowerTraces(A,order):       
    IX=eye(A.shape[0])
    delta=series(trace((IX-t*A).inv()),t,0,order)
    for i in range(order):
       display(delta.coeff(t,i))
Esempio n. 52
0
def load_ipython_extension(ipython):
	"""
	Load the %eups extension. IPython extension API entry point.
	"""

	# Sanity checks. Do as many of these as necessary, to make sure we catch issues
	# early on that may cause difficult-to-debug misbehaviors later.
	#
	# Refuse to proceed if there's no pointer to the linkfarm in the environment,
	# or the linkfarm doesn't exist, or the linkfarm dir isn't in LD_LIBRARY_PATH.
	# The most likely cause of this is not having started ipython via the
	# supplied 'ipython' wrapper script, or some bug in the wrapper itself.
	if 'IPYTHON_EUPS_LIB_LINKFARM' not in os.environ:
		raise Exception(textwrap.dedent("""\
			It looks like IPython hasn't been started using the 'ipython' wrapper
			script supplied by ipython_eups. Maybe you forgot to add it to your path?
			
			Guru Meditation: IPYTHON_EUPS_LIB_LINKFARM environmental variable has not
			been set. The aforementioned wrapper script sets this variable before
			calling IPython.
		""").replace('\n', ' ').replace('  ', '\n\n'))

	linkfarm = os.environ['IPYTHON_EUPS_LIB_LINKFARM']
	if not os.path.isdir(linkfarm):
		raise Exception(textwrap.dedent("""\
			Something is amiss with how ipython_eups has been started; directories
			that are needed for %eups to work don't exist. Try restarting IPython
			and see if the problem clears up.
			
			Guru Meditation: The directory that IPYTHON_EUPS_LIB_LINKFARM
			environmental variable points to -- %(linkfarm)s -- does not exist. This
			directory is supposed to be created by the 'ipython' wrapper script.
		""" % { 'linkfarm': linkfarm } ).replace('\n', ' ').replace('  ', '\n\n'))

	if LD_LIBRARY_PATH not in os.environ:
		raise Exception(textwrap.dedent("""\
			Something is amiss with ipython_eups. Try restarting IPython and see if
			the problem clears up.
			
			Guru Meditation: The %(lddir)s environment variable has not been set.
			This variable was supposed to be created by the 'ipython' wrapper script.
			You may have uncovered a bug in the wrapper script.
		""" % { 'lddir': LD_LIBRARY_PATH } ).replace('\n', ' ').replace('  ', '\n\n'))

	liblinkfarm = os.path.join(linkfarm, 'lib')
	if liblinkfarm not in os.environ[LD_LIBRARY_PATH].split(':'):
		print os.environ[LD_LIBRARY_PATH].split(':')
		raise Exception(textwrap.dedent("""\
			Something is amiss with ipython_eups. Try restarting IPython and see if
			the problem clears up.
			
			Guru Meditation: The "library linkfarm" directory exists [== %(linkfarm)s], but
			isn't on %(lddir)s [== %(ldpath)s]. It was supposed to be added to it by
			the 'ipython' wrapper script. This may be a bug in the wrapper script.
		""" % { 'lddir': LD_LIBRARY_PATH, 'linkfarm' : liblinkfarm, 'ldpath' : os.environ[LD_LIBRARY_PATH] } 
		    ).replace('\n', ' ').replace('  ', '\n\n'))


	# Re-initialize the link farm every time IPython is started, so that the environment
	# is properly cleaned of any left-overs from prior runs. E.g., this may happen
	# when IPython notebook kernel is restarted by the user.
	rebuild_ld_library_path_linkfarm(os.environ[LD_LIBRARY_PATH])

	#print "-----------------------------------------------------------------------"
	#print "Note to readers: if you don't have ipython_eups installed, get it from"
	#print "     http://github.com/mjuric/ipython_eups to enable eups_magic."
	#print "-----------------------------------------------------------------------"

	# Register %eups magic
	ipython.register_magic_function(eups)

	display("``%eups`` magics loaded. Documentation and source at http://github.com/mjuric/ipython_eups.")

	# Check if EUPS has been setup, if not, try to set it up
	# from the default environment.
	if 'EUPS_DIR' not in os.environ:
		if os.path.isdir(EUPS_DIR_DEFAULT):
			init_eups()
		else:
			warn(("EUPS not initialized, and no default EUPS has been symlinked as %s. " +
			      "Make sure to initialize it with `%%eups init <path_to_eups>'") % EUPS_DIR_DEFAULT)
Esempio n. 53
0
def eups(line):
	"""\
	Setup and unsetup EUPS products from within IPython

	Common usage:

	    # Set up a product
	    %eups setup <product>

	    # Unsetup a product
	    %eups unsetup <product>

	If no EUPS has been setup (i.e., you didn't source setups.sh before
	starting IPython), the default EUPS will be set up once this
	extension is loaded with %load_ext. You can also set it up manually
	with %eups init (see below).

	More examples:

	    # Initialize EUPS
	    %eups init [[--set-default] path_to_eups [EUPS_PATH]]

	    # Version of ipython_eups script
	    %eups version

	    # EUPS subcommands are passed on to EUPS
	    %eups list
	    %eups --version

	More documentation on http://github.com/mjuric/ipython_eups.
	"""

	split = line.split()
	cmd, args = split[0], split[1:]

	if cmd == "unsetup":
		cmd = "setup"
		args.insert(0, '--unsetup')
		unsetup = True
	else:
		unsetup = False

	if cmd == "init":
		# find the '--set-default' flag
		set_default = '--set-default' in args
		if set_default:
			args.remove('--set-default')
		return init_eups(*args, set_default=set_default)
	elif cmd == "setup":
		# run 'setup'
		args2 = [ arg for arg in args if not arg.startswith('-') ]
		product = args2[0] if args2 else None

		# If this is an unsetup call, remember the version for printing at the end
		if unsetup:
			version = _get_setuped_product_version(product)

		setupimpl = os.path.join(os.environ['EUPS_DIR'], 'bin/eups_setup_impl.py')
		setupcmd = "python '%s' %s" % (setupimpl, ' '.join(args))

		try:
			ret = subprocess.check_output(setupcmd, stderr=subprocess.STDOUT, shell=True).strip()
		except subprocess.CalledProcessError as e:
			error("%s\n%s" % (str(e), e.output))
		else:
			if product is None:
				# If the user ran something like 'setup -h', just print out the result
				print ret
			else:
				ret = ret.split('\n')
				if not len(ret) or ret[-1] == 'false':
					# setup failed; return the error message
					error(str('\n'.join(ret[:-1])))
				else:
					exportRe = re.compile('export\s+(\w+)=(.*?);?$')
					unsetRe  = re.compile('unset\s+(\w+);?$')
					export = collections.OrderedDict()
					unset  = set()
					for line in ret[:-1]:
						m = exportRe.match(line)
						if m:
							export[m.group(1)] = m.group(2)
							continue

						m = unsetRe.match(line)
						if m:
							unset.add(m.group(1))
							continue
				
						error("EUPS told me to '%s' but I don't know how to handle that. Aborting." % (line))

					# do the variable (un)setups. We do this only after
					# the entire output is processed above, to avoid
					# aborting half-way in case of errors (and leaving
					# the environment in an incoherent state).

					for var, value in export.iteritems():
						value = subprocess.check_output('/bin/echo -n %s' % value, shell=True)
						if var == "PYTHONPATH":
							update_sys_path(value, os.environ[var])
						if var == LD_LIBRARY_PATH:
							rebuild_ld_library_path_linkfarm(value)
						os.environ[var] = value
						#print "set: %s=[%s]" % (var, os.environ[var])
					for var in unset:
						#print "unset: " + var
						del os.environ[var]

				if not unsetup:
					version = _get_setuped_product_version(product)

				# print out some useful info about what we've just setup-ed
				msg = "**``%%eups %s:``** `%s`, version `%s`" % ('setup' if not unsetup else 'unsetup', product, version)
				display(msg)
	elif cmd == "version":
		msg = "**``%%eups version:``** `%s`" % (__version__)
		display(msg)
	else:
		setupcmd = "eups %s %s" % (cmd, ' '.join(args))
		
		IPython.utils.process.system(setupcmd)
Esempio n. 54
0
def init_eups(eups_loc='default', eups_path=None, set_default=False):
	"""
		If the user forgot to run setups.sh, initialize EUPS
		from scratch. Do it by running setups.sh and replacing our
		current environment with the environment it will generate.
		
		Arguments:
		
		   eups_loc:    directory where EUPS is installed (where 
		                bin/setups.sh will be found). If not
		                given, a default from ~/.eups/default
		                will be assumed

		   eups_path:   The location of the EUPS product stack 
		                (EUPS_PATH environment variable). Optional.
		
		   set_default: If set, eups_loc will be symlinked to
		   		~/.eups/default.
	"""

	# Locate EUPS
	if eups_loc == 'default':
		if not os.path.isdir(EUPS_DIR_DEFAULT):
			error(textwrap.dedent("""\
				You're trying to initialize EUPS without specifying its location,
				and the default in %(default)s does not exist (or is inaccessible).
				
				Either rerun the command as '%%eups init <eups_location>', or symlink
				the path to EUPS (the location where 'bin/setups.sh' can be found)
				as %(default)s .
			""" % { 'default': EUPS_DIR_DEFAULT } ).replace('\n', ' ').replace('  ', '\n\n'))
			return
		else:
			eups_loc = EUPS_DIR_DEFAULT

	# Verify that EUPS exists
	setups_sh = os.path.join(eups_loc, 'bin', 'setups.sh')
	if not os.path.isfile(setups_sh):
		error(textwrap.dedent("""\
			Cannot find %s.
			
			Are you sure that EUPS has been installed in %s?
		""" % (setups_sh, eups_loc) ).replace('\n', ' ').replace('  ', '\n\n'))
		return

	try:
		# Load the environment
		cmd = r"""
source %(setups_sh)s >/dev/null
%(python)s -c '
import os, sys;
for k, v in os.environ.iteritems():
    sys.stdout.write("%%s\0%%s\0" %% (k, v))
'""" % { 'python' : sys.executable, 'setups_sh' : setups_sh }

		envl = subprocess.check_output(cmd, shell=True).split('\0')
		env = { k: v for k, v in zip(envl[::2], envl[1::2]) }

		os.environ.clear()
		os.environ.update(dict=env)

		# Override EUPS_PATH, if requested
		if eups_path is not None:
			os.environ['EUPS_PATH'] = eups_path
	finally:
		# Why do this in a finally clause?
		# a) we want to print out the messages about eups_loc and
		#    the message about EUPS_PATH in the same Markdown block,
		#    so they look nice on the screen.
		# b) but we also want the message about eups_loc to be printed
		#    no matter what, so the user is given information about where
		#    eups is being loaded from in case anything went wrong.
		msg = "**``%%eups init:``** loading EUPS from `%s`." % eups_loc
		if 'EUPS_PATH' in os.environ:
			msg += "  \n**``%%eups init:``** using `EUPS_PATH=%s`." % os.environ['EUPS_PATH']
		display(msg)

	if eups_loc != EUPS_DIR_DEFAULT:
		if set_default:
			if os.path.islink(EUPS_DIR_DEFAULT):
				os.unlink(EUPS_DIR_DEFAULT)

			msg="**``%%eups init:``** symlinking `%s` -> `%s`" % (EUPS_DIR_DEFAULT, eups_loc)
			display(msg)

			os.symlink(eups_loc, EUPS_DIR_DEFAULT)
		elif not os.path.islink(EUPS_DIR_DEFAULT):
			display("**``%%eups init:``** To make this default, rerun with ``%%eups init --set-default %s``" % eups_loc)
Esempio n. 55
0
 def show(self, width=None, **kw):
     display(Image(self.fullpath, width=width and width * 100))
Esempio n. 56
0
def unprotect ():
    """Makes current notebook unprotected."""
    display(Javascript("document.radiopadre.unprotect()"))
    display(HTML(render_status_message("""This notebook is now unprotected.
        All users can treat it as read-write.""")))
Esempio n. 57
0
 def show(self):
     display(self._widget)     
Esempio n. 58
0
 def _pngDisplay(self):
     ofile = tempfile.NamedTemporaryFile(suffix=".png")
     with _setIgnoreLevel(ROOT.kError):
         self.canvas.SaveAs(ofile.name)
     img = IPython.display.Image(filename=ofile.name, format='png', embed=True)
     display(img)
Esempio n. 59
0
 def sympy_latex(self, line):
     from sympy import latex
     from IPython.display import Latex, display
     ip = get_ipython()
     latex = Latex("$${}$$".format(latex(ip.ev(line))))
     display(latex)
def SymmTraces(A,order):

    IX=eye(A.shape[0])
    delta=series(((IX-t*A).det())**(-1),t,0,order)
    for i in range(order):
        display(delta.coeff(t,i))