omlish 0.0.0.dev102__py3-none-any.whl → 0.0.0.dev104__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev102'
-__revision__ = '591e5229fd5080d01399bef3d509a4686af32891'
+__version__ = '0.0.0.dev104'
+__revision__ = '1ffe2eb6d42217c0ee8b049c6c3b04fd970f9e66'
 
 
 #

omlish/concurrent/threadlets.py

@@ -94,3 +94,6 @@ class GreenletThreadlets(Threadlets):
 
     def get_current(self) -> Threadlet:
         return GreenletThreadlet(greenlet.getcurrent())
+
+
+GREENLET_THREADLETS = GreenletThreadlets()

omlish/diag/pycharm/pycharm.py

@@ -1,7 +1,9 @@
 import dataclasses as dc
+import json
 import os.path
 import plistlib
 import re
+import shutil
 import subprocess
 import sys
 import typing as ta
@@ -43,6 +45,26 @@ def read_darwin_pycharm_info_plist() -> ta.Mapping[str, ta.Any] | None:
     return root
 
 
+#
+
+
+UBUNTU_PYCHARM_HOME = '/snap/pycharm-professional/current'
+
+
+def read_ubuntu_pycharm_product_info() -> ta.Mapping[str, ta.Any] | None:
+    json_file = os.path.join(UBUNTU_PYCHARM_HOME, 'product-info.json')
+    if not os.path.isfile(json_file):
+        return None
+
+    with open(json_file) as f:
+        root = json.load(f)
+
+    return root
+
+
+#
+
+
 @lang.cached_function
 def get_pycharm_version() -> str | None:
     if sys.platform == 'darwin':
@@ -54,6 +76,17 @@ def get_pycharm_version() -> str | None:
         check.state(ver.startswith('PY-'))
         return ver[3:]
 
+    elif sys.platform == 'linux':
+        if shutil.which('lsb_release') is not None:
+            lsb_id = subprocess.check_output(['lsb_release', '-is']).decode().strip()
+            if lsb_id == 'Ubuntu':
+                pi = read_ubuntu_pycharm_product_info()
+                if pi is not None:
+                    ver = check.non_empty_str(pi['buildNumber'])
+                    return ver
+
+        return None
+
     else:
         return None
 

omlish/fnpairs.py

@@ -26,7 +26,6 @@ from . import lang
 if ta.TYPE_CHECKING:
     import bz2 as _bz2
     import gzip as _gzip
-    import json as _json
     import lzma as _lzma
     import pickle as _pickle
     import struct as _struct
@@ -40,10 +39,11 @@ if ta.TYPE_CHECKING:
     import yaml as _yaml
     import zstandard as _zstandard
 
+    from .formats import json as _json
+
 else:
     _bz2 = lang.proxy_import('bz2')
     _gzip = lang.proxy_import('gzip')
-    _json = lang.proxy_import('json')
     _lzma = lang.proxy_import('lzma')
     _pickle = lang.proxy_import('pickle')
     _struct = lang.proxy_import('struct')
@@ -57,6 +57,8 @@ else:
     _yaml = lang.proxy_import('yaml')
     _zstandard = lang.proxy_import('zstandard')
 
+    _json = lang.proxy_import('.formats.json', __package__)
+
 
 ##
 
@@ -277,7 +279,7 @@ def _register_extension(*ss):
     def inner(cls):
         for s in ss:
             if s in _EXTENSION_REGISTRY:
-                raise Exception(s)
+                raise KeyError(s)
             _EXTENSION_REGISTRY[s] = cls
         return cls
     return inner
@@ -409,22 +411,30 @@ class Pickle(ObjectBytes_):
         return _pickle.loads(t)
 
 
+class _Json(ObjectStr_, lang.Abstract):  # noqa
+    def backward(self, t: str) -> ta.Any:
+        return _json.loads(t)
+
+
 @_register_extension('json')
