How to use pytest_collection_modifyitems method in Pytest

well, for anyone looking around here the first problem is solved. How:

removed the sys.stdout highjack and replaced it with a thread write(deleted also write function that's not needed, same with console_output_to_ui and its call):

self.__process = subprocess.Popen(cmd, stdout=PIPE,  universal_newlines=True, shell=False)
t = Thread(target=self.thread_read)
t.start()


def thread_read(self):
    while self.__process.poll() is None:
        line = self.__process.stdout.readline()
        temp = line.lstrip()
        temp = temp.replace("\n", "")
        # don't print empty lines
        if len(temp) > 1:
            self.ui.textEdit.append(temp)

this way in the ui textEdit I hav a log that looks like this:

evaluate_condition(): '6'
evaluate_condition(): '7'
evaluate_condition(): '8'
evaluate_condition(): '9'

and it's updated line by line just as the cmd window output.

Now working on a solution for problem no.2

Yes, there is a way.

config fixture has all the options associated with a particular test run. Use config.option.lf which will return True/False denoted whether it is a normal run/rerun.

I hope you are already familiar with pytest hook functions. For the below example, I used the pytest_configure hook function. But you can use any hook which gives access to config fixture

Example (conftest.py):-

def pytest_configure(config):
    print(config.option)
    print(config.option.lf)

For the above example result will look like this:-

Namespace(keyword='', markexpr='', maxfail=0, continue_on_collection_errors=False, confcutdir=None, noconftest=False, keepduplicates=False, collect_in_virtualenv=False, importmode='prepend', basetemp=None, durations=None, durations_min=0.005, version=0, plugins=['no:warning'], traceconfig=False, debug=False, showfixtures=False, show_fixtures_per_test=False, verbose=0, no_header=False, no_summary=False, reportchars='fE', disable_warnings=False, showlocals=False, tbstyle='auto', showcapture='all', fulltrace=False, color='auto', code_highlight='yes', capture='fd', runxfail=False, pastebin=None, assertmode='rewrite', xmlpath=None, junitprefix=None, doctestmodules=False, doctestreport='udiff', doctestglob=[], doctest_ignore_import_errors=False, doctest_continue_on_failure=False, last_failed_no_failures='all', stepwise=False, stepwise_skip=False, teamcity=0, no_teamcity=0, markers=False, usepdb=False, usepdb_cls=None, trace=False, lf=False, failedfirst=False, newfirst=False, cacheshow=None, cacheclear=False, pythonwarnings=None, strict_config=False, strict_markers=False, strict=False, inifilename=None, rootdir=None, collectonly=False, pyargs=False, ignore=None, ignore_glob=None, deselect=None, help=False, override_ini=None, setuponly=False, setupshow=False, setupplan=False, log_level=None, log_format=None, log_date_format=None, log_cli_level=None, log_cli_format=None, log_cli_date_format=None, log_file=None, log_file_level=None, log_file_format=None, log_file_date_format=None, log_auto_indent=None, file_or_dir=['test_pytest.py::test_group_a_uppercase'])
False

The argparse module actually reads input variables from special variable, which is called ARGV (short from ARGument Vector). This variable is usually accessed by reading sys.argv from sys module.

This variable is a ordinary list, so you can append your command-line parameters to it like this:

import sys
sys.argv.extend(['-a', SOME_VALUE])
main()

However, messing with sys.argv at runtime is not a good way of testing. A much more cleaner way to replace the sys.argv for some limited scope is using unittest.mock.patch context manager, like this:

with unittest.mock.patch('sys.argv'. ['-a', SOME_VALUE]):
    main()

Read more about unittest.mock.patch in documentation

Also, check this SO question:

How do I set sys.argv so I can unit test it?

You replaced the Python 2 bytes-only sys.stdout with one that only takes Unicode. You'll have to adjust your strategy on the Python version here, and use a different object:

try:
    # Python 2
    from cStringIO import StringIO
except ImportError:
    # Python 3
    from io import StringIO

and remove the io. prefix in your context manager:

origout,  sys.stdout = sys.stdout, StringIO()

The cStringIO.StringIO object is the Python 2 equivalent of io.BytesIO; it requires that you write plain bytestrings, not aunicode objects.

You can also use io.BytesIO in Python 2, but then you want to test if sys.stdout is a io.TextIOBase subclass; if it is not, replace the object with a binary BytesIO, object, otherwise use a StringIO object:

import io

if isinstance(sys.stdout, io.TextIOBase):
    # Python 3
    origout, sys.stdout = sys.stdout, io.StringIO()
else:
    # Python 2 or an unorthodox binary stdout setup
    origout, sys.stdout = sys.stdout, io.BytesIO()

You have to create conftest.py file and override pytest_keyboard_interrupt in that file:

# content of conftest.py

def pytest_keyboard_interrupt(excinfo):
    # Calling tearDown.

NOTE: Not duplicate question, however answer may be use full for your case to: py.test: get KeyboardInterrupt to call teardown

So, nobody knows the answer and I decided to offer my solution (it can be useful for others):

    class TestBaseClass:
        __test__ = True

    def mark_test(f):
        setattr(f, "__test__", True)
        return f

    # using base class and decorator
    class MyTestClass(TestBaseClass):
        @mark_test
        def some_func(self):
            pass

Pytest uses attribute __test__ to detect nose-tests, so you can use nose-library or just use such base class and decorator.

It depends how it was split.

MP3 files are a header block followed by some data, you can split the file at any header block and combine them by just concating them together. There isn't necessarily anything in the header block to say what order it's in. ( http://en.wikipedia.org/wiki/MP3#File_structure )

If the MP3 files are separate tracks from an album they will have ID tags that list the track number. There are a few python MP3 libraries - see Accessing mp3 Meta-Data with Python

edit: if you mean analyse the music so that you can tell if one note is supposed to follow another, that's a little out of my expertise!

For Python 2.6 and later, the open function in the io module has an optional newline parameter that lets you specify which newlines you want to use.

For example:

import io
with io.open('tmpfile', 'w', newline='\r\n') as f:
    f.write(u'foo\nbar\nbaz\n')

will create a file that contains this:

foo\r\n
bar\r\n
baz\r\n

Though classmethod and staticmethod are quite similar, there's a slight difference in usage for both entities: classmethod must have a reference to a class object as the first parameter, whereas staticmethod can have no parameters at all.

Example

class Date(object):
    
    def __init__(self, day=0, month=0, year=0):
        self.day = day
        self.month = month
        self.year = year

    @classmethod
    def from_string(cls, date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        date1 = cls(day, month, year)
        return date1

    @staticmethod
    def is_date_valid(date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        return day <= 31 and month <= 12 and year <= 3999

date2 = Date.from_string('11-09-2012')
is_date = Date.is_date_valid('11-09-2012')

Explanation

Let's assume an example of a class, dealing with date information (this will be our boilerplate):

class Date(object):
    
    def __init__(self, day=0, month=0, year=0):
        self.day = day
        self.month = month
        self.year = year

This class obviously could be used to store information about certain dates (without timezone information; let's assume all dates are presented in UTC).

Here we have __init__, a typical initializer of Python class instances, which receives arguments as a typical instance method, having the first non-optional argument (self) that holds a reference to a newly created instance.

Class Method

We have some tasks that can be nicely done using classmethods.

Let's assume that we want to create a lot of Date class instances having date information coming from an outer source encoded as a string with format 'dd-mm-yyyy'. Suppose we have to do this in different places in the source code of our project.

So what we must do here is:

1. Parse a string to receive day, month and year as three integer variables or a 3-item tuple consisting of that variable.
2. Instantiate Date by passing those values to the initialization call.

This will look like:

day, month, year = map(int, string_date.split('-'))
date1 = Date(day, month, year)

For this purpose, C++ can implement such a feature with overloading, but Python lacks this overloading. Instead, we can use classmethod. Let's create another constructor.

    @classmethod
    def from_string(cls, date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        date1 = cls(day, month, year)
        return date1

date2 = Date.from_string('11-09-2012')

Let's look more carefully at the above implementation, and review what advantages we have here:

1. We've implemented date string parsing in one place and it's reusable now.
2. Encapsulation works fine here (if you think that you could implement string parsing as a single function elsewhere, this solution fits the OOP paradigm far better).
3. cls is the class itself, not an instance of the class. It's pretty cool because if we inherit our Date class, all children will have from_string defined also.

Static method

What about staticmethod? It's pretty similar to classmethod but doesn't take any obligatory parameters (like a class method or instance method does).

Let's look at the next use case.

We have a date string that we want to validate somehow. This task is also logically bound to the Date class we've used so far, but doesn't require instantiation of it.

Here is where staticmethod can be useful. Let's look at the next piece of code:

    @staticmethod
    def is_date_valid(date_as_string):
        day, month, year = map(int, date_as_string.split('-'))
        return day <= 31 and month <= 12 and year <= 3999

# usage:
is_date = Date.is_date_valid('11-09-2012')

So, as we can see from usage of staticmethod, we don't have any access to what the class is---it's basically just a function, called syntactically like a method, but without access to the object and its internals (fields and other methods), which classmethod does have.