Saravanan666/pypi-org huggingface dataset:
Package: asyncpixel
AsyncpixelAsyncpixel is an open source asynchronous python wrapper for the Hypixel api with 100% of all endpoints.✨ FeaturesAsynchronous.Unlike other libraries Asyncpixel is fully asynchronous. This makes it perfect to use in your next discord bot or powerful website without having to worry about blocking.100% API coverage.Asyncpixel is currently the only python library with full coverage of the Hypixel API meaning that no endpoints are left untouched and out of your reach.Pydantic models.All models are checked and validated byPydanticmeaning that the data is always in the correct format perfect for you to use.Available on pypi.Asyncpixel is available on pypi meaning no building from source, just usepip install asyncpixelto use it in your project.🏁 Getting Started with AsyncpixelTo get started check out the documentation whichlives hereand is generously hosted by readthedocs.InstallationUse the package managerpipor your favourite tool to install asyncpixel.pipinstallasyncpixelExampleimportasyncpixelimportasyncioasyncdefmain():hypixel=asyncpixel.Hypixel("hypixel_api_key")player=awaithypixel.player("405dcf08b80f4e23b97d943ad93d14fd")print(player.stats.bedwars)awaithypixel.close()asyncio.run(main())❗ Code of ConductDarkflame72 is dedicated to providing a welcoming, diverse, and harassment-free experience for everyone. We expect everyone in the Darkflame72 community to abide by ourCode of Conduct. Please read it.🙌 Contributing to AsyncpixelFrom opening a bug report to creating a pull request: every contribution is appreciated and welcomed. If you are planning to implement a new feature or change the library please create an issue first. This way we can ensure your work is not in vain.Not Sure Where to Start?A good place to start contributing, are theGood first issues.📝 LicenseAsyncpixel is open-source. The library is licensedGPL v3.💬 Get in touchIf you have a question or would like to discuss anything related to the library, please hop over toGithub discussionsor join our room onMatrix.Contributors ✨Thanks goes to these wonderful people (emoji key):AjayACST🚧Alex💻🐛Damian Grzanka💻satyamedh hulyalkar🐛dubs🐛Amund Eggen Svandal💻🐛wald0040🐛MillionthOdin16🐛ch-iv🐛💻This project follows theall-contributorsspecification. Contributions of any kind are welcome!
Package: async-pixiv
Async-Pixiv异步调用 Pixiv APIBuilding...此项目的开发者很忙，所以没啥时间修 bug ，写文档什么的特点支持 API 请求速率限制（RateLimiter）可使用账号和密码直接登录 Pixiv（注：可能会因为遇到 Cloudflare 验证而登录失败）自动将请求后的数据转为 Model ，再也不用以字典形式调用获取数据了（pydantic typed）支持多种代理模式（http/https/socks5）支持下载 gif 帧序列文件，并将其转为 gif 或 mp4 （需要ffmpeg）。。。（想到再写）安装使用pip(任选一行指令进行安装)pipinstall--upgradeasync-pixiv# 安装额外依赖（用于提升数据解析速度）pipinstall--upgradeasync-pixiv[extra]# 安装 playwright，使之可以使用账号密码登录pipinstall--upgradeasync-pixiv[playwright]# 安装全部额外依赖pipinstall--upgradeasync-pixiv[full]使用poetrypoetryaddasync-pixiv# 安装额外依赖（用于提升数据解析速度）poetryaddasync-pixiv[extra]# 安装 playwright，使之可以使用账号密码登录poetryaddasync-pixiv[playwright]# 安装全部额外依赖poetryaddasync-pixiv[full]使用fromasync_pixivimportPixivClient# 导入# 初始化 Clientclient=PixivClient(max_rate=100,# API 请求速率限制。默认 100 次rate_time_period=60,# API 请求速率限制时间区间。默认 60 秒timeout=10,# 默认超时秒数proxies=None,# 代理配置trust_env=False,# 是否从环境变量中获取代理配置retry=5,# 默认请求重试次数retry_sleep=1,# 默认重复请求间隔秒数)asyncdefmain():user=awaitclient.login_with_token('TOKEN')# 使用 token 登录 pixivprint(user.name)# 获取作品详情detail_result=awaitclient.ILLUST.detail(91725675)illust=detail_result.illustprint(f"链接：{illust.link}",f"标题：{illust.title}",f"作者：{illust.user.name}",f"标签：#{' #'.join(map(str,illust.tags))}",f"是否为 AI 作品：{'是'ifillust.ai_typeelse'否'}",f"是否为 R18 作品：{'是'ifawaitillust.is_r18()else'否'}",sep='\n')file_data=illust.download()# 下载breakpoint()# 下载动图bytes_data=awaitclient.ILLUST.download_ugoira(105369892,type='mp4')# bytesgif_data=awaitclient.ILLUST.download_ugoira(105369892,type='gif')breakpoint()# 小说novel_result=awaitclient.NOVEL.detail(15739859)novel=novel_result.novelprint(f"标题：{novel.title}",f"字数：{novel.text_length}",sep='\n')breakpoint()# 漫画# 下次再写def__main__():importasyncioasyncio.run(main())if__name__=='__main__':__main__()
Package: asyncplot
Async PlotterSimple two-process client/server plotting with the following features:Plotting does not slow down calculations.User maintains control of the calculation (i.e. KeyboardInterrupts work).Auto-launch client from the server.The user defines the plotting code in a (picklable) class, and
provides the class to the Server() constructor.  The Server passes the pickled Plotter
to the client when the client process is launched in a new python interpreter.
The python interpreter command line options for the client are passed to the Server
constructor at the time of instantiation. Default values are:
(ex. [“ipython”, “–pylab=osx”, “-c”])To DoPrototype for asynchronous plotting with separate processes using socketsStill Needs:Comprehensive testingLogging (print debug messages in debug mode for checking network problems)Profile performance.Configuration (hostname, port specification etc.)I think that these have been dealt with, but they need testing:socket buffer overflow (recv)cleanup thread and socket command line terminationerror handling. ex. when a client disconnects then server listen continues,
network errorsmultiple clients (plotting)Other Design ApproachesThreading SolutionThe simplest approach is a multi-thread approach.  In principle, one can run the
computations in the main thread and plotting in a separate thread.  This
solution is sketched inthread.pybut fails with mostmatplotlibbackends
due to their requirement of running in the main thread.  A quick work-around is
to run the computation in a secondary thread, but this precludes the user being
able to interrupt the computation.A nice feature of the python GIL is that one can be fairly confident about
sharing data (a careful solution would require locks etc.)Multiprocessing SolutionThis same solution should work withmultiprocessing, but this fails on my
development platform (Mac OS X 10.5) with the following error:The process has forked and you cannot use this CoreFoundation
functionality safely. You MUST exec().
Break on
__THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__() to debug.Separate ProcessesIt seems that the most robust solution is to have the calculation and plotters
run in completely separate processes.  This has an added benefit:User can plot remotely.One issue that needs to be addressed here (and in themultiprocessingsolution)
is the copying of data.  One common use-case is that the plotter may be slower
than the computation.  Thus, intermediate data may be discarded and should not
be sent across the network.Additional ApproachesIt seems that one should be able to useIPythonto do this, but I have not
found a simple way to do this yet.
Package: async-pluct
[![Build Status](https://travis-ci.org/globocom/async-pluct.svg?branch=master)](https://travis-ci.org/globocom/async-pluct)
[![Maintainability](https://api.codeclimate.com/v1/badges/00e056bdf0ba0061c54e/maintainability)](https://codeclimate.com/github/globocom/async-pluct/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/00e056bdf0ba0061c54e/test_coverage)](https://codeclimate.com/github/globocom/async-pluct/test_coverage)A Python asyncio JSON Hyper Schema client that allows hypermedia navigation and resource validation.
Kind API compatible with [Pluct](https://github.com/globocom/pluct)
Package: async-plus
Async-related stuff you miss in standard library“The horrors of hanging tasks when using asyncio” by Jacques CallotSafely run coroutines concurrentlyTheasyncio.gather()function has anissue: in case of error in one of
coroutines the rest coroutines are left running detached.  This might cause
hard to detect problems.  On the contrary, theasync_plus.try_gather()insures all tasks are cancelled on error:result1,result2=awaitasync_plus.try_gather(coroutine_func1(...),coroutine_func2(...),)Fire-and-forget taskWithcreate_task()it’s your responsibility to retrieve exception.
Usually this causes that exception is not seen until process finishes or
even is not seen at all if process is killed.  Withlaunch_watched()exception is logged immediately when it’s raised.async_plus.launch_watched(your_coroutine_func(...))Structuring groups of tasksasyncwithasync_plus.task_scope()asscope:scope.launch(coroutine_func1(...))scope.launch(coroutine_func2(...))awaitscope.wait()By default,wait()call returns when all tasks finish or first exception
occurs.  In all cases all unfinished tasks are cancelled at the end ofasync withblock.Increase delay between attempts in supervisorretry_delayer=async_plus.RetryDelayer([0,10,60],random_shift=1)whileTrue:try:awaitrun_service_x()# In Python <3.8 it inherits from Exceptionexceptasyncio.CancelledError:raiseexceptException:logger.exception('Error in service X:')awaitretry_delayer.sleep()Log long waitsDoes your program hang and you don’t know what it’s waiting for?  Wrap
suspicious coroutines withimpatient()to see bottlenecks:awaitasync_plus.impatient(asyncio.sleep(10),log_after=5)Or just log the time it took:awaitasync_plus.impatient(asyncio.sleep(10),log_completion='always')Change logSeeCHANGELOG.
Package: asyncpokepy
An asynchronous Python API wrapper for the PokéAPIInstallationMacOS / Linux:python3-mpipinstall-UasyncpokepyWindows:py-3-mpipinstall-UasyncpokepyUsageYou must create an instance of the pokeclient in order to utilise its functionality:fromasyncpokepyimportpokeclientpokeclient=pokeclient()ExamplesThese examples assume you have created an instance as above.asyncdefgetpikachu():# This will return an object, setting object to False will return a dictionaryreturnpokeclient.getpokemon('pikachu',object=True)Output:<asyncpokepy.objects.Pokemonobjectat0x7fa4bb929580>Authorsasyncpokepywas written byRaj Sharma.PokéAPIwas constructed byPaul Hallett.
Package: async-pokepy
async_pokepyAn, in the works, asynchronous wrapper for thePokeAPI.co API.You can check out the (failing) pipelines @gitlab.DocumentationThe docs are available @readthedocs.InstallingThe wrapper is available on PyPi, you can install it with:pip install async_pokepyBetter cachingIt's very recommended to install the library with lru-dict,
you can do this by installing the wrapper with this command:pip install async_pokepy[lru]The wrapper will throw a warning if you try to use it without this extra package.Tests and docsIf you also want to be able to run the tests/lint install it with:pip install async_pokepy[tests]The best way to run tests is by usingtox.For docs building:pip install async_pokepy[docs]Exampleimportasyncioimportasync_pokepyasyncdefmain(query):client=awaitasync_pokepy.Client.connect()pokemon=awaitclient.get_pokemon(query)fmt=", ".join(map(str,pokemon.abilities))print("{0}has the abilities{1}".format(pokemon,fmt))awaitclient.close()loop=asyncio.get_event_loop()loop.run_until_complete(main("Snorlax"))This will output: "Snorlax has the abilities Gluttony, Thick Fat, Immunity".You can check out more examples in theexamplefolder in the github repository or in the introduction section of the docs.
Package: async-polygon
async-polygonThis is an unofficial asynchronous version ofOfficial Polygon Api(REST API)Getting StartedClient exampleimport asyncio
from async_polygon import RestAsyncClient


async def main():
    api_key = 'API KEY'
    async with RestAsyncClient(api_key) as requestor:
        requestor: RestAsyncClient
        _from: str = '2022-03-29'
        _to: str = '2022-04-26'
        _timespan: str = 'hour'
        data = await requestor.aggregate_bars('AAPL', 1, _timespan, _from, _to)
        
        print(data)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())In near future I'll expand the functionality of the library
Package: async-pool-executor
pip install async_pool_executor主要功能主要功能是仿照 concurrent.futures 的线程池报的submit shutdown方法。

使得在做生产 消费 时候，无需学习烦人的异步 loop 、 run_until_complete ，可以直接在同步函数中 submit。
生产和消费不需要在同一个loop中，喜欢同步编程思维的人可以用这个。实现代码importasyncioimportatexitimporttimeimporttracebackfromthreadingimportThreadclassAsyncPoolExecutor:"""使api和线程池一样，最好的性能做法是submit也弄成 async def，生产和消费在同一个线程同一个loop一起运行，但会对调用链路的兼容性产生破坏，从而调用方式不兼容线程池。"""def__init__(self,size,loop=None):""":param size: 同时并发运行的协程任务数量。:param loop:"""self._size=sizeself.loop=looporasyncio.new_event_loop()self._sem=asyncio.Semaphore(self._size,loop=self.loop)self._queue=asyncio.Queue(maxsize=size,loop=self.loop)t=Thread(target=self._start_loop_in_new_thread)t.setDaemon(True)# 设置守护线程是为了有机会触发atexit，使程序自动结束，不用手动调用shutdownt.start()self._can_be_closed_flag=Falseatexit.register(self.shutdown)defsubmit(self,func,*args,**kwargs):future=asyncio.run_coroutine_threadsafe(self._produce(func,*args,**kwargs),self.loop)# 这个 run_coroutine_threadsafe 方法也有缺点，消耗的性能巨大。future.result()# 阻止过快放入，放入超过队列大小后，使submit阻塞。asyncdef_produce(self,func,*args,**kwargs):awaitself._queue.put((func,args,kwargs))asyncdef_consume(self):whileTrue:func,args,kwargs=awaitself._queue.get()iffunc=='stop':breaktry:awaitfunc(*args,**kwargs)exceptExceptionase:traceback.print_exc()def_start_loop_in_new_thread(self,):# self._loop.run_until_complete(self.__run())  # 这种也可以。# self._loop.run_forever()# asyncio.set_event_loop(self.loop)self.loop.run_until_complete(asyncio.wait([self._consume()for_inrange(self._size)],loop=self.loop))self._can_be_closed_flag=Truedefshutdown(self):for_inrange(self._size):self.submit('stop',)whilenotself._can_be_closed_flag:time.sleep(0.1)self.loop.close()print('关闭循环')if__name__=='__main__':importnb_logasyncdefasync_f(x):awaitasyncio.sleep(2)print(x)pool=AsyncPoolExecutor(3)foriinrange(30):pool.submit(async_f,i)
Package: async-pq
Python async api for creating and managing queues in postgresPostgres is not best solution for storing and managing queues,
but sometimes we have no choice.async-pqcan work with millions of entities and thousands of
requests in one queue. Is used in production. So its well tested and stable.Install> pip install async-pqQuick startTo work withasync-pqwe needasyncpglibrary:importasyncpgconn=awaitasyncpg.connect('postgresql://postgres@localhost/test')QueueFabric.find_queuemethod will create needed
tables (one for requests and one for messages) in database if it is new queue.
Also it hasis_exists_queuemethod for situations when you
need to know that it is exists or not and will be the new queue.fromasync_pqimportQueue,QueueFabricqueue:Queue=awaitQueueFabric(conn).find_queue('items')Operations with queuePut new items (should be dumped JSONs) in queue:awaitqueue.put('{"id":1,"data":[1,2,3]}','{"id":2,"data":[3,2,6]}')Pop items from queue with somelimit.
It will create one request and return its id.
It is useful when you want to use acknowledgement pattern:# If with_ack=False (default from > 0.2.1), massage will be acknowledged in place automaticallyrequest_id,data=awaitqueue.pop(limit=2,with_ack=True)To acknowledge request useackmethod:# returns False if request does not found or acked alreadyis_acked:bool=awaitqueue.ack(request_id)Or vice versa:# returns False if request does not found or acked alreadyis_unacked:bool=awaitqueue.unack(request_id)You can return unacknowledged massages older thantimeoutseconds
(default limit=1000 requests) to queue:requests_number=awaitqueue.return_unacked(timeout=300,limit=500)Clean queue (delete acknowledged massages) to not overfill database with old data
(default limit= messages of 1000 requests):requests_number=awaitqueue.clean_acked_queue(limit=500)
Package: asyncprawcore
asyncprawcore is a low-level communication layer used by Async PRAW 7+.InstallationInstall asyncprawcore usingpipvia:pip install asyncprawcoreExecution ExampleThe following example demonstrates how to use asyncprawcore to obtain the list of
trophies for a given user using the script-app type. This example assumes you have the
environment variablesPRAWCORE_CLIENT_IDandPRAWCORE_CLIENT_SECRETset to the
appropriate values for your application.importosimportpprintimportasyncioimportasyncprawcoreasyncdefmain():authenticator=asyncprawcore.TrustedAuthenticator(asyncprawcore.Requestor("YOUR_VALID_USER_AGENT"),os.environ["PRAWCORE_CLIENT_ID"],os.environ["PRAWCORE_CLIENT_SECRET"],)authorizer=asyncprawcore.ReadOnlyAuthorizer(authenticator)awaitauthorizer.refresh()asyncwithasyncprawcore.session(authorizer)assession:pprint.pprint(awaitsession.request("GET","/api/v1/user/bboe/trophies"))if__name__=="__main__":asyncio.run(main())Save the above astrophies.pyand then execute via:python trophies.pyAdditional examples can be found at:https://github.com/praw-dev/asyncprawcore/tree/main/examplesDepending on asyncprawcoreasyncprawcore followssemantic versioningwith the exception
that deprecations will not be preceded by a minor release. In essence, expect only major
versions to introduce breaking changes to asyncprawcore’s public interface. As a result,
if you depend on asyncprawcore then it is a good idea to specify not only the minimum
version of asyncprawcore your package requires, but to also limit the major version.Below are two examples of how you may want to specify your asyncprawcore dependency:setup.pysetup(...,install_requires=["asyncprawcore >=0.1, <1"],...)requirements.txtasyncprawcore >=1.5.1, <2
Package: async-processor
Async ServiceInstallpip install "async_processor[sqs]"Quick startWrite the Processorapp.pyfromasync_processorimport(InputMessage,Processor,WorkerConfig,SQSInputConfig,SQSOutputConfig,)classMultiplicationProcessor(Processor):defprocess(self,input_message:InputMessage)->int:body=input_message.bodyreturnbody["x"]*body["y"]app=MultiplicationProcessor().build_app(worker_config=WorkerConfig(input_config=SQSInputConfig(queue_url="YOUR_INPUT_SQS_URL",visibility_timeout=2,),output_config=SQSOutputConfig(queue_url="YOUR_OUTPUT_SQS_URL"),),)Run the appgunicorn app:app --workers 1 --worker-class uvicorn.workers.UvicornWorker --bind 127.0.0.1:8000Output:✦6 ❯ gunicorn app:app --workers 1 --worker-class uvicorn.workers.UvicornWorker --bind 127.0.0.1:8000[2023-08-17 16:10:33 +0530] [78736] [INFO] Starting gunicorn 21.2.0[2023-08-17 16:10:33 +0530] [78736] [INFO] Listening at: http://127.0.0.1:8000 (78736)[2023-08-17 16:10:33 +0530] [78736] [INFO] Using worker: uvicorn.workers.UvicornWorker[2023-08-17 16:10:33 +0530] [78738] [INFO] Booting worker with pid: 78738[2023-08-17 16:10:33 +0530] [78738] [INFO] Started server process [78738][2023-08-17 16:10:33 +0530] [78738] [INFO] Waiting for application startup.2023-08-17 16:10:33,764 - app - INFO - Invoking the processor init method2023-08-17 16:10:33,765 - app - INFO - Processor init method execution completed2023-08-17 16:10:33,765 - app - INFO - Starting processor runner2023-08-17 16:10:34,461 - app - INFO - Started processor runner2023-08-17 16:10:34,462 - app - INFO - Polling messages[2023-08-17 16:10:34 +0530] [78738] [INFO] Application startup complete.Send a synchronus process requestcurl 'http://localhost:8000/process' -H 'Content-Type: application/json'  -d '{"request_id": "abc", "body": {"x": 1, "y": 2}}'Output:❯ curl 'http://localhost:8000/process' -H 'Content-Type: application/json'  -d '{"request_id": "abc", "body": {"x": 1, "y": 2}}'{"request_id":"abc","status":"SUCCESS","body":2,"error":null}A FastAPI documentation dashboard will be available onhttp://localhostSend an asynchronus process requestsend_async_request.pyimportjsonimportuuidfromasync_processorimportInputMessage,OutputMessage,ProcessStatusimportboto3defsend_request(input_sqs_url:str,output_sqs_url:str):sqs=boto3.client("sqs")request_id=str(uuid.uuid4())sqs.send_message(QueueUrl=input_sqs_url,MessageBody=json.dumps(InputMessage(request_id=request_id,body={"x":1,"y":2}).dict()),)whileTrue:response=sqs.receive_message(QueueUrl=output_sqs_url,MaxNumberOfMessages=1,WaitTimeSeconds=19)if"Messages"notinresponse:continuemsg=response["Messages"][0]response=OutputMessage(**json.loads(msg["Body"]))ifProcessStatus[response.status]isnotProcessStatus.SUCCESS:raiseException(f"processing failed:{response.error}")print(response)breakif__name__=="__main__":send_request(input_sqs_url="YOUR_INPUT_SQS_URL",output_sqs_url="YOUR_OUTPUT_SQS_URL")Run the above python scriptpython send_async_request.pyOutput:❯ python send_async_request.pyrequest_id='46a4ebc6-afdb-46a0-8587-ba29abf0f0d4' status='SUCCESS' body=2 error=None
Package: async-process-pool
Async Process Pool and QueueThis contains anasyncioaware multiprocessing utility that allows work to be scheduled across multiple processes.It consists of the following sub-utilities:Async Process Queue: allows awaitable cross-process queuesProcess Pool: allows for a pool of processes to be created which can take work.
Communication to these processes is via an async process queue.Watchdog: a asyncio implementation of a watchdog timer. It will fire an action if it is not reset within a set time. For example: re-registering a worker if a heartbeat signal is not received at least every 5 seconds.RequirementsThis library requires Python 3.7 or greater to be able to run. The library package installer will block attempts to use Python 3.6 or lower.The library is tested on Python 3.7, taking advantage of significant improvements to theasyncioAPI and implementation in Python.
It is tested most heavily on Debian/Ubuntu Linux, but known to work on Microsoft Windows.
Package: async-property
async_propertyPython decorator for async properties.Python: 3.7+Free software: MIT licenseDocumentation:https://async-property.readthedocs.ioPackage:https://pypi.org/project/async-propertySource code:https://github.com/ryananguiano/async_propertyInstallTo install async_property, run this command in your terminal:$pipinstallasync-propertyOr if you have pipenv:$pipenvinstallasync-propertyUsageYou can use@async_propertyjust as you would with@property, but on an async function.classFoo:@async_propertyasyncdefremote_value(self):returnawaitget_remote_value()The propertyremote_valuenow returns an awaitable coroutine.instance=Foo()awaitinstance.remote_valueCached Properties@async_cached_propertywill call the function only once. Subsequent awaits to the property will return a cached value.classFoo:@async_cached_propertyasyncdefvalue(self):print('loading value')return123>>>instance=Foo()>>>instance.value<AwaitableOnly"Foo.value">>>>awaitinstance.valueloadingvalue123>>>awaitinstance.value123>>>instance.value123>>>instance.value='abc'>>>instance.value'abc'>>>awaitinstance.value'abc'>>>delinstance.value>>>awaitinstance.valueloadingvalue123AwaitLoaderIf you have an object with multiple cached properties, you can subclassAwaitLoader. This will make your class instances awaitable and will load all@async_cached_propertyfields concurrently.AwaitLoaderwill callawait instance.load(), if it exists, before loading properties.classFoo(AwaitLoader):asyncdefload(self):print('load called')@async_cached_propertyasyncdefdb_lookup(self):return'success'@async_cached_propertyasyncdefapi_call(self):print('calling api')return'works every time'>>>instance=awaitFoo()loadcalledcallingapi>>>instance.db_lookup'success'>>>instance.api_call'works every time'FeaturesBoth regular and cached property.Cached properties can be accessed multiple times without repeating function call.Uses asyncio.Lock to ensure cached functions are called only once.Full test coverage with py.testCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.TheObjectProxyclass was taken fromwraptlibrary by Graham Dumpleton.History0.2.2 (2023-07-03)Add Python 3.11 support and drop Python 3.6.0.2.1 (2019-04-13)Update docs and readme0.2.0 (2019-04-12)Use instance state to hold cache and locks0.1.4 (2019-04-12)Fix inheritance issues on AwaitLoader0.1.3 (2019-04-12)Cleanup code0.1.2 (2019-04-12)Fix asyncio.Lock issues0.1.1 (2019-04-11)Complete test coverage and update readme0.1.0 (2019-04-11)First release on PyPI.