ominfra 0.0.0.dev200__py3-none-any.whl → 0.0.0.dev201__py3-none-any.whl

ominfra/clouds/aws/models/gen/cli.py

@@ -1,4 +1,5 @@
 import dataclasses as dc
+import keyword
 import os.path
 import sys
 import typing as ta
@@ -78,7 +79,10 @@ class Cli(ap.Cli):
             operation_names=svc.operations,
         )
 
-        output_file = os.path.join(output_dir, f'{svc.name}.py')
+        fn = svc.name
+        if fn in keyword.kwlist:
+            fn += '_'
+        output_file = os.path.join(output_dir, f'{fn}.py')
         with open(output_file, 'w') as f:
             f.write(mod)
 
@@ -105,6 +109,11 @@ class Cli(ap.Cli):
 
     #
 
+    @ap.cmd()
+    def list_services(self) -> None:
+        for name in sorted(ModelGen.list_available_services()):
+            print(name)
+
     @ap.cmd(
         ap.arg('service'),
     )

ominfra/clouds/aws/models/gen/gen.py

@@ -3,6 +3,7 @@ TODO:
  - default values? nullability? maybe a new_default helper?
  - relative import base
 """
+import builtins
 import dataclasses as dc
 import io
 import typing as ta
@@ -13,10 +14,12 @@ from omlish import lang
 
 
 if ta.TYPE_CHECKING:
+    import botocore.loaders
     import botocore.model
     import botocore.session
 else:
     botocore = lang.proxy_import('botocore', extras=[
+        'loaders',
         'model',
         'session',
     ])
@@ -25,6 +28,13 @@ else:
 ##
 
 
+ServiceTypeName: ta.TypeAlias = ta.Literal[
+    'service-2',
+    'paginators-1',
+    'waiters-2',
+]
+
+
 class ModelGen:
     def __init__(
             self,
@@ -53,16 +63,29 @@ class ModelGen:
 
     #
 
+    @classmethod
+    def create_data_loader(cls) -> 'botocore.loaders.Loader':
+        session = botocore.session.get_session()
+        return session.get_component('data_loader')
+
+    @classmethod
+    def list_available_services(
+            cls,
+            *,
+            type_name: ServiceTypeName = 'service-2',
+    ) -> list[str]:
+        loader = cls.create_data_loader()
+        return list(loader.list_available_services(type_name))
+
     @classmethod
     def load_service_model(
             cls,
             service_name: str,
             *,
-            type_name: ta.Literal['service-2', 'paginators-1', 'waiters-2'] = 'service-2',
+            type_name: ServiceTypeName = 'service-2',
             api_version: str | None = None,
     ) -> 'botocore.model.ServiceModel':
-        session = botocore.session.get_session()
-        loader = session.get_component('data_loader')
+        loader = cls.create_data_loader()
         json_model = loader.load_service_model(service_name, type_name, api_version=api_version)
         return botocore.model.ServiceModel(json_model, service_name=service_name)
 
@@ -137,6 +160,7 @@ class ModelGen:
             pass
 
         if name in self._shape_names:
+            name = self.sanitize_class_name(name)
             if not unquoted_names:
                 return f"'{name}'"
             else:
@@ -150,44 +174,69 @@ class ModelGen:
         'AAAA',
         'ACL',
         'ACP',
+        'AES',
+        'AES256',
+        'AZ',
+        'CA',
         'CRC32',
         'CRC32C',
+        'DB',
+        'EFS',
         'ETag',
+        'IAM',
+        'IO',
+        'IP',
+        'JSON',
         'KMS',
         'MD5',
         'MFA',
         'SHA1',
         'SHA256',
         'SSE',
+        'TTL',
     ]
 
     def demangle_name(self, n: str) -> str:
         ps: list[str] = []
         while n:
             ms: list[tuple[str, int]] = []
+
             for pfx in self.DEMANGLE_PREFIXES:
                 if (i := n.find(pfx)) >= 0:
                     ms.append((pfx, i))
+
             if not ms:
                 ps.append(n)
                 break
+
             if len(ms) > 1:
                 m = sorted(ms, key=lambda t: (t[1], -len(t[0])))[0]
             else:
                 m = ms[0]
+
             pfx, i = m
             l, r = n[:i], n[i + len(pfx):]
+
             if l:
                 ps.append(l)
             ps.append(pfx.lower())
+
             n = r
+
         return '_'.join(lang.snake_case(p) for p in ps)
 
     #
 
+    def sanitize_class_name(self, n: str) -> str:
+        if hasattr(builtins, n):
+            n += '_'
+        return n
+
+    #
+
     PREAMBLE_LINES: ta.Sequence[str] = [
         '# flake8: noqa: E501',
-        '# ruff: noqa: S105',
+        '# ruff: noqa: N801 S105',
         '# fmt: off',
         'import dataclasses as _dc  # noqa',
         'import enum as _enum  # noqa',
@@ -229,6 +278,8 @@ class ModelGen:
     ) -> ShapeSrc:
         shape: botocore.model.Shape = self._service_model.shape_for(name)
 
+        san_name = self.sanitize_class_name(shape.name)
+
         if isinstance(shape, botocore.model.StructureShape):
             lines: list[str] = []
 
@@ -238,7 +289,7 @@ class ModelGen:
 
             lines.extend([
                 '@_dc.dataclass(frozen=True)',
-                f'class {shape.name}(',
+                f'class {san_name}(',
                 '    _base.Shape,',
                 *[f'    {dl},' for dl in mds],
                 '):',
@@ -247,7 +298,9 @@ class ModelGen:
             if not shape.members:
                 lines.append('    pass')
 
-            for mn, ms in shape.members.items():
+            for i, (mn, ms) in enumerate(shape.members.items()):
+                if i:
+                    lines.append('')
                 fn = self.demangle_name(mn)
                 mds = [
                     f'member_name={mn!r}',
@@ -268,7 +321,7 @@ class ModelGen:
 
             return self.ShapeSrc(
                 '\n'.join(lines),
-                class_name=shape.name,
+                class_name=san_name,
                 double_space=True,
             )
 
@@ -278,7 +331,7 @@ class ModelGen:
                 mn,
                 unquoted_names=unquoted_names,
             )
-            l = f'{shape.name}: _ta.TypeAlias = _ta.Sequence[{ma or mn}]'
+            l = f'{san_name}: _ta.TypeAlias = _ta.Sequence[{ma or mn}]'
             if ma is None:
                 l = '# ' + l
             return self.ShapeSrc(l)
@@ -295,7 +348,7 @@ class ModelGen:
                 vn,
                 unquoted_names=unquoted_names,
             )
-            l = f'{shape.name}: _ta.TypeAlias = _ta.Mapping[{ka or kn}, {va or vn}]'
+            l = f'{san_name}: _ta.TypeAlias = _ta.Mapping[{ka or kn}, {va or vn}]'
             if ka is None or va is None:
                 l = '# ' + l
             return self.ShapeSrc(l)
@@ -303,10 +356,14 @@ class ModelGen:
         elif isinstance(shape, botocore.model.StringShape):
             if shape.enum:
                 ls = [
-                    f'class {shape.name}(_enum.Enum):',
+                    f'class {san_name}(_enum.Enum):',
                 ]
+                all_caps = all(v == v.upper() for v in shape.enum)
                 for v in shape.enum:
-                    n = v.upper()
+                    n = v
+                    if not all_caps:
+                        n = self.demangle_name(n)
+                    n = n.upper()
                     for c in '.-:':
                         n = n.replace(c, '_')
                     ls.append(f'    {n} = {v!r}')
@@ -316,10 +373,10 @@ class ModelGen:
                 )
 
             else:
-                return self.ShapeSrc(f"{shape.name} = _ta.NewType('{shape.name}', str)")
+                return self.ShapeSrc(f"{san_name} = _ta.NewType('{san_name}', str)")
 
         elif (pt := self.PRIMITIVE_SHAPE_TYPES.get(shape.type_name)) is not None:
-            return self.ShapeSrc(f"{shape.name} = _ta.NewType('{shape.name}', {pt})")
+            return self.ShapeSrc(f'{san_name} = _ta.NewType({san_name!r}, {pt})')
 
         else:
             raise TypeError(shape.type_name)
@@ -354,7 +411,7 @@ class ModelGen:
 
         out.write('\n\n')
         out.write('ALL_SHAPES: frozenset[type[_base.Shape]] = frozenset([\n')
-        for n in all_shapes:
+        for n in sorted(all_shapes):
             out.write(f'    {n},\n')
         out.write('])\n')
 
@@ -415,7 +472,7 @@ class ModelGen:
 
         out.write('\n')
         out.write('ALL_OPERATIONS: frozenset[_base.Operation] = frozenset([\n')
-        for n in all_operations:
+        for n in sorted(all_operations):
             out.write(f'    {n},\n')
         out.write('])\n')