cloudoll 3.0.5__tar.gz → 3.0.7__tar.gz

{cloudoll-3.0.5 → cloudoll-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudoll
-Version: 3.0.5
+Version: 3.0.7
 Summary: Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use.
 Home-page: https://github.com/smallerqiu/cloudoll-py
 Author: Qiu

cloudoll-3.0.7/cloudoll/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.7"

cloudoll-3.0.7/cloudoll/orm/__init__.py

@@ -0,0 +1,44 @@
+from redis import asyncio as aioredis
+from cloudoll.orm.parse import parse_coon
+import aiopg as pg
+from .mysql import Mysql
+from .postgres import Postgres
+from .awspostgres import AwsPostgres
+from .awsmysql import AwsMysql
+
+__all__ = ["create_engine"]
+
+
+async def create_engine(**kw):
+    url = kw.get("url")
+    driver = None
+    configs = {}
+    query = {}
+
+    if url is not None:
+        configs, query = parse_coon(url)
+        driver = configs["type"]
+    else:
+        driver = kw.get("type")
+        configs = kw
+
+    # info("DB Config:", configs, query)
+
+    if driver == "mysql":
+        return await Mysql().create_engine(**configs, **query)
+    elif driver == "aws-mysql":
+        return await AwsMysql().create_engine(**configs, **query)
+    elif driver in ["aws-postgres", "aws-postgressql"]:
+        return await AwsPostgres().create_engine(**configs, **query)
+    elif driver in ["postgres", "postgressql"]:
+        return await Postgres().create_engine(**configs, **query)
+    elif driver in ["redis", "rediss"]:
+        """
+        redis://[[username]:[password]]@localhost:6379/0
+        rediss://[[username]:[password]]@localhost:6379/0
+        """
+        if url is None:
+            url = f"{driver}://{configs['username']}:{configs['password']}@{configs['host']}:{configs['port']}/{configs['db']}"
+        return await aioredis.from_url(url, **query)
+    else:
+        raise ValueError("Not support this database type.")

cloudoll-3.0.7/cloudoll/orm/awsmysql.py

@@ -0,0 +1,79 @@
+from mysql.connector import Connect
+
+from aws_advanced_python_wrapper import AwsWrapperConnection
+from aws_advanced_python_wrapper.connection_provider import ConnectionProviderManager
+from aws_advanced_python_wrapper.sql_alchemy_connection_provider import (
+    SqlAlchemyPooledConnectionProvider,
+)
+
+from cloudoll.orm.base import MeteBase, QueryTypes
+from cloudoll.logging import info, error
+
+
+class AwsMysql(MeteBase):
+    def __init__(self):
+        self.driver = "aws-mysql"
+        provider = SqlAlchemyPooledConnectionProvider()
+        ConnectionProviderManager.set_connection_provider(provider)
+
+    async def close(self):
+        ConnectionProviderManager.release_resources()
+
+    async def create_engine(self, **kw):
+        self._dsn = f"host={kw.get("host")} database={kw.get("db")} user={kw.get("username")} password={kw.get("password","")}"
+        self._params = {
+            "plugins": kw.get("plugins", ""),
+            "wrapper_dialect": kw.get("wrapper_dialect", ""),
+            "autocommit": True,
+        }
+        return self
+
+    async def query(self, sql, params=None, query_type=QueryTypes.ONE, size=10):
+        sql = sql.replace("?", "%s")
+        try:
+            with AwsWrapperConnection.connect(
+                Connect, self._dsn, **self._params
+            ) as conn:
+                with conn.cursor() as cursor:
+                    if (
+                        query_type == QueryTypes.CREATEBATCH
+                        or query_type == QueryTypes.UPDATEBATCH
+                    ):
+                        cursor.executemany(sql, params)
+                    else:
+                        cursor.execute(sql, params)
+
+                    if query_type == QueryTypes.ALL:
+                        return cursor.fetchall()
+                    elif query_type == QueryTypes.ONE:
+                        return cursor.fetchone()
+                    elif query_type == QueryTypes.MANY:
+                        return cursor.fetchmany(size)
+                    elif query_type == QueryTypes.COUNT:
+                        rows = cursor.fetchone()
+                        count = 0
+                        if rows is None:
+                            return count
+                        for row in rows:
+                            count = rows[row]
+                        return count
+                    elif query_type == QueryTypes.GROUP_COUNT:
+                        result = cursor.fetchall()
+                        return 0 if not result else len(result)
+                    elif query_type == QueryTypes.CREATE:
+                        result = cursor.rowcount > 0
+                        id = cursor.target_cursor.lastrowid
+                        return result, id
+                    elif query_type == QueryTypes.CREATEBATCH:
+                        count = cursor.rowcount
+                        id = cursor.target_cursor.lastrowid
+                        return count, id
+                    elif query_type == QueryTypes.UPDATE:
+                        return cursor.rowcount > 0
+                    elif query_type == QueryTypes.UPDATEBATCH:
+                        return cursor.rowcount
+                    elif query_type == QueryTypes.DELETE:
+                        return cursor.rowcount > 0
+        except Exception as e:
+            error(f"[AWS PG] query error: {e}, SQL: {sql}")
+            raise e

cloudoll-3.0.7/cloudoll/orm/awspostgres.py

@@ -0,0 +1,93 @@
+import psycopg
+from aws_advanced_python_wrapper import AwsWrapperConnection
+from aws_advanced_python_wrapper.connection_provider import ConnectionProviderManager
+from aws_advanced_python_wrapper.sql_alchemy_connection_provider import (
+    SqlAlchemyPooledConnectionProvider,
+)
+
+from cloudoll.orm.base import MeteBase, QueryTypes
+from cloudoll.logging import info, error
+
+
+class AwsPostgres(MeteBase):
+    def __init__(self):
+        self.driver = "aws-postgres"
+        provider = SqlAlchemyPooledConnectionProvider()
+        ConnectionProviderManager.set_connection_provider(provider)
+
+    async def close(self):
+        ConnectionProviderManager.release_resources()
+
+    async def create_engine(self, **kw):
+        self._dsn = f"host={kw.get("host")} dbname={kw.get("db")} user={kw.get("username")} password={kw.get("username")}"
+        self._params = {
+            "plugins": kw.get("plugins", ""),
+            "wrapper_dialect": kw.get("wrapper_dialect"),
+            "autocommit": True,
+        }
+        return self
+
+    async def query(self, sql, params=None, query_type=QueryTypes.ONE, size=10):
+        sql = sql.replace("?", "%s").replace("`", '"')
+        try:
+            with AwsWrapperConnection.connect(
+                psycopg.Connection.connect, self._dsn, **self._params
+            ) as conn:
+                with conn.cursor() as cursor:
+                    if (
+                        query_type == QueryTypes.CREATEBATCH
+                        or query_type == QueryTypes.UPDATEBATCH
+                    ):
+                        cursor.executemany(sql, params)
+                    else:
+                        cursor.execute(sql, params)
+
+                    result = None
+
+                    if query_type == QueryTypes.ALL and cursor.description is not None:
+                        columns = [desc[0] for desc in cursor.target_cursor.description]
+                        rows = cursor.fetchall()
+                        result = [dict(zip(columns, row)) for row in rows]
+                        return result
+                    elif (
+                        query_type == QueryTypes.ONE and cursor.description is not None
+                    ):
+                        columns = [desc[0] for desc in cursor.target_cursor.description]
+                        row = cursor.fetchone()
+                        result = dict(zip(columns, row)) if row else {}
+                        return result
+                    elif (
+                        query_type == QueryTypes.MANY and cursor.description is not None
+                    ):
+                        columns = [desc[0] for desc in cursor.target_cursor.description]
+                        rows = cursor.fetchmany(size)
+                        result = [dict(zip(columns, row)) for row in rows]
+                        return result
+                    elif query_type == QueryTypes.COUNT:
+                        result = cursor.fetchone()
+                        count = 0
+                        if result is None:
+                            return count
+                        for value in result:
+                            count = value
+                        return count
+                    elif query_type == QueryTypes.GROUP_COUNT:
+                        result = cursor.fetchall()
+                        return 0 if not result else len(result)
+                    elif query_type == QueryTypes.CREATE:
+                        result = cursor.rowcount > 0
+                        id = cursor.target_cursor.lastrowid
+                        return result, id
+                    elif query_type == QueryTypes.CREATEBATCH:
+                        count = cursor.rowcount
+                        id = cursor.target_cursor.lastrowid
+                        return count, id
+                    elif query_type == QueryTypes.UPDATE:
+                        return cursor.rowcount > 0
+                    elif query_type == QueryTypes.UPDATEBATCH:
+                        return cursor.rowcount
+                    elif query_type == QueryTypes.DELETE:
+                        return cursor.rowcount > 0
+        except Exception as e:
+            error(f"[AWS PG] query error: {e}, SQL: {sql}")
+            raise e

{cloudoll-3.0.5 → cloudoll-3.0.7}/cloudoll/orm/base.py

@@ -1,5 +1,8 @@
+from abc import abstractmethod
 from enum import Enum
-from typing import Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
+from aiomysql.pool import Pool as MyPool
+from aiopg import Pool as PGPool
 
 
 class QueryTypes(Enum):
@@ -16,14 +19,16 @@ class QueryTypes(Enum):
 
 
 class MeteBase:
+    # def __init__(self):
+        # self.pool: Optional[MyPool | PGPool] = None
+        # self.cursor: Optional[Cursor] = None
+        # self.conn: Optional[Connection] = None
 
     async def __aexit__(self):
         await self.close()
 
     async def close(self):
-        if self.pool:
-            self.pool.close()
-            await self.pool.wait_closed()
+        ...
 
     # async def begin_transaction(self):
     #     conn = await self._set_conn()
@@ -46,9 +51,10 @@ class MeteBase:
     #             if cursor:
     #                 await cursor.close()
     #         self.pool.release(conn)
+    @abstractmethod
     async def query(
-        self, sql, params=None, query_type: QueryTypes = 2, size: int = 10
-    ): ...
+        self, sql, params=None, query_type: QueryTypes = QueryTypes.ONE, size: int = 10
+    ) -> Union[None, int, Tuple[Any, Any], Dict, List[Dict]]: ...
 
     async def all(self, sql, params):
         return await self.query(sql, params, QueryTypes.ALL)
