co6co.web-session 0.0.1__tar.gz

co6co_web_session-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: co6co.web_session
+Version: 0.0.1
+Summary: web session 扩展
+Home-page: http://github.com/co6co
+Author: co6co
+Author-email: co6co@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Description-Content-Type: text/markdown
+Requires-Dist: co6co
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+# web session header
+
+```
+0.0.1 未经严谨测试
+```

co6co_web_session-0.0.1/README.md

@@ -0,0 +1,5 @@
+# web session header
+
+```
+0.0.1 未经严谨测试
+```

co6co_web_session-0.0.1/co6co.web_session.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.2
+Name: co6co.web_session
+Version: 0.0.1
+Summary: web session 扩展
+Home-page: http://github.com/co6co
+Author: co6co
+Author-email: co6co@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Description-Content-Type: text/markdown
+Requires-Dist: co6co
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+# web session header
+
+```
+0.0.1 未经严谨测试
+```

co6co_web_session-0.0.1/co6co.web_session.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+setup.py
+co6co.web_session.egg-info/PKG-INFO
+co6co.web_session.egg-info/SOURCES.txt
+co6co.web_session.egg-info/dependency_links.txt
+co6co.web_session.egg-info/requires.txt
+co6co.web_session.egg-info/top_level.txt
+co6co.web_session.egg-info/zip-safe
+co6co_web_session/__init__.py
+co6co_web_session/aioredis.py
+co6co_web_session/base.py
+co6co_web_session/memcache.py
+co6co_web_session/memory.py
+co6co_web_session/mongodb.py
+co6co_web_session/redis.py
+co6co_web_session/session.py
+co6co_web_session/utils.py
+co6co_web_session/versions.py

co6co_web_session-0.0.1/co6co.web_session.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

co6co_web_session-0.0.1/co6co.web_session.egg-info/requires.txt

@@ -0,0 +1 @@
+co6co

co6co_web_session-0.0.1/co6co.web_session.egg-info/top_level.txt

@@ -0,0 +1 @@
+co6co_web_session

co6co_web_session-0.0.1/co6co.web_session.egg-info/zip-safe

@@ -0,0 +1 @@
+

co6co_web_session-0.0.1/co6co_web_session/__init__.py

@@ -0,0 +1,17 @@
+from .memcache import MemcacheSessionImp
+from .redis import RedisSessionImp
+from .memory import MemorySessionImp
+from .mongodb import MongoDBSessionImp
+from .aioredis import AIORedisSessionImp
+from .session import Session
+from .base import IBaseSession
+
+__all__ = (
+    "IBaseSession",
+    "Session",
+    "MemcacheSessionImp",
+    "RedisSessionImp",
+    "MemorySessionImp",
+    "MongoDBSessionImp",
+    "AIORedisSessionImp",
+)

co6co_web_session-0.0.1/co6co_web_session/aioredis.py