-@dc.dataclass(frozen=True)
-class Json(ObjectStr_):
-    indent: int | str | None = dc.field(default=None, kw_only=True)
-    separators: tuple[str, str] | None = dc.field(default=None, kw_only=True)
+class Json(_Json):
+    def forward(self, f: ta.Any) -> str:
+        return _json.dumps(f)
+
 
+class JsonPretty(_Json):
     def forward(self, f: ta.Any) -> str:
-        return _json.dumps(f, indent=self.indent, separators=self.separators)
+        return _json.dumps_pretty(f)
 
-    def backward(self, t: str) -> ta.Any:
-        return _json.loads(t)
+
+class JsonCompact(_Json):
+    def forward(self, f: ta.Any) -> str:
+        return _json.dumps_compact(f)
 
 
 JSON = Json()
-PRETTY_JSON = Json(indent=2)
-COMPACT_JSON = Json(separators=(',', ':'))
+PRETTY_JSON = JsonPretty()
+COMPACT_JSON = JsonCompact()
 
 
 @_register_extension('jsonl')

omlish/formats/json/cli/cli.py

@@ -1,7 +1,41 @@
 """
 TODO:
- - -I/-Ogz, lz4, etc - fnpairs
  - read from http
+ - jmespath output flat, unquoted strs like jq '.[]'
+
+==
+
+jq Command options:
+  -n, --null-input          use `null` as the single input value;
+  -R, --raw-input           read each line as string instead of JSON;
+  -s, --slurp               read all inputs into an array and use it as the single input value;
+  -c, --compact-output      compact instead of pretty-printed output;
+  -r, --raw-output          output strings without escapes and quotes;
+      --raw-output0         implies -r and output NUL after each output;
+  -j, --join-output         implies -r and output without newline after each output;
+  -a, --ascii-output        output strings by only ASCII characters using escape sequences;
+  -S, --sort-keys           sort keys of each object on output;
+  -C, --color-output        colorize JSON output;
+  -M, --monochrome-output   disable colored output;
+      --tab                 use tabs for indentation;
+      --indent n            use n spaces for indentation (max 7 spaces);
+      --unbuffered          flush output stream after each output;
+      --stream              parse the input value in streaming fashion;
+      --stream-errors       implies --stream and report parse error as an array;
+      --seq                 parse input/output as application/json-seq;
+  -f, --from-file file      load filter from the file;
+  -L directory              search modules from the directory;
+      --arg name value      set $name to the string value;
+      --argjson name value  set $name to the JSON value;
+      --slurpfile name file set $name to an array of JSON values read from the file;
+      --rawfile name file   set $name to string contents of file;
+      --args                consume remaining arguments as positional string values;
+      --jsonargs            consume remaining arguments as positional JSON values;
+  -e, --exit-status         set exit status code based on the output;
+  -V, --version             show the version;
+  --build-configuration     show jq's build configuration;
+  -h, --help                show the help;
+  --                        terminates argument processing;
 """
 import argparse
 import codecs

omlish/formats/json/cli/formats.py

@@ -44,12 +44,19 @@ class Format:
 
 class Formats(enum.Enum):
     JSON = Format(['json'], json.load)
+
     YAML = Format(['yaml', 'yml'], lambda f: yaml.safe_load(f))
+
     TOML = Format(['toml'], lambda f: tomllib.loads(f.read()))
+
     ENV = Format(['env', 'dotenv'], lambda f: dotenv.dotenv_values(stream=f))
+
     PROPS = Format(['properties', 'props'], lambda f: dict(props.Properties().load(f.read())))
+
     PY = Format(['py', 'python', 'repr'], lambda f: ast.literal_eval(f.read()))
+
     XML = Format(['xml'], lambda f: xml.build_simple_element(xml.parse_tree(f.read()).getroot()).as_dict())