@@ -61,6 +67,7 @@ class MeteBase:
 
     async def count(self, sql, params):
         return await self.query(sql, params, QueryTypes.COUNT)
+
     async def group_count(self, sql, params):
         return await self.query(sql, params, QueryTypes.GROUP_COUNT)
 
@@ -73,7 +80,7 @@ class MeteBase:
     async def delete(self, sql, params):
         return await self.query(sql, params, QueryTypes.DELETE)
 
-    async def create(self, sql, params) -> Tuple[bool, int]:
+    async def create(self, sql, params):
         return await self.query(sql, params, QueryTypes.CREATE)
 
     async def create_batch(self, sql, params):

{cloudoll-3.0.5 → cloudoll-3.0.7}/cloudoll/orm/field.py

@@ -1,3 +1,6 @@
+from typing import Optional
+
+
 class objdict(dict):
     def __getattr__(self, attr):
         try:
@@ -502,7 +505,7 @@ class Field(FieldBase):
         **kwargs,
     ):
         super().__init__()
-        self.full_name = None
+        self.full_name: Optional[str] = None
         self._value = None
         self.name = name
         self.column_type = column_type

{cloudoll-3.0.5 → cloudoll-3.0.7}/cloudoll/orm/model.py

@@ -150,14 +150,18 @@ class Model(metaclass=ModelMetaclass):
     @classmethod
     def use(cls, pool=None):
         cls.__pool__ = pool
