Pycharm Code Coverage Community Edition



News

We are happy and proud to let you know that we’ve just released PyCharm 3.0, the newest version of our Python IDE. It comes with an outstanding lineup of new features and enhancements, including:

  • SQLAlchemy support
  • Pyramid & Web2Py web frameworks support
  • Full-featured embedded local terminal
  • Configurable language injections
  • Improvements in Python and Django code intelligence
  • Much better code insight for PyQt and PyGTK
  • and a lot more…

The Community Edition is free, so if all you need is a well featured Python IDE, to get your started, the Community Edition will serve you well. The Educational version of PyCharm is dedicated to. PyCharm UI can be customized according to the preferences and needs of developers. Moreover, there are a variety of options by which an IDE can be extended from over 50 plugins. Undoubtedly, the program is designed to meet the requirements of complex projects as PyCharm Community Edition.

  • Basically, everything is quick and simple. To collect coverage statistics, all you need to do is have your code open in PyCharm, have the project Python interpreter specified in the project settings, and have one or several run configurations (preferably including some configurations for tests).
  • When this button is pressed, when source code of certain class gets the focus in the editor, the corresponding node is automatically highlighted in the tool window. Click this button to generate a code coverage report and save it to the specified directory. See Generating code coverage report for details.

But the most noteworthy announcement for version 3.0 is:
PyCharm now comes in two editions: Community and Professional.

And yes, you read it right: a free and open-source edition of PyCharm is now available!

We all know that Python has long been used in scientific computing and is rapidly being adopted by education and outreach programs. And these are the circles that JetBrains traditionally supports. So the the idea of opening PyCharm’s major functionality to a broader developer community came naturally to us.

We are also confident that a rich set of intelligent language features designed for productive and error-free development will be also appreciated by professionals who use Python for their lightweight coding or scripting tasks.

PyCharm Community Edition is totally free and open-source, available under the Apache 2.0 license. The feature set of this edition is limited to support pure Python coding, while the major functionality and complementary tooling is still there. Community Edition provides core Python language support with code completion, one-the-fly code analysis, refactorings, local debugger, test runner, virtualenv, version control integrations, etc.

PyCharm Professional Edition represents a superset of the Community Edition, and is ultimately the most powerful and full-featured IDE for Python and Web development. It supports a broad range of advanced technologies including Django, Flask, GAE, SQLAlchemy, Pyramid, web2py and other frameworks and toolkits on top of those supported in Community edition. Starting from v3.0, PyCharm supports several new frameworks and libraries listed above, offers more intelligent code insight for core Python and supported frameworks, new inspections, language injections, Django improvements, Local terminal, and a lot more.

Read more about what’s new in PyCharm 3.0 and download the IDE for your platform.
For more details on the differences between Community Edition and Professional Edition, please visit the Editions Comparison page.

PyCharm 3.0 Professional Edition is a free update for everyone who purchased their license after Sep 24, 2012. As usual, a 30-day trial is available if you want to try PyCharm as your new Python/Django IDE.

Develop with pleasure!
JetBrains PyCharm Team

Isp for mac. I've using Eclipse and PyDev for some years now, but I always wanted to switch to PyCharm. The main problem I found was the integration with coverage.py and pylint, which are very easy in Pydev, but not available with the Community version of PyCharm.

Edition

This is the solution for both tools using PyCharm 5 in a python3 project:

Let's do the easier one first. PyCharm comes with the pep8.py and other syntax checks, but I like pylint because it gives some indications about number of class methods, variables in a function, etc.

Install pylint if you don't have it in your system:Then, open File->Settings->Tools->External tools and click the + button. You will get a window that has to be filled like this:

  • Remember to check the Show console when a message is printed to standard output stream and the same with errors. If not, the pylint output won't be shown.
  • Program is the path to the program to be executed. No parameters can be passed here
  • The params section gives the parameters to the executed program. $FilePath$ is a macro. All the available macros can be selected with the right button. $FilePath$ is changed to the selected file path when the fuinction is launched
  • The working directory section indicates the directory the order will be executed from. I've set it with a macro to the project root path

You can run the pylint script by going to tools->External tools->pylint when you have a file open or right clicking the file name at the project pane.

coverage.py is a tool to check if all the lines are executed in a module when a test for this module is run. With it is easy to know if all the coded possibilities have been tested. We could use the script directly, but since PyCharm uses nose to run the tests and gives a nice output and nose can integrate the coverage.py script, I've configured the later to give the test result and coverage at once.

To run the test with the coverage option, some flags have to be applied (all the options here):

  • --with-coverage enables the coverage
  • --cover-package restricts the coverage to the specified packages (more than one can be specified separating with commas). When the flag is not enable, all the dependencies will be checked, with all the libraries used, so the result can be difficult to read. This is the point that gave me some troubles
  • --cover-tests Covers the modules and tests. Can be useful to check if all the test has been run (if you use some condition inside them, for instance)
  • --cover-erase Reset the results before running the tests. If tests are not erased, the output results can be confusing if the changed code is not covered but it was in a previous version

I didn't find a really satisfactory way to integrate coverage in PyCharm community, so I'll show three ways to do it:

Modifying the run parameters

Once a test is created, go to Run->Edit Configurations and find the configuration for the test you want to use. Edit it and add to the params text box:

--with-coverage --cover-erase --cover-package package_name

Now, when running the test, the console will output the coverage result

  • Pros: The output keeps the test result view
  • Cons: You have to configure it for each test. The package name has to be changed each times

Adding an external tool

As in the pylint case, an external tool can be set: Open File->Settings->Tools->External tools and click the + button.

  • The program is nosetests3 in my case, since I'm running a python3 project
  • The parameters are the same as in the other case, but calling the macro $Prompt$ to give the name of the packages. This will open a window to ask which packages to check

Pycharm Code Coverage Community Edition Pdf

You can call the coverage script using tools->External tools->noseCoverage

Pycharm Run With Coverage

  • Pros: The tool can be called from any test
  • Cons: The package name has to be written every time. The output is only at the console, without the test pane.

Calling a script from an external tool

The external tool way could be improved if the packages where automatically called instead of opening a window. Unfortunately, I haven't been able to execute code inside the parameters field, so the solution is creating an external file with the following command:And then, create the external tool this way:

EditionPdf
  • All the available packages are passed to the --cover-package option so no prompt is needed
  • Since the working directory is set to the project root, the paths are at the correct point
2020.2.3

I haven't been able to pass the echo part inside the parameters field, PyCharm avoids executing it.

  • Pros: The most automatic way I have found to do it
  • Cons: Requires an external script, which I don't like




Comments are closed.