Merge pull request #2 from imneonizer/imneonizer-patch-1

decorators support

Author: imneonizer

README.md

@@ -180,6 +180,106 @@ imthread.elapsed(output=True)
 
 we kept a time gap of 1 sec inside the function still it repeated the task 4 times in same time. since it can access the global variables we can assign certain tasks that don't need different inputs every time.
 
+#### Decorators support
+
+Apart from calling the ``start()`` attribute we can also use decorators to explicitly make our functions for concurrent execution.
+
+**Example 1**
+
+````python
+import imthread
+import time
+
+@imthread.run(repeat=5, max_threads=5)
+def my_func(i):
+    time.sleep(1)
+    return i*2
+
+print(imthread.result['my_func'])
+````
+
+**Output**
+
+````python
+[0, 2, 4, 6, 8]
+````
+
+This will execute the function as soon as you run your python code, in this case we are trying to perform the same task five times in a row concurrently. The final output of all the function can be accessed by ``imthread.result['function_name']``. Notice if you set your function on repeat it will always receive a parameter which is it's thread number.
+
+----
+
+**Example 2**
+
+````python
+import imthread
+import time
+
+@imthread.run(data=[1,2,3,4,5,6], max_threads=5)
+def my_func(i):
+    time.sleep(1)
+    return i*2
+
+print(imthread.result['my_func'])
+````
+
+**Output**
+
+````python
+[2, 4, 6, 8, 10, 12]
+````
+
+In this case we are directly passing our arguments in a list via decorator and receiving the result same way as we did in previous example.
+
+----
+
+**Exampe 3**
+
+````python
+import imthread
+import time
+
+@imthread.set(max_threads=10)
+def my_func(i):
+    time.sleep(1)
+    return i*2
+
+result = my_func(repeat=7)
+print(result)
+````
+
+**Output**
+
+````python
+[0, 2, 4, 6, 8, 10, 12]
+````
+
+This is an another cool way to first convert your function in concurrent function and then passing the argument as how many time you want to execute that function all in parallel.
+
+----
+
+**Example 4**
+
+````python
+import imthread
+import time
+
+@imthread.set()
+def my_func(i):
+    time.sleep(1)
+    return i*2
+
+result = my_func([5,6,7])
+print(result)
+````
+
+**Output**
+
+````python
+[10, 12, 14]
+````
+
+Again we can also specify what arguments we want to pass to the function to process it concurrently. if in the ``@imthread.set()`` decorator you won't pass any ``max_threads`` argument ``max_threads=10`` will be set.
+
 #### Handling errors and killing all threads
 
 So, by default if any error occurs the threads will keep on running, in case if you want to ignore some errors but if you want to kill all the thread at once you can use ``imthread.stop()`` while handling errors.

dist/imthread-1.1.tar.gz

@@ -1,7 +1,11 @@
 from imthread.imthread import multi_threading, console_log
 import time
 
+__version__='1.1'
+__author__='Nitin Rai'
+
 st = 0
+#default start function for spawning threads
 def start(processing_func, data=None, repeat=None, max_threads=10):
     assert type(max_threads) == int, 'max_threads value should be an integer'
     assert max_threads>0, 'max_threads value cannot be less than 1'
@@ -21,9 +25,38 @@ def start(processing_func, data=None, repeat=None, max_threads=10):
     else:
         print(f'data: {data}, repeat: {repeat}')
 
+
+result = {}
+#decorator support function for quick launch
+def run(*args, **kwargs):
+    def inter(func, kwargs):
+        global result
+        data = kwargs['data'] if 'data' in kwargs else None
+        repeat = kwargs['repeat'] if 'repeat'in kwargs else None
+        assert data!=None or repeat!=None, "one or more arguments missing!"
+        max_threads = kwargs['max_threads'] if 'max_threads' in kwargs else 10
+        result[func.__name__] = start(func, data=data, repeat=repeat, max_threads=max_threads)
+
+    return lambda func:inter(func, kwargs)
+
+#decorator support function for setting up input function
+def set(*args, **kwargs):
+    def inter1(func, kwargs):
+        def inter2(*args, **extra):
+            max_threads =  kwargs['max_threads'] if 'max_threads' in kwargs else 10
+            try:
+                args = extra['repeat'] if len(args)==0 else args[0]
+            except Exception as e:
+                assert len(args)>0, func.__name__+' requires atleast one argument'
+            res = start(func, data=args, max_threads=max_threads)
+            return res
+        return inter2
+    return lambda func:inter1(func, kwargs)
+
 def stop():
     raise Exception('stop')
 
+
 def elapsed(output=False):
     tt = round((time.time()-st), 2)
     if output:

imthread/__init__.py

@@ -33,6 +33,7 @@ def process_frames(data):
 
             try:
                 processed_data = self.process(data[1]) #actually processing the data
+
             except Exception as e:
                 processed_data = None
                 if str(e) == 'stop': #if manually stop exception raised

imthread/imthread.py

@@ -2,13 +2,13 @@
 setup(
   name = 'imthread',         # How you named your package folder (MyLib)
   packages = ['imthread'],   # Chose the same as "name"
-  version = '1.0',      # Start with a small number and increase it with every change you make
+  version = '1.1',      # Start with a small number and increase it with every change you make
   license='MIT',        # Chose a license from here: https://help.github.com/articles/licensing-a-repository
   description = 'This short little python module can help you with running your iterable functions on multithreading without any hassle of creating threads by yourself.',   # Give a short description about your library
   author = 'Nitin Rai',                   # Type in your name
   author_email = 'mneonizer@gmail.com',      # Type in your E-Mail
   url = 'https://github.com/imneonizer/imthread',   # Provide either the link to your github or to your website
-  download_url = 'https://github.com/imneonizer/imthread/archive/v1.0.tar.gz',    # I explain this later on
+  download_url = 'https://github.com/imneonizer/imthread/archive/v1.1.tar.gz',    # I explain this later on
   keywords = ['Multi Threading', 'Synchronous Threading', 'Asyncio'],   # Keywords that define your package best
   classifiers=[
     'Development Status :: 4 - Beta',      # Chose either "3 - Alpha", "4 - Beta" or "5 - Production/Stable" as the current state of your package