How to use pytest_enter_pdb method in Pytest

from app_name import api

# to use serializer
serializer=api.serializeFileName

Since you have a GraphQL server, all you need is a GraphQL client implementation. From official documentation, you can find the latest implementations of Python GraphQL client libraries according to your python version needs. Find more here

For you could use the GQL package from https://github.com/graphql-python/gql like so,

from gql import gql, Client

client = Client(schema=schema)
query = gql('''
{
  hello
}
''')

client.execute(query)

Keep in mind, that since GraphQL is a specification you could also write a Client of your own. The GraphQL specification isn’t opinionated about the transportation layer, so it can be any. An example of HTTP implementation of it can be found at https://www.robinwieruch.de/react-graphql-client-library/

1. Checking for __iter__ works on sequence types, but it would fail on e.g. strings in Python 2. I would like to know the right answer too, until then, here is one possibility (which would work on strings, too):

    try:
        some_object_iterator = iter(some_object)
    except TypeError as te:
        print(some_object, 'is not iterable')
   

The iter built-in checks for the __iter__ method or in the case of strings the __getitem__ method.

2. Another general pythonic approach is to assume an iterable, then fail gracefully if it does not work on the given object. The Python glossary:

Pythonic programming style that determines an object's type by inspection of its method or attribute signature rather than by explicit relationship to some type object ("If it looks like a duck and quacks like a duck, it must be a duck.") By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution. Duck-typing avoids tests using type() or isinstance(). Instead, it typically employs the EAFP (Easier to Ask Forgiveness than Permission) style of programming.

...

try:
   _ = (e for e in my_object)
except TypeError:
   print my_object, 'is not iterable'

3. The collections module provides some abstract base classes, which allow to ask classes or instances if they provide particular functionality, for example:

    from collections.abc import Iterable
   
    if isinstance(e, Iterable):
        # e is iterable
   

However, this does not check for classes that are iterable through __getitem__.

If you want to set the attribute for all nodes to the same value, you can use graph.add_nodes_from(graph.nodes,attribute_name='attribute_value')

This updates the provided attribute (adds the node and attribute if non-existent) but maintains any other node attributes and edges you already have in the graph. See the example below:

import networkx as nx

graph = nx.erdos_renyi_graph(n = 3, p = 0.1, seed = 5)

# setup some initial attributes
graph.nodes[0]['attr1'] = 'foo'
graph.nodes[1]['attr1'] = 'bar'
graph.nodes[2]['attr1'] = 'baz'

# make some attribute we want to change
for node in graph.nodes:
    graph.nodes[node]['attr_to_change'] = 'orig_value'

# View initial attribute values
print(graph.nodes(data=True))
# [(0, {'attr1': 'foo', 'attr_to_change': 'orig_value'}),
#  (1, {'attr1': 'bar', 'attr_to_change': 'orig_value'}),
#  (2, {'attr1': 'baz', 'attr_to_change': 'orig_value'})]

# change the value of the attr_to_change attribute for all
graph.add_nodes_from(graph.nodes,attr_to_change='new_value')

# View updated attribute value
print(graph.nodes(data=True))
# [(0, {'attr1': 'foo', 'attr_to_change': 'new_value'}),
#  (1, {'attr1': 'bar', 'attr_to_change': 'new_value'}),
#  (2, {'attr1': 'baz', 'attr_to_change': 'new_value'})]

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

You can use -k option to run test cases with different patterns:

py.test tests_directory/foo.py tests_directory/bar.py -k 'test_001 or test_some_other_test'

This will run test cases with name test_001 and test_some_other_test deselecting the rest of the test cases.

Note: This will select any test case starting with test_001 or test_some_other_test. For example, if you have test case test_0012 it will also be selected.

In conftest.py, you can override the 'collection' hooks to print information about collected test 'items'.

You may introduce your own command line option (like --collect-only). If this option is specified, print the test items (in whichever way you like) and exit.

Sample conftest.py below (tested locally):

import pytest

def pytest_addoption(parser):
    parser.addoption("--my_test_dump", action="store", default=None,
        help="Print test items in my custom format")

def pytest_collection_finish(session):
    if session.config.option.my_test_dump is not None:
        for item in session.items:
            print('{}::{}'.format(item.fspath, item.name))
        pytest.exit('Done!')

For more information on pytest hooks, see:

http://doc.pytest.org/en/latest/_modules/_pytest/hookspec.html

At first I was only focussing on the new way, how QThreads should be used since QT4 (Link), by creating a QObject, and then invoking moveToThread(), pretty much like in my first code sample (at least thats how I understood it). However I just could not figure out, why I was not able to pass signals from the QThread to the main application.

As I really needed a fast solution to my problem, I desperately tried varius things. Here is some second code, that does seem to work the way I wanted:

from PyQt4 import QtCore, QtGui
import time
import sys
import math


class SerialCon(QtCore.QThread):

    received = QtCore.pyqtSignal(object)

    def __init__(self, parent=None):
        QtCore.QThread.__init__(self)
        # specify thread context for signals and slots:
        # test: comment following line, and run again
        self.moveToThread(self)
        # timer:
        self.timer = QtCore.QTimer()
        self.timer.moveToThread(self)
        self.timer.setInterval(800)
        self.timer.timeout.connect(self.readData)

    def run(self):
        self.timer.start()
        #start eventloop
        self.exec_()

    def readData(self):
        # keeping the thread busy
        # figure out if the GUI remains responsive (should be running on a different thread)
        result = []
        for i in range(1,1000000):
            result.append(math.pow(i,0.2)*math.pow(i,0.1)*math.pow(i,0.3))
        #
        self.received.emit("New serial data!")

    @QtCore.pyqtSlot(object)
    def writeData(self, data):
       #print(self.currentThreadId())
       print(data)

class MyGui(QtGui.QWidget):
    serialWrite = QtCore.pyqtSignal(object)

    def __init__(self, app, parent=None):
       self.app = app
       super(MyGui, self).__init__(parent)
       self.initUI()

    def initUI(self):
       self.bSend = QtGui.QPushButton("Send",self)
       self.bSend.clicked.connect(self.sendData)
       self.show()
    def closeEvent(self, event):
        print("Close.")
        self.serialc.quit();

    @QtCore.pyqtSlot(object)
    def updateData(self, data):
        print(data)

    def sendData(self, pressed):
       self.serialWrite.emit("Send Me! Please?")

    def usingMoveToThread(self):
        self.serialc = SerialCon()
        # binding signals:
        self.serialc.received.connect(self.updateData)
        self.serialWrite.connect(self.serialc.writeData)
        # start thread
        self.serialc.start()

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    guui = MyGui(app)
    guui.usingMoveToThread()
    sys.exit(app.exec_())

I consider it a workaround for now, but it does not really answer the question for me. Plus, as mentioned in the previously linked QT blog entry, it is not really the intended way to use the QThread. So I am still wondering how to get the first code in my question to work as expected. If you have some ideas about what is wrong with my first code, please let my know!

Harvey's answer won't work with command groups. Effectively this would replace the 'hello' command with 'wrapper' which is not what we want. Instead try something like:

from functools import wraps

def test_decorator(f):
    @wraps(f)
    def wrapper(*args, **kwargs):
        kwargs['name'] = kwargs['name'].upper()
        return f(*args, **kwargs)
    return wrapper