+
     CSV = Format(['csv'], lambda f: list(csv.DictReader(f)))
     TSV = Format(['tsv'], lambda f: list(csv.DictReader(f, delimiter='\t')))
     FLAT_CSV = Format(['fcsv'], lambda f: list(csv.reader(f)))

omlish/formats/json/cli/io.py

@@ -0,0 +1,74 @@
+# """
+# TODO:
+#  - -I/-Ogz, lz4, etc
+#   - fnpairs? or not yet just do it
+# """
+# import abc
+# import contextlib
+# import dataclasses as dc
+# import gzip
+# import os
+# import typing as ta
+#
+# from .... import lang
+#
+#
+# if ta.TYPE_CHECKING:
+#     import bz2 as _bz2
+#     import gzip as _gzip
+#     import lzma as _lzma
+# else:
+#     _bz2 = lang.proxy_import('bz2')
+#     _gzip = lang.proxy_import('gzip')
+#     _lzma = lang.proxy_import('lzma')
+#
+#
+# ##
+#
+#
+# class BaseIo(lang.Abstract):
+#     def close(self) -> None:
+#         raise NotImplementedError
+#
+#     def fileno(self) -> int | None:
+#         return None
+#
+#
+# class Input(BaseIo):
+#     @abc.abstractmethod
+#     def read(self, sz: int | None = None) -> bytes:
+#         raise NotImplementedError
+#
+#
+# class Output(BaseIo):
+#     @abc.abstractmethod
+#     def write(self, data: bytes) -> int:
+#         raise NotImplementedError
+#
+#
+# #
+#
+#
+# DEFAULT_READ_SZ = 0x4000
+#
+#
+# @dc.dataclass(frozen=True)
+# class FdIo(Input, Output):
+#     fd: int
+#
+#     default_read_sz: int = DEFAULT_READ_SZ
+#
+#     def read(self, sz: int | None = None) -> bytes:
+#         return os.read(self.fd, sz or self.default_read_sz)
+#
+#     def write(self, data: bytes) -> int:
+#         return os.write(self.fd, data)
+#
+#
+# ##
+#
+#
+# @contextlib.contextmanager
+# def gzip_io_codec(f: ta.IO, mode: str) -> ta.ContextManager[ta.IO]:
+#     with gzip.open(f, mode) as o:
+#         yield o

omlish/http/consts.py

@@ -42,6 +42,8 @@ CONTENT_CHARSET_UTF8 = b'charset=utf-8'
 
 CONTENT_TYPE_BYTES = b'application/octet-stream'
 
+CONTENT_TYPE_FORM_URLENCODED = b'application/x-www-form-urlencoded'
+
 CONTENT_TYPE_HTML = b'text/html'
 CONTENT_TYPE_HTML_UTF8 = b'; '.join([CONTENT_TYPE_HTML, CONTENT_CHARSET_UTF8])
 

omlish/http/jwt.py

