easycoder 251215.2__py2.py3-none-any.whl → 260111.1__py2.py3-none-any.whl

easycoder/ec_classes.py

@@ -1,5 +1,37 @@
-import sys, paramiko
-from typing import Optional, Any
+import sys, paramiko, json
+from typing import Optional, Any, Union
+
+###############################################################################
+# Type normalization: support both Python types and string type names
+def normalize_type(t: Union[type, str, None]) -> Optional[str]:
+	"""Convert a type to its string representation. Supports both Python types and string names."""
+	if t is None:
+		return None
+	if isinstance(t, str):
+		return t
+	# Map Python types to string names
+	type_map = {
+		str: 'str',
+		int: 'int',
+		float: 'float',
+		bool: 'bool',
+		dict: 'dict',
+		list: 'list',
+		object: 'object',
+	}
+	return type_map.get(t, str(t) if t else None)
+
+def types_equal(t1: Union[type, str, None], t2: Union[type, str, None]) -> bool:
+	"""Compare two types, normalizing both to strings first."""
+	return normalize_type(t1) == normalize_type(t2)
+
+def type_in(t: Union[type, str, None], types: tuple) -> bool:
+	"""Check if a type is in a tuple of types, normalizing both."""
+	normalized = normalize_type(t)
+	for typ in types:
+		if normalize_type(typ) == normalized:
+			return True
+	return False
 
 class FatalError(BaseException):
 	def __init__(self, compiler, message):
@@ -64,8 +96,8 @@ class Token:
 ###############################################################################
 # A multipurpose value object. Holds a single value, with domain and type information
 class ECValue():
-    def __init__(self, domain: Optional[str] = None, type: Optional[str] = None, 
-                 content: Any = None, name: Optional[str] = None):
+    def __init__(self, domain = 'core', type = None, content: Any = None, name = None):
+        if type == None: type = str
         object.__setattr__(self, 'domain', domain)
         object.__setattr__(self, 'type', type)
         object.__setattr__(self, 'content', content)
@@ -95,10 +127,10 @@ class ECValue():
         return self.domain
     
     def setType(self, type):
-        self.type = type
+        self.type = normalize_type(type)
     
     def getType(self):
-        return self.type
+        return normalize_type(self.type)
     
     def setContent(self, content):
         self.content = content
@@ -137,6 +169,7 @@ class ECObject():
         self.index: Optional[int] = None
         self.values: Optional[list] = None
         self.name: Optional[str] = None
+        self.properties = {}
 
     # Set the index for the variable
     def setIndex(self, index: int) -> None:
@@ -208,7 +241,7 @@ class ECObject():
         if not self.hasRuntimeValue(): return None
         v = self.getValue()
         if v is None: return None
-        return v.getContent()
+        return v
     
     # Get the type of the value at the current index
     def getType(self):
@@ -229,16 +262,23 @@ class ECObject():
     def getName(self):
         return self.name
     
-    # Check if the object can have properties
-    def hasProperties(self):
-        return False
+    # Set a specific property on the object
+    def setProperty(self, name, value):
+        self.properties[name] = value
+    
+    # Check if the object has a specific property
+    def hasProperty(self, name):
+        return name in self.properties
+    
+    # Get a specific property
+    def getProperty(self, name):
+        return self.properties[name]
 
 ###############################################################################
 # A generic variable object that can hold a mutable value
-class ECVariable(ECObject):
+class ECValueHolder(ECObject):
     def __init__(self):
         super().__init__()
-        self.properties = {}
 
     # Set the content of the value at the current index
     def setContent(self, content):
@@ -271,23 +311,180 @@ class ECVariable(ECObject):
 
     # Reset the object to empty state
     def reset(self):