-        cls.__ispg = cls.__pool__.driver == "postgres" if pool else False
+        cls.__is_pg = (
+            pool.driver in ["postgres", "postgressql", "aws-postgres"]
+            if pool
+            else False
+        )
         return cls()
 
     def select(cls, *args):
         cols = []
         for col in args:
             if isinstance(col, Field):
-                cols.append(col.name if cls.__ispg else col.full_name)
+                cols.append(col.name if cls.__is_pg else col.full_name)
             elif isinstance(col, Function):
                 q, p = col.sql()
                 cols.append(q)
@@ -200,7 +204,7 @@ class Model(metaclass=ModelMetaclass):
             if isinstance(f, str):
                 by.append(f)
             else:
-                by.append(f"{f.lhs.name if self.__ispg else f.lhs.full_name} {f.op}")
+                by.append(f"{f.lhs.name if self.__is_pg else f.lhs.full_name} {f.op}")
         if self.__order_by__ is not None:
             by = self.__order_by__ + by
         self.__order_by__ = by
@@ -209,7 +213,7 @@ class Model(metaclass=ModelMetaclass):
     def group_by(self, *args):
         by = []
         for f in args:
-            by.append(f.name if self.__ispg else f.full_name)
+            by.append(f.name if self.__is_pg else f.full_name)
         if self.__group_by__ is not None:
             by = self.__group_by__ + by
         self.__group_by__ = by