@@ -0,0 +1,77 @@
+from .base import IBaseSession
+
+try:
+    import aioredis
+except ImportError:
+    aioredis = None
+
+
+class AIORedisSessionImp(IBaseSession):
+    def __init__(
+        self,
+        redis,
+        expiry: int = 2592000,
+        head_name: str = "session",
+        prefix: str = "session:",
+        samesite: str = None,
+        session_name: str = "Session",
+        secure: bool = False,
+    ):
+        """Initializes a session interface backed by Redis.
+
+        Args:
+            redis (Callable):
+                aioredis connection or connection pool instance.
+            domain (str, optional):
+                Optional domain which will be attached to the cookie.
+            expiry (int, optional):
+                Seconds until the session should expire.
+            httponly (bool, optional):
+                Adds the `httponly` flag to the session cookie.
+            cookie_name (str, optional):
+                Name used for the client cookie.
+            prefix (str, optional):
+                Memcache keys will take the format of `prefix+session_id`;
+                specify the prefix here.
+            sessioncookie (bool, optional):
+                Specifies if the sent cookie should be a 'session cookie', i.e
+                no Expires or Max-age headers are included. Expiry is still
+                fully tracked on the server side. Default setting is False.
+            samesite (str, optional):
+                Will prevent the cookie from being sent by the browser to the target
+                site in all cross-site browsing context, even when following a regular link.
+                One of ('lax', 'strict')
+                Default: None
+            session_name (str, optional):
+                Name of the session that will be accessible through the request.
+                e.g. If ``session_name`` is ``alt_session``, it should be
+                accessed like that: ``request.ctx.alt_session``
+                e.g. And if ``session_name`` is left to default, it should be
+                accessed like that: ``request.ctx.session``
+                Default: 'session'
+            secure (bool, optional):
+                Adds the `Secure` flag to the session cookie.
+        """
+        if aioredis is None:
+            raise RuntimeError("Please install aioredis: pip install sanic_session[aioredis]")
+
+        self.redis = redis
+
+        super().__init__(
+            expiry=expiry,
+            prefix=prefix,
+            head_name=head_name,
+
+            samesite=samesite,
+            session_name=session_name,
+            secure=secure,
+        )
+
+    async def _get_value(self, prefix, sid):
+        return await self.redis.get(self.prefix + sid)
+
+    async def _delete_key(self, key):
+        await self.redis.delete(key)
+
+    async def _set_value(self, key, data):
+        await self.redis.setex(key, self.expiry, data)

co6co_web_session-0.0.1/co6co_web_session/base.py

@@ -0,0 +1,143 @@
+import time
+import datetime
+import abc
+import uuid
+from co6co.utils import log
+from co6co.storage.Dict import CallbackDict
+try:
+    import ujson
+except ImportError:
+    import json as ujson
+
+
+def get_request_container(request):
+    """
+    用于获取请求的容器对象
+    """
+    return request.ctx.__dict__ if hasattr(request, "ctx") else request
+
+
+class SessionDict(CallbackDict):
+    def __init__(self, initial=None, sid=None):
+        def on_update(self):
+            self.modified = True
+
+        super().__init__(initial, on_update)
+
+        self.sid = sid
+        self.modified = False
+
+
+class IBaseSession(metaclass=abc.ABCMeta):
+    # this flag show does this Interface need request/response middleware hooks
+
+    def __init__(
+        # 会话的过期时间，单位为秒
+        self, expiry: int,
+        # 存储会话数据时使用的键前缀
+        prefix: str,
+        # 头部名称，可能用于自定义请求头或响应头
+        head_name: str,
+        # 用于设置 Cookie 的 SameSite 属性
+        samesite,
+        # 会话对象在请求容器中的名称
+        session_name,
+        # 是否使用安全的 Cookie（仅通过 HTTPS 传输）
+        secure,
+    ):
+
+        self.expiry = expiry
+        self.prefix = prefix
+        self.head_name = head_name
+        self.samesite = samesite
+        self.session_name = session_name
+        self.secure = secure
+
+    @staticmethod
+    def _calculate_expires(expiry):
+        expires = time.time() + expiry
+        return datetime.datetime.fromtimestamp(expires)
+
+    @abc.abstractmethod
+    async def _get_value(self, prefix: str, sid: str):
+        """
+        Get value from datastore. Specific implementation for each datastore.
+
+        Args:
+            prefix:
+                A prefix for the key, useful to namespace keys.
+            sid:
+                a uuid in hex string
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def _delete_key(self, key: str):
+        """Delete key from datastore"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def _set_value(self, key: str, data: SessionDict):
+        """Set value for datastore"""
+        raise NotImplementedError
+
+    def getSid(self, request):
+        sid = request.headers.get(self.head_name)
+        return sid
+
+    async def open(self, request) -> SessionDict:
+        """
+        Opens a session onto the request. Restores the client's session
+        from the datastore if one exists.The session data will be available on
+        `request.session`. 
+        Args:
+            request (sanic.request.Request):
+                The request, which a sessionwill be opened onto.
+
+        Returns:
+            SessionDict:
+                the client's session data,
+                attached as well to `request.session`.
+        """
+
+        sid = self. getSid(request)
+        if not sid:
+            sid = uuid.uuid4().hex
+            session_dict = SessionDict(sid=sid)
+        else:
+            val = await self._get_value(self.prefix, sid)
+
+            if val is not None:
+                data = ujson.loads(val)
+                session_dict = SessionDict(data, sid=sid)
+            else:
+                session_dict = SessionDict(sid=sid)
+
+        # attach the session data to the request, return it for convenience
+        req = get_request_container(request)
+        req[self.session_name] = session_dict
+        return session_dict
+
+    async def save(self, request, response) -> None:
+        """Saves the session to the datastore.
+
+        Args:
+            request (sanic.request.Request):
+                The sanic request which has an attached session.
+            response (sanic.response.Response):
+                The Sanic response. Cookies with the appropriate expiration
+                will be added onto this response.
+
+        Returns:
+            None
+        """
+        req = get_request_container(request)
+        if self.session_name not in req:
+            return
+
+        key = self.prefix + req[self.session_name].sid
+        if not req[self.session_name]:
+            await self._delete_key(key)
+
+        val = ujson.dumps(dict(req[self.session_name]))
+        await self._set_value(key, val)

