Merge pull request #178 from skogsbaer/sw/fixes-for-2.0.1

more fixes for 2.0.*

Author: skogsbaer

ChangeLog.md

@@ -1,11 +1,7 @@
 # Write Your Python Program - CHANGELOG
 
-* 2.0.3 (2025-09-24)
-  * More fixes
-* 2.0.2 (2025-09-24)
-  * More fixes
-* 2.0.1 (2025-09-24)
-  * Minor fixes
+* 2.0.1 - 2.0.5 (2025-09-24)
+  * Many minor fixes
 * 2.0.0 (2025-09-24)
   * Remove wrappers, only check types at function enter/exit points
   * Restructure directory layout

package.json

@@ -3,7 +3,7 @@
 	"displayName": "Write Your Python Program!",
 	"description": "A user friendly python environment for beginners",
 	"license": "See license in LICENSE",
-	"version": "2.0.3",
+	"version": "2.0.5",
 	"publisher": "StefanWehr",
 	"icon": "icon.png",
 	"engines": {

python/code/wypp/i18n.py

@@ -49,15 +49,15 @@ def tr(key: str, **kws) -> str:
 DE = {
     'Expecting no return value when calling function `{fun}`.':
         'Kein Rückgabewert erwartet bei Aufruf der Funktion `{fun}`.',
-    'Expecting no return value when calling method `{method}` of class `{cls}.':
-        'Kein Rückgabewert erwartet bei Aufruf der Methode `{method}` aus Klasse `{cls}`.',
+    'Expecting no return value when calling method `{method}` of class `{cls}`.':
+        'Kein Rückgabewert erwartet bei Aufruf der Methode `{method}` der Klasse `{cls}`.',
     'Expecting no return value when calling constructor of record `{cls}`.':
         'Kein Rückgabewert erwartet bei Aufruf des Konstruktors des Records `{cls}`.',
 
     'Expecting return value of type `{ty}` when calling function `{fun}`.':
         'Rückgabewert vom Typ `{ty}` erwartet bei Aufruf der Funktion `{fun}`.',
     'Expecting return value of type `{ty}` when calling method `{method}` of class `{cls}`.':
-        'Rückgabewert vom Typ `{ty}` erwartet bei Aufruf von Methode `{method}` aus Klasse `{cls}`.',
+        'Rückgabewert vom Typ `{ty}` erwartet bei Aufruf der Methode `{method}` der Klasse `{cls}`.',
     'Expecting return value of type `{ty}` when calling constructor of record `{cls}`.':
         'Rückgabewert vom Typ `{ty}` erwartet bei Aufruf des Konstruktors des Records `{cls}`.',
 
@@ -71,14 +71,14 @@ def tr(key: str, **kws) -> str:
         'Aufruf in Zeile {line} führt dazu, dass die Funktion keinen Wert zurückgibt:',
 
     'The call of function `{fun}` expects value of type `{ty}` as {arg}.':
-        'Der Aufruf der Funktion `{fun}` erwartet Wert vom Typ `{ty}` als {arg}.',
+        'Der Aufruf der Funktion `{fun}` erwartet einen Wert vom Typ `{ty}` als {arg}.',
     'The call of method `{method}` of class `{cls}` expects value of type `{ty}` as {arg}.':
-        'Der Aufruf der Methode `{method}` aus Klasse `{cls}` erwartet Wert vom Typ `{ty}` als {arg}.',
+        'Der Aufruf der Methode `{method}` der Klasse `{cls}` erwartet einen Wert vom Typ `{ty}` als {arg}.',
     'The call of the constructor of record `{cls}` expects value of type `{ty}` as {arg}.':
-        'Der Aufruf des Konstruktors des Records `{cls}` erwartet Wert vom Typ `{ty}` als {arg}.',
+        'Der Aufruf des Konstruktors des Records `{cls}` erwartet einen Wert vom Typ `{ty}` als {arg}.',
 
-    'But the value given has type `{ty}`.': 'Aber der übergebene Wert hat Typ `{ty}`.',
-    'But the default value has type `{ty}`.': 'Aber der Default-Wert hat Typ `{ty}`.',
+    'But the value given has type `{ty}`.': 'Aber der übergebene Wert hat den Typ `{ty}`.',
+    'But the default value has type `{ty}`.': 'Aber der Default-Wert hat den Typ `{ty}`.',
 
     'File': 'Datei',
     'Line': 'Zeile',
@@ -93,22 +93,22 @@ def tr(key: str, **kws) -> str:
     'Parameter `{param}` of function `{fun}` requires a type annotation.':
         'Parameter `{param}` der Funktion `{fun}` benötigt eine Typannotation.',
     'Parameter `{param}` of method `{method}` from class `{cls}` requires a type annotation.':
-        'Parameter `{param}` der Methode `{method}` aus Klasse `{cls}` benötigt eine Typannotation.',
+        'Parameter `{param}` der Methode `{method}` der Klasse `{cls}` benötigt eine Typannotation.',
     'Parameter `{param}` of constructor of record `{cls}` requires a type annotation.':
         'Parameter `{param}` des Konstruktors des Records `{cls}` benötigt eine Typannotation.',
 
-    'Attribute `{name}` of record `{record}` required a type annotation.':
+    'Attribute `{name}` of record `{record}` requires a type annotation.':
         'Attribut `{name}` des Records `{record}` benötigt eine Typannotation.',
 
     'invalid type `{ty}`':
         'ungültiger Typ `{ty}`',
     'Cannot set attribute to value of type `{ty}`.':
-        'Das Attribute kann nicht auf einen Wert vom Typ `{ty}` gesetzt werden.',
+        'Das Attribut kann nicht auf einen Wert vom Typ `{ty}` gesetzt werden.',
     'Problematic assignment in line': 'Fehlerhafte Zuweisung in Zeile',
-    'Attribute `{attrName}` of record `{recordName}` declared with type `{ty}.`':
+    'Attribute `{attrName}` of record `{recordName}` declared with type `{ty}`.':
         'Attribut `{attrName}` des Records `{recordName}` deklariert als Typ `{ty}`.',
 
-    'argument count mismatch': 'Anzahl der Argument passt nicht',
+    'argument count mismatch': 'Anzahl der Argumente stimmt nicht',
     'Call in line': 'Aufruf in Zeile',
     'Function `{fun}` takes ': 'Funktion `{fun}` benötigt ',
     'Function `{fun}` takes at least ': 'Funktion `{fun}` benötigt mindestens ',
@@ -124,12 +124,12 @@ def tr(key: str, **kws) -> str:
     'Default value for parameter `{paramName}` of function `{fun}` must have type `{ty}`.':
         'Default-Wert des Parameters `{paramName}` der Funktion `{fun}` muss vom Typ `{ty}` sein.',
     'Default value for parameter `{paramName}` of method `{method}` in class `{cls}` must have type `{ty}`.':
-        'Default-Wert des Parameters `{paramName}` der Methode `{method}` aus Klasse `{cls}` muss vom Typ `{ty}` sein.',
+        'Default-Wert des Parameters `{paramName}` der Methode `{method}` der Klasse `{cls}` muss vom Typ `{ty}` sein.',
     'Default value for attribute `{paramName}` of record `{cls}` must have type `{ty}`.':
         'Default-Wert des Attributs `{paramName}` des Records `{cls}` muss vom Typ `{ty}` sein.',
 
     'Unknown attribute {attrName} for record {clsName}':
-        'Attribut {attrName} ist nicht bekannt für Record {clsName}',
+        'Attribut {attrName} ist nicht bekannt für den Record {clsName}',
     'Did you mean `{ty}`?': 'Wolltest du `{ty}` schreiben?',
 
     'unknown keyword argument': 'unbekanntes Schlüsselwort-Argument',
@@ -152,13 +152,12 @@ def tr(key: str, **kws) -> str:
     'The impossible happened!': 'Das Unmögliche ist passiert!',
     'Stop of execution': 'Abbruch der Ausführung',
     '1 successful test': '1 erfolgreicher Test',
-    'all succesful': 'alle erfolgreich',
-    'and stop of execution': 'und Abbruch der Ausführung',
     'all successful': 'alle erfolgreich',
+    'and stop of execution': 'und Abbruch der Ausführung',
 
     'NOTE: running the code failed, some definitions might not be available in the interactive window!':
-        'ACHTUNG: der Code enthält Fehler, einige Definition sind möglicherweise in interaktiven Fenster nicht verfügbar!'
-
+        'ACHTUNG: Das Ausführen des Codes ist fehlgeschlagen; einige Definitionen sind möglicherweise im interaktiven Fenster nicht verfügbar!',
+    '=== WELCOME to ': '=== WILLKOMMEN bei '
 }
 
 def expectingNoReturn(cn: location.CallableName) -> str:
@@ -167,7 +166,7 @@ def expectingNoReturn(cn: location.CallableName) -> str:
             return tr('Expecting no return value when calling function `{fun}`.',
                     fun=cn.name)
         case location.ClassMember('method', cls):
-            return tr('Expecting no return value when calling method `{method}` of class `{cls}.',
+            return tr('Expecting no return value when calling method `{method}` of class `{cls}`.',
                     method=cn.name, cls=cls)
         case location.ClassMember('recordConstructor', cls):
             return tr('Expecting no return value when calling constructor of record `{cls}`.',
@@ -339,7 +338,7 @@ def expectingTypeAnnotation(cn: location.CallableName, param: str) -> str:
     raise ValueError(f'Unexpected: {cn}')
 
 def noTypeAnnotationForAttribute(attrName: str, recordName: str) -> str:
-    return tr('Attribute `{name}` of record `{record}` required a type annotation.',
+    return tr('Attribute `{name}` of record `{record}` requires a type annotation.',
               name=attrName, record=recordName)
 
 def invalidTy(ty: Any) -> str:
@@ -349,7 +348,7 @@ def didYouMean(ty: str) -> str:
     return tr('Did you mean `{ty}`?', ty=ty)
 
 def recordAttrDeclTy(recordName: str, attrName: str, ty: Any) -> str:
-    return tr('Attribute `{attrName}` of record `{recordName}` declared with type `{ty}.`',
+    return tr('Attribute `{attrName}` of record `{recordName}` declared with type `{ty}`.',
               recordName=recordName, attrName=attrName, ty=ty)
 
 def unknownKeywordArgument(cn: location.CallableName, name: str) -> str:

python/code/wypp/paths.py

@@ -10,8 +10,9 @@ def projectDir(d: str):
     global _projectDir
     old = _projectDir
     _projectDir = _normPath(d)
-    if _projectDir and not _projectDir[-1] == '/':
-        _projectDir = _projectDir + '/'
+    sep = os.path.sep
+    if _projectDir and _projectDir[-1] != sep:
+        _projectDir = _projectDir + sep
     try:
         yield
     finally:

python/code/wypp/runner.py

@@ -5,6 +5,24 @@
 import sys
 import os
 
+requiredVersion = (3, 12, 0)
+def pythonVersionOk(v):
+    (reqMajor, reqMinor, reqMicro) = requiredVersion
+    if v.major < reqMajor or v.minor < reqMinor:
+        return False
+    if v.major == reqMajor and v.minor == reqMinor and v.micro < reqMicro:
+        return False
+    else:
+        return True
+
+if not pythonVersionOk(sys.version_info):
+    vStr = sys.version.split()[0]
+    reqVStr = '.'.join([str(x) for x in requiredVersion])
+    print(f"""
+Python in version {reqVStr} or newer is required. You are still using version {vStr}, please upgrade!
+""")
+    sys.exit(1)
+
 # local imports
 from constants import *
 import i18n
@@ -16,15 +34,6 @@
 import exceptionHandler
 import cmdlineArgs
 
-requiredVersion = (3, 12, 0)
-def pythonVersionOk(v):
-    (reqMajor, reqMinor, reqMicro) = requiredVersion
-    if v.major < reqMajor or v.minor < reqMinor:
-        return False
-    if v.major == reqMajor and v.minor == reqMinor and v.micro < reqMicro:
-        return False
-    else:
-        return True
 
 def printWelcomeString(file, version, doTypecheck):
     cwd = os.getcwd() + "/"
@@ -35,19 +44,10 @@ def printWelcomeString(file, version, doTypecheck):
     tycheck = ''
     if not doTypecheck:
         tycheck = ', no typechecking'
-    printStderr('=== WELCOME to "Write Your Python Program" ' +
+    printStderr(i18n.tr('=== WELCOME to ') + '"Write Your Python Program" ' +
                 '(%sPython %s, %s%s) ===' % (versionStr, pythonVersion, file, tycheck))
 
 def main(globals, argList=None):
-    v = sys.version_info
-    if not pythonVersionOk(v):
-        vStr = sys.version.split()[0]
-        reqVStr = '.'.join([str(x) for x in requiredVersion])
-        print(f"""
-Python in version {reqVStr} or newer is required. You are still using version {vStr}, please upgrade!
-""")
-        sys.exit(1)
-
     (args, restArgs) = cmdlineArgs.parseCmdlineArgs(argList)
     if args.verbose:
         enableVerbose()
@@ -92,7 +92,7 @@ def main(globals, argList=None):
             globals = runCode.runStudentCode(fileToRun, globals, args.checkRunnable,
                                              doTypecheck=args.checkTypes, extraDirs=args.extraDirs)
         except Exception as e:
-            verbose(f'Error while running code in {fileToRun}: {e}')
+            verbose(f'Error while running code in {fileToRun}')
             exceptionHandler.handleCurrentException(exit=not isInteractive)
             loadingFailed = True
 

python/file-test-data/basics/async.err

@@ -12,8 +12,8 @@ Traceback (most recent call last):
 
 WyppTypeError: "blub"
 
-Der Aufruf der Funktion `foo` erwartet Wert vom Typ `int` als erstes Argument.
-Aber der übergebene Wert hat Typ `str`.
+Der Aufruf der Funktion `foo` erwartet einen Wert vom Typ `int` als erstes Argument.
+Aber der übergebene Wert hat den Typ `str`.
 
 ## Datei file-test-data/basics/async.py
 ## Fehlerhafter Aufruf in Zeile 7:
@@ -22,4 +22,4 @@ Aber der übergebene Wert hat Typ `str`.
 
 ## Typ deklariert in Zeile 3:
 
-async def foo(i: int):
+async def foo(i: int):

python/file-test-data/basics/constructor.err

@@ -4,8 +4,8 @@ Traceback (most recent call last):
 
 WyppTypeError: "1"
 
-Der Aufruf der Methode `__init__` aus Klasse `C` erwartet Wert vom Typ `int` als erstes Argument.
-Aber der übergebene Wert hat Typ `str`.
+Der Aufruf der Methode `__init__` der Klasse `C` erwartet einen Wert vom Typ `int` als erstes Argument.
+Aber der übergebene Wert hat den Typ `str`.
 
 ## Datei file-test-data/basics/constructor.py
 ## Fehlerhafter Aufruf in Zeile 5:

python/file-test-data/basics/forwardRefs.err

@@ -4,8 +4,8 @@ Traceback (most recent call last):
 
 WyppTypeError: <__wypp__.A object at 0x00>
 
-Der Aufruf der Methode `foo` aus Klasse `A` erwartet Wert vom Typ `B` als erstes Argument.
-Aber der übergebene Wert hat Typ `A`.
+Der Aufruf der Methode `foo` der Klasse `A` erwartet einen Wert vom Typ `B` als erstes Argument.
+Aber der übergebene Wert hat den Typ `A`.
 
 ## Datei file-test-data/basics/forwardRefs.py
 ## Fehlerhafter Aufruf in Zeile 12:

python/file-test-data/basics/functionArg.err

@@ -4,8 +4,8 @@ Traceback (most recent call last):
 
 WyppTypeError: "1"
 
-Der Aufruf der Funktion `foo` erwartet Wert vom Typ `int` als zweites Argument.
-Aber der übergebene Wert hat Typ `str`.
+Der Aufruf der Funktion `foo` erwartet einen Wert vom Typ `int` als zweites Argument.
+Aber der übergebene Wert hat den Typ `str`.
 
 ## Datei file-test-data/basics/functionArg.py
 ## Fehlerhafter Aufruf in Zeile 8:

python/file-test-data/basics/kwargs.err

@@ -4,8 +4,8 @@ Traceback (most recent call last):
 
 WyppTypeError: 2
 
-Der Aufruf der Funktion `foo` erwartet Wert vom Typ `str` als Argument `z`.
-Aber der übergebene Wert hat Typ `int`.
+Der Aufruf der Funktion `foo` erwartet einen Wert vom Typ `str` als Argument `z`.
+Aber der übergebene Wert hat den Typ `int`.
 
 ## Datei file-test-data/basics/kwargs.py
 ## Fehlerhafter Aufruf in Zeile 4: