ominfra 0.0.0.dev204__tar.gz → 0.0.0.dev206__tar.gz

{ominfra-0.0.0.dev204/ominfra.egg-info → ominfra-0.0.0.dev206}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ominfra
-Version: 0.0.0.dev204
+Version: 0.0.0.dev206
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,9 +12,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev204
-Requires-Dist: omlish==0.0.0.dev204
-Requires-Dist: omserv==0.0.0.dev204
+Requires-Dist: omdev==0.0.0.dev206
+Requires-Dist: omlish==0.0.0.dev206
+Requires-Dist: omserv==0.0.0.dev206
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.18; extra == "all"

ominfra-0.0.0.dev206/ominfra/clouds/aws/instancetypes/cache.py

@@ -0,0 +1,12 @@
+import gzip
+import typing as ta
+
+from omlish import lang
+from omlish.formats import json
+
+
+@lang.cached_function()
+def load_instance_types() -> ta.Mapping[str, ta.Mapping[str, ta.Any]]:
+    raw = lang.get_relative_resources(globals=globals())['cache.json.gz'].read_bytes()
+    data = gzip.decompress(raw)
+    return json.loads(data)

ominfra-0.0.0.dev206/ominfra/clouds/aws/instancetypes/cli.py

@@ -0,0 +1,80 @@
+import datetime
+import gzip
+import os.path
+import typing as ta
+
+from omdev.secrets import load_secrets
+from omlish import lang
+from omlish import secrets as sec
+from omlish.argparse import all as ap
+from omlish.formats import json
+
+from .cache import load_instance_types
+
+
+if ta.TYPE_CHECKING:
+    import boto3
+else:
+    boto3 = lang.proxy_import('boto3')
+
+
+# Use a hardcoded gz mtime to prevent the gz file from changing when the contents don't. We still have the git metadata
+# to track modifications.
+FIXED_CACHE_TIMESTAMP = datetime.datetime(2025, 1, 1, tzinfo=datetime.UTC).timestamp()
+
+
+@lang.cached_function
+def _get_secrets() -> sec.Secrets:
+    return load_secrets()
+
+
+def get_ec2_instance_types(session: boto3.Session) -> dict[str, dict[str, ta.Any]]:
+    ec2 = session.client('ec2')
+    next_token = None
+    dct = {}
+    while True:
+        resp = ec2.describe_instance_types(**(dict(NextToken=next_token) if next_token else {}))
+        for instance_type in resp['InstanceTypes']:
+            name = instance_type['InstanceType']
+            dct[name] = instance_type
+        next_token = resp.get('NextToken')
+        if not next_token:
+            break
+    dct = dict(sorted(dct.items(), key=lambda t: t[0]))
+    return dct
+
+
+class Cli(ap.Cli):
+    @ap.cmd()
+    def fetch(self) -> None:
+        cfg = _get_secrets()
+
+        session = boto3.Session(
+            aws_access_key_id=cfg.get('aws_access_key_id').reveal(),
+            aws_secret_access_key=cfg.get('aws_secret_access_key').reveal(),
+            region_name=cfg.get('aws_region').reveal(),
+        )
+
+        instance_types = get_ec2_instance_types(session)
+
+        cache_file = os.path.join(os.path.dirname(__file__), 'cache.json.gz')
+        with open(cache_file, 'wb') as f:
+            with gzip.GzipFile(
+                    fileobj=f,
+                    mode='w',
+                    mtime=FIXED_CACHE_TIMESTAMP,
+            ) as gf:
+                gf.write(json.dumps_compact(instance_types).encode('utf-8'))
+
+    @ap.cmd()
+    def dump(self) -> None:
+        dct = load_instance_types()
+        print(json.dumps_pretty(dct))
+
+
+def _main() -> None:
+    Cli()()
+
+
+if __name__ == '__main__':
+    _main()

ominfra-0.0.0.dev206/ominfra/clouds/aws/models/base.py