-        self.setValue(ECValue())
+        self.setValue(ECValue(content=None))
+
+###############################################################################
+# A string or int variable
+class ECVariable(ECValueHolder):
+    def __init__(self):
+        super().__init__()
+
+    # Reset the object to an empty string
+    def reset(self):
+        self.setValue(ECValue(type=str, content=''))
+
+    # Set the value to a given ECValue
+    def setValue(self, value):
+        val_type = value.getType()
+        if type_in(val_type, ('dict', 'list')):
+             value.setContent(json.dumps(value.getContent()))
+        elif not type_in(val_type, (str, int, float, bool, None)):
+            raise RuntimeError(None, 'ECVariable can only hold str, int, float, or bool values') # type: ignore
+        super().setValue(value)
+
+###############################################################################
+# A dictionary variable
+class ECDictionary(ECValueHolder):
+    def __init__(self):
+        super().__init__()
+        self.reset()
+
+    # Reset the object to empty state
+    def reset(self):
+        self.setValue(ECValue(content={}))
+
+    # Set the value to an ECValue
+    def setValue(self, value):
+        varType = value.getType()
+        if type_in(varType, (str, 'dict')):
+            content = value.getContent()
+            if types_equal(varType, str):
+                try:
+                    if content in ('', {}, None): content = {}
+                    else: content = json.loads(content)
+                except:
+                    raise RuntimeError(None, 'ECDictionary string value is not valid JSON') # type: ignore
+        elif varType == None:
+             content = {}
+        else:
+            raise RuntimeError(None, 'ECDictionary can only hold dict values or None') # type: ignore
+        super().setValue(content)
     
-    # Check if the object can have properties
-    def hasProperties(self):
-        return True
+    def getValue(self):
+        return super().getValue()
+    
+    # Set an entry in the dictionary
+    def setEntry(self, key, value):
+        content = self.getValue()
+        if content is None:
+            return
+        if isinstance(value, str):
+             try:
+                 value = json.loads(value)
+             except Exception:
+                 pass
+        content[key] = value # type: ignore
+    
+    # Test if an entry exists in the dictionary
+    def hasEntry(self, key):
+        content = self.getValue()
+        if content is None:
+            return False
+        return key in content
     
-    # Set a specific property on the object
-    def setProperty(self, name, value):
-        self.properties[name] = value
+    # Get an entry from the dictionary
+    def getEntry(self, key):
+        content = self.getValue()
+        if content is None:
+            return None
+        return content.get(key, None)
+
+    # Delete an entry from the dictionary
+    def deleteEntry(self, key):
+        content = self.getValue()
+        if content is None:
+            return
+        if key in content:
+            del content[key]
+    
+    # Get the keys of the dictionary
+    def keys(self):
+        content = self.getValue()
+        if content is None:
+            return []
+        return list(content.keys()) 
+    
+    # Check if the dictionary is empty
+    def isEmpty(self):
+        return len(self.keys()) == 0
+
+###############################################################################
+# A list variable
+class ECList(ECValueHolder):
+    def __init__(self):
+        super().__init__()
+        self.reset()
+
+    # Reset the object to empty state
+    def reset(self):
+        self.setValue(ECValue(content=[]))
+
+    # Set the value to an ECValue
+    def setValue(self, value):
+        content = value.getContent()
+        if content in ('', None): content = []
+        else:
+            try:
+                content = json.loads(content) # type: ignore
+            except:
+                pass
+        super().setValue(content)
     
-    # Check if the object has a specific property
-    def hasProperty(self, name):
-        return name in self.properties
+    def getValue(self):
+        return super().getValue()
+    
+    # Append an item to the list
+    def append(self, item):
+        content = self.getContent()
+        if content is None:
+            return
+        if isinstance(item, str):
+             try:
+                 item = json.loads(item)
+             except Exception:
+                  pass
+        content.append(item) # type: ignore
+        self.setContent(content)
+    
+    # Set an item in the list
+    def setItem(self, index, value):
+        content = self.getValue()
+        if content is None:
+            return
+        if isinstance(value, str):
+             try:
+                 value = json.loads(value)
+             except Exception:
+                 pass
+        content[index] = value # type: ignore
+    
+    # Return the number of items in the list
+    def getItemCount(self):
+        content = self.getContent()
+        if content is None:
+            return 0
+        return len(content)
+    
+    # Get an item from the list
+    def getItem(self, index):
+        content = self.getContent()
+        if content is None:
+            return None
+        return content[index]
     
