a ƹDfS@sxdZGdddeZGdddeZGdddeZGdddeZGd d d eZGd d d eZGd ddeZdS)zB maps: stand-alone map-like objects using lazy pool instantiation c@sneZdZdddZddZddZdd Zd d ZeeZ eeZ eeZ d d Z ddZ ddZddZdS)MapNcOsV|dd|_|d|j|_|d|j|_|tur:dn||_||_||_d|_dS)amap instance with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, a builtins.map will be used with the returned iterator cast to a list. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. clearFjoincloseN) pop_clear_join_closemappoolargskwds_poolselfr r r rX/nfs/NAS7/SABIOD/METHODE/ermites/ermites_venv/lib/python3.9/site-packages/pathos/maps.py__init__ s z Map.__init__cOs~|jdurtt|g|RS|j|ji|j|_}|j|g|Ri|}|jr^||jrl| |j rz| |S)aAinstantiate a pool and execute the pool's map Args: func: function object to map *args: positional arguments for map **kwds: keyword arguments for map Returns: results from execution of ``map(func, *args, **kwds)`` NOTE: initializes a new worker pool with each call N) r listr r r r rrrrrr)rfuncr r r resultrrr__call__5s z Map.__call__cCs|SNrrrrr__cls__Lsz Map.__cls__cCs|jjSr)r__func__rrrr__meth__Nsz Map.__meth__cCs|jjSr)r__get__rrrr__attr__Psz Map.__attr__cCs&z|jWnty Yn0dS)zclose the map to any new jobsN)r rAttributeErrorrrrrrVs z Map.closecCs&z|jWnty Yn0dS)zreclaim the closed workersN)r rrrrrrr]s zMap.joincCs&z|jWnty Yn0dS)z remove pool singleton, if existsN)r rrrrrrrds z Map.clearcCs:z|||Wnty.Yn0d|_dS)z-shutdown the worker pool and tidy up N)rrr Exceptionr rrrr__del__ks  z Map.__del__)N)__name__ __module__ __qualname__rrrrrproperty__self__rrrrrr rrrrr s (rcs&eZdZdfdd ZddZZS)SmapNcstj|g|Ri|dS)astarmap instance with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, an itertools.starmap will be used with the returned iterator cast to a list. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nsuperrr __class__rrrys z Smap.__init__cs|jdur*ddlm}t|g|RS|j|ji|j|_}t|dt|dd}|dur|jfddg|Ri|}n|g|Ri|}|j r| |j r| |j r||S)aQinstantiate a pool and execute the pool's starmap Args: func: function object to map *args: positional arguments for starmap **kwds: keyword arguments for starmap Returns: results from execution of ``starmap(func, *args, **kwds)`` NOTE: initializes a new worker pool with each call Nstarmapsmapr-cs|SrrxrrrzSmap.__call__..)r itertoolsr-rr r r getattrr rrrrrr)rrr r r-r r.rrr1rrs  "z Smap.__call__)Nr!r"r#rr __classcell__rrr)rr&ws"r&cs&eZdZdfdd ZddZZS)ImapNcstj|g|Ri|dS)amap iterator with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, a builtins.map will be used. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nr'rr)rrrs z Imap.__init__cOs|jdurt|g|RS|j|ji|j|_}t|dd}|durLtS||g|Ri|}|jrp||j r~| |j r| |S)aeinstantiate a pool and execute the pool's map iterator Args: func: function object to map *args: positional arguments for map iterator **kwds: keyword arguments for map iterator Returns: results from execution of ``map(func, *args, **kwds)`` iterator NOTE: initializes a new worker pool with each call Nimap) r r r r r r5NotImplementedrrrrrr)rrr r r r9rrrrrs  z Imap.__call__)Nr6rrr)rr8s"r8cs&eZdZdfdd ZddZZS)AmapNcstj|g|Ri|dS)aasync map instance with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, NotImplemented is returned upon use. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nr'rr)rrrs z Amap.__init__cOs|jdurtS|j|ji|j|_}t|dt|dd}|durHtS||g|Ri|}|jrl||jrz| |j r| |S)aYinstantiate a pool and execute the pool's async map Args: func: function object to map *args: positional arguments for async map **kwds: keyword arguments for async map Returns: results from execution of async ``map(func, *args, **kwds)`` NOTE: initializes a new worker pool with each call NamapZ map_async r r:r r r r5rrrrrr)rrr r r r<rrrrrs z Amap.__call__)Nr6rrr)rr;s"r;cs&eZdZdfdd ZddZZS)AsmapNcstj|g|Ri|dS)aasync starmap instance with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, NotImplemented is returned upon use. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nr'rr)rrr5s zAsmap.__init__cs|jdurtS|j|ji|j|_}t|dt|dd}|durf|jfddg|Ri|}n|g|Ri|}|jr||j r| |j r| |S)aiinstantiate a pool and execute the pool's async starmap Args: func: function object to map *args: positional arguments for async starmap **kwds: keyword arguments for async starmap Returns: results from execution of async ``starmap(func, *args, **kwds)`` NOTE: initializes a new worker pool with each call NasmapZ starmap_asynccs|Srrr/r1rrr2ir3z Asmap.__call__..) r r:r r r r5r<rrrrrr)rrr r r r?rrr1rrWs "zAsmap.__call__)Nr6rrr)rr>3s"r>cs&eZdZdfdd ZddZZS)UimapNcstj|g|Ri|dS)aunordered map iterator with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, NotImplemented is returned upon use. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nr'rr)rrrts zUimap.__init__cOs|jdurtS|j|ji|j|_}t|dt|dd}|durHtS||g|Ri|}|jrl||jrz| |j r| |S)ainstantiate a pool and execute the pool's unordered map iterator Args: func: function object to map *args: positional arguments for unordered map iterator **kwds: keyword arguments for unordered map iterator Returns: results from execution of unordered ``map(func, *args, **kwds)`` iterator NOTE: initializes a new worker pool with each call NuimapZimap_unorderedr=)rrr r r rArrrrrs zUimap.__call__)Nr6rrr)rr@rs"r@cs&eZdZdfdd ZddZZS)IsmapNcstj|g|Ri|dS)astarmap iterator with internal lazy pool instantiation Args: pool: pool object (i.e. pathos.pools.ProcessPool) *args: positional arguments for pool initialization **kwds: keyword arguments for pool initialization close: if True, close the pool to any new jobs [Default: False] join: if True, reclaim the pool's closed workers [Default: False] clear: if True, delete the pool singleton [Default: False] NOTE: if a pool object is not provided, an itertools.starmap will be used. NOTE: pools from both multiprocess and pathos.pools can be used, however the behavior is slightly different. Pools from both pathos and multiprocess have close and join methods, to close the pool to new jobs, and to shut down the pool's workers. Pools from pathos, however, are launched as singletons, so they also include a clear method that deletes the singleton. In either case, a pool that has been "closed" will throw a ValueError if map is then called, and similarly, a ValueError will be thrown if join is called before a pool is "closed". The major difference is that if a pathos.pool is closed, the map instance cannot run new jobs until "clear" is called, while a new multiprocess pool will be created each time the map is executed. This leads to pathos.pools generally being called with either ``clear=True`` or ``clear=False``, and pools from multprocess either using ``close=True`` or ``join=True`` or both. Some hierarchical parallel workflows are not allowed, and will result in an error being thrown; however, changing close, join, or clear can often remove the error. Nr'rr)rrrs zIsmap.__init__cs|jdur&ddlm}|g|RS|j|ji|j|_}t|dd}|durv|jfddg|Ri|}n|g|Ri|}|jr| |j r| |j r| |S)auinstantiate a pool and execute the pool's starmap iterator Args: func: function object to map *args: positional arguments for starmap iterator **kwds: keyword arguments for starmap iterator Returns: results from execution of ``starmap(func, *args, **kwds)`` iterator NOTE: initializes a new worker pool with each call Nr+r,ismapcs|Srrr/r1rrr2r3z Ismap.__call__..)r r4r-r r r r5r9rrrrrr)rrr r r-r rCrrr1rrs   "zIsmap.__call__)Nr6rrr)rrBs"rBN) __doc__objectrr&r8r;r>r@rBrrrrsl@>>?>