co6co_web_session-0.0.1/co6co_web_session/memcache.py

@@ -0,0 +1,92 @@
+import warnings
+
+from .base import IBaseSession
+
+try:
+    import aiomcache
+except ImportError:  # pragma: no cover
+    aiomcache = None
+
+
+class MemcacheSessionImp(IBaseSession):
+    def __init__(
+        self,
+        memcache_connection,
+        domain: str = None,
+        expiry: int = 2592000,
+        httponly: bool = True,
+        cookie_name: str = "session",
+        prefix: str = "session:",
+        sessioncookie: bool = False,
+        samesite: str = None,
+        session_name: str = "Session",
+        secure: bool = False,
+    ):
+        """Initializes the interface for storing client sessions in memcache.
+        Requires a client object establised with `asyncio_memcache`.
+
+        Args:
+            memcache_connection (aiomccache.Client):
+                The memcache client used for interfacing with memcache.
+            domain (str, optional):
+                Optional domain which will be attached to the cookie.
+            expiry (int, optional):
+                Seconds until the session should expire.
+            httponly (bool, optional):
+                Adds the `httponly` flag to the session cookie.
+            cookie_name (str, optional):
+                Name used for the client cookie.
+            prefix (str, optional):
+                Memcache keys will take the format of `prefix+session_id`;
+                specify the prefix here.
+            sessioncookie (bool, optional):
+                Specifies if the sent cookie should be a 'session cookie', i.e
+                no Expires or Max-age headers are included. Expiry is still
+                fully tracked on the server side. Default setting is False.
+            samesite (str, optional):
+                Will prevent the cookie from being sent by the browser to
+                the target site in all cross-site browsing context, even when
+                following a regular link. One of ('lax', 'strict')
+                Default: None
+            session_name (str, optional):
+                Name of the session that will be accessible through the
+                request.
+                e.g. If ``session_name`` is ``alt_session``, it should be
+                accessed like that: ``request.ctx.alt_session``
+                e.g. And if ``session_name`` is left to default, it should be
+                accessed like that: ``request.ctx.session``
+                Default: 'session'
+            secure (bool, optional):
+                Adds the `Secure` flag to the session cookie.
+        """
+        if aiomcache is None:
+            raise RuntimeError("Please install aiomcache: pip install " "sanic_session[aiomcache]")
+
+        self.memcache_connection = memcache_connection
+
+        if expiry > 2592000:
+            warnings.warn("Memcache has a maximum 30-day cache limit")
+            expiry = 0
+
+        super().__init__(
+            expiry=expiry,
+            prefix=prefix,
+            cookie_name=cookie_name,
+            domain=domain,
+            httponly=httponly,
+            sessioncookie=sessioncookie,
+            samesite=samesite,
+            session_name=session_name,
+            secure=secure,
+        )
+
+    async def _get_value(self, prefix, sid):
+        key = (self.prefix + sid).encode()
+        value = await self.memcache_connection.get(key)
+        return value.decode() if value else None
+
+    async def _delete_key(self, key):
+        return await self.memcache_connection.delete(key.encode())
+
+    async def _set_value(self, key, data):
+        return await self.memcache_connection.set(key.encode(), data.encode(), exptime=self.expiry)

