Changeset 3537:0377c0070e40 in livinglogic.python.xist

Show
Ignore:
Timestamp:
07/26/08 15:29:49 (11 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Implement Action method getargs() and getkwargs() that generate argument for execute().

This makes it possible for many action to implement what they do in an execute()
method instead of get(). Also it simplifies implementing a repr() method.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • src/ll/make.py

    r3536 r3537  
    265265            if data is not nodata and not havedata: # The first real output 
    266266                since = bigbang # force inputs to produce data for the rest of the loop 
    267                 resultdata = dict((key, getoutputs(project, since, input[key])) for key in resultdata) # refetch data from previous inputs 
     267                resultdata = dict((key, getoutputs(project, since, input[key])[0]) for key in resultdata) # refetch data from previous inputs 
    268268                havedata = True 
    269269            resultdata[key] = data 
     
    306306        return output.__rdiv__(self) 
    307307 
    308     @misc.notimplemented 
     308    @report 
    309309    def get(self, project, since): 
    310310        """ 
     
    337337        cases this if the newest :attr:`changed` timestamp of the input actions. 
    338338        """ 
     339        input = (self.getargs(), self.getkwargs()) 
     340        (data, self.changed) = getoutputs(project, since, input) 
     341        if data is not nodata: 
     342            data = self.execute(project, *data[0], **data[1]) 
     343        return data 
     344 
     345    @misc.notimplemented 
     346    def execute(self, project, *args, **kwargs): 
     347        """ 
     348        Execute the action: transform the input data in :var:`args` and 
     349        :var:`kwargs` and return the resulting output data. This method must be 
     350        implemented in subclasses. 
     351        """ 
    339352 
    340353    def getkey(self): 
     
    344357        """ 
    345358        return getattr(self, "key", None) 
     359 
     360    def getargs(self): 
     361        return () 
     362 
     363    def getkwargs(self): 
     364        return {} 
     365 
     366    def __repr__(self): 
     367        def format(arg): 
     368            if isinstance(arg, Action): 
     369                return " from %s.%s" % (arg.__class__.__module__, arg.__class__.__name__) 
     370            elif isinstance(arg, tuple): 
     371                return "=(?)" 
     372            elif isinstance(arg, list): 
     373                return "=[?]" 
     374            elif isinstance(arg, dict): 
     375                return "={?}" 
     376            else: 
     377                return "=%r" % (arg,) 
     378 
     379        output = ["%d%s" % (i, format(arg)) for (i, arg) in enumerate(self.getargs())] 
     380        for (argname, arg) in self.getkwargs().iteritems(): 
     381            output.append("%s%s" % (argname, format(arg))) 
     382             
     383        if output: 
     384            output = " with %s" % ", ".join(output) 
     385        else: 
     386            output = "" 
     387        return "<%s.%s object%s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, output, id(self)) 
    346388 
    347389    @misc.notimplemented 
     
    435477        yield self.input 
    436478 
    437     @misc.notimplemented 
    438     def execute(self, project, data): 
    439         """ 
    440         Execute the action: transform the input data :var:`data` and return 
    441         the resulting output data. This method must be implemented in subclasses. 
    442         """ 
    443  
    444     @report 
    445     def get(self, project, since): 
    446         (data, self.changed) = getoutputs(project, since, self.input) 
    447         if data is not nodata: 
    448             data = self.execute(project, data) 
    449         return data 
     479    def getkwargs(self): 
     480        return dict(data=self.input) 
    450481 
    451482 
     
    629660    """ 
    630661    def execute(self, project, data): 
    631         project.writestep(self, "Unpickling") 
     662        project.writestep(self, "Unpickling ", len(data), " bytes") 
    632663        return cPickle.loads(data) 
    633  
    634     def __repr__(self): 
    635         return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    636664 
    637665 
     
    653681        yield self.protocol 
    654682 
    655     @report 
    656     def get(self, project, since): 
    657         (data, self.changed) = getoutputs(project, since, (self.input, self.protocol)) 
    658         if data is not nodata: 
    659             project.writestep(self, "Pickling data with protocol %r" % data[1]) 
    660             data = cPickle.dumps(data[0], data[1]) 
     683    def getkwargs(self): 
     684        return dict(data=self.input, protocol=self.protocol) 
     685 
     686    def execute(self, data, protocol): 
     687        project.writestep(self, "Pickling ", len(data), " bytes with protocol %r" % protocol) 
     688        return cPickle.dumps(data, protocol) 
    661689        return data 
    662  
    663     def __repr__(self): 
    664         if isinstance(self.protocol, Action): 
    665             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    666         else: 
    667             return "<%s.%s object with protocol=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.protocol, id(self)) 
    668690 
    669691 
     
    687709        return iter(self.inputs) 
    688710 
    689     @report 
    690     def get(self, project, since): 
    691         (data, self.changed) = getoutputs(project, since, self.inputs) 
    692         if data is not nodata: 
    693             project.writestep(self, "Joining data from %d inputs" % len(data)) 
    694             data = "".join(data) 
    695         return data 
     711    def getargs(self): 
     712        return (self.inputs,) 
     713 
     714    def execute(self, project, inputs): 
     715        project.writestep(self, "Joining data from ", len(data), " inputs") 
     716        return "".join(data) 
    696717 
    697718 
     
    760781        yield self.attrname 
    761782 
    762     @report 
    763     def get(self, project, since): 
    764         (data, self.changed) = getoutputs(project, since, (self.input, self.attrname)) 
    765         if data is not nodata: 
    766             project.writestep(self, "Getting attribute ", self.attrname) 
    767             data = getattr(data[0], data[1]) 
    768         return data 
    769  
    770     def __repr__(self): 
    771         if isinstance(self.attrname, Action): 
    772             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    773         else: 
    774             return "<%s.%s object with attrname=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.attrname, id(self)) 
     783    def getkwargs(self): 
     784        return dict(data=self.input, attrname=self.attrname) 
     785 
     786    def execute(self, project, data, attrname): 
     787        project.writestep(self, "Getting attribute ", attrname) 
     788        return getattr(data, attrname) 
    775789 
    776790 
     
    801815        return misc.Pool(*data) 
    802816 
    803     @report 
    804     def get(self, project, since): 
    805         (data, self.changed) = getoutputs(project, since, self.inputs) 
    806  
    807         if data is not nodata: 
    808             data = self._getpool(*data) 
    809             project.writestep(self, "Created ", data.__class__.__module__, ".", data.__class__.__name__," object") 
     817    def getargs(self): 
     818        return (self.inputs,) 
     819 
     820    def execute(self, project, data): 
     821        data = self._getpool(*data) 
     822        project.writestep(self, "Created ", data.__class__.__module__, ".", data.__class__.__name__," object") 
    810823        return data 
    811  
    812     def __repr__(self): 
    813         return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    814824 
    815825 
     
    853863        yield self.base 
    854864 
    855     @report 
    856     def get(self, project, since): 
    857         (data, self.changed) = getoutputs(project, since, (self.input, self.builder, self.pool, self.base)) 
    858  
    859         if data is not nodata: 
    860             # We really have to do some work 
    861             from ll.xist import xsc 
    862             (data, builder, pool, base) = data 
    863             oldpool = builder.pool 
    864             try: 
    865                 builder.pool = xsc.Pool(pool, oldpool) 
    866  
    867                 project.writestep(self, "Parsing XIST input with base ", base) 
    868                 data = builder.parsestring(data, base) 
    869             finally: 
    870                 builder.pool = oldpool # Restore old pool 
     865    def getkwargs(self): 
     866        return dict(data=self.input, builder=self.builder, pool=self.pool, base=self.base) 
     867 
     868    def execute(self, project, data, builder, pool, base): 
     869        from ll.xist import xsc 
     870        oldpool = builder.pool 
     871        try: 
     872            builder.pool = xsc.Pool(pool, oldpool) 
     873            project.writestep(self, "Parsing XIST input with base ", base) 
     874            data = builder.parsestring(data, base) 
     875        finally: 
     876            builder.pool = oldpool # Restore old pool 
    871877        return data 
    872  
    873     def __repr__(self): 
    874         return "<%s.%s object with base=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.base, id(self)) 
    875878 
    876879 
     
    907910        yield self.root 
    908911 
    909     @report 
    910     def get(self, project, since): 
    911         (data, self.changed) = getoutputs(project, since, (self.input, dict(mode=self.mode, target=self.target, stage=self.stage, lang=self.lang, root=self.root))) 
    912  
    913         if data is not nodata: 
    914             from ll.xist import converters 
    915             args = [] 
    916             for argname in ("mode", "target", "stage", "lang", "root"): 
    917                 arg = data[1][argname] 
    918                 if arg is not None: 
    919                     args.append("%s=%r" % (argname, arg)) 
    920             if args: 
    921                 args = " with %s" % ", ".join(args) 
    922             else: 
    923                 args = "" 
    924             project.writestep(self, "Converting XIST node", args) 
    925             converter = converters.Converter(makeaction=self, makeproject=project, **data[1]) 
    926             data = data[0].convert(converter) 
    927         return data 
    928  
    929     def __repr__(self): 
     912    def getkwargs(self): 
     913        return dict(data=self.input, mode=self.mode, target=self.target, stage=self.stage, lang=self.lang, root=self.root) 
     914 
     915    def execute(self, project, data, mode, target, stage, lang, root): 
     916        from ll.xist import converters 
    930917        args = [] 
    931         for argname in ("mode", "target", "stage", "lang", "targetroot"): 
    932             arg = getattr(self, argname, None) 
    933             if arg is not None and not isinstance(arg, Action): 
     918        for (argname, arg) in (("mode", mode), ("target", target), ("stage", stage), ("lang", lang), ("root", root)): 
     919            if arg is not None: 
    934920                args.append("%s=%r" % (argname, arg)) 
    935         if args: 
    936             args = " with %s" % ", ".join(args) 
    937         else: 
    938             args = "" 
    939         return "<%s.%s object%s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, "".join(args), id(self)) 
     921        args = " with %s" % ", ".join(args) if args else "" 
     922        project.writestep(self, "Converting XIST node", args) 
     923        converter = converters.Converter(makeaction=self, makeproject=project, mode=mode, target=target, stage=stage, lang=lang, root=root) 
     924        return data.convert(converter) 
    940925 
    941926 
     
    962947        yield self.base 
    963948 
    964     @report 
    965     def get(self, project, since): 
    966         (data, self.changed) = getoutputs(project, since, (self.input, self.publisher, self.base)) 
    967  
    968         if data is not nodata: 
    969             project.writestep(self, "Publishing XIST node as byte string with base ", data[2]) 
    970             data = data[0].bytes(publisher=data[1], base=data[2]) 
    971         return data 
    972  
    973     def __repr__(self): 
    974         if isinstance(self.base, Action): 
    975             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    976         else: 
    977             return "<%s.%s object with base=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.base, id(self)) 
     949    def getkwargs(self): 
     950        return dict(data=self.input, publisher=self.publisher, base=self.base) 
     951 
     952    def execute(self, project, data, publisher, base): 
     953        project.writestep(self, "Publishing XIST node as byte string with base ", base) 
     954        return data.bytes(publisher=publisher, base=base) 
    978955 
    979956 
     
    1000977        yield self.base 
    1001978 
    1002     @report 
    1003     def get(self, project, since): 
    1004         (data, self.changed) = getoutputs(project, since, (self.input, self.publisher, self.base)) 
    1005  
    1006         if data is not nodata: 
    1007             project.writestep(self, "Publishing XIST node as unicode string with base ", data[2]) 
    1008             data = data[0].string(publisher=data[1], base=data[2]) 
    1009         return data 
    1010  
    1011     def __repr__(self): 
    1012         if isinstance(self.base, Action): 
    1013             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    1014         else: 
    1015             return "<%s.%s object with base=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.base, id(self)) 
     979    def getkwargs(self): 
     980        return dict(data=self.input, publisher=self.publisher, base=self.base) 
     981 
     982    def execute(self, project, data, publisher, base): 
     983        project.writestep(self, "Publishing XIST node as unicode string with base ", base) 
     984        return data.string(publisher=publisher, base=base) 
    1016985 
    1017986 
     
    10311000        yield self.width 
    10321001 
    1033     @report 
    1034     def get(self, project, since): 
    1035         (data, self.changed) = getoutputs(project, since, (self.input, self.encoding, self.width)) 
    1036  
    1037         if data is not nodata: 
    1038             project.writestep(self, "Converting XIST node to text with encoding=%r, width=%r" % (data[1], data[2])) 
    1039             from ll.xist.ns import html 
    1040             data = html.astext(data[0], encoding=data[1], width=data[2]) 
    1041         return data 
    1042  
    1043     def __repr__(self): 
    1044         args = [] 
    1045         for argname in ("encoding", "width"): 
    1046             arg = getattr(self, argname, None) 
    1047             if arg is not None and not isinstance(arg, Action): 
    1048                 args.append("%s=%r" % (argname, arg)) 
    1049         if args: 
    1050             args = " with %s" % ", ".join(args) 
    1051         else: 
    1052             args = "" 
    1053         return "<%s.%s object%s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, "".join(args), id(self)) 
     1002    def getkwargs(self): 
     1003        return dict(data=self.input, encoding=self.encoding, width=self.width) 
     1004 
     1005    def execute(self, project, input, encoding, width): 
     1006        project.writestep(self, "Converting XIST node to text with encoding=%r, width=%r" % (encoding, width)) 
     1007        from ll.xist.ns import html 
     1008        return html.astext(data, encoding=encoding, width=width) 
    10541009 
    10551010 
     
    11031058        yield self.encoding 
    11041059 
    1105     @report 
    1106     def get(self, project, since): 
    1107         (data, self.changed) = getoutputs(project, since, (self.input, self.encoding)) 
    1108  
    1109         if data is not nodata: 
    1110             project.writestep(self, "Decoding ", len(data[0]), " bytes with encoding ", data[1]) 
    1111             data = data[0].decode(data[1]) 
    1112         return data 
    1113  
    1114     def __repr__(self): 
    1115         if isinstance(self.encoding, Action): 
    1116             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    1117         else: 
    1118             return "<%s.%s object encoding=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.encoding, id(self)) 
     1060    def getkwargs(self): 
     1061        return dict(data=self.input, encoding=self.encoding) 
     1062 
     1063    def execute(self, project, data, encoding): 
     1064        project.writestep(self, "Decoding ", len(data), " bytes with encoding ", encoding) 
     1065        return data.decode(encoding) 
    11191066 
    11201067 
     
    11411088        yield self.encoding 
    11421089 
    1143     @report 
    1144     def get(self, project, since): 
    1145         (data, self.changed) = getoutputs(project, since, (self.input, self.encoding)) 
    1146  
    1147         if data is not nodata: 
    1148             project.writestep(self, "Encoding ", len(data[0]), " characters with encoding ", data[1]) 
    1149             data = data[0].encode(data[1]) 
    1150         return data 
    1151  
    1152     def __repr__(self): 
    1153         if isinstance(self.encoding, Action): 
    1154             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    1155         else: 
    1156             return "<%s.%s object encoding=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.encoding, id(self)) 
     1090    def getkwargs(self): 
     1091        return dict(data=self.input, encoding=self.encoding) 
     1092 
     1093    def execute(self, project, data, encoding): 
     1094        project.writestep(self, "Encoding ", len(data), " characters with encoding ", encoding) 
     1095        return data.encode(encoding) 
    11571096 
    11581097 
     
    11821121        yield self.compresslevel 
    11831122 
    1184     @report 
    1185     def get(self, project, since): 
    1186         (data, self.changed) = getoutputs(project, since, (self.input, self.compresslevel)) 
    1187  
    1188         if data is not nodata: 
    1189             project.writestep(self, "Compressing ", len(data), " bytes with level %d" % data[1]) 
    1190             import gzip, cStringIO 
    1191             stream = cStringIO.StringIO() 
    1192             compressor = gzip.GzipFile(filename="", mode="wb", fileobj=stream, compresslevel=data[1]) 
    1193             compressor.write(data[0]) 
    1194             compressor.close() 
    1195             data = stream.getvalue() 
    1196         return data 
     1123    def getkwargs(self): 
     1124        return dict(data=self.input, compresslevel=self.compresslevel) 
     1125 
     1126    def execute(self, project, data, compresslevel): 
     1127        project.writestep(self, "Compressing ", len(data), " bytes with level " % compresslevel) 
     1128        import gzip, cStringIO 
     1129        stream = cStringIO.StringIO() 
     1130        compressor = gzip.GzipFile(filename="", mode="wb", fileobj=stream, compresslevel=compresslevel) 
     1131        compressor.write(data) 
     1132        compressor.close() 
     1133        return stream.getvalue() 
    11971134 
    11981135 
     
    12291166            yield input 
    12301167 
    1231     @report 
    1232     def get(self, project, since): 
    1233         (data, self.changed) = getoutputs(project, since, (self.func, self.args, self.kwargs)) 
    1234         if data is not nodata: 
    1235             project.writestep(self, "Calling function %r" % data[0]) 
    1236             data = data[0](*data[1], **data[2]) 
    1237         return data 
     1168    def getargs(self): 
     1169        return (self.func,) + self.args 
     1170 
     1171    def getkwargs(self): 
     1172        return self.kwargs 
     1173 
     1174    def execute(self, project, func, *args, **kwargs): 
     1175        project.writestep(self, "Calling function %r" % func) 
     1176        return func(*args **kwargs) 
    12381177 
    12391178 
     
    12591198            yield input 
    12601199 
    1261     @report 
    1262     def get(self, project, since): 
    1263         (data, self.changed) = getoutputs(project, since, (self.obj, self.methname, self.args, self.kwargs)) 
    1264         if data is not nodata: 
    1265             meth = getattr(data[0], data[1]) 
    1266             project.writestep(self, "Calling %r" % meth) 
    1267             data = meth(*data[2], **data[3]) 
    1268         return data 
     1200    def getargs(self): 
     1201        return (self.obj, self.methname) + self.args 
     1202 
     1203    def getkwargs(self): 
     1204        return self.kwargs 
     1205 
     1206    def execute(self, project, obj, methname, *args, **kwargs): 
     1207        meth = getattr(obj, methname) 
     1208        project.writestep(self, "Calling %r" % meth) 
     1209        return meth(*args, **kwrags) 
    12691210 
    12701211 
     
    12791220        self.mode = mode 
    12801221 
    1281     @report 
    1282     def get(self, project, since): 
    1283         (data, self.changed) = getoutputs(project, since, (self.input, self.mode)) 
    1284         if data is not nodata: 
    1285             project.writestep(self, "Compiling TOXIC template with mode %r" % data[1]) 
    1286             from ll import toxicc 
    1287             return toxicc.compile(data[0], mode=data[1]) 
    1288         return data 
     1222    def getkwargs(self): 
     1223        return dict(data=self.input, mode=self.mode) 
     1224 
     1225    def execute(self, project, data, mode): 
     1226        project.writestep(self, "Compiling TOXIC template with mode %r" % mode) 
     1227        from ll import toxicc 
     1228        return toxicc.compile(data, mode=mode) 
    12891229 
    12901230 
     
    13041244        yield self.mode 
    13051245 
    1306     @report 
    1307     def get(self, project, since): 
    1308         (data, self.changed) = getoutputs(project, since, (self.input, self.mode)) 
    1309         if data is not nodata: 
    1310             project.writestep(self, "Prettifying SQL code with mode %r" % data[1]) 
    1311             from ll import toxicc 
    1312             return toxicc.prettify(data[0], mode=data[1]) 
    1313         return data 
     1246    def getkwargs(self): 
     1247        return dict(data=self.input, mode=self.mode) 
     1248 
     1249    def execute(self, project, data, mode): 
     1250        project.writestep(self, "Prettifying SQL code with mode %r" % mode) 
     1251        from ll import toxicc 
     1252        return toxicc.prettify(data, mode=mode) 
    13141253 
    13151254 
     
    13281267        self.patterns = patterns 
    13291268 
    1330     def execute(self, project, data): 
    1331         for (search, replace) in self.patterns: 
     1269    def getkwargs(self): 
     1270        return dict(data=self.input, patterns=self.patterns) 
     1271 
     1272    def execute(self, project, data, patterns): 
     1273        for (search, replace) in patterns: 
    13321274            project.writestep(self, "Replacing ", search, " with ", replace) 
    13331275            data = re.sub(search, replace, data) 
     
    13581300        yield self.nsinput 
    13591301 
    1360     def execute(self, project, data, ns): 
     1302    def getargs(self): 
     1303        return (self.nsinput, self.input) 
     1304 
     1305    def execute(self, project, ns, data): 
    13611306        from ll import xpit 
    13621307        globals = dict(makeaction=self, makeproject=project) 
     
    13641309        return xpit.convert(data, globals, ns) 
    13651310 
    1366     @report 
    1367     def get(self, project, since): 
    1368         (data, self.changed) = getoutputs(project, since, (self.nsinput, self.input)) 
    1369         if data is not nodata: 
    1370             data = self.execute(project, data[1], data[0]) 
    1371         return data 
    1372  
    13731311 
    13741312class UL4CompileAction(PipeAction): 
     
    14001338            yield input 
    14011339 
    1402     @report 
    1403     def get(self, project, since): 
    1404         (data, self.changed) = getoutputs(project, since, (self.input, self.templates, self.vars)) 
    1405         if data is not nodata: 
    1406             project.writestep(self, "Rendering UL4 template") 
    1407             data = data[0].renders(data[1], **data[2]) 
    1408         return data 
     1340    def getargs(self): 
     1341        return (self.input, self.templates) 
     1342 
     1343    def getkwargs(self): 
     1344        return self.vars 
     1345 
     1346    def execute(self, project, data, templates, **vars): 
     1347        project.writestep(self, "Rendering UL4 template with ", len(self.opcodes), " opcodes") 
     1348        return data.renders(templates, **vars) 
    14091349 
    14101350 
     
    14701410        yield self.mode 
    14711411 
    1472     @report 
    1473     def get(self, project, since): 
     1412    def getkwargs(self): 
     1413        return dict(data=self.input, mode=self.mode) 
     1414 
     1415    def execute(self, project, data, mode): 
    14741416        """ 
    14751417        Change the permission bits of the file ``self.getkey()``. 
    14761418        """ 
    1477         (data, self.changed) = getoutputs(project, since, (self.input, self.mode)) 
    1478         if data is not nodata: 
    1479             key = self.getkey() 
    1480             project.writestep(self, "Changing mode of ", project.strkey(key), " to 0%03o" % data[1]) 
    1481             key.chmod(data[1]) 
    1482             data = data[0] 
     1419        key = self.getkey() 
     1420        project.writestep(self, "Changing mode of ", project.strkey(key), " to 0%03o" % mode) 
     1421        key.chmod(mode) 
    14831422        return data 
    1484  
    1485     def __repr__(self): 
    1486         if isinstance(self.mode, Action): 
    1487             return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
    1488         else: 
    1489             return "<%s.%s object mode=0%03o at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.mode, id(self)) 
    14901423 
    14911424 
     
    15131446        yield self.group 
    15141447 
    1515     @report 
    1516     def get(self, project, since): 
     1448    def getkwargs(self): 
     1449        return dict(data=self.input, user=self.user, group=self.group) 
     1450 
     1451    def execute(self, project, data, user, group): 
    15171452        """ 
    15181453        Change the ownership of the file ``self.getkey()``. 
    15191454        """ 
    1520         (data, self.changed) = getoutputs(project, since, (self.input, self.user, self.group)) 
    1521         if data is not nodata: 
    1522             key = self.getkey() 
    1523             project.writestep(self, "Changing owner of ", project.strkey(key), " to ", data[1], " and group to ", data[2]) 
    1524             key.chown(data[0], data[1]) 
    1525             data = data[0] 
     1455        key = self.getkey() 
     1456        project.writestep(self, "Changing owner of ", project.strkey(key), " to ", user, " and group to ", group) 
     1457        key.chown(user, group) 
    15261458        return data 
    1527  
    1528     def __repr__(self): 
    1529         args = [] 
    1530         for argname in ("user", "group"): 
    1531             arg = getattr(self, argname, None) 
    1532             if arg is not None and not isinstance(arg, Action): 
    1533                 args.append("%s=%r" % (argname, arg)) 
    1534         if args: 
    1535             args = " with %s" % ", ".join(args) 
    1536         else: 
    1537             args = "" 
    1538         return "<%s.%s object%s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, "".join(args), id(self)) 
    15391459 
    15401460