semvec/pypi-packages huggingface dataset:
fugue-icons 3.5.6
Fugue Icons packaged for simple use in web apps.
License: MIT
Keywords: icon css sprite graphics ui

Fugue Icons are created by Yusuke Kamiyamane
    <http://p.yusukekamiyamane.com/> and licensed under Creative Commons
    Attribution 3.0 <http://creativecommons.org/licenses/by/3.0/> license.
    This is a helper script and convenience packaging of those icons.
    The code is licensed under MIT license.
semisync 0.1
A decorator-based module for semi-synchronous programming
License: MIT
Keywords: async, asynchronous, decorator, callback, process

What is semisync.py?
--------------------

Some problems are best solved synchronously, while others are a better
fit for the asynchronous paradigm. Most problems fall somewhere in
between -- they could benefit from asynchronous execution, but require
some events to happen in a certain order. This module seeks to make
blending the two paradigms a bit easier by introducing a concept of
dependencies. If one process must not run until another process has
completed, that process is said to be "dependent" on the second process.
Semisync.py was built using python's multiprocessing library and a
liberal dose of decorator syntax.

Installation
------------

Install via pip

::

    sudo pip install semisync

or via setup.py

::

    sudo python setup.py install

Let's See Some Code
-------------------

::

    from semisync import semisync
    from multiprocessing import Manager
    from random import random, randint
    from time import sleep

    # shared data between processes
    shared = Manager().Namespace()

    # a demo callback function
    def output(field, value):
      print field + ": $" + str(value)

    # simple callback syntax
    @semisync(callback=output)
    def revenue():
      # simulated api call
      sleep(random())
      shared.revenue = randint(1, 1000)
      return "Revenue", shared.revenue

    @semisync(callback=output)
    def expenses():
      # simulated api call
      sleep(random())
      shared.expenses = randint(1, 500)
      return "Expenses", shared.expenses

    # will run only when revenue() and expenses() have completed
    @semisync(callback=output, dependencies=[revenue, expenses])
    def profit():
      shared.profit = shared.revenue - shared.expenses
      return "Profit", shared.profit

    # queue function calls
    revenue()
    expenses()
    profit()

    # executes queued calls semi-synchronously
    semisync.begin()

To repeat the process, simply clear the cache of function calls by using
semisync.clear() after each iteration

::

    for i in range(10):
      revenue()
      expenses()
      profit()
      semisync.begin()
      semisync.clear()

In this simple example, moving from synchronous to semi-synchronous
execution cuts the average execution time from 1.00 seconds to .700
seconds. And although the example used is trivial, dependency trees can
be arbitrarily complex.

Additional Notes
----------------

In order to make the module more flexible, few assumptions are made
about how you choose to deal with shared data. Although Manager() from
the multiprocessing library is used in the example, you're free to use
whatever format you desire. You're also in charge of locking shared data
if multiple processes access the same variable. With great flexibility
comes great responsibility.