co6co_web_session-0.0.1/co6co_web_session/memory.py

@@ -0,0 +1,34 @@
+from .base import IBaseSession
+from co6co.storage.Dict import ExpiringDict
+
+
+class MemorySessionImp(IBaseSession):
+    def __init__(
+        self,
+        expiry: int = 2592000,
+        head_name: str = "session",
+        prefix: str = "session:",
+        samesite: str = None,
+        session_name="Session",
+        secure: bool = False,
+    ):
+
+        super().__init__(
+            expiry=expiry,
+            prefix=prefix,
+            head_name=head_name,
+            samesite=samesite,
+            session_name=session_name,
+            secure=secure,
+        )
+        self.session_store = ExpiringDict()
+
+    async def _get_value(self, prefix, sid):
+        return self.session_store.get(self.prefix + sid)
+
+    async def _delete_key(self, key):
+        if key in self.session_store:
+            self.session_store.delete(key)
+
+    async def _set_value(self, key, data):
+        self.session_store.set(key, data, self.expiry)

co6co_web_session-0.0.1/co6co_web_session/mongodb.py

@@ -0,0 +1,129 @@
+from datetime import datetime, timedelta
+import warnings
+from .base import IBaseSession
+
+try:
+    from sanic_motor import BaseModel
+
+    class _SessionModel(BaseModel):
+        """Collection for session storing.
+
+        Collection name (default session)
+
+        Fields:
+            sid
+            expiry
+            data:
+                User's session data
+        """
+
+        pass
+
+
+except ImportError:  # pragma: no cover
+    _SessionModel = None
+
+
+class MongoDBSessionImp(IBaseSession):
+    def __init__(
+        self,
+        app,
+        coll: str = "session",
+        domain: str = None,
+        expiry: int = 30 * 24 * 60 * 60,
+        httponly: bool = True,
+        hand_name: str = "session",
+        sessioncookie: bool = False,
+        samesite: str = None,
+        session_name: str = "Session",
+        secure: bool = False,
+    ):
+        """Initializes the interface for storing client sessions in MongoDB.
+
+        Args:
+            app (sanic.Sanic):
+                Sanic instance to register listener('after_server_start')
+            coll (str, optional):
+                MongoDB collection name for session
+            domain (str, optional):
+                Optional domain which will be attached to the cookie.
+            expiry (int, optional):
+                Seconds until the session should expire.
+            httponly (bool, optional):
+                Adds the `httponly` flag to the session cookie.
+            cookie_name (str, optional):
+                Name used for the client cookie.
+            sessioncookie (bool, optional):
+                Specifies if the sent cookie should be a 'session cookie', i.e
+                no Expires or Max-age headers are included. Expiry is still
+                fully tracked on the server side. Default setting is False.
+            samesite (str, optional):
+                Will prevent the cookie from being sent by the browser to
+                the target site in all cross-site browsing context, even when
+                following a regular link.
+                One of ('lax', 'strict')
+                Default: None
+            session_name (str, optional):
+                Name of the session that will be accessible through the
+                request.
+                e.g. If ``session_name`` is ``alt_session``, it should be
+                accessed like that: ``request.ctx.alt_session``
+                e.g. And if ``session_name`` is left to default, it should be
+                accessed like that: ``request.ctx.session``
+                Default: 'session'
+            secure (bool, optional):
+                Adds the `Secure` flag to the session cookie.
+        """
+        if _SessionModel is None:
+            raise RuntimeError("Please install Mongo dependencies: " "pip install sanic_session[mongo]")
+
+        # prefix not needed for mongodb as mongodb uses uuid4 natively
+        prefix = ""
+
+        if httponly is not True:
+            warnings.warn(
+                """
+                httponly default arg has changed.
+                To spare you some debugging time, httponly is currently
+                hardcoded as True. This message will be removed with the
+                next release. And ``httponly`` will no longer be hardcoded
+            """,
+                DeprecationWarning,
+            )
+
+        super().__init__(
+            expiry=expiry,
+            prefix=prefix,
+            hand_name=hand_name,
+            samesite=samesite,
+            session_name=session_name,
+            secure=secure,
+        )
+
+        # set collection name
+        _SessionModel.__coll__ = coll
+
+        @app.listener("after_server_start")
+        async def apply_session_indexes(app, loop):
+            """Create indexes in session collection
+            if doesn't exist.
+
+            Indexes:
+                sid:
+                    For faster lookup.
+                expiry:
+                    For document expiration.
+            """
+            await _SessionModel.create_index("sid")
+            await _SessionModel.create_index("expiry", expireAfterSeconds=0)
+
+    async def _get_value(self, prefix, key):
+        value = await _SessionModel.find_one({"sid": key}, as_raw=True)
+        return value["data"] if value else None
+
+    async def _delete_key(self, key):
+        await _SessionModel.delete_one({"sid": key})
+
+    async def _set_value(self, key, data):
+        expiry = datetime.utcnow() + timedelta(seconds=self.expiry)
+        await _SessionModel.replace_one({"sid": key}, {"sid": key, "expiry": expiry, "data": data}, upsert=True)