@@ -365,7 +369,7 @@ class Model(metaclass=ModelMetaclass):
         return await self.__pool__.all(sql, args)
 
     def _exchange_sql(self, sql: str):
-        if self.__ispg:
+        if self.__is_pg:
             sql = sql.replace("CURDATE()", "CURRENT_DATE")
             sql = sql.replace("NOW()", "CURRENT_TIMESTAMP")
 

cloudoll-3.0.7/cloudoll/orm/mysql.py

@@ -0,0 +1,112 @@
+from typing import Any, Optional
+import aiomysql
+from cloudoll.logging import error
+from cloudoll.orm.base import MeteBase, QueryTypes
+from cloudoll.logging import info, error
+
+
+class AttrDict(dict):
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            return None
+
+
+class AttrDictCursor(aiomysql.DictCursor):
+    dict_type = AttrDict
+
+
+class Mysql(MeteBase):
+    def __init__(self):
+        self.pool: aiomysql.Pool
+        self.driver = "mysql"
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        self.__init__(*args, **kwds)
+        return self
+
+    async def close(self):
+        if self.pool:
+            self.pool.close()
+            await self.pool.wait_closed()
+
+    async def query(
+        self, sql, params=None, query_type: QueryTypes = QueryTypes.ONE, size: int = 10
+    ):
+        sql = sql.replace("?", "%s")
+        if not self.pool:
+            raise ValueError("must be create_engine first.")
+        if self.pool._closing or self.pool._closed:
+            return None
+        async with self.pool.acquire() as conn:
+            if conn.echo:
+                info("sql: %s , %s", sql, params)
+
+            async with conn.cursor() as cursor:
+                cursor: aiomysql.Cursor = cursor
+                if (
+                    query_type == QueryTypes.CREATEBATCH
+                    or query_type == QueryTypes.UPDATEBATCH
+                ):
+                    await cursor.executemany(sql, params)
+                else:
+                    await cursor.execute(sql, params)
+
+                await conn.commit()
+
+                if query_type == QueryTypes.ALL:
+                    return await cursor.fetchall()
+                elif query_type == QueryTypes.ONE:
+                    return await cursor.fetchone()
+                elif query_type == QueryTypes.MANY:
+                    return await cursor.fetchmany(size)
+                elif query_type == QueryTypes.COUNT:
+                    rows = await cursor.fetchone()
+                    count = 0
+                    if rows is None:
+                        return count
+                    for row in rows:
+                        count = rows[row]
+                    return count
+                elif query_type == QueryTypes.GROUP_COUNT:
+                    result = await cursor.fetchall()
+                    return 0 if not result else len(result)
+                elif query_type == QueryTypes.CREATE:
+                    result = cursor.rowcount > 0
+                    id = cursor.lastrowid
+                    return result, id
+                elif query_type == QueryTypes.CREATEBATCH:
+                    count = cursor.rowcount
+                    id = cursor.lastrowid
+                    return count, id
+                elif query_type == QueryTypes.UPDATE:
+                    return cursor.rowcount > 0
+                elif query_type == QueryTypes.UPDATEBATCH:
+                    return cursor.rowcount
+                elif query_type == QueryTypes.DELETE:
+                    return cursor.rowcount > 0
+
+        self.pool.release(conn)
+
+    async def create_engine(self, loop=None, **kw):
+        try:
+            self.pool = await aiomysql.create_pool(
+                host=kw.get("host", "localhost"),
+                port=kw.get("port", 3306),
+                user=kw.get("username"),
+                password=str(kw.get("password", "")),
+                db=kw.get("db"),
+                echo=kw.get("echo", False),
+                charset=kw.get("charset", "utf8"),
+                autocommit=False,  # kw.get("autocommit", False),
+                maxsize=kw.get("maxsize", 10),
+                minsize=kw.get("minsize", 5),
+                cursorclass=AttrDictCursor,
+                loop=loop,
+            )
+            info(f"Database connection successfully for mysql/{kw.get('db')}.")
+        except Exception as e:
+            # print(traceback.format_exc())
+            error(f"Database connection failed,the instance : mysql/{kw.get('db')}")
+        return self

