easycoder 251104.2__py2.py3-none-any.whl → 260110.1__py2.py3-none-any.whl

easycoder/pre/ec_border.py

@@ -0,0 +1,67 @@
+import os
+from PySide6.QtWidgets import QWidget
+from PySide6.QtGui import QPixmap, QPainter
+from PySide6.QtCore import Qt, Signal, QRect
+
+class Border(QWidget):
+    tickClicked = Signal()
+    closeClicked = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self._size = 40
+        self.setFixedHeight(self._size)
+        self._drag_active = False
+        self._drag_start_pos = None
+        self._tick: QPixmap = QPixmap()
+        self._close_icon: QPixmap = QPixmap()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        # Draw the tick icon
+        self._tick = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/icons/tick.png').scaled(
+            self._size, self._size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+        x = 0
+        y = 0
+        painter.drawPixmap(x, y, self._tick)
+        # Draw the close icon
+        self._close_icon = QPixmap(f'{os.path.dirname(os.path.abspath(__file__))}/icons/close.png').scaled(
+            self._size, self._size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+        x = self.width() - self._close_icon.width()
+        y = 0
+        painter.drawPixmap(x, y, self._close_icon)
+
+    def mousePressEvent(self, event):
+        # Tick icon
+        x = 0
+        y = 0
+        tickRect = self._tick.rect().translated(x, y)
+        # Close icon
+        x = self.width() - self._close_icon.width()
+        y = 0
+        closeRect = self._close_icon.rect().translated(x, y)
+        if tickRect.contains(event.pos()):
+            self.tickClicked.emit()
+        if closeRect.contains(event.pos()):
+            self.closeClicked.emit()
+        elif QRect(0, 0, self.width(), self.height()).contains(event.pos()):
+            if hasattr(self.window().windowHandle(), 'startSystemMove'):
+                self.window().windowHandle().startSystemMove()
+            else:
+                self._drag_active = True
+                self._drag_start_pos = event.globalPosition().toPoint()
+                self._dialog_start_pos = self.window().pos()
+        else:
+            super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if self._drag_active:
+            delta = event.globalPosition().toPoint() - self._drag_start_pos
+            self.window().move(self._dialog_start_pos + delta)
+        else:
+            super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        self._drag_active = False
+        super().mouseReleaseEvent(event)

easycoder/pre/ec_classes.py

@@ -0,0 +1,470 @@
+import sys, paramiko, json
+from typing import Optional, Any
+
+class FatalError(BaseException):
+	def __init__(self, compiler, message):
+		compiler.showWarnings()
+		lino = compiler.tokens[compiler.index].lino
+		script = compiler.script.lines[lino].strip()
+		print(f'Compile error in {compiler.program.name} at line {lino + 1} ({script}):\n-> {message}')
+		sys.exit()
+
+class NoValueError(FatalError):
+	def __init__(self, compiler, record):
+		super().__init__(compiler, f'Variable {record["name"]} does not hold a value')
+
+class RuntimeAssertionError:
+	def __init__(self, program, msg=None):
+		code = program.code[program.pc]
+		lino = code['lino']
+		message = f'Assertion Error in {program.name} at line {lino + 1}'
+		if msg != None:
+			message += f': {msg}'
+		print(message)
+		sys.exit()
+
+class RuntimeError(BaseException):
+	def __init__(self, program, message):
+		if program == None:
+			sys.exit(f'Runtime Error: {message}')
+		else:
+			code = program.code[program.pc]
+			lino = code['lino']
+			script = program.script.lines[lino].strip()
+			print(f'Runtime Error in {program.name} at line {lino + 1} ({script}):\n-> {message}')
+			sys.exit()
+
+class NoValueRuntimeError(RuntimeError):
+	def __init__(self, program, record):
+		super().__init__(program, 'Variable {record["name"]} does not hold a value')
+
+class RuntimeWarning:
+	def __init__(self, program, message):
+		if program == None:
+			print(f'Runtime Warning: {message}')
+		else:
+			code = program.code[program.pc]
+			lino = code['lino']
+			script = program.script.lines[lino].strip()
+			print(f'Runtime Warning in {program.name} at line {lino + 1} ({script}): {message}')
+
+class Script:
+	def __init__(self, source):
+		self.lines = source.splitlines()
+		self.tokens = []
+
+class Token:
+	def __init__(self, lino, token):
+		self.lino = lino
+		self.token = token
+
+###############################################################################
+# This is the set of generic EasyCoder objects (values and variables)
+
+###############################################################################
+# A multipurpose value object. Holds a single value, with domain and type information
+class ECValue():
+    def __init__(self, domain: Optional[str] = 'core', type: Optional[str] = None, 
+                 content: Any = None, name: Optional[str] = None):
+        object.__setattr__(self, 'domain', domain)
+        object.__setattr__(self, 'type', type)
+        object.__setattr__(self, 'content', content)
+        object.__setattr__(self, 'name', name)
+        object.__setattr__(self, 'properties', {})
+        object.__setattr__(self, 'locked', False)
+        object.__setattr__(self, '_attrs', {})  # Store dynamic attributes
+    
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Allow setting any attribute dynamically."""
+        if name in ('domain', 'type', 'content', 'name', 'properties', 'locked', '_attrs'):
+            object.__setattr__(self, name, value)
+        else:
+            # Store dynamic attributes in _attrs dict
+            self._attrs[name] = value
+    
+    def __getattr__(self, name: str) -> Any:
+        """Retrieve dynamic attributes or return None if not found."""
+        if name == '_attrs':
+            return object.__getattribute__(self, '_attrs')
+        return self._attrs.get(name)
+    
+    def setDomain(self, domain):
+        self.domain = domain
+    
+    def getDomain(self):
+        return self.domain
+    
+    def setType(self, type):
+        self.type = type
+    
+    def getType(self):
+        return self.type
+    
+    def setContent(self, content):
+        self.content = content
+    
+    def getContent(self):
+        return self.content 
+    
+    def setValue(self, type=None, content=None):
+        self.type = type
+        self.content = content
+
+    def setProperty(self, key, value):
+        self.properties[key] = value
+
+    def getProperty(self, key):
+        return self.properties.get(key, None)
+    
+    def setName(self, name):
+        self.name = name
+    
+    def getName(self):
+        return self.name
+    
+    def lock(self):
+        self.locked = True
+    
+    def isLocked(self):
+        return self.locked
+
+###############################################################################
+# The base class for all EasyCoder variable types
+class ECObject():
+    def __init__(self):
+        self.locked: bool = False
+        self.elements: int = 0
+        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:
+        self.index = index
+    
+    # Get the index for the variable
+    def getIndex(self):
+        return self.index
+    
+    # Lock the variable
+    def setLocked(self):
+        self.locked = True
+    
+    # Check if the variable is locked
+    def isLocked(self):
+        return self.locked
+
+    # Set the value at the current index
+    def setValue(self, value):
+        if self.values is None:
+            self.index = 0
+            self.elements = 1
+            self.values = [None]
+        if isinstance(value, ECValue): value.setName(self.name)
+        self.values[self.index] = value # type: ignore
+
+    # Get the value at the current index
+    def getValue(self):
+        if self.values is None: return None
+        return self.values[self.index] # type: ignore
+    
+    # Get all the values
+    def getValues(self):
+        return self.values
+
+    # Set the number of elements in the variable
+    def setElements(self, elements):
+        if self.elements == 0:
+            self.values = [None] * elements
+            self.elements = elements
+            self.index = 0
+        if elements == self.elements:
+            pass
+        elif elements > self.elements:
+            self.values.extend([None] * (elements - self.elements)) # pyright: ignore[reportOptionalMemberAccess]
+        else:
+            del self.values[elements:] # pyright: ignore[reportOptionalSubscript]
+            self.index = 0
+        self.elements = elements
+    
+    # Get the number of elements in the variable
+    def getElements(self):
+        return self.elements
+    
+    # Check if the object has a runtime value. Default is False
+    def hasRuntimeValue(self):
+        return False
+    
+    # Check if the object is mutable. Default is False
+    def isMutable(self):
+        return False
+    
+    # Check if the object is clearable
+    def isClearable(self):
+         return False
+
+    # Get the content of the value at the current index
+    def getContent(self):
+        if not self.hasRuntimeValue(): return None
+        v = self.getValue()
+        if v is None: return None
+        return v.getContent()
+    
+    # Get the type of the value at the current index
+    def getType(self):
+        if not self.hasRuntimeValue(): return None
+        v = self.getValue()
+        if v is None: return None
+        return v.getType()
+
+    # Check if the object is empty. Default is True
+    def isEmpty(self):
+        return True
+    
+    # Set the name of the object
+    def setName(self, name):
+        self.name = name
+    
+    # Get the name of the object
+    def getName(self):
+        return self.name
+    
+    # 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 ECValueHolder(ECObject):
+    def __init__(self):
+        super().__init__()
+
+    # Set the content of the value at the current index
+    def setContent(self, content):
+        if self.values is None:
+            self.index = 0
+            self.elements = 1
+            self.values = [None]
+        self.values[self.index] = content # type: ignore
+
+    # Set the value to a given ECValue
+    def setValue(self, value):
+        if self.values is None:
+            self.index = 0
+            self.elements = 1
+            self.values = [None]
+        if self.index >= self.elements: raise RuntimeError(None, 'Index out of range') # type: ignore
+        self.values[self.index] = value # type: ignore
+    
+    # Report if the object is clearable
+    def isClearable(self):
+         return True
+    
+    # This object has a runtime value
+    def hasRuntimeValue(self):
+        return True
+    
+    # This object is mutable.
+    def isMutable(self):
+        return True
+
+    # Reset the object to empty state
+    def reset(self):
+        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):
+        if value.getType() not in (str, int, float, bool):
+            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 varType in (str, 'dict'):
+            content = value.getContent()
+            if 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)
+    
+    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
+    
+    # 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 a given ECValue
+    def setValue(self, value):
+        if value.getType() not in ('list', None):
+            raise RuntimeError(None, 'ECList can only hold list values or None') # type: ignore
+        super().setValue(value)
+    
+    # Add an item to the list
+    def addItem(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
+    
+    # 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]
+    
+    # Check if the list is empty
+    def isEmpty(self):
+        return self.getItemCount() == 0
+
+###############################################################################
+# A file variable
+class ECFile(ECObject):
+    def __init__(self):
+        super().__init__()
+
+###############################################################################
+# An SSH variable
+class ECSSH(ECObject):
+    def __init__(self):
+        super().__init__()
+
+    # Set up the SSH connection
+    def setup(self, host=None, user=None, password=None):
+        ssh = paramiko.SSHClient()
+        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        try:
+            ssh.connect(host, username=user, password=password, timeout=10) # type: ignore
+            self.setValue(ssh)
+            self.sftp = ssh.open_sftp()
+            return True
+        except:
+            return False
+    
+    # Get the SFTP client
+    def getSFTP(self):
+        return self.sftp
+
+###############################################################################
+# A stack variable
+class ECStack(ECObject):
+
+    def __init__(self):
+        super().__init__()
+        self.values: Optional[list[list[Any]]] = None  # List of stacks, each holding any type
+    
+    def push(self, item: Any) -> None:
+        if self.values is None:
+            self.index = 0
+            self.elements = 1
+            self.values = [[]]
+        assert self.index is not None  # Type narrowing: index is always set when values exists
+        self.values[self.index].append(item)
+    
+    def pop(self) -> Any:
+        if self.values is None or self.index is None or self.values[self.index] is None or len(self.values[self.index]) == 0:
+            return None
+        return self.values[self.index].pop()