co6co_web_session-0.0.1/co6co_web_session/redis.py

@@ -0,0 +1,86 @@
+from typing import Callable
+from co6co_web_session.base import IBaseSession
+
+try:
+    import asyncio_redis
+except ImportError:
+    asyncio_redis = None
+
+
+class RedisSessionImp(IBaseSession):
+    def __init__(
+        self,
+        redis_getter: Callable,
+        domain: str = None,
+        expiry: int = 2592000,
+        httponly: bool = True,
+        head_anme: str = "session",
+        prefix: str = "session:",
+        sessioncookie: bool = False,
+        samesite: str = None,
+        session_name: str = "Session",
+        secure: bool = False,
+    ):
+        """Initializes a session interface backed by Redis.
+
+        Args:
+            redis_getter (Callable):
+                Coroutine which should return an asyncio_redis connection pool
+                (suggested) or an asyncio_redis Redis connection.
+            domain (str, optional):
+                Optional domain which will be attached to the cookie.
+            expiry (int, optional):
+                Seconds until the session should expire.
+            httponly (bool, optional):
+                Adds the `httponly` flag to the session cookie.
+            cookie_name (str, optional):
+                Name used for the client cookie.
+            prefix (str, optional):
+                Memcache keys will take the format of `prefix+session_id`;
+                specify the prefix here.
+            sessioncookie (bool, optional):
+                Specifies if the sent cookie should be a 'session cookie', i.e
+                no Expires or Max-age headers are included. Expiry is still
+                fully tracked on the server side. Default setting is False.
+            samesite (str, optional):
+                Will prevent the cookie from being sent by the browser to the
+                target site in all cross-site browsing context, even when
+                following a regular link.
+                One of ('lax', 'strict')
+                Default: None
+            session_name (str, optional):
+                Name of the session that will be accessible through the
+                request.
+                e.g. If ``session_name`` is ``alt_session``, it should be
+                accessed like that: ``request.ctx.alt_session``
+                e.g. And if ``session_name`` is left to default, it should be
+                accessed like that: ``request.ctx.session``
+                Default: 'session'
+            secure (bool, optional):
+                Adds the `Secure` flag to the session cookie.
+        """
+        if asyncio_redis is None:
+            raise RuntimeError("Please install asyncio_redis: pip install sanic_session[redis]")
+
+        self.redis_getter = redis_getter
+
+        super().__init__(
+            expiry=expiry,
+            prefix=prefix,
+            head_anme=head_anme,
+            samesite=samesite,
+            session_name=session_name,
+            secure=secure,
+        )
+
+    async def _get_value(self, prefix, key):
+        redis_connection = await self.redis_getter()
+        return await redis_connection.get(prefix + key)
+
+    async def _delete_key(self, key):
+        redis_connection = await self.redis_getter()
+        await redis_connection.delete([key])
+
+    async def _set_value(self, key, data):
+        redis_connection = await self.redis_getter()
+        await redis_connection.setex(key, self.expiry, data)