cloudoll-3.0.7/cloudoll/orm/postgres.py

@@ -0,0 +1,116 @@
+import aiopg
+from cloudoll.logging import error
+from cloudoll.orm.base import MeteBase, QueryTypes
+from cloudoll.logging import info, error
+from typing import Any, Optional
+
+class Postgres(MeteBase):
+    def __init__(self):
+        self.pool: Optional[aiopg.Pool] = None
+        self.driver = "postgres"
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        self.__init__(*args, **kwds)
+        return self
+
+    async def close(self):
+        if self.pool:
+            self.pool.close()
+            await self.pool.wait_closed()
+
+    async def query(
+        self,
+        sql,
+        params=None,
+        query_type: QueryTypes = QueryTypes.COUNT,
+        size: int = 10,
+    ):
+        sql = sql.replace("?", "%s").replace("`", '"')
+        if not self.pool:
+            raise ValueError("must be create_engine first.")
+        if self.pool._closing or self.pool._closed:
+            return None
+
+        async with self.pool.acquire() as conn:
+            if conn.echo:
+                info("sql: %s ,%s", sql, params)
+
+            async with conn.cursor() as cursor:
+                # current_cursor = getattr(cursor, 'lastrowid', None)
+                if (
+                    query_type == QueryTypes.CREATEBATCH
+                    or query_type == QueryTypes.UPDATEBATCH
+                ):
+                    await cursor.executemany(sql, params)
+                else:
+                    await cursor.execute(sql, params)
+
+                # await conn.commit()
+                result = None
+
+                if query_type == QueryTypes.ALL and cursor.description is not None:
+                    columns = [desc[0] for desc in cursor.description]
+                    rows = await cursor.fetchall()
+                    result = [dict(zip(columns, row)) for row in rows]
+                    return result
+                elif query_type == QueryTypes.ONE and cursor.description is not None:
+                    columns = [desc[0] for desc in cursor.description]
+                    row = await cursor.fetchone()
+                    result = dict(zip(columns, row)) if row else {}
+                    return result
+                elif query_type == QueryTypes.MANY and cursor.description is not None:
+                    columns = [desc[0] for desc in cursor.description]
+                    rows = await cursor.fetchmany(size)
+                    result = [dict(zip(columns, row)) for row in rows]
+                    return result
+                elif query_type == QueryTypes.COUNT:
+                    result = await cursor.fetchone()
+                    count = 0
+                    if result is None:
+                        return count
+                    for value in result:
+                        count = value
+                    return count
+                elif query_type == QueryTypes.GROUP_COUNT:
+                    result = await cursor.fetchall()
+                    return 0 if not result else len(result)
+                elif query_type == QueryTypes.CREATE:
+                    result = cursor.rowcount > 0
+                    id = cursor.lastrowid
+                    return result, id
+                elif query_type == QueryTypes.CREATEBATCH:
+                    count = cursor.rowcount
+                    id = cursor.lastrowid
+                    return count, id
+                elif query_type == QueryTypes.UPDATE:
+                    return cursor.rowcount > 0
+                elif query_type == QueryTypes.UPDATEBATCH:
+                    return cursor.rowcount
+                elif query_type == QueryTypes.DELETE:
+                    return cursor.rowcount > 0
+
+    async def create_engine(self, **kw):
+        try:
+            host = (kw.get("host", "localhost"),)
+            port = (kw.get("port", 5432),)
+            user = (kw.get("username"),)
+            password = (str(kw.get("password", "")),)
+            db = (kw.get("db"),)
+            dsn = f"dbname={db[0]} user={user[0]} password={password[0]} host={host[0]} port={port[0]}"  # aiopg
+            # dsn = f"postgres://{user[0]}:{password[0]}@{host[0]}:{port[0]}/{db[0]}" # asyncpg
+            self.pool = await aiopg.create_pool(
+                dsn=dsn,
+                timeout=float(kw.get("timeout", 60)),
+                echo=kw.get("echo", False),  # aiopg
+                # max_size=kw.get("maxsize", 10), # asyncpg
+                # min_size=kw.get("minsize", 5), # asyncpg
+                maxsize=kw.get("maxsize", 10),  # aiopg
+                minsize=kw.get("minsize", 5),  # aiopg
+            )
+            info(f"Database connection successfully for postgres/{kw.get('db')}")
+        except Exception as e:
+            error(e)
+            # print(traceback.format_exc())
+            error(f"Database connection failed,the instance : postgres/{kw.get('db')}")
+
+        return self

