ul-api-utils 9.3.0__py3-none-any.whl

ul_api_utils/internal_api/internal_api_response.py

@@ -0,0 +1,296 @@
+import json
+import uuid
+from enum import IntEnum, unique
+from functools import cached_property
+from typing import Any, Optional, List, Generic, Type, TypeVar, Union, Dict, NamedTuple
+
+import requests
+from pydantic import ValidationError
+
+from ul_api_utils.api_resource.api_response import JsonApiResponsePayload, RootJsonApiResponsePayload
+from ul_api_utils.api_resource.signature_check import set_model
+from ul_api_utils.const import RESPONSE_PROP_DEBUG_STATS, RESPONSE_PROP_PAYLOAD, RESPONSE_PROP_OK, RESPONSE_PROP_ERRORS, RESPONSE_PROP_TOTAL, RESPONSE_PROP_COUNT, MIME__JSON, \
+    RESPONSE_HEADER__CONTENT_TYPE
+from ul_api_utils.errors import Server5XXInternalApiError, Client4XXInternalApiError, \
+    ResponseStatusAbstractInternalApiError, ResponsePayloadTypeInternalApiError, ResponseJsonSchemaInternalApiError, ResponseJsonInternalApiError
+from ul_api_utils.internal_api.internal_api_check_context import internal_api_check_context_rm_response, internal_api_check_context_add_response
+from ul_api_utils.utils.api_format import ApiFormat
+from ul_api_utils.internal_api.internal_api_error import InternalApiResponseErrorObj
+from ul_api_utils.utils.unwrap_typing import UnwrappedOptionalObjOrListOfObj
+
+TPyloadType = TypeVar('TPyloadType', bound=Union[JsonApiResponsePayload, List[JsonApiResponsePayload], RootJsonApiResponsePayload[Any], List[RootJsonApiResponsePayload[Any]], None])
+TResp = TypeVar('TResp', bound='InternalApiResponse[Any]')
+
+
+CHECK_TYPE = {'payload_type', 'json', 'std_schema'}
+
+
+class InternalApiResponseSchema(NamedTuple):
+    response_ok: bool
+    response_status_code: int
+    response_payload_raw: Any
+    response_errors: List[InternalApiResponseErrorObj]
+    response_total_count: Optional[int]
+    response_count: Optional[int]
+    response_many: bool
+
+
+@unique
+class InternalApiResponseCheckLevel(IntEnum):
+    STATUS_CODE = 1
+    JSON = 2
+    STD_SCHEMA = 3
+    PAYLOAD_TYPE = 4
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+
+class InternalApiOverriddenResponse(NamedTuple):
+    status_code: int
+    text: str
+    headers: Dict[str, str]
+
+    @property
+    def content(self) -> bytes:
+        return self.text.encode('utf-8')
+
+    def json(self) -> Any:
+        return json.loads(self.text)
+
+
+class InternalApiResponse(Generic[TPyloadType]):
+
+    @property
+    def id(self) -> uuid.UUID:
+        return self._id
+
+    def __init__(self, info: str, resp: Union[requests.Response, InternalApiOverriddenResponse], std_schema: bool, payload_type: Optional[Type[TPyloadType]]) -> None:
+        self._id = uuid.uuid4()
+        self._resp = resp
+        self._has_std_schema = std_schema
+        self._payload_type = None
+
+        self._parsed_schema: Optional[InternalApiResponseSchema] = None
+        self._parsed_json: Any = None
+        self._parsed_payload: Union[None, JsonApiResponsePayload, List[JsonApiResponsePayload], RootJsonApiResponsePayload[Any], List[RootJsonApiResponsePayload[Any]]] = None
+
+        self._status_checked = False
+        self._info = info
+
+        if payload_type is not None:
+            self._payload_type = UnwrappedOptionalObjOrListOfObj.parse(payload_type, JsonApiResponsePayload) or UnwrappedOptionalObjOrListOfObj.parse(payload_type, RootJsonApiResponsePayload)
+            if self._payload_type is None:
+                tn1, tn2 = JsonApiResponsePayload.__name__, RootJsonApiResponsePayload.__name__
+                raise ValueError(
+                    f'payload_typing is invalid. must be Union[Type[{tn1} | {tn2}], Optional[Type[{tn1} | {tn2}]], List[Type[{tn1} | {tn2}]], Optional[List[Type[{tn1} | {tn2}]]]]. {payload_type} was given',
+                )
+
+    def typed(self, payload_type: Type[TPyloadType]) -> 'InternalApiResponse[TPyloadType]':
+        assert payload_type is not None
+        internal_api_check_context_rm_response(self._id)
+        new_one = InternalApiResponse(self._info, self._resp, self._has_std_schema, payload_type)
+        internal_api_check_context_add_response(new_one)
+        return new_one
+
+    @property
+    def has_payload_type(self) -> bool:
+        return self._payload_type is not None
+
+    @property
+    def many(self) -> bool:
+        if self._payload_type is not None:
+            return self._payload_type.many
+        return self._schema.response_many
+
+    # ERROR HANDLING
+
+    def check(self: TResp, *, level: InternalApiResponseCheckLevel = InternalApiResponseCheckLevel.PAYLOAD_TYPE) -> TResp:
+        assert isinstance(level, InternalApiResponseCheckLevel)
+        self._raise_for_err(self._status_code_error)
+
+        if level < InternalApiResponseCheckLevel.JSON:
+            return self
+        self._raise_for_err(self._result_json_error)
+
+        if level < InternalApiResponseCheckLevel.STD_SCHEMA:
+            return self
+        self._raise_for_err(self._result_json_schema_error)
+
+        if level < InternalApiResponseCheckLevel.PAYLOAD_TYPE:
+            return self
+
+        if self._payload_type is None:
+            return self
+
+        self._raise_for_err(self._payload_type_error)
+        return self
+
+    @cached_property
+    def _schema(self) -> InternalApiResponseSchema:
+        self._raise_for_err(self._status_code_error, self._status_checked)
+        self._raise_for_err(self._result_json_error)
+        self._raise_for_err(self._result_json_schema_error)
+        assert self._parsed_schema is not None
+        return self._parsed_schema
+
+    @cached_property
+    def _payload_type_error(self) -> Optional[ResponsePayloadTypeInternalApiError]:
+        if self._payload_type is None:
+            return ResponsePayloadTypeInternalApiError('payload type is invalid', ValueError('payload_type for response must be specified'))
+
+        try:
+            assert self._parsed_schema is not None
+            self._parsed_payload = self._payload_type.apply(self._parsed_schema.response_payload_raw, set_model)
+        except Exception as e:  # noqa: B902
+            return ResponsePayloadTypeInternalApiError('payload schema type is not valid', e)
+        return None
+
+    @cached_property
+    def _result_json_schema_error(self) -> Optional[ResponseJsonSchemaInternalApiError]:
+        ok = self._resp.status_code < 400
+        payload_raw = self._parsed_json
+        errors = []
+        response_many = isinstance(payload_raw, list)
+        total_count = len(payload_raw) if response_many else None
+        count = len(payload_raw) if response_many else None
+
+        if self._has_std_schema:
+            try:
+                assert isinstance(self._parsed_json, dict)
+                ok = self._parsed_json.get(RESPONSE_PROP_OK, False)
+                total_count = self._parsed_json.get(RESPONSE_PROP_TOTAL, None)
+                assert count is None or isinstance(total_count, int), f'total_count must be int. "{type(total_count).__name__}" was given'
+                count = self._parsed_json.get(RESPONSE_PROP_COUNT, None)
+                assert count is None or isinstance(count, int), f'count must be int. "{type(count).__name__}" was given'
+                payload_raw = self._parsed_json.get(RESPONSE_PROP_PAYLOAD, None)
+                response_many = isinstance(payload_raw, list)
+
+                if response_many:
+                    assert count is not None and count >= 0
+                    assert total_count is not None and total_count >= 0
+
+                errors = self._mk_std_errors(self._parsed_json)
+            except Exception as e:  # noqa: B902
+                return ResponseJsonSchemaInternalApiError('invalid schema', e)
+
+        self._parsed_schema = InternalApiResponseSchema(
+            response_ok=ok,
+            response_status_code=self._resp.status_code,
+            response_payload_raw=payload_raw,
+            response_errors=errors,
+            response_total_count=total_count,
+            response_count=count,
+            response_many=response_many,
+        )
+        return None
+
+    @property
+    def _internal_use__checked_once(self) -> bool:
+        return self._status_checked
+
+    @property
+    def _internal_use__info(self) -> str:
+        return self._info
+
+    @cached_property
+    def _result_json_error(self) -> Optional[ResponseJsonInternalApiError]:
+        content_mime: str = self._resp.headers.get(RESPONSE_HEADER__CONTENT_TYPE, MIME__JSON)
+        api_format = ApiFormat.from_mime(content_mime)
+        if api_format is None:
+            return ResponseJsonInternalApiError('content is not parsable as json', ValueError(f'content type "{content_mime}" was given'))
+
+        try:
+            self._parsed_json = api_format.parse_bytes(self._resp.content)
+        except Exception as e:  # noqa: B902
+            return ResponseJsonInternalApiError('content is not parsable as json', e)
+        return None
+
+    def _mk_std_errors(self, result_json: Dict[str, Any]) -> List[InternalApiResponseErrorObj]:
+        if not isinstance(result_json, dict):
+            return []  # type: ignore
+        return [set_model(InternalApiResponseErrorObj, error) for error in result_json.get(RESPONSE_PROP_ERRORS, [])]
+
+    @cached_property
+    def _status_code_error(self) -> Optional[ResponseStatusAbstractInternalApiError]:
+        self._status_checked = True
+        code = self._resp.status_code
+
+        if code >= 400:
+            errors = []
+            if self._has_std_schema and self._result_json_error is None:
+                try:
+                    errors = self._mk_std_errors(self._parsed_json)
+                except ValidationError:
+                    pass
+            return Server5XXInternalApiError(code, errors) if code >= 500 else Client4XXInternalApiError(code, errors)
+        return None
+
+    def _raise_for_err(self, err: Optional[Exception], checked: bool = False) -> None:
+        if not checked and err is not None:
+            raise err
+
+    # STANDARD PAYLOAD SCHEMA PROPERTIES
+
+    @property
+    def ok(self) -> bool:
+        return self._schema.response_ok
+
+    @property
+    def total_count(self) -> Optional[int]:
+        sch = self._schema
+        if not sch.response_many:
+            raise OverflowError('count it is not permitted for not array payload')
+        return sch.response_total_count
+
+    @property
+    def count(self) -> Optional[int]:
+        sch = self._schema
+        if not sch.response_many:
+            raise OverflowError('count it is not permitted for not array payload')
+        return sch.response_count
+
+    @property
+    def errors(self) -> List[InternalApiResponseErrorObj]:
+        return self._schema.response_errors
+
+    @property
+    def payload_raw(self) -> Union[Optional[Dict[str, Any]], List[Dict[str, Any]]]:  # for backward compatibility
+        return self._schema.response_payload_raw
+
+    @property
+    def payload(self) -> TPyloadType:
+        _sch = self._schema  # noqa: F841
+        self._raise_for_err(self._payload_type_error)
+        return self._parsed_payload  # type: ignore
+
+    @cached_property
+    def internal_use__debug_stats(self) -> List[List[Any]]:
+        if not self._has_std_schema:
+            return []
+        if self._result_json_error is not None or self._parsed_json is None:
+            return []
+        return self._parsed_json.get(RESPONSE_PROP_DEBUG_STATS, [])
+
+    # STANDARD PAYLOAD PROPS
+
+    @property
+    def status_code(self) -> int:
+        self._raise_for_err(self._status_code_error, self._status_checked)
+        return self._resp.status_code
+
+    @property
+    def result_bytes(self) -> bytes:
+        self._raise_for_err(self._status_code_error, self._status_checked)
+        return self._resp.content
+
+    @property
+    def result_text(self) -> str:
+        self._raise_for_err(self._status_code_error, self._status_checked)
+        return self._resp.text
+
+    @property
+    def result_json(self) -> Any:
+        self._raise_for_err(self._status_code_error, self._status_checked)
+        self._raise_for_err(self._result_json_error)
+        return self._parsed_json

