When using autocomplete in Jupyter Notebooks it is super nice that you can use autocomplete out of the box, but the autocomplete makes too many suggestions that are not relevant. E.g. when autocompleting inside a function, then I only want relevant parameters to be autocompleted, not 60 random python values.
People have suggested using %config Completer.use_jedi = True, but that turns everything off and is even worse.
You can try installing nbextension for suggestions in jupyter notebook.
for more info plz Click here
Is there a way to import rotated text from a PDF table such as with tabula-py in python?
I realize I can just rename the column headers in this case, but I was wondering if there is a way to set a parameter for importing rotated text. I don't see any mention of rotation in the readthedocs for tabula-py and haven't found other packages that would do this yet either (although I did see a mention of rotating an entire page- which doesn't fit this use case exactly as renaming the columns would be easier).
Example:
import tabula
list_df = tabula.read_pdf(
'https://sos.oregon.gov/elections/Documents/statistics/G22-Daily-Ballot-Returns.pdf',
pages=3
)
list_df[0]
I just tried using camelot and it correctly reads the rotated text in the columns header: this is the result.
As #Francesco mentioned, there is a particular way in which camelot is a better than tabula-py, since camelot finds the rotated text.
It was a difficult process to install camelot, so I thought to share some of my learnings here.
Dependency for camelot: ghostwriter
https://camelot-py.readthedocs.io/en/master/user/install-deps.html
For a mac brew install ghostscript tcl-tk and then troubleshoot any errors (many errors for me, but after copy-pasting each error, there was gold at the end of the rainbow).
Overview of camelot install https://camelot-py.readthedocs.io/en/master/user/install.html
On a mac:
pip install "camelot-py[cv]"
The documentation page currently actually says [base] rather than [cv], but above in the comments it says [cv] (and stack overflow articles say [cv]).
In python (if you are using jupyter notebook, restart the notebook kernel)
With the following, the rotated column headers are read in just fine.
import camelot
tables = camelot.read_pdf(
'https://sos.oregon.gov/elections/Documents/statistics/G22-Daily-Ballot-Returns.pdf',
pages='all')
tables[3].df
I am using jupyter notebook on my PC. As the length of my codes is increasing, I want to hide and display some sections of the python code based on the heading markings in Jupyter Notebook like the google colab does.
Is there any python package to install in the environment specifically for this functionality? Similar to the screenshots below.
Hidden Codes based on the headings
[1]: https://i.stack.imgur.com/kQSMG.png
Expanded Python Codes
[2]: https://i.stack.imgur.com/20HNw.png
I'm currently running a default/basic notebook on EMR (Release label: emr-6.1.0, Applications: Spark 3.0.0, Zeppelin 0.9.0, JupyterHub 1.1.0) and i'm having some issues getting the notebook to output a data profiling report in HTML.
I've installed pandas-profiling a variety of ways, using custom bootstrap actions & with the command sc.install_pypi_package("pandas-profiling")
I run into the following issue after trying to generate the report's HTML using IPython. It only produces the object vs the HTML.
I'm also aware that adding %%local can help produce it, like below.
But installing through bootstrap actions/on the notebook does not install from wherever %%local is located. As seen below.
So my first question is, can this profile report be produced without the %%local magic? I know there is also an %%html magic command, but that cannot print out a variable based on my testing, hence why I need IPython.
Second question is, how can pandas-profiling be added to this %%local environment? Should this even be the approach?
Thanks!!
I am using ipython Jupyter notebook. Let's say I defined a function that occupies a lot of space on my screen. Is there a way to collapse the cell?
I want the function to remain executed and callable, yet I want to hide / collapse the cell in order to better visualize the notebook. How can I do this?
UPDATE:
The newer jupyter-lab is a more modern and feature-rich interface which supports cell folding by default. See #intsco's answer below
UPDATE 2
Since jupyter-lab now also supports extensions, you can extend the built-in cell-folding functionality with the Collapsible_Headings extension.
Original answer:
The jupyter contrib nbextensions Python package contains a code-folding extension that can be enabled within the notebook. Follow the link (Github) for documentation.
To install using command line:
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
To make life easier in managing them, I'd also recommend the jupyter nbextensions configurator package. This provides an extra tab in your Notebook interface from where you can easily (de)activate all installed extensions.
Installation:
pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user
JupyterLab supports cell collapsing. Clicking on the blue cell bar on the left will fold the cell.
You can create a cell and put the following code in it:
%%html
<style>
div.input {
display:none;
}
</style>
Running this cell will hide all input cells. To show them back, you can use the menu to clear all outputs.
Otherwise you can try notebook extensions like below:
https://github.com/ipython-contrib/IPython-notebook-extensions/wiki/Home_3x
I had a similar issue and the "nbextensions" pointed out by #Energya worked very well and effortlessly. The install instructions are straight forward (I tried with anaconda on Windows) for the notebook extensions and for their configurator.
That said, I would like to add that the following extensions should be of interest.
Hide Input |
This extension allows hiding of an individual codecell in a notebook. This can be achieved by clicking on the toolbar button:
Collapsible Headings | Allows notebook to have collapsible sections, separated by headings
Codefolding | This has been mentioned but I add it for completeness
There are many answers to this question, all of which I feel are not satisfactory (some more than others), of the many extensions - code folding, folding by headings etc etc. None do what I want in simple and effective way. I am literally amazed that a solution has not been implemented (as it has for Jupyter Lab).
In fact, I was so dissatisfied that I have developed a very simple notebook extension that can expand/collapse the code in a notebook cell, while keeping it executable.
The GitHub repository: https://github.com/BenedictWilkinsAI/cellfolding
Below is a small demo of what the extension does:
Simply double clicking left of the code cell will collapse it to a single line:
Double clicking again will expand the cell.
The extension can be installed easily with pip:
pip install nbextension-cellfolding
jupyter nbextension install --py cellfolding --user
jupyter nbextension enable --py cellfolding --user
and is also compatible with nbextension configurator. I hope that people will find this useful!
Create custom.js file inside ~/.jupyter/custom/ with following contents:
$("<style type='text/css'> .cell.code_cell.collapse { max-height:30px; overflow:hidden;} </style>").appendTo("head");
$('.prompt.input_prompt').on('click', function(event) {
console.log("CLICKED", arguments)
var c = $(event.target.closest('.cell.code_cell'))
if(c.hasClass('collapse')) {
c.removeClass('collapse');
} else {
c.addClass('collapse');
}
});
After saving, restart the server and refresh the notebook. You can collapse any cell by clicking on the input label (In[]).
The hide_code extension allows you to hide individual cells, and/or the prompts next to them. Install as
pip3 install hide_code
Visit https://github.com/kirbs-/hide_code/ for more info about this extension.
Firstly, follow Energya's instruction:
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user
Second is the key: After opening jupiter notebook, click the Nbextension tab. Now Search "colla" from the searching tool provided by Nbextension(not by the web browser), then you will find something called "Collapsible Headings"
This is what you want!
As others have mentioned, you can do this via nbextensions. I wanted to give the brief explanation of what I did, which was quick and easy:
To enable collabsible headings:
In your terminal, enable/install Jupyter Notebook Extensions by first entering:
pip install jupyter_contrib_nbextensions
Then, enter:
jupyter contrib nbextension install
Re-open Jupyter Notebook. Go to "Edit" tab, and select "nbextensions config".
Un-check box directly under title "Configurable nbextensions", then select "collapsible headings".
There's also an improved version of Pan Yan suggestion. It adds the button that shows code cells back:
%%html
<style id=hide>div.input{display:none;}</style>
<button type="button"
onclick="var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);">
Show inputs</button>
Or python:
# Run me to hide code cells
from IPython.core.display import display, HTML
display(HTML(r"""<style id=hide>div.input{display:none;}</style><button type="button"onclick="var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);">Show inputs</button>"""))
You don't need to do much except to enable the extensions:
http://localhost:8888/nbextensions?nbextension=collapsible_headings
http://localhost:8888/nbextensions?nbextension=codefolding/main
Most probable you will find all your extensions in here:
http://localhost:8888/nbextensions
What I use to get the desired outcome is:
Save the below code block in a file named toggle_cell.py in the same directory as of your notebook
from IPython.core.display import display, HTML
toggle_code_str = '''
<form action="javascript:code_toggle()"><input type="submit" id="toggleButton" value="Show Sloution"></form>
'''
toggle_code_prepare_str = '''
<script>
function code_toggle() {
if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){
$('div.cell.code_cell.rendered.selected div.input').hide();
} else {
$('div.cell.code_cell.rendered.selected div.input').show();
}
}
</script>
'''
display(HTML(toggle_code_prepare_str + toggle_code_str))
def hide_sloution():
display(HTML(toggle_code_str))
Add the following in the first cell of your notebook
from toggle_cell import toggle_code as hide_sloution
Any cell you need to add the toggle button to simply call hide_sloution()
I had the same problem, I found this extension useful
pip install aquirdturtle_collapsible_headings