co6co_web_session-0.0.1/co6co_web_session/session.py

@@ -0,0 +1,41 @@
+
+from .memory import MemorySessionImp
+from .base import IBaseSession
+
+
+class Session:
+
+    def __init__(self, app=None, interface: IBaseSession = None):
+        self.interface = None
+        if app:
+            self.init_app(app, interface)
+
+    @property
+    def expiry(self):
+        """
+        session 过期时间
+        """
+        return self.interface.expiry if self.interface else None
+
+    def init_app(self, app, interface: IBaseSession):
+        self.interface = interface or MemorySessionImp()
+        if not hasattr(app.ctx, "extensions"):
+            app.ctx.extensions = {}
+
+        app.ctx.extensions[self.interface.session_name] = self  # session_name defaults to 'session'
+
+        # @app.middleware('request')
+        async def add_session_to_request(request):
+            """Before each request initialize a session
+            using the client's request."""
+            await self.interface.open(request)
+
+        # @app.middleware('response')
+        async def save_session(request, response):
+            """After each request save the session, pass
+            the response to set client cookies.
+            """
+            await self.interface.save(request, response)
+
+        app.request_middleware.appendleft(add_session_to_request)
+        app.response_middleware.append(save_session)

co6co_web_session-0.0.1/co6co_web_session/utils.py

@@ -0,0 +1,17 @@
+import datetime
+from .base import get_request_container
+
+# 只做一些备份 没作用
+
+
+def _delete_cookie(self, request, response):
+    req = get_request_container(request)
+    response.cookies[self.cookie_name] = req[self.session_name].sid
+
+    # We set expires/max-age even for session cookies to force expiration
+    response.cookies[self.cookie_name]["expires"] = datetime.datetime.utcnow()
+    response.cookies[self.cookie_name]["max-age"] = 0
+
+
+def getSid(self, request):
+    return request.cookies.get(self.cookie_name)

co6co_web_session-0.0.1/co6co_web_session/versions.py

@@ -0,0 +1,2 @@
+__version_info = (0, 0, 1)
+__version__ = ".".join([str(x) for x in __version_info])

co6co_web_session-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

co6co_web_session-0.0.1/setup.py

@@ -0,0 +1,51 @@
+from os import path
+from setuptools import setup, find_packages
+
+
+packages = find_packages()
+packageName = packages[0]
+
+
+def get_version():
+    package_dir = path.abspath(path.dirname(__file__))
+    version_file = path.join(package_dir, packageName, 'versions.py')
+    with open(version_file, "rb") as f:
+        source_code = f.read()
+    exec_code = compile(source_code, version_file, "exec")
+    scope = {}
+    exec(exec_code, scope)
+    version = scope.get("__version__", None)
+    if version:
+        return version
+    raise RuntimeError("Unable to find version string.")
+
+
+# read readmeFile contents
+currentDir = path.abspath(path.dirname(__file__))
+with open(path.join(currentDir, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name=packageName.replace('_', '.', 1),
+    version=get_version(),
+    description="web session 扩展",
+    packages=packages,
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    classifiers=["Programming Language :: Python :: 3", "Programming Language :: Python :: 3.6"],
+    include_package_data=True, zip_safe=True,
+    # 依赖哪些模块
+    install_requires=["co6co"],
+    # package_dir= {'utils':'src/log','main_package':'main'},#告诉Distutils哪些目录下的文件被映射到哪个源码
+    author='co6co',
+    author_email='co6co@qq.com',
+    url="http://github.com/co6co",
+    data_file={
+        ('', "*.txt"),
+        ('', "*.md"),
+    },
+    package_data={
+        '': ['*.txt', '*.md'],
+        'bandwidth_reporter': ['*.txt']
+    }
+)