Metadata-Version: 2.1
Name: fastapi-plugins
Version: 0.9.0
Summary: Plugins for FastAPI framework
Home-page: https://github.com/madkote/fastapi-plugins
Author: madkote
Author-email: madkote <madkote@bluewin.ch>
License: MIT License
Download-URL: https://github.com/madkote/fastapi-plugins/archive/0.9.0.tar.gz
Description: <p align="center">
            <em>Plugins for FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>
        </p>
        <p align="center">
        <a href="https://travis-ci.org/madkote/fastapi-plugins" target="_blank">
            <img src="https://travis-ci.org/madkote/fastapi_plugins.svg?branch=master" alt="Build Status">
        </a>
        <a href="https://codecov.io/gh/madkote/fastapi-plugins" target="_blank">
            <img src="https://codecov.io/gh/madkote/fastapi_plugins/branch/master/graph/badge.svg" alt="Coverage">
        </a>
        <a href="https://pypi.org/project/fastapi-plugins" target="_blank">
            <img src="https://img.shields.io/pypi/v/fastapi_plugins.svg" alt="Package version">
        </a>
        <a href="https://gitter.im/tiangolo/fastapi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge" target="_blank">
            <img src="https://badges.gitter.im/tiangolo/fastapi.svg" alt="Join the chat at https://gitter.im/tiangolo/fastapi">
        </a>
        </p>
        
        # fastapi-plugins
        FastAPI framework plugins - simple way to share `fastapi` code and utilities across applications.
        
        The concept is `plugin` - plug a functional utility into your application without or with minimal effort.
        
        * [Cache](./docs/cache.md)
          * [Memcached](./docs/cache.md#memcached)
          * [Redis](./docs/cache.md#redis)
        * [Scheduler](./docs/scheduler.md)
        * [Control](./docs/control.md)
          * [Version](./docs/control.md#version)
          * [Environment](./docs/control.md#environment)
          * [Health](./docs/control.md#health)
          * [Heartbeat](./docs/control.md#heartbeat)
        * [Application settings/configuration](./docs/settings.md)
        * [Logging](./docs/logger.md)
        * Celery
        * MQ
        * and much more is already in progress...
        
        ## Changes
        See [release notes](CHANGES.md)
        
        ## Installation
        * by default contains
          * [Redis](./docs/cache.md#redis)
          * [Scheduler](./docs/scheduler.md)
          * [Control](./docs/control.md)
          * [Logging](./docs/logger.md)
        * `memcached` adds [Memcached](#memcached)
        * `all` add everything above
        
        ```sh
        pip install fastapi-plugins
        pip install fastapi-plugins[memcached]
        pip install fastapi-plugins[all]
        ```
        
        ## Quick start
        ### Plugin
        Add information about plugin system.
        ### Application settings
        Add information about settings.
        ### Application configuration
        Add information about configuration of an application
        ### Complete example
        ```python
        import fastapi
        import fastapi_plugins
        
        from fastapi_plugins.memcached import MemcachedSettings
        from fastapi_plugins.memcached import MemcachedClient
        from fastapi_plugins.memcached import depends_memcached
        from fastapi_plugins.memcached import memcached_plugin
        
        import asyncio
        import aiojobs
        import aioredis
        import logging
        
        @fastapi_plugins.registered_configuration
        class AppSettings(
                fastapi_plugins.ControlSettings,
                fastapi_plugins.RedisSettings,
                fastapi_plugins.SchedulerSettings,
                fastapi_plugins.LoggingSettings,
                MemcachedSettings,
        ):
            api_name: str = str(__name__)
            logging_level: int = logging.DEBUG
            logging_style: fastapi_plugins.LoggingStyle = fastapi_plugins.LoggingStyle.logjson
        
        
        @fastapi_plugins.registered_configuration(name='sentinel')
        class AppSettingsSentinel(AppSettings):
            redis_type = fastapi_plugins.RedisType.sentinel
            redis_sentinels = 'localhost:26379'
        
        
        app = fastapi_plugins.register_middleware(fastapi.FastAPI())
        config = fastapi_plugins.get_config()
        
        @app.get("/")
        async def root_get(
                cache: aioredis.Redis=fastapi.Depends(fastapi_plugins.depends_redis),
                conf: pydantic.BaseSettings=fastapi.Depends(fastapi_plugins.depends_config), # noqa E501
                logger: logging.Logger=fastapi.Depends(fastapi_plugins.depends_logging)
        ) -> typing.Dict:
            ping = await cache.ping()
            logger.debug('root_get', extra=dict(ping=ping, api_name=conf.api_name))
            return dict(ping=ping, api_name=conf.api_name)
        
        
        @app.post("/jobs/schedule/<timeout>")
        async def job_post(
            timeout: int=fastapi.Query(..., title='the job sleep time'),
            cache: aioredis.Redis=fastapi.Depends(fastapi_plugins.depends_redis),
            scheduler: aiojobs.Scheduler=fastapi.Depends(fastapi_plugins.depends_scheduler),  # noqa E501
            logger: logging.Logger=fastapi.Depends(fastapi_plugins.depends_logging)
        ) -> str:
            async def coro(job_id, timeout, cache):
                await cache.set(job_id, 'processing')
                try:
                    await asyncio.sleep(timeout)
                    if timeout == 8:
                        logger.critical('Ugly erred job %s' % job_id)
                        raise Exception('ugly error')
                except asyncio.CancelledError:
                    await cache.set(job_id, 'canceled')
                    logger.warning('Cancel job %s' % job_id)
                except Exception:
                    await cache.set(job_id, 'erred')
                    logger.error('Erred job %s' % job_id)
                else:
                    await cache.set(job_id, 'success')
                    logger.info('Done job %s' % job_id)
        
            job_id = str(uuid.uuid4()).replace('-', '')
            logger = await fastapi_plugins.log_adapter(logger, extra=dict(job_id=job_id, timeout=timeout))    # noqa E501
            logger.info('New job %s' % job_id)
            await cache.set(job_id, 'pending')
            logger.debug('Pending job %s' % job_id)
            await scheduler.spawn(coro(job_id, timeout, cache))
            return job_id
        
        
        @app.get("/jobs/status/<job_id>")
        async def job_get(
            job_id: str=fastapi.Query(..., title='the job id'),
            cache: aioredis.Redis=fastapi.Depends(fastapi_plugins.depends_redis),
        ) -> typing.Dict:
            status = await cache.get(job_id)
            if status is None:
                raise fastapi.HTTPException(
                    status_code=starlette.status.HTTP_404_NOT_FOUND,
                    detail='Job %s not found' % job_id
                )
            return dict(job_id=job_id, status=status)
        
        
        @app.post("/memcached/demo/<key>")
        async def memcached_demo_post(
            key: str=fastapi.Query(..., title='the job id'),
            cache: MemcachedClient=fastapi.Depends(depends_memcached),
        ) -> typing.Dict:
            await cache.set(key.encode(), str(key + '_value').encode())
            value = await cache.get(key.encode())
            return dict(ping=(await cache.ping()).decode(), key=key, value=value)
        
        
        @app.on_event('startup')
        async def on_startup() -> None:
            await fastapi_plugins.config_plugin.init_app(app, config)
            await fastapi_plugins.config_plugin.init()
            await fastapi_plugins.log_plugin.init_app(app, config, name=__name__)
            await fastapi_plugins.log_plugin.init()
            await memcached_plugin.init_app(app, config)
            await memcached_plugin.init()
            await fastapi_plugins.redis_plugin.init_app(app, config=config)
            await fastapi_plugins.redis_plugin.init()
            await fastapi_plugins.scheduler_plugin.init_app(app=app, config=config)
            await fastapi_plugins.scheduler_plugin.init()
            await fastapi_plugins.control_plugin.init_app(
                app,
                config=config,
                version=__version__,
                environ=config.dict()
            )
            await fastapi_plugins.control_plugin.init()
        
        
        @app.on_event('shutdown')
        async def on_shutdown() -> None:
            await fastapi_plugins.control_plugin.terminate()
            await fastapi_plugins.scheduler_plugin.terminate()
            await fastapi_plugins.redis_plugin.terminate()
            await memcached_plugin.terminate()
            await fastapi_plugins.log_plugin.terminate()
            await fastapi_plugins.config_plugin.terminate()
        ```
        
        # Development
        Issues and suggestions are welcome through [issues](https://github.com/madkote/fastapi-plugins/issues)
        
        # License
        This project is licensed under the terms of the MIT license.
        
        
        # Changes
        ## 0.9.0 (2021-09-27)
        - `[feature]` Logging plugin
        - `[feature]` Middleware interface - register middleware at application
        ## 0.8.2 (2021-09-23)
        - `[fix]` Fix dependency for aioredis
        ## 0.8.1 (2021-03-31)
        - `[fix]` Fix settings for Python 3.7
        ## 0.8.0 (2021-03-31)
        - `[feature]` Settings plugin
        ## 0.7.0 (2021-03-29)
        - `[feature]` Control plugin with Health, Heartbeat, Environment and Version
        ## 0.6.1 (2021-03-24)
        - `[fix]` Bump `aiojobs`to get rid of not required dependencies
        ## 0.6.0 (2020-11-26)
        - `[feature]` Memcached
        ## 0.5.0 (2020-11-25)
        - [bug] remove `__all__` since no API as such ([#6][i6]).
        - [typo] Fix typos in README ([#7][i7]).
        - [feature] Add Redis TTL ([#8][i8]).
        ## 0.4.2 (2020-11-24)
        - [bug] Fix Redis URL ([#4][i4]). 
        ## 0.4.1 (2020-06-16)
        - Refactor requirements
        ## 0.4.0 (2020-04-09)
        - structure and split dependencies to `extra`
        ## 0.3.0 (2020-04-07)
        - Scheduler: tasks scheduler based on `aiojobs`
        ## 0.2.1 (2020-04-06)
        - Redis: pre-start
        ## 0.2.0 (2019-12-11)
        - Redis: sentinels
        ## 0.1.0 (2019-11-20)
        - Initial release: simple redis pool client
        
        [i4]: https://github.com/madkote/fastapi-plugins/pull/4
        [i6]: https://github.com/madkote/fastapi-plugins/pull/6
        [i7]: https://github.com/madkote/fastapi-plugins/pull/7
        [i8]: https://github.com/madkote/fastapi-plugins/issues/8
        
Keywords: async,redis,aioredis,json,asyncio,plugin,fastapi,aiojobs,scheduler,starlette,memcached,aiomcache
Platform: any
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Utilities
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: System :: Logging
Classifier: Framework :: AsyncIO
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Requires-Python: >=3.6.0
Description-Content-Type: text/markdown
Provides-Extra: all
Provides-Extra: memcached
Provides-Extra: test