-    # Get a specific property
-    def getProperty(self, name):
-        return self.properties[name]
+    # Check if the list is empty
+    def isEmpty(self):
+        return self.getItemCount() == 0
+    
+    # Delete an item from the list
+    def deleteItem(self, index):
+        content = self.getValue()
+        if content is None:
+            return
+        if index < 0 or index >= len(content):
+            return
+        del content[index]
+        self.setContent(content)
 
 ###############################################################################
 # A file variable
@@ -295,6 +492,12 @@ class ECFile(ECObject):
     def __init__(self):
         super().__init__()
 
+###############################################################################
+# A module variable
+class ECModule(ECObject):
+    def __init__(self):
+        super().__init__()
+
 ###############################################################################
 # An SSH variable
 class ECSSH(ECObject):

easycoder/ec_compiler.py

@@ -56,10 +56,12 @@ class Compiler:
 
 	# Get a value
 	def getValue(self):
+		self.program.ensureNotRunning()
 		return self.value.compileValue()
 
 	# Get the next value
 	def nextValue(self):
+		self.program.ensureNotRunning()
 		self.index += 1
 		return self.value.compileValue()
 
@@ -112,7 +114,19 @@ class Compiler:
 				if next == item:
 					self.nextToken()
 					return
-		elif next == token: self.nextToken()
+		elif next == token:
+			self.nextToken()
+
+	# Skip common articles (optional syntactic noise for readability/disambiguation)
+	# Consumes leading articles ('the', 'a', 'an') at the next position
+	def skipArticles(self):
+		# Consume leading articles at next position(s) — like skip() but for multiple
+		while True:
+			next_tok = self.peek()
+			if next_tok in ['the', 'a', 'an']:
+				self.nextToken()
+			else:
+				break
 
 	# Rewind to a given position in the code list
 	def rewindTo(self, index):
@@ -135,6 +149,7 @@ class Compiler:
 
 	# Get the symbol record for the current token (assumes it is a symbol name)
 	def getSymbolRecord(self, name=None):
+		self.program.ensureNotRunning()
 		if name == None: name = self.getToken()
 		if not name in self.symbols:
 			FatalError(self, f'Undefined symbol name "{name}"')
@@ -147,7 +162,15 @@ class Compiler:
 
 	# Add a value type
 	def addValueType(self):
-		self.valueTypes[self.getToken()] = True
+		name = self.peek()
+		record = None
+		try:
+			record = self.symbols[name]
+		except:
+			pass
+		if record != None:
+			raise FatalError(self, f'Duplicate symbol name "{name}"')
+		self.valueTypes[name] = True
 
 	# Test if a given value is in the value types list
 	def hasValue(self, type):
@@ -180,10 +203,10 @@ class Compiler:
 
 	# Compile a symbol
 	def compileSymbol(self, command, name, classname):
-		try:
-			self.symbols[name]
-			raise FatalError(self, f'Duplicate symbol name "{name}"')
-		except: pass
+		# try:
+		# 	self.symbols[name]
+		# 	raise FatalError(self, f'Duplicate symbol name "{name}"')
+		# except: pass
 		command['name'] = name
 		command['classname'] = classname
 		command['program'] = self.program
@@ -249,9 +272,7 @@ class Compiler:
 		self.index = index
 		while True:
 			token = self.tokens[self.index]
-#			keyword = token.token
 			if self.debugCompile: print(f'{token.lino + 1}: {self.script.lines[token.lino]}')
-#			if keyword != 'else':
 			if self.compileOne() == True:
 				if self.index == len(self.tokens) - 1:
 					return True