ominfra 0.0.0.dev204__py3-none-any.whl → 0.0.0.dev206__py3-none-any.whl

ominfra/clouds/aws/instancetypes/__main__.py

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

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/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/clouds/aws/models/base.py

@@ -1,7 +1,9 @@
-import dataclasses as dc
 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
 
 
@@ -21,17 +23,10 @@ class TagList:
 ##
 
 
-class MEMBER_NAME(lang.Marker):  # noqa
-    pass
-
-
 class SHAPE_NAME(lang.Marker):  # noqa
     pass
 
 
-##
-
-
 def common_metadata(
         *,
         shape_name: str | None = None,
@@ -55,9 +50,58 @@ def shape_metadata(
     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_metadata__: ta.ClassVar[ta.Mapping[ta.Any, ta.Any]]
+    __shape__: ShapeInfo
 
     def __init_subclass__(
             cls,
@@ -67,23 +111,39 @@ class Shape:
     ) -> None:
         super().__init_subclass__(**kwargs)
 
-        check.state(not hasattr(cls, '__shape_metadata__'))
+        check.state(not hasattr(cls, '__shape__'))
 
-        cls.__shape_metadata__ = shape_metadata(**kwargs)
+        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
 

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')