https://wiki.python.org/moin/Pyjamas?action=show&redirect=PyJamas

#Pyjamas is a toolkit and applications #framework, for the Web. (see #PyjamasDesktop for the desktop version). Pyjamas comprises a widget set, a library containing "AJAX tricks", and a python-to-javascript compiler. Although it can be helpful, no knowledge of CSS stylesheets, HTML, Javascript or AJAX is required to develop comprehensive applications very quickly.

Welcome to the home of #wxPython, a blending of the wxWidgets C++ class library with the Python programming language.

https://wxpython.org/

http://wxglade.sourceforge.net/

Description

#wxGlade is a #GUI #designer written in Python with the popular GUI toolkit #wxPython, that helps you create wxWidgets/wxPython user interfaces. At the moment it can generate Python, C++, Perl, Lisp and XRC (wxWidgets' XML resources) code.

As you can guess by the name, its model is Glade, the famous GTK+/GNOME GUI builder, with which wxGlade shares the philosophy and the look & feel (but not a line of code).

It is not (and will never be) a full featured IDE, but simply a "designer": the generated code does nothing apart from displaying the created widgets. If you are looking for a complete IDE, maybe Eric Python IDE, PyCharm, Code::Blocks or one of the many other IDE is the right tool.
News

https://github.com/python-telegram-bot/python-telegram-bot/pull/331

To hold a conversation with users, the #bot has to implement a #state machine to keep track of the different paths in the #conversation. This is a pretty common pattern and we don't have a good way to deal with it right now. The #state_machine_bot.py example is far from perfect.

This PR introduces a new Handler subclass called ConversationHandler to take care of this. Instead of re-inventing the wheel, this handler acts only as "management" for the existing handler classes.

Copied from documentation:

A handler to hold a conversation with a user by managing four collections of other handlers.

The first collection, a list named entry_points, is used to initiate the conversation,
for example with a CommandHandler or RegexHandler.

http://www.tutorialspoint.com/python/python_multithreading.htm

Running several threads is similar to running several different programs concurrently, but with the following benefits −

Multiple threads within a process share the same data space with the main thread and can therefore share information or communicate with each other more easily than if they were separate processes.

#Threads sometimes called light-weight processes and they do not require much memory overhead; they care cheaper than processes.

A thread has a beginning, an execution sequence, and a #conclusion. It has an instruction pointer that keeps track of where within its context it is currently running.

It can be pre-empted (interrupted)

It can temporarily be put on hold (also known as sleeping) while other threads are running - this is called yielding.

https://docs.python.org/3/library/functions.html#classmethod


classmethod(function)

Return a class method for function.

A #class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:

class C:
@classmethod
def f(cls, arg1, arg2, ...): ...

The @classmethod form is a function decorator – see the description of function definitions in Function definitions for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.

Class methods are different than C++ or Java static methods. If you want those, see staticmethod() in this section.

For more information on class methods, consult the documentation on the standard type hierarchy in The standard type hierarchy.

https://docs.python.org/3/library/functions.html#staticmethod

#staticmethod(function)

Return a #static method for function.

A static method does not receive an implicit first argument. To declare a static method, use this idiom:

class C:
@staticmethod
def f(arg1, arg2, ...): ...

The @staticmethod form is a function decorator – see the description of function definitions in Function definitions for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class.

Static methods in Python are similar to those found in Java or C++. Also see classmethod() for a variant that is useful for creating alternate class constructors.

For more information on static methods, consult the documentation on the standard type hierarchy in The standard type hierarchy.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

Return a str version of object. See str() for details.

str is the built-in string class. For general information about strings, see Text Sequence Type — str.

https://docs.python.org/3/library/functools.html#functools.partialmethod

class #functools.partialmethod(func, *args, **keywords)

Return a new #partialmethod descriptor which behaves like partial except that it is designed to be used as a method definition rather than being directly callable.

func must be a descriptor or a callable (objects which are both, like normal functions, are handled as descriptors).

When func is a descriptor (such as a normal Python function, classmethod(), staticmethod(), abstractmethod() or another instance of partialmethod), calls to __get__ are delegated to the underlying descriptor, and an appropriate partial object returned as the result.

When func is a non-descriptor callable, an appropriate bound method is created dynamically. This behaves like a normal Python function when used as a method: the self argument will be inserted as the first positional argument, even before the args and keywords supplied to the partialmethod constructor.

https://docs.python.org/3/library/functions.html#map

#map(function, iterable, ...)

Return an iterator that applies function to every item of iterable, yielding the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see itertools.starmap().

https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor

17.4.1. #Executor Objects

