Conda is known as a package manager for Python and R packages produced by Anaconda, Inc. and conda-forge, the open-source community for conda Python packages. In addition to managing packages, Conda is also an environment…
The post Moving Conda Environments appeared first on Anaconda.
Last week, I worked on several steps to finalize my project.
Some work was put into correcting and improving my pull requests, so they can be merged soon. I created an example file to demonstrate the useability of this project, and opened up a new pull request for it (next to another PR, that introduces the plotting support I implemented the previous week).
As mentioned in my last blog post, I also thought about an alternative solution, i.e. to create a genuine plotting function for SourceTFR. But as I already suspected, this will not work without a lot of additional work. I originally intended to introduce a new type of plot derived from MNE's "TimeViewer", where you can not only skim along the time axis through the plotting GUI, but also along the frequency (and maybe the epochs) axis. After trying out some stuff, my best intuition to reaching this goal would be to simplify the "TimeViewer" class, and make it some kind of a "AxisViewer" class. This class would allow a developer to decide which axis (or even multiple axes) should be manipulable through the GUI. Yet, this would be only a part of the work, as this does not include the actual plotting function used by SourceTFR, and also would only work for the plots made on surface type source level data (since volume type source level data employs an entirely different plotting GUI). In my opinion, this functionality should rather be added later, so I can now concentrate on the finishing touches of the rest of the project.
One such finishing touch is for example time and memory saving computation of tfr_stockwell, which is for now only available for tfr_morlet and tfr_multitaper. I already made attempts to tackle this problem, and currently try to make it pass the equivalence tests. But this will definitely be one of the things to do this week, as it will have big implications on the practical useability of the function.
Another thing I worked on last week (and will continue to work on this week) was the project page where I'll upload my final results next week. I decided to create a GitHub gist for this purpose, since it is simple and good looking at the same time. Most of the gist is already finished, only the links to the PRs and some direct examples will need to be added there. So I hope, everything will work out this week, and I'll be able to show you a nice conclusion on my Google Summer of Code project until next week.
So, for the last time (this summer?!): Stay tuned!
PyPI is a core component of the Python ecosystem that most developer’s have interacted with as either a producer or a consumer. But have you ever thought deeply about how it is implemented, who designs those interactions, and how it is secured? In this episode Nicole Harris and William Woodruff discuss their recent work to add new security capabilities and improve the overall accessibility and user experience. It is a worthwhile exercise to consider how much effort goes into making sure that we don’t have to think much about this piece of infrastructure that we all rely on.
The intro and outro music is from Requiem for a Fish The Freak Fandango Orchestra / CC BY-SA
Hello folks,
Hey! welcome back.
As I mentioned in my previous blog, internet services were paused here in J&K, India. And internet is not back yet. But somehow I have internet access, and its a long story(see previous blog).
Lets come to main point. I was working on the cheatsheet and was fixing some landing page bugs when internet stopped working here. After that I somehow managed to finish those changes.
Then a week ago I started working on the documentation page. I finished the working prototype of that a few days ago and right now mentors are reviewing that.
In the meanwhile I am trying to implement the documentation section. Originally I had to use opensource CMS, Strapi which will manage all our content and documentation page was to made separate from rest of the website and has to be generated through API. But since time is less mentors decided to leave that for later. So, right now I am creating that page within the main repo and after that when it is complete, I will start working on Strapi and then separate this documentation section from the main menu.
The final week of Google Summer of Code is almost here. Time to make some final adjustmens and wrap up the project.
Intergation into MNE's API.
This week, I focused mostly on bug fixes and improving my PyPI-pytest automation script while also working on adding more standalone tests.
I created a pull request https://github.com/Nuitka/Nuitka/pull/483 to add support for py_modules compilation support in Nuitka. The pull request turned out very well, adding support for not only py_modules compilation but also the combination of package and module. In addition, a new distutil example was also added to showcase the compilation of package and module
In the process of the above pull request, I discovered a regression in Nuitka and https://github.com/Nuitka/Nuitka/pull/487 was created as a hotfix.
In addition, Issue https://github.com/Nuitka/Nuitka/issues/479 is fixed by #483 and is now closed
I continued to improve my PyPI-pytest automated testing script, including functional improvements, minor speed improvements, readability, and documentation improvements. My work could be found at https://github.com/Nuitka/Nuitka/pull/495.
More standalone tests were also added to my pull request at https://github.com/Nuitka/Nuitka/pull/484. This is a side goal and is less important
I am very proud of the work I have done this week. The goal for this final week is to finish up pull request #495, and I plan on finishing #484 after GSoC ends. I also discussed with my mentor and plan on working for Nuitka long term, even after GSoC :).
Hi everyone!
"""
The truth was that it was an incredible experience I recommend it
Anyone who likes challenges in new technologies,
development and especially python.
Work under the supervision of titans such as PSF and Google
It gives an interesting boost.
Thank you for supporting the development of the potential of
people.
As for work, the second stage was complicated enough for me
I was running out of time and my lack of knowledge complicated
even more, set aside the web service testing by the client test of pyafipws that for now is more important for the project.
I will continue working on my knowledge,
A lot of ink remains in the inkwell.
I want to thank my mentors for the support,
to this beautiful community that is PyAr,
to all the participants of Gsoc-2019 I hope you had a great experience,
to sounak98 you did a great job on the blog,
to the botanic for being aware of us,
and of course,
to the administrators :!: team-psf / \ team-gsoc :!: for having followed up and marked the development, which was very important for our performance.
To improve my knowledge I could not have had more luck working with the pyafipws project, seeing the code you can see the great handling of the python language, it runs through it and being complex at the same time, with which you can learn a lot about the management of it and its tools, my congratulations to Mariano Reingart the author / maintainer of this opensource project.
I don't want to leave the opportunity to mention an excellent book,
which is so far the best one I read and which has become author In my referent, very complete, extraordinary handling of the writing and explanation connecting all topics, using experiences and problems of my own in work done and the star is 'dive in to Python3' its author Mark Pilgrim, to whom I give my thanks.
and to the translator of his Spanish version Jose Miguel Gonzalez Aguilera.
PS: that you have read it does not mean that you have learned :)
Well, I leave you. I have to finish the tests!
"""
Regards and Good Life!
The main feature I've been working on this week has been adding pre-planned transforms to pypocketfft in (pypocketfft!28). This will allow users to speed-up cases where many transforms of the same shape are done, without needing to rely on any internal caches. This gives the users a small performance improvement in pypocketfft but adding this to the scipy.fft interface will also allow other backends to benefit. e.g. pyFFTW can have a significantly more expensive planning phase.
Plans have now been added into the c++ interface of pypocketfft but I have still got to expose these in the python interface. Additionally, I've made a number of other contributions in several other places:
The coding period has officially ended and it's now time to "submit the code". Most of my code has already been merged into the SciPy master branch so this will just involve writing a summary of my work over the whole GSoC project.
I would also like to finish up the pre-planned transform code but it's likely too late to get this merged in time for the evaluation.
Fixing the race condition in pypocketfft was quite challenging. The only symptom was a SEGFAULT that occurred only rarely and only on macOS, a platform which I don't use and so couldn't reproduce the issue locally. This made diagnosing and solving the issue very tricky. Thankfully, Martin (pypocketfft's author) had access to apple hardware and was eventually able to give me enough details that I found an issue from another project that had run into almost exactly the same issue.
These two weeks, I've been working on fixing bug #1. I think my algorithm will work in general, but right now the get_cves function doesn't work as I expected, which would cause some problem with data format in futher. Previously, the function will run the query that selects all the version of a product_vendor pair, and then save the result in memory, and using Python code to check whether the version we want is in it. This is actually inefficient and memory-consuming. Therefore, I refactored the code for conducting the query. Right now, the query will only select the version we want and return it to memory. The time for running the whole test cases reduced from 83 seconds to 61 second. So right now, I will try to implement the dynamic programming method and see if the time complexity is not too high.
Last week, me and my mentor started testing mscolab. At first, I exposed my port through ngrok. But the network I/O were extremely slow. I couldn't demonstrate all of mscolab's features. Then we setup an AWS instance with mscolab server deployed. We could test and improve on many of its features. Some things I worked on this week:
There are very few development tasks remaining. Since this is the last week of GSoC, I'd be working on documenting the code I've written, externally. That would take most of my time this week.
Yes, I got stuck in a bad place for some-time this week. While setting up Postgres, I had to manually autoincrement sequence to assign 'id' to tables, if I explicitly insert rows. I have documented the issue and solution in this blogpost if you're interested in learning more about it.
Adafruit enables beginners to make amazing hardware/software projects.
With CircuitPython, these projects can now use Python.
The combination of Python's ease of use and Adafruit's super cool hardware and a focus on a successful beginner experience makes learning to write code that controls hardware super fun.
In this episode, Scott Shawcroft, the project lead, talks about the past, present, and future of CircuitPython, and discusses the focus on the beginner.
We also discuss contributing to the project, testing CircuitPython, and many of the cool projects and hardware boards that can use CircuitPython, and Blinka, a library to allow you to use "CircuitPython APIs for non-CircuitPython versions of Python such as CPython on Linux and MicroPython," including Raspberry Pi.
Special Guest: Scott Shawcroft.
Sponsored By:
Links:
<p>Adafruit enables beginners to make amazing hardware/software projects.<br> With CircuitPython, these projects can now use Python.</p> <p>The combination of Python's ease of use and Adafruit's super cool hardware and a focus on a successful beginner experience makes learning to write code that controls hardware super fun.</p> <p>In this episode, Scott Shawcroft, the project lead, talks about the past, present, and future of CircuitPython, and discusses the focus on the beginner.</p> <p>We also discuss contributing to the project, testing CircuitPython, and many of the cool projects and hardware boards that can use CircuitPython, and Blinka, a library to allow you to use "CircuitPython APIs for non-CircuitPython versions of Python such as CPython on Linux and MicroPython," including Raspberry Pi.</p><p>Special Guest: Scott Shawcroft.</p><p>Sponsored By:</p><ul><li><a href="https://www.patreon.com/testpodcast" rel="nofollow">Patreon Supporters</a>: <a href="https://www.patreon.com/testpodcast" rel="nofollow">Help support the show with as little as $1 per month and be the first to know when new episodes come out.</a></li></ul><p>Links:</p><ul><li><a href="https://circuitpython.org/" title="CircuitPython" rel="nofollow">CircuitPython</a></li><li><a href="https://circuitpython.org/downloads" title="Downloads" rel="nofollow">Downloads</a> — All the products that run CircuitPython</li><li><a href="https://learn.adafruit.com/category/circuitpython" title="Learning Guides with CircuitPython" rel="nofollow">Learning Guides with CircuitPython</a></li><li><a href="https://learn.adafruit.com/adafruit-circuit-playground-express/circuitpython-quickstart" title="Loading CircuitPython on Circuit Playground Express" rel="nofollow">Loading CircuitPython on Circuit Playground Express</a></li><li><a href="https://adafru.it/discord" title="Adafruit Discord Server" rel="nofollow">Adafruit Discord Server</a></li><li><a href="https://twitter.com/tannewt" title="Scott Shawcroft (@tannewt) / Twitter" rel="nofollow">Scott Shawcroft (@tannewt) / Twitter</a></li><li><a href="https://pypi.org/project/Adafruit-Blinka/" title="Adafruit-Blinka " rel="nofollow">Adafruit-Blinka </a></li></ul>Companies that are data science literate make and communicate decisions on the basis of real data models, and not merely instinct or tradition. They welcome new data science technologies as opportunities for potential innovation, rather…
The post Enterprises Need to Think Differently about Data Science. Here’s How. appeared first on Anaconda.
In this course, you’ll be equipped to make production-quality, presentation-ready Python histogram plots with a range of choices and features.
If you have introductory to intermediate knowledge in Python and statistics, then you can use this article as a one-stop shop for building and plotting histograms in Python using libraries from its scientific stack, including NumPy, Matplotlib, Pandas, and Seaborn.
A histogram is a great tool for quickly assessing a probability distribution that is intuitively understood by almost any audience. Python offers a handful of different options for building and plotting histograms. Most people know a histogram by its graphical representation, which is similar to a bar graph:
This course will guide you through creating plots like the one above as well as more complex ones. Here’s what you’ll cover:
Free Bonus: Short on time? Click here to get access to a free two-page Python histograms cheat sheet that summarizes the techniques explained in this tutorial.
[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]
#382 – AUGUST 20, 2019
View in Browser »
This guide will walk you through the decisions you need to make when customizing your development environment for working with Python: shells, terminal emulators, version management (pyenv), virtual environments & pipenv, package management, and more.
REAL PYTHON
Instagram’s back-end is a massive Django app with several million lines of code. This post is about how they’ve used linting and automated refactoring to help manage the scale of their Python codebase.
BENJAMIN WOODRUFF (INSTAGRAM)
Take the hassle out of code reviews - Codacy flags errors so you can fix them quickly. Address security concerns, duplication, complexity, drops in coverage, and style violations before you merge. Integrates seamlessly with GitHub, Bitbucket, and GitLab →
CODACYsponsor
In this article you’ll learn how to write custom profilers, and in particular profilers that will help you pinpoint the places in your code where it just sits there waiting.
ITAMAR TURNER-TRAURING
Django, Flask, Pyramid, and many, many others—get an overview of what’s available so you can choose the right Python framework for your web development project.
STXNEXT.COM
How to use Python and Sanic to handle webhook events from GitHub in continuous build systems.
CHRISTIAN MEDINA• Shared by Cristian Medina
PyCon 2020 takes place April 15–23, 2020 in Pittsburgh, PA.
PYCON.ORG
Learn how to do simplify your data preprocessing work using the Pyjanitor package. More specifically, you’ll learn how to: Add a column to a Pandas dataframe, remove missing values, remove an empty column, and clean up column names.
ERIK MARSJA
Get equipped to make production-quality, presentation-ready Python histogram plots with a range of choices and features. It’s your one-stop shop for constructing and manipulating histograms with Python’s scientific stack.
REAL PYTHONvideo
Slack Python SDK v2 is now available to help you build Slack apps faster with less complexity. Built for Python 3, you can now use new features (like type hints and return types) to help you accomplish more while coding less. Looking for a tutorial or migration guide? It all lives here →
SLACKsponsor
“You can now use your EV3 Brick to unleash the power of Python programming using MicroPython. Simply install the EV3 MicroPython image onto any micro SD card and boot up your EV3 Brick from it to start programming straight away.”
LEGO.COM• Shared by Python Bytes FM
Learn how to make a Discord bot in Python and interact with several APIs. See how to handle events, accept commands, validate and verify input, and all the basics that can help you create useful and exciting automations!
REAL PYTHON
“In this article I demonstrate a novel Node.js package named PyNode used to invoke Python code within a Node.js application and, more importantly, receive Python return types in the calling Node.js application.”
ADAM MCQUISTAN
Python support for Azure Functions is now generally available and ready to host your production workloads across data science and machine learning, automated resource management, and more.
MICROSOFT.COM
A curated list of practical business machine learning (BML) and business data science (BDS) applications for Accounting, Customer, Employee, Legal, Management and Operations.
GITHUB.COM/FIRMAI
How to give your Python scripts a full-featured Command-Line Interface (CLI) using the click library.
RICHARD BARELLA
Learn how to implement a simple scene boundary and shot transition detector with OpenCV and Python.
ADRIAN ROSEBROCK
Explains a simple implementation of a switching hub using software defined networking with Python.
REBECA SARAI
How far along has Mozilla come in the Python 3 migration?
ANDREW HALBERSTADT• Shared by Python Bytes FM
August 23 to August 26, 2019
PYTHON.NZ
August 23 to August 24, 2019
INDYPY.ORG
August 26, 2019
MEETUP.COM
August 27, 2019
GOOGLE.COM
August 29 to September 1, 2019
PYLATAM.ORG
Happy Pythoning!
This was PyCoder’s Weekly Issue #382.
View in Browser »
[ Subscribe to 🐍 PyCoder’s Weekly 💌 – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]
Qt Designer is a great tool for designing PyQt5 GUIs, allowing you to use the entire range of Qt5 widgets and layouts to construct your apps. As your applications get more complex however you may find yourself creating custom widgets, or using PyQt5 libraries such as PyQtGraph, who's widgets are not available within Designer.
Helpfully, Qt Designer supports a mechanism for using placeholder widgets to represent your custom or external widgets in your design. This tutorial will walk you through the process of using placeholders to include a PyQtGraph plot in your app from within Qt Designer.
The principle of using placeholders in Qt Designer is quite straightforward —
In Qt this final step is referred to as promoting (as in promoting a base class).
If the custom widget you are adding is a subclass of an existing Qt widget, you may want to use the base class as your placeholder to promote from. For example, if you have a custom MyAwesomeButton button widget subclassed from QPushButton use QPushButton as the placeholder and promote it to MyAwesomeButton. This gives you access to the base class properties, events and actions from within Qt Designer.
If you don't have an obvious base class to use, then you can use QWidget, the common base class of all Qt widgets.
Data science is one of the post popular uses of Python, and building dashboards and analysis tools is a common use case of PyQt5. For all of these being able to add plots to your UI is very useful — and being able to do this from Qt Designer even more so.
There are a number of plotting libraries available in Python, with matplotlib being the most popular and offering some basic support for PyQt5. PyQtGraph is an popular alternative which uses Qt's native QGraphicsScene to provide fast zooming, scaling, drag-drop behaviour that feels a natural part of your application.
Whether you're using PyQtGraph or maplotlib for your plotting needs, the plot canvas widgets are not available from within Qt Designer. In this tutorial I'll walk you through the process of using these custom widgets in your apps.
If you don't have PyQtGraph installed already, you can install it using:
pip install pyqtgraph
The instructions below aren't specific to PyQtGraph, and you can use the same process to add matplotlib or any other custom widgets to your app.
We will be using Qt Designer to create a simple UI design, and adding a placeholder for our PyQtGraph widget. First open Qt Designer and create a new QMainWindow as normal.
We next need to add the placeholder widget. As there is no suitable baseclass for the PyQtGraph plot widget, we'll use the basic QWidget as our placeholder. Select the Widget from the left sidebar and place it in the centre of your window.
Give the widget a name, "graphWidget" will do. This is just a tag to reference the element in code.
Right click on the widget and select Promote to from the widget's context menu.
Promoting a QWidget indicates that it should be replaced with the specified subclass, in our case the PyQtGraph plot widget.
A promoted widget can be reverted back to its base class by right-clicking and choosing Demote to from the widget's context menu.
You will be presented with a dialog to specify the custom widget class the placeholder widget will become.
The header file is the name of the Python module used to import the class, which is pyqtgraph. Specify PlotWidget as the class name of the widget to replace it with.
The name you use for the file doesn't matter, but it's usually a good idea to name it after the class you're going to create with it.
Voila! The widget is now promoted to a canvas to plot. But you won't be able to see any changes within Qt Designer. Save the window as mainwindow.ui in the same directory as your PyQt app.
For a complete guide to using Qt Designer .ui files from Python check out First steps with Qt Creator.
We now have the mainwindow.ui file containing our UI definition. We can load this from Python to show the window and our custom widget.
Let's start from a basic app template.
Qt Creator — Select MainWindow for widget type
Right click to show the promotion menu
Promote the widget by specifying the class name as PlotWidget and header file as pyqtgraph.
fromPyQt5importQtWidgets,uicimportpyqtgraphaspgimportsysclassMainWindow(QtWidgets.QMainWindow):def__init__(self,*args,**kwargs):super(MainWindow,self).__init__(*args,**kwargs)#Load the UI Pageuic.loadUi('mainwindow.ui',self)defmain():app=QtWidgets.QApplication(sys.argv)main=MainWindow()main.show()sys.exit(app.exec_())if__name__=='__main__':main()Save the code above in the same folder as your mainwindow.ui file, and run it as normal.
python3 my_app.py
You should see a window with your widget transformed into a PyQtGraph plotting widget.
Let's now create a function to make a simple plot of x and y data.
Your graph is now embedded
fromPyQt5importQtWidgets,uicfrompyqtgraphimportPlotWidget,plotimportpyqtgraphaspgimportsys# We need sys so that we can pass argv to QApplicationimportosclassMainWindow(QtWidgets.QMainWindow):def__init__(self,*args,**kwargs):super(MainWindow,self).__init__(*args,**kwargs)#Load the UI Pageuic.loadUi('mainwindow.ui',self)self.plot([1,2,3,4,5,6,7,8,9,10],[30,32,34,32,33,31,29,32,35,45])defplot(self,hour,temperature):self.graphWidget.plot(hour,temperature)defmain():app=QtWidgets.QApplication(sys.argv)main=MainWindow()main.show()sys.exit(app.exec_())if__name__=='__main__':main()So we added the plot() method which accepts two arrays, tempTemperature and hourHour, then plots the data using the graph widget.plot() method.
Run the code, you should see the following.
That's it! You have just embedded your first plot with PyQtGraph.
The default PyQtGraph plot isn't very pretty, however can play around with the .plot() call to change the data shown.
We'll cover more complex PyQtGraph plots and plot customization, including line colours, styles and alternative types of plots in an upcoming tutorial.
The custom PyQtGraph widget showing dummy data.