Refactor script part

podctl/console_script.py

@@ -19,51 +19,18 @@ class ConsoleScript(cli2.ConsoleScript):
         import inspect
         from podctl.podfile import Podfile
         self.podfile = Podfile.factory(os.getenv('PODFILE', 'pod.py'))
-        for name in self.podfile.pod.script_names():
+        for name in self.podfile.pod.scripts.keys():
-            self[name] = self.podfile.pod.script(name)
+            self[name] = cli2.Callable(name, self.podfile.pod.script(name),)
-            '''
+        return super().__call__(*args, **kwargs)
-            ee = self.script(pod, name)
-            ee.__doc__ = inspect.getdoc(cb)
-            self[name] = cli2.Callable(name, ee)
-            '''
-
-        super().__call__(*args, **kwargs)
-
-    @staticmethod
-    def script(script_name):
-        async def script(*services_or_flags, **options):
-            flags = []
-            services = []
-            for arg in services_or_flags:
-                if arg.startswith('-') or arg.startswith('+'):
-                    flags.append(arg)
-                else:
-                    services.append(arg)
-
-            if services:
-                services = {
-                    k: v
-                    for k, v in console_script.pod.services.items()
-                    if k in services
-                }
-            else:
-                services = console_script.pod.services
-
-            procs = []
-            asyncio.events.get_event_loop()
-            for name, service in services.items():
-                service.container.name = name
-                service.container.flags = flags
-                procs.append(service.container.script(script_name, flags))
 
+    def call(self, command):
         try:
-                result = await asyncio.gather(*procs)
+            return super().call(command)
         except Mistake as e:
             print(e)
             sys.exit(1)
         except WrongResult:
             sys.exit(1)
-        return script
 
 
 console_script = ConsoleScript(__doc__).add_module('podctl.console_script')

podctl/container.py

@@ -8,12 +8,4 @@ from .visitable import Visitable
 
 
 class Container(Visitable):
-    default_scripts = dict(
+    pass
-        build=Build(),
-        run=Run(),
-    )
-
-    def script(self, name):
-        script = super().script(name)
-        script.container = self
-        return script

podctl/pod.py

@@ -1,21 +1,42 @@
+import asyncio
+import copy
 import os
 
+from .build import Build
+from .container import Container
+from .run import Run
 from .script import Script
 from .visitable import Visitable
 
 
 class Pod(Visitable):
-    def script_names(self):
+    default_scripts = dict(
-        for name in self.scripts.keys():
+        build=Build(),
-            yield name
+        run=Run(),
+    )
 
-        for visitor in self.visitors:
+    @property
-            for script in visitor.scripts.keys():
+    def containers(self):
-                yield script
+        return [i for i in self.visitors if type(i) == Container]
 
     def script(self, name):
-        for script_name in self.scripts.keys():
+        async def cb(*args, **kwargs):
-            if script_name == name:
+            asyncio.events.get_event_loop()
-                break
+            script = copy.deepcopy(self.scripts[name])
-        script.pod = self
+
-        return script
+            if args:
+                containers = [c for c in self.containers if c.name in args]
+            else:
+                containers = self.containers
+
+            procs = []
+            for container in containers:
+                procs.append(script(
+                    container,
+                    *args,
+                    container=container,
+                    pod=self,
+                    **kwargs,
+                ))
+            return await asyncio.gather(*procs)
+        return cb

podctl/script.py

@@ -4,6 +4,9 @@ from .proc import Proc
 
 
 class Script:
+    def __init__(self, name=None):
+        self.name = name or type(self).__name__.lower()
+
     async def exec(self, *args, **kwargs):
         """Execute a command on the host."""
         kwargs.setdefault('prefix', self.container.name)
@@ -12,27 +15,33 @@ class Script:
             await proc.wait()
         return proc
 
-    async def __call__(self, name, loop=None):
+    async def __call__(self, visitable, *args, **kwargs):
-        script = copy(self.scripts[name])
+        for key, value in kwargs.items():
-        script.loop = loop or asyncio.events.get_event_loop()
+            setattr(self, key, value)
-        results = []
 
+        visitors = visitable.visitors
+
+        results = []
         async def clean():
-            for visitor in self.visitors:
+            for visitor in visitable.visitors:
-                if hasattr(visitor, 'clean_' + name):
+                if hasattr(visitor, 'clean_' + self.name):
-                    result = getattr(visitor, 'clean_' + name)(script)
+                    result = getattr(visitor, 'clean_' + self.name)(self)
                     if result:
                         await result
 
         for prefix in ('init_', 'pre_', '', 'post_', 'clean_'):
-            method = prefix + name
+            method = prefix + self.name
-            for visitor in self.visitors:
+            for visitor in visitable.visitors:
                 if not hasattr(visitor, method):
                     continue
 
-                rep = {k: v if not isinstance(v, object) else type(v).__name__ for k, v in visitor.__dict__.items()}
+                print(
-                print(self.name + ' | ', type(visitor).__name__, method, rep)
+                    visitable.name + ' | ',
-                result = getattr(visitor, method)(script)
+                    type(visitor).__name__,
+                    method,
+                    ' '.join(f'{k}={v}' for k, v in visitor.__dict__.items())
+                )
+                result = getattr(visitor, method)(self)
                 if result:
                     try:
                         await result