ul_api_utils/main.py

@@ -0,0 +1,29 @@
+import os
+import sys
+
+if __name__ == "__main__":
+    sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+from ul_api_utils.commands.cmd_worker_start import CmdWorkerStart
+from ul_py_tool.commands.cmd import Cmd
+from ul_api_utils.commands.cmd_enc_keys import CmdEncKeys
+from ul_api_utils.commands.cmd_gen_new_api_user import CmdGenerateNewApiUser
+from ul_api_utils.commands.cmd_gen_api_user_token import CmdGenerateApiUserToken
+from ul_api_utils.commands.cmd_generate_api_docs import CmdGenApiFunctionDocumentation
+
+from ul_api_utils.commands.cmd_start import CmdStart
+
+
+def main() -> None:
+    Cmd.main({
+        'start': CmdStart,
+        'enc_keys': CmdEncKeys,
+        'start_worker': CmdWorkerStart,
+        'gen_new_api_user': CmdGenerateNewApiUser,
+        'gen_api_user_token': CmdGenerateApiUserToken,
+        'gen_api_docs': CmdGenApiFunctionDocumentation,
+    })
+
+
+if __name__ == '__main__':
+    main()

ul_api_utils/modules/__tests__/test_api_sdk_jwt.py

@@ -0,0 +1,195 @@
+import json
+import sys
+from datetime import datetime, time
+from typing import List
+from uuid import uuid4, UUID
+
+from ul_py_tool.utils.write_stdout import write_stdout
+
+from ul_api_utils.conf import APPLICATION_ENV
+from ul_api_utils.modules.api_sdk_jwt import ApiSdkJwt
+
+
+def print_score(name: str, compressed: str, uncompressed: str) -> None:
+    write_stdout(
+        f'\n\n{name} '
+        f':: uncompressed={len(uncompressed)} '
+        f'({sys.getsizeof(uncompressed)}) '
+        f':: compressed={len(compressed)} '
+        f'({sys.getsizeof(compressed)}) '
+        f':: diff={((len(uncompressed) - len(compressed)) / len(uncompressed)) * 100:0.3f}% '
+        f'({((sys.getsizeof(uncompressed) - sys.getsizeof(compressed)) / sys.getsizeof(uncompressed)) * 100:0.3f}%)',
+    )
+
+
+def test_jwt_compressed() -> None:
+    att, _rtt = ApiSdkJwt.create_jwt_pair(
+        environment='production',
+        user_id=UUID('1870e062-7914-4e56-8fe7-dad7b00a67c3'),
+        organization_id=UUID("5dca46d3-8fcb-4ce7-856e-f6c0104f3b72"),
+        permissions=[13127, 91701, 91702, 91703, 91704, 91705, 90901, 90905, 91801, 91802, 91803, 91804, 91805, 10007, 90301, 13068, 13014, 13017, 13032, 13033, 13034, 13072, 13040, 13041, 13042, 13043, 13044, 13046, 13047, 13048, 13049, 13050, 13052, 13053, 13054, 13055, 13056, 13057, 13058, 13059, 13060, 13061, 13062, 13064, 91401, 91402, 13065, 13066, 91403, 91404, 91405, 91406, 10001, 13067, 13069, 13076, 13077, 10005, 13070, 13071, 90902, 90903, 90904, 90906, 10013, 90907, 90908, 90909, 90401, 90402, 90403, 90404, 90405, 90406, 90407, 90408, 13083, 13084, 13085, 13091, 10021, 10023, 13086, 10025, 13097, 10034, 13098, 13087, 10029, 10031, 10033, 13105, 13106, 13088, 10036, 10037, 10039, 10040, 13089, 13113, 13112, 13114, 13115, 13090, 13116, 13122, 13118, 13119, 13120, 13121, 13125, 13132, 13124, 13126, 13092, 13128, 13129, 13130, 13131, 13093, 13133, 13134, 10041, 13094, 13095, 13080, 13096, 91501, 91502, 91503, 91504, 13099, 91505, 91506, 13100, 91001, 13081, 13101, 13102, 13103, 90501, 90502, 90503, 90504, 13104, 90505, 90506, 90507, 90508, 90001, 90002, 90003, 13082, 13107, 13108, 13109, 13110, 13111, 13117, 91601, 91602, 91603, 91604, 91605, 90101, 90102, 90103, 90104, 90105, 90106, 90107, 90108, 90109, 90110, 90111],  # noqa: E501
+    )
+
+    for algo in ['RS256', 'ES256']:
+        priv_k, pub_k_fn = ApiSdkJwt.generate_cert(algo)  # type: ignore
+        pub_key = pub_k_fn()
+
+        uncompressed = att.encode(priv_k, algo)  # type: ignore
+        compressed = att.encode(priv_k, algo, compressed=True)  # type: ignore
+
+        print_score(algo, compressed, uncompressed)
+
+        t_decoded_uncompressed = ApiSdkJwt.decode(uncompressed, pub_key)._asdict()
+        t_decoded_compressed = ApiSdkJwt.decode(compressed, pub_key)._asdict()
+
+        t_decoded_uncompressed.pop('raw')
+        t_decoded_compressed.pop('raw')
+
+        t_decoded_uncompressed['exp_date'] = datetime.combine(
+            t_decoded_uncompressed['exp_date'].date(),
+            time(
+                hour=t_decoded_uncompressed['exp_date'].time().hour,
+                minute=t_decoded_uncompressed['exp_date'].time().minute,
+            ),
+        )
+
+        assert t_decoded_uncompressed == t_decoded_compressed
+
+
+def test_jwt_cert() -> None:
+    for algo in ['RS256', 'ES256']:
+        pk1, pkf1 = ApiSdkJwt.generate_cert(algo)  # type: ignore
+
+        pk2, pkf2 = ApiSdkJwt.load_cert(pk1)
+
+        att, rtt = ApiSdkJwt.create_jwt_pair(
+            environment=APPLICATION_ENV,
+            user_id=uuid4(),
+            organization_id=uuid4(),
+            permissions=[],
+        )
+        at, *_ = att.encode(pk1, algo), rtt.encode(pk1, algo)  # type: ignore
+
+        assert ApiSdkJwt.decode(at, pkf1()) == ApiSdkJwt.decode(at, pkf2())
+
+        assert pk1 == pk2
+
+    for algo1, algo2 in [('RS256', 'ES256'), ('ES256', 'RS256')]:
+        pk1, _pkf1 = ApiSdkJwt.generate_cert(algo1)  # type: ignore
+
+        att, _rtt = ApiSdkJwt.create_jwt_pair(
+            environment=APPLICATION_ENV,
+            user_id=uuid4(),
+            organization_id=uuid4(),
+            permissions=[],
+        )
+
+        try:
+            att.encode(pk1, algo2)  # type: ignore
+        except Exception:  # noqa: B902
+            pass
+        else:
+            raise AssertionError()
+
+
+def test_jwt() -> None:
+    for algo in ['RS256', 'ES256']:
+        private_key, public_key_factory = ApiSdkJwt.generate_cert(algo)  # type: ignore
+        att, rtt = ApiSdkJwt.create_jwt_pair(
+            environment=APPLICATION_ENV,
+            user_id=uuid4(),
+            organization_id=uuid4(),
+            permissions=[13127, 91701, 91702, 91703, 91704, 91705, 90901, 90905, 91801, 91802, 91803, 91804, 91805, 10007, 90301, 13068, 13014, 13017, 13032, 13033, 13034, 13072, 13040, 13041, 13042, 13043, 13044, 13046, 13047, 13048, 13049, 13050, 13052, 13053, 13054, 13055, 13056, 13057, 13058, 13059, 13060, 13061, 13062, 13064, 91401, 91402, 13065, 13066, 91403, 91404, 91405, 91406, 10001, 13067, 13069, 13076, 13077, 10005, 13070, 13071, 90902, 90903, 90904, 90906, 10013, 90907, 90908, 90909, 90401, 90402, 90403, 90404, 90405, 90406, 90407, 90408, 13083, 13084, 13085, 13091, 10021, 10023, 13086, 10025, 13097, 10034, 13098, 13087, 10029, 10031, 10033, 13105, 13106, 13088, 10036, 10037, 10039, 10040, 13089, 13113, 13112, 13114, 13115, 13090, 13116, 13122, 13118, 13119, 13120, 13121, 13125, 13132, 13124, 13126, 13092, 13128, 13129, 13130, 13131, 13093, 13133, 13134, 10041, 13094, 13095, 13080, 13096, 91501, 91502, 91503, 91504, 13099, 91505, 91506, 13100, 91001, 13081, 13101, 13102, 13103, 90501, 90502, 90503, 90504, 13104, 90505, 90506, 90507, 90508, 90001, 90002, 90003, 13082, 13107, 13108, 13109, 13110, 13111, 13117, 91601, 91602, 91603, 91604, 91605, 90101, 90102, 90103, 90104, 90105, 90106, 90107, 90108, 90109, 90110, 90111],  # noqa: E501,
+        )
+
+        at, rt = att.encode(private_key, algo), rtt.encode(private_key, algo)  # type: ignore
+
+        parsed_at = ApiSdkJwt.decode(at, public_key_factory())
+
+        assert att.env == parsed_at.env == APPLICATION_ENV
+        assert att.id == parsed_at.id
+        assert att.user_id == parsed_at.user_id
+        assert att.organization_id == parsed_at.organization_id
+        assert att.version == parsed_at.version
+        assert att.token_type == parsed_at.token_type
+        assert att.exp_date == parsed_at.exp_date
+        assert att.permissions == parsed_at.permissions
+        assert att.additional_data == parsed_at.additional_data
+
+        new_at = ApiSdkJwt.decode(rt, public_key_factory()).create_access_token().encode(private_key, algo, True)  # type: ignore
+
+        parsed_t = ApiSdkJwt.decode(token=new_at, username=None, certificate=public_key_factory())
+
+        assert parsed_t.env == rtt.env == APPLICATION_ENV
+        assert parsed_t.id == rtt.id
+        assert parsed_t.user_id == rtt.user_id
+        assert parsed_t.organization_id == rtt.organization_id
+        assert parsed_t.version == rtt.version
+        assert parsed_t.token_type == 'access'
+        assert parsed_t.exp_date <= rtt.exp_date
+        assert parsed_t.permissions == rtt.permissions
+        assert parsed_t.additional_data == rtt.additional_data
+
+
+# opts: [5] => [1111011, 11110000011110011]
+
+
+def test_permission_compression() -> None:
+    c_permissions = ApiSdkJwt.compress_permissions([1, 2, 5, 3, 4])
+    assert c_permissions == '%1'
+
+
+def test_permission_decompression() -> None:
+    c_permissions = ApiSdkJwt.decompress_permissions('A5')
+    assert c_permissions == [1, 2, 3, 4, 5]
+
+
+def test_permission_compression_decompression() -> None:
+    permissions = [13127, 91701, 91702, 91703, 91704, 91705, 90901, 90905, 91801, 91802, 91803, 91804, 91805, 10007, 90301, 13068, 13014, 13017, 13032, 13033, 13034, 13072, 13040, 13041, 13042, 13043, 13044, 13046, 13047, 13048, 13049, 13050, 13052, 13053, 13054, 13055, 13056, 13057, 13058, 13059, 13060, 13061, 13062, 13064, 91401, 91402, 13065, 13066, 91403, 91404, 91405, 91406, 10001, 13067, 13069, 13076, 13077, 10005, 13070, 13071, 90902, 90903, 90904, 90906, 10013, 90907, 90908, 90909, 90401, 90402, 90403, 90404, 90405, 90406, 90407, 90408, 13083, 13084, 13085, 13091, 10021, 10023, 13086, 10025, 13097, 10034, 13098, 13087, 10029, 10031, 10033, 13105, 13106, 13088, 10036, 10037, 10039, 10040, 13089, 13113, 13112, 13114, 13115, 13090, 13116, 13122, 13118, 13119, 13120, 13121, 13125, 13132, 13124, 13126, 13092, 13128, 13129, 13130, 13131, 13093, 13133, 13134, 10041, 13094, 13095, 13080, 13096, 91501, 91502, 91503, 91504, 13099, 91505, 91506, 13100, 91001, 13081, 13101, 13102, 13103, 90501, 90502, 90503, 90504, 13104, 90505, 90506, 90507, 90508, 90001, 90002, 90003, 13082, 13107, 13108, 13109, 13110, 13111, 13117, 91601, 91602, 91603, 91604, 91605, 90101, 90102, 90103, 90104, 90105, 90106, 90107, 90108, 90109, 90110, 90111]  # noqa: E501
+    p_permissions = list(sorted(set(permissions)))
+    c_permissions = ApiSdkJwt.compress_permissions(permissions)
+    assert p_permissions == ApiSdkJwt.decompress_permissions(c_permissions)
+
+    r_p = json.dumps(p_permissions, separators=(',', ':'))
+    r_c = json.dumps(c_permissions, separators=(',', ':'))
+
+    print_score('', r_c, r_p)
+    write_stdout(c_permissions)
+
+
+def test_permission_compression_decompression2() -> None:
+    compressed_win = 0
+    total_len = 0
+    for step in range(1, 999):
+        for i in range(0, 100):
+            permissions = list(range(999, 999 + step * i, step))
+            p_permissions = list(sorted(set(permissions)))
+            c_permissions = ApiSdkJwt.compress_permissions(permissions)
+
+            p_l = len(json.dumps(p_permissions, separators=(',', ':')))
+            total_len += p_l
+            compressed_win += p_l - len(json.dumps(c_permissions, separators=(',', ':')))
+            assert p_permissions == ApiSdkJwt.decompress_permissions(c_permissions), f'{i}::{step}::{c_permissions}'
+
+    write_stdout(f'compressed_win={compressed_win}  total_len={total_len}   {compressed_win * 100 / total_len:0.3f}%')
+
+
+def test_permission_compression_decompression4() -> None:
+    import random
+    r = random.Random()
+    r.seed("test")
+
+    permissions: List[int] = []
+    for j in range(1, 501, 20):
+        for _i in range(10000):
+            v = r.randint(1, j)
+            permissions.append(v if not permissions else permissions[-1] + v)
+
+    p_permissions = list(sorted(set(permissions)))
+    c_permissions = ApiSdkJwt.compress_permissions(permissions)
+    assert p_permissions == ApiSdkJwt.decompress_permissions(c_permissions), c_permissions
+
+    r_p = json.dumps(p_permissions, separators=(',', ':'))
+    r_c = json.dumps(c_permissions, separators=(',', ':'))
+
+    print_score('', r_c, r_p)