class #concurrent.futures.Executor

An abstract class that provides methods to execute calls asynchronously. It should not be used directly, but through its concrete subclasses.

submit(fn, *args, **kwargs)

Schedules the callable, fn, to be executed as fn(*args **kwargs) and returns a Future object representing the execution of the callable.

with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(pow, 323, 1235)
print(future.result())

map(func, *iterables, timeout=None, chunksize=1)

Equivalent to #map(func, *iterables) except func is executed asynchronously and several calls to func may be made concurrently. The returned iterator raises a concurrent.futures.TimeoutError if __next__() is called and the result isn’t available after timeout seconds from the original call to #Executor.map(). timeout can be an int or a float. If timeout is not specified or None, there is no limit to the wait time. If a call raises an exception, then that exception will be raised when its value is retrieved from the iterator. When using ProcessPoolExecutor, this method chops iterables into a number of chunks which it submits to the pool as separate tasks. The (approximate) size of these chunks can be specified by setting chunksize to a positive integer. For very long iterables, using a large value for chunksize can significantly improve performance compared to the default size of 1. With ThreadPoolExecutor, chunksize has no effect.

Changed in version 3.5: Added the chunksize argument.

https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Future

17.4.4. Future Objects

The Future class encapsulates the asynchronous execution of a callable. Future instances are created by Executor.submit().

class concurrent.futures.Future

Encapsulates the asynchronous execution of a callable. Future instances are created by Executor.submit() and should not be created directly except for testing.

https://docs.python.org/3/library/asyncio-dev.html#asyncio-coroutine-not-scheduled

18.5.9.6. Detect #coroutine objects never #scheduled

When a coroutine function is called and its result is not passed to ensure_future() or to the BaseEventLoop.create_task() method, the execution of the coroutine object will never be scheduled which is probably a bug. Enable the debug mode of asyncio to log a warning to detect it.

Example with the bug:

import asyncio

@asyncio.coroutine
def test():
print("never scheduled")

test()

Output in debug mode:

Coroutine test() at test.py:3 was never yielded from
Coroutine object created at (most recent call last):
File "test.py", line 7, in <module>
test()

The fix is to call the ensure_future() function or the BaseEventLoop.create_task() method with the coroutine object.

https://docs.python.org/3/library/asyncio-task.html#asyncio.coroutine

@asyncio.#coroutine

#Decorator to mark #generator-based coroutines. This enables the generator use yield from to call async def coroutines, and also enables the generator to be called by async def coroutines, for instance using an await expression.

There is no need to decorate async def coroutines themselves.

If the generator is not yielded from before it is destroyed, an error message is logged. See Detect coroutines never scheduled.

Note

In this documentation, some methods are documented as coroutines, even if they are plain Python functions returning a Future. This is intentional to have a freedom of tweaking the implementation of these functions in the future. If such a function is needed to be used in a callback-style code, wrap its result with ensure_future().

https://docs.python.org/3/library/asyncio-task.html#asyncio.coroutine

18.5.3. Tasks and coroutines
18.5.3.1. Coroutines

Coroutines used with asyncio may be implemented using the async def statement, or by using generators. The async def type of coroutine was added in Python 3.5, and is recommended if there is no need to support older Python versions.

Generator-based coroutines should be decorated with @asyncio.coroutine, although this is not strictly enforced. The decorator enables compatibility with async def coroutines, and also serves as documentation. Generator-based coroutines use the yield from syntax introduced in PEP 380, instead of the original yield syntax.

The word “coroutine”, like the word “generator”, is used for two different (though related) concepts:

The function that defines a coroutine (a function definition using async def or decorated with @asyncio.coroutine). If disambiguation is needed we will call this a coroutine function (iscoroutinefunction() returns True).
The object obtained by calling a coroutine function. This object represents a computation or an I/O operation (usually a combination) that will complete eventually. If disambiguation is needed we will call it a coroutine object (iscoroutine() returns True).

Things a coroutine can do:

result = await future or result = yield from future – suspends the coroutine until the future is done, then returns the future’s result, or raises an exception, which will be propagated. (If the future is cancelled, it will raise a CancelledError exception.) Note that tasks are futures, and everything said about futures also applies to tasks.
result = await coroutine or result = yield from coroutine – wait for another coroutine to produce a result (or raise an exception, which will be propagated). The coroutine expression must be a call to another coroutine.
return expression – produce a result to the coroutine that is waiting for this one using await or yield from.
raise exception – raise an exception in the coroutine that is waiting for this one using await or yield from.

https://docs.python.org/3/library/asyncio-dev.html#asyncio-multithreading