@@ -0,0 +1,161 @@
+import typing as ta
+
+from omlish import cached
+from omlish import check
+from omlish import collections as col
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+DateTime = ta.NewType('DateTime', str)
+MillisecondDateTime = ta.NewType('MillisecondDateTime', str)
+
+Timestamp = ta.NewType('Timestamp', str)
+
+
+##
+
+
+class TagList:
+    pass
+
+
+##
+
+
+class SHAPE_NAME(lang.Marker):  # noqa
+    pass
+
+
+def common_metadata(
+        *,
+        shape_name: str | None = None,
+) -> dict[ta.Any, ta.Any]:
+    md = {}
+
+    if shape_name is not None:
+        md[SHAPE_NAME] = shape_name
+
+    return md
+
+
+##
+
+
+def shape_metadata(
+        **kwargs: ta.Any,
+) -> dict[ta.Any, ta.Any]:
+    md = {**common_metadata(**kwargs)}
+
+    return md
+
+
+class ShapeInfo:
+    def __init__(
+            self,
+            cls: type['Shape'],
+            metadata: ta.Mapping[ta.Any, ta.Any],
+    ) -> None:
+        super().__init__()
+
+        self._cls = check.issubclass(cls, Shape)
+        self._metadata = metadata
+
+    @property
+    def cls(self) -> type['Shape']:
+        return self._cls
+
+    @property
+    def metadata(self) -> ta.Mapping[ta.Any, ta.Any]:
+        return self._metadata
+
+    #
+
+    @cached.function
+    def fields(self) -> ta.Sequence[dc.Field]:
+        check.state(dc.is_immediate_dataclass(self._cls))
+        fls = dc.fields(self._cls)
+        return fls  # noqa
+
+    @cached.function
+    def fields_by_name(self) -> ta.Mapping[str, dc.Field]:
+        return col.make_map_by(lambda fl: fl.name, self.fields(), strict=True)
+
+    @cached.function
+    def fields_by_member_name(self) -> ta.Mapping[str, dc.Field]:
+        return col.make_map(
+            [(n, f) for f in self.fields() if (n := f.metadata.get(MEMBER_NAME)) is not None],
+            strict=True,
+        )
+
+    @cached.function
+    def fields_by_serialization_name(self) -> ta.Mapping[str, dc.Field]:
+        l = []
+        for f in self.fields():
+            if sn := f.metadata.get(SERIALIZATION_NAME):
+                l.append((sn, f))
+            elif mn := f.metadata.get(MEMBER_NAME):
+                l.append((mn, f))
+        return col.make_map(l, strict=True)
+
+
+@dc.dataclass(frozen=True)
+class Shape:
+    __shape__: ShapeInfo
+
+    def __init_subclass__(
+            cls,
+            *,
+            shape_name: str | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+
+        check.state(not hasattr(cls, '__shape__'))
+
+        info = ShapeInfo(
+            cls,
+            shape_metadata(**kwargs),
+        )
+
+        cls.__shape__ = info
+
+
+##
+
+
+class MEMBER_NAME(lang.Marker):  # noqa
+    pass
+
+
+class SERIALIZATION_NAME(lang.Marker):  # noqa
+    pass
+
+
+def field_metadata(
+        *,
+        member_name: str | None = None,
+        serialization_name: str | None = None,
+        **kwargs: ta.Any,
+) -> dict[ta.Any, ta.Any]:
+    md = {**common_metadata(**kwargs)}
+
+    if member_name is not None:
+        md[MEMBER_NAME] = member_name
+    if serialization_name is not None:
+        md[SERIALIZATION_NAME] = serialization_name
+
+    return md
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False, kw_only=True)
+class Operation:
+    name: str
+
+    input: type[Shape] | None = None
+    output: type[Shape] | None = None
+
+    errors: ta.Sequence[type[Shape]] | None = None

ominfra-0.0.0.dev206/ominfra/clouds/aws/models/gen/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .cli import _main  # noqa
+
+    _main()

{ominfra-0.0.0.dev204 → ominfra-0.0.0.dev206}/ominfra/clouds/aws/models/gen/gen.py

@@ -317,8 +317,10 @@ class ModelGen:
                 fn = self.demangle_name(mn)
                 mds = [
                     f'member_name={mn!r}',
-                    f'shape_name={ms.name!r}',
                 ]
+                if msn := ms.serialization.get('name'):
+                    mds.append(f'serialization_name={msn!r}')
+                mds.append(f'shape_name={ms.name!r}')
                 ma = self.get_type_ann(
                     ms.name,
                     unquoted_names=unquoted_names,
@@ -508,3 +510,7 @@ class ModelGen:
             self.gen_all_operations(out)
 
         return out.getvalue()
+
+
+if __name__ == '__main__':
+    raise RuntimeError('Use cli')