@@ -0,0 +1,179 @@
+import abc
+import base64
+import hashlib
+import hmac
+import json
+import typing as ta
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import cryptography.hazmat.primitives.asymmetric.padding
+    import cryptography.hazmat.primitives.hashes
+    import cryptography.hazmat.primitives.serialization
+else:
+    cryptography = lang.proxy_import('cryptography', extras=[
+        'hazmat.primitives.asymmetric.padding',
+        'hazmat.primitives.hashes',
+        'hazmat.primitives.serialization',
+    ])
+
+
+##
+
+
+def as_bytes(v: str | bytes, encoding: str = 'utf-8') -> bytes:
+    return v.encode(encoding) if isinstance(v, str) else v
+
+
+def base64url_encode(b: bytes) -> bytes:
+    return base64.urlsafe_b64encode(b).replace(b'=', b'')
+
+
+##
+
+
+class Algorithm(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def prepare_key(self, key: str | bytes) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def sign(self, msg: str | bytes, key: ta.Any) -> bytes:
+        raise NotImplementedError
+
+
+class HmacAlgorithm(Algorithm):
+    def __init__(self, name: str, digest: ta.Any) -> None:
+        super().__init__()
+        self._name = name
+        self._digest = digest
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def prepare_key(self, key: str | bytes) -> ta.Any:
+        return as_bytes(key)
+
+    def sign(self, msg: str | bytes, key: ta.Any) -> bytes:
+        return hmac.new(key, as_bytes(msg), self._digest).digest()
+
+
+class RsaAlgorithm(Algorithm):
+    def __init__(self, name: str, digest: str) -> None:
+        super().__init__()
+        self._name = name
+        self._digest = digest
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def prepare_key(self, key: str | bytes) -> ta.Any:
+        if (key_bytes := as_bytes(key)).startswith(b'ssh-rsa'):
+            return cryptography.hazmat.primitives.serialization.load_ssh_public_key(key_bytes)
+        else:
+            return cryptography.hazmat.primitives.serialization.load_pem_private_key(key_bytes, password=None)
+
+    def sign(self, msg: str | bytes, key: ta.Any) -> bytes:
+        return key.sign(
+            as_bytes(msg),
+            cryptography.hazmat.primitives.asymmetric.padding.PKCS1v15(),
+            getattr(cryptography.hazmat.primitives.hashes, self._digest)(),
+        )
+
+
+ALGORITHMS_BY_NAME = {
+    a.name: a for a in [
+        HmacAlgorithm('HS256', hashlib.sha256),
+        HmacAlgorithm('HS384', hashlib.sha384),
+        HmacAlgorithm('HS512', hashlib.sha512),
+
+        RsaAlgorithm('RS256', 'SHA256'),
+        RsaAlgorithm('RS384', 'SHA384'),
+        RsaAlgorithm('RS512', 'SHA512'),
+    ]
+}
+
+
+##
+
+
+def jwt_encode(
+        payload: ta.Mapping[str, ta.Any],
+        key: str | bytes,
+        *,
+        algorithm: str = 'HS256',
+) -> str:
+    alg = ALGORITHMS_BY_NAME[algorithm]
+
+    segments: list[bytes] = []
+
+    header: dict[str, ta.Any] = {
+        'typ': 'jwt',
+        'alg': alg.name,
+    }
+    json_header = json.dumps(header, separators=(',', ':'), sort_keys=True).encode('utf-8')
+    segments.append(base64url_encode(json_header))
+
+    json_payload = json.dumps(payload, separators=(',', ':')).encode('utf-8')
+    msg_payload = base64url_encode(json_payload)
+    segments.append(msg_payload)
+
+    signing_input = b'.'.join(segments)
+
+    key = alg.prepare_key(key)
+    signature = alg.sign(signing_input, key)
+
+    segments.append(base64url_encode(signature))
+
+    encoded_string = b'.'.join(segments)
+    return encoded_string.decode('utf-8')
+
+
+def generate_jwt(
+        *,
+        issuer: str,
+        subject: str,
+        audience: str,
+        issued_at: int,
+        expires_at: int,
+        scope: str,
+        key: str | bytes,
+        **kwargs: ta.Any,
+) -> str:
+    payload = {
+        'iss': issuer,
+        'sub': subject,
+        'aud': audience,
+        'iat': issued_at,
+        'exp': expires_at,
+        'scope': scope,
+    }
+
+    return jwt_encode(
+        payload,
+        key,
+        **kwargs,
+    )
+
+
+##
+
+
+SERVICE_APPLICATION_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+
+
+def build_get_token_body(
+        signed_jwt: str,
+        *,
+        grant_type: str = SERVICE_APPLICATION_GRANT_TYPE,
+) -> str:
+    return f'grant_type={grant_type}&assertion={signed_jwt}'

omlish/io/__init__.py

@@ -0,0 +1,3 @@
+from ..lite.io import (  # noqa
+    DelimitingBuffer,
+)