18.5.9.3. #Concurrency and #multithreading

An event loop runs in a thread and executes all callbacks and tasks in the same thread. While a task is running in the event loop, no other task is running in the same thread. But when the task uses yield from, the task is suspended and the event loop executes the next task.

To schedule a callback from a different thread, the BaseEventLoop.call_soon_threadsafe() method should be used. Example:

loop.call_soon_threadsafe(callback, *args)

Most asyncio objects are not thread safe. You should only worry if you access objects outside the event loop. For example, to cancel a future, don’t call directly its Future.cancel() method, but:

loop.call_soon_threadsafe(fut.cancel)

To handle signals and to execute subprocesses, the event loop must be run in the main thread.

To schedule a coroutine object from a different thread, the run_coroutine_threadsafe() function should be used. It returns a concurrent.futures.Future to access the result:

future = asyncio.run_coroutine_threadsafe(coro_func(), loop)
result = future.result(timeout) # Wait for the result with a timeout

The BaseEventLoop.run_in_executor() method can be used with a thread pool executor to execute a callback in different thread to not block the thread of the event loop.

See also

The Synchronization primitives section describes ways to synchronize tasks.

The Subprocess and threads section lists asyncio limitations to run subprocesses from different threads.

https://docs.python.org/3/library/asyncio-task.html#asyncio.run_coroutine_threadsafe

#asyncio.run_coroutine_threadsafe(coro, loop)

Submit a coroutine object to a given event loop.

Return a concurrent.futures.Future to access the result.

https://docs.python.org/3/library/asyncio-eventloop.html

#Calls

Most #asyncio functions don’t accept keywords. If you want to pass #keywords to your callback, use #functools.partial(). For example, #loop.#call_soon(functools.partial(print, "Hello", flush=True)) will call print("Hello", flush=True).

#Note

functools.partial() is better than lambda functions, because asyncio can inspect functools.partial() object to display parameters in debug mode, whereas lambda functions have a poor representation.

BaseEventLoop.call_soon(callback, *args)

Arrange for a callback to be called as soon as possible. The callback is called after call_soon() returns, when control returns to the event loop.

This operates as a FIFO queue, callbacks are called in the order in which they are registered. Each callback will be called exactly once.

Any positional arguments after the callback will be passed to the callback when it is called.

An instance of asyncio.Handle is returned, which can be used to cancel the callback.

Use functools.partial to pass keywords to the callback.

BaseEventLoop.call_soon_threadsafe(callback, *args)

Like call_soon(), but thread safe.

See the concurrency and multithreading section of the documentation.

https://docs.python.org/3/library/asyncio.html

#asyncio

#Asynchronous programming is more complex than classical “#sequential” programming: see the Develop with asyncio page which lists common traps and explains how to avoid them. Enable the debug mode during development to detect common issues.

https://github.com/daleroberts/tv

tv ("#textview") is a small tool to quickly view high-resolution multi-band imagery directly in your terminal. It was designed for working with (very large) #satellite imagery data over a low-bandwidth connection. For example, you can directly visualise a Himawari 8 (11K x 11K pixel) image of the Earth directly from its URL:

It is built upon the wonderful #GDAL library so it is able to load a large variety of image formats (GeoTiff, PNG, Jpeg, NetCDF, ...) and subsample the image as it reads from disk so it can handle very large files quickly. It has the ability to read filenames (or URLs) from stdin and load files directly from URLs without writing locally to disk. Command line options are styled after gdal_translate such as:

-b to specify the bands (and ordering) to use,
-srcwin xoff yoff xsize ysize to view a subset of the image,
-r to specify the subsampling algorithm (nearest, bilinear, cubic, cubicspline, lanczos, average, mode).

http://robotframework.org/

#Robot #Framework is a generic test #automation framework for acceptance testing and acceptance test-driven development (ATDD). It has easy-to-use tabular test data syntax and it utilizes the keyword-driven testing approach. Its testing capabilities can be extended by test libraries implemented either with Python or Java, and users can create new higher-level keywords from existing ones using the same syntax that is used for creating test cases.

#pytest: helps you write better programs

a mature full-featured Python testing tool

runs on Posix/Windows, Python 2.6-3.5, #PyPy and (possibly still) Jython-2.5.1
free and open source software, distributed under the terms of the MIT license
well tested with more than a thousand tests against itself
strict backward compatibility policy for safe pytest upgrades
comprehensive online and PDF documentation
many third party plugins and builtin helpers,
used in many small and large projects and organisations
comes with many tested examples

http://docs.pytest.org/en/latest/