{cloudoll-3.0.5 → cloudoll-3.0.7}/cloudoll/orm/test_sql.py

@@ -42,7 +42,7 @@ class B(Model):
 
 class C(Model):
 
-    __table__ = "i_network_speed_result"
+    __table__ = "c"
 
     id = models.BigIntegerField(primary_key=True, max_length=64, not_null=True)
     pack_id = models.BigIntegerField(max_length=64, default="0", not_null=True)

{cloudoll-3.0.5 → cloudoll-3.0.7}/cloudoll/utils/snowflake.py

@@ -1,34 +1,30 @@
-
 import time
 import threading
 
 
 """
-雪花算法（全局唯一id）
-
-# 最早是Twitter公司在其内部用于分布式环境下生成唯一ID
-
 # Twitter's Snowflake algorithm implementation which is used to generate distributed IDs.
-
 # https://github.com/twitter-archive/snowflake/blob/snowflake-2010/src/main/scala/com/twitter/service/snowflake/IdWorker.scala
 """
 
 
 class IdWorker:
     def __init__(self, worker_id, datacenter_id, sequence=0):
-         # 位移值
+        # 位移值
         self.worker_id_bits = 5
         self.datacenter_id_bits = 5
         self.sequence_bits = 12
-        
+
         self.max_worker_id = -1 ^ (-1 << self.worker_id_bits)
         self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)
 
         # 参数校验
         if worker_id > self.max_worker_id or worker_id < 0:
-            raise ValueError(f'worker_id must be between 0 and {self.max_worker_id}')
+            raise ValueError(f"worker_id must be between 0 and {self.max_worker_id}")
         if datacenter_id > self.max_datacenter_id or datacenter_id < 0:
-            raise ValueError(f'datacenter_id must be between 0 and {self.max_datacenter_id}')
+            raise ValueError(
+                f"datacenter_id must be between 0 and {self.max_datacenter_id}"
+            )
 
         self.worker_id = worker_id
         self.datacenter_id = datacenter_id
@@ -38,12 +34,11 @@ class IdWorker:
         # Twitter Epoch (2010-11-04 01:42:54 UTC)
         self.twepoch = 1288834974657
 
-       
-
-       
         self.worker_id_shift = self.sequence_bits
         self.datacenter_id_shift = self.sequence_bits + self.worker_id_bits
-        self.timestamp_left_shift = self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
+        self.timestamp_left_shift = (
+            self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
+        )
         self.sequence_mask = -1 ^ (-1 << self.sequence_bits)
 
         self.last_timestamp = -1
@@ -62,7 +57,9 @@ class IdWorker:
             timestamp = self._time_gen()
 
             if timestamp < self.last_timestamp:
-                raise Exception(f'Clock moved backwards. Refusing to generate id for {self.last_timestamp - timestamp} milliseconds')
+                raise Exception(
+                    f"Clock moved backwards. Refusing to generate id for {self.last_timestamp - timestamp} milliseconds"
+                )
 
             if self.last_timestamp == timestamp:
                 self.sequence = (self.sequence + 1) & self.sequence_mask
@@ -73,10 +70,12 @@ class IdWorker:
 
             self.last_timestamp = timestamp
 
-            id = ((timestamp - self.twepoch) << self.timestamp_left_shift) | \
-                (self.datacenter_id << self.datacenter_id_shift) | \
-                (self.worker_id << self.worker_id_shift) | \
-                self.sequence
+            id = (
+                ((timestamp - self.twepoch) << self.timestamp_left_shift)
+                | (self.datacenter_id << self.datacenter_id_shift)
+                | (self.worker_id << self.worker_id_shift)
+                | self.sequence
+            )
 
             return id