TouchPortalAPI.TpToPy

  1#!/usr/bin/env python3
  2__copyright__ = """
  3This file is part of the TouchPortal-API project.
  4Copyright TouchPortal-API Developers
  5Copyright (c) 2021 DamienS
  6All rights reserved.
  7
  8This program is free software: you can redistribute it and/or modify
  9it under the terms of the GNU General Public License as published by
 10the Free Software Foundation, either version 3 of the License, or
 11(at your option) any later version.
 12
 13This program is distributed in the hope that it will be useful,
 14but WITHOUT ANY WARRANTY; without even the implied warranty of
 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16GNU General Public License for more details.
 17
 18You should have received a copy of the GNU General Public License
 19along with this program.  If not, see <https://www.gnu.org/licenses/>.
 20"""
 21
 22
 23import json
 24import re
 25from pathlib import Path
 26
 27
 28class TpToPy():
 29    """
 30    This is used to convert entry.tp to a fully usable python version entry.
 31    """
 32
 33    def __init__(self, entry):
 34        self.entry = json.loads(Path(entry).resolve().read_text())
 35        self.structState = {}
 36        self.structAction = {}
 37        self.structEvent = {}
 38        self.structConnector = {}
 39        self.structCalegories = {}
 40    
 41    def getPluginId(self):
 42        """ 
 43        A helper method that returns the plugin id from entry.tp
 44        """
 45        return self.entry.get("id", "")
 46
 47    def __convertData(self, data):
 48        """
 49        convert Action and connector data to python struct format
 50        """
 51        newData = {}
 52        if isinstance(data, list):
 53            for item in range(len(data)):
 54                newData[item] = data[item]
 55        return newData
 56
 57    def __convertFormat(self, actionFormat, data):
 58        """
 59        This will automatically convert `format`. eg `{$dataid$}` to `$[data_index starts from 1]  
 60        """
 61
 62        newFormat = actionFormat
 63        for item in range(len(data)):
 64            if data[item]['id'] in actionFormat:
 65                newFormat = newFormat.replace("{$" + data[item]['id'] + "$}", "$[" + str(item+1) + "]")
 66
 67        return newFormat
 68
 69    def generateInfo(self):
 70        """
 71        This will generate TP_PLUGIN_INFO struct
 72        """
 73
 74        generatedInfo = {}
 75        infoKeys = ["sdk", "version", "name", "id", "configuration", "plugin_start_cmd_windows", "plugin_start_cmd_linux", "plugin_start_cmd_mac", "plugin_start_cmd"]
 76
 77        for key in self.entry.keys():
 78            if key in infoKeys:
 79                generatedInfo[key] = self.entry[key]
 80
 81        return generatedInfo
 82    
 83    def generateSettings(self):
 84        """
 85        This will generate TP_PLUGIN_SETTINGS struct
 86        """
 87
 88        generatedSetting = {}
 89        if not self.entry.get("settings", True): return generatedSetting
 90
 91        settings = self.entry.get("settings", [])
 92
 93        if isinstance(settings, list):
 94            for setting in range(len(settings)):
 95                generatedSetting[setting+1] = settings[setting]
 96
 97        return generatedSetting
 98
 99    def generateStates(self, data, category):
100        """
101        This generates TP_PLUGIN_STATES struct
102        """
103
104        startIndex = len(self.structState)
105
106        for state in data:
107            self.structState[startIndex] = state
108            self.structState[startIndex]["category"] = category
109
110            startIndex += 1
111
112        return self.structState
113        
114
115    def generateActions(self, data, category):
116        """
117        This generates TP_PLUGIN_ACTION struct
118        """
119
120        startIndex = len(self.structAction)
121
122        for action in data:
123            startIndex += 1
124            self.structAction[startIndex] = action
125            if self.structAction[startIndex].get("format", False):
126                self.structAction[startIndex]['format'] = self.__convertFormat(action["format"], action['data'])
127            if action.get('data', False):
128                self.structAction[startIndex]['data'] = self.__convertData(action['data'])
129            self.structAction[startIndex]["category"] = category
130
131        return self.structAction
132
133    def generateEvents(self, data, category):
134        """
135        This will generates TP_PLUGIN_EVENTS struct
136        """
137
138        startIndex = len(self.structEvent)
139
140        for event in data:
141            self.structEvent[startIndex] = event
142            self.structEvent[startIndex]["category"] = category
143
144        return self.structEvent
145
146    def generateConnectors(self, data, category):
147        """
148        This generates TP_PLUGIN_CONNECTORS struct
149        """
150
151        startIndex = len(self.structConnector)
152
153        for connector in data:
154            self.structConnector[startIndex] = connector
155            self.structConnector[startIndex]['category'] = category
156            if self.structConnector[startIndex].get('format', False):
157                self.structConnector[startIndex]['format'] = self.__convertFormat(connector['format'], connector['data'])
158            if connector.get("data", False):
159                self.structConnector[startIndex]['data'] = self.__convertData(connector['data'])
160
161        return self.structConnector
162    
163    def generateCalegories(self):
164        """
165        This generates TP_PLUGIN_CATEGORIES struct and also when looping each category it will
166        populate Actions, States, Connectors and Event struct.
167        """
168
169        generatedCalegory = {}
170        categories = self.entry.get("categories", [])
171
172        for category in categories:
173            categId = category.get("id", "").split(".")
174            generatedCalegory[categId[-1]] = {
175                "id": category.get("id"),
176                "name": category.get("name", ""),
177                "imagepath": category.get("imagepath", ""),
178            }
179
180            todoList = {"actions": self.generateActions, "states": self.generateStates,
181                        "connectors": self.generateConnectors, "events": self.generateEvents}
182
183            for todo in todoList: # hack
184                if (data := category.get(todo)) and isinstance(data, list):
185                    todoList[todo](data, categId[-1])
186        
187        return generatedCalegory
188
189    def writetoFile(self, fileName):
190        """
191        This method will collects struct INFO, SETTINGS, STATES etc... and write python
192        version of entry.tp to file.
193        """
194
195        TP_PLUGIN_INFO = self.generateInfo()
196        TP_PLUGIN_SETTINGS = self.generateSettings()
197        TP_PLUGIN_STATES = self.structState
198        TP_PLUGIN_ACTIONS = self.structAction
199        TP_PLUGIN_CONNECTORS = self.structConnector
200        TP_PLUGIN_EVENTS = self.structEvent
201        TP_PLUGIN_CATEGORIES = self.generateCalegories()
202
203        with open(fileName, 'w') as f:
204            f.write("#!/usr/bin/env python3\n")
205            for entryVar in ["TP_PLUGIN_INFO", "TP_PLUGIN_SETTINGS", "TP_PLUGIN_CATEGORIES", "TP_PLUGIN_CONNECTORS", "TP_PLUGIN_ACTIONS", "TP_PLUGIN_STATES", "TP_PLUGIN_EVENTS"]:
206                struct = json.dumps(locals()[entryVar], indent=4, sort_keys=False, skipkeys=True)
207                struct = re.sub(r'": (true|false)(,?)\n', lambda m: f'": {m.group(1).title()}{m.group(2)}\n', struct)
208                f.write(f"{entryVar} = {struct}\n\n")
209
210class toString():
211    """
212    This basically `emulate` import a python struct. for example
213
214    ```py
215    import TPPEntry # Python file
216
217    TPPEntry.TP_PLUGIN_INFO # because it contain `TP_PLUGIN_INFO` variable in that file
218    ```
219
220    and This trys to do same thing as that.
221    ```py
222    import TpToPy
223
224    myEntry = TpToPy.toString(TpToPy.TpToPy("entry.tp"))
225    myEntry.TP_PLUGIN_INFO
226    ```
227    """
228
229    def __init__(self, entry):
230        self.entry = TpToPy(entry)
231
232        self.TP_PLUGIN_INFO = self.entry.generateInfo()
233        self.TP_PLUGIN_SETTINGS = self.entry.generateSettings()
234        self.TP_PLUGIN_CATEGORIES = self.entry.generateCalegories()
235        self.TP_PLUGIN_STATES = self.entry.structState
236        self.TP_PLUGIN_ACTIONS = self.entry.structAction
237        self.TP_PLUGIN_CONNECTORS = self.entry.structConnector
238        self.TP_PLUGIN_EVENTS = self.entry.structEvent