6cc4b919ec
* Upgraded CI workflow to use Python 3.11.2 and Pytest 7.2.2 * Pinned Pylint version to ~=2.17.1 * Added tomli to test_exercises.py imports. * Adding in tomli for dependancies. * Need to use latest build of Black due to Python 3.11 and packaging problems with tomli * Regenerated test files for exercises failing CI. * Try removing tomli to see if it fixes CI for Py3.11 * And more version fishing for black, which is the culprit here. * Regeneraed test files with black 22.3.0, since black 23.3.0 is incompatible with Python 3.11 due to tomli conflicts. * Trying a different strategy. Using only 3.11 for the main container. * Must import tomllib, part of exteded standard lib not core. * Wrapped tomllib in a try-catch and aliased importing tomli. Updated requirements to only install tmli on 3.10 and below. * Forgot to update the imports in the generator. * Added paasio test changes here, since this changes the CI checker to use Python 3.11. * Trying a msg= approach.
382 lines
9.9 KiB
Python
382 lines
9.9 KiB
Python
from enum import Enum
|
|
from dataclasses import dataclass, asdict, fields
|
|
import dataclasses
|
|
from itertools import chain
|
|
import json
|
|
from pathlib import Path
|
|
from typing import List, Any, Dict, Type
|
|
|
|
# Tomli was subsumed into Python 3.11.x, but was renamed to to tomllib.
|
|
# This avoids ci failures for Python < 3.11.2.
|
|
try:
|
|
import tomllib
|
|
except ModuleNotFoundError:
|
|
import tomli as tomllib
|
|
|
|
|
|
|
|
def _custom_dataclass_init(self, *args, **kwargs):
|
|
# print(self.__class__.__name__, "__init__")
|
|
names = [field.name for field in fields(self)]
|
|
used_names = set()
|
|
|
|
# Handle positional arguments
|
|
for value in args:
|
|
try:
|
|
name = names.pop(0)
|
|
except IndexError:
|
|
raise TypeError(f"__init__() given too many positional arguments")
|
|
# print(f'setting {k}={v}')
|
|
setattr(self, name, value)
|
|
used_names.add(name)
|
|
|
|
# Handle keyword arguments
|
|
for name, value in kwargs.items():
|
|
if name in names:
|
|
# print(f'setting {k}={v}')
|
|
setattr(self, name, value)
|
|
used_names.add(name)
|
|
elif name in used_names:
|
|
raise TypeError(f"__init__() got multiple values for argument '{name}'")
|
|
else:
|
|
raise TypeError(
|
|
f"Unrecognized field '{name}' for dataclass {self.__class__.__name__}."
|
|
"\nIf this field is valid, please add it to the dataclass in data.py."
|
|
"\nIf adding an object-type field, please create a new dataclass for it."
|
|
)
|
|
|
|
# Check for missing positional arguments
|
|
missing = [
|
|
f"'{field.name}'" for field in fields(self)
|
|
if isinstance(field.default, dataclasses._MISSING_TYPE) and field.name not in used_names
|
|
]
|
|
if len(missing) == 1:
|
|
raise TypeError(f"__init__() missing 1 required positional argument: {missing[0]}")
|
|
elif len(missing) == 2:
|
|
raise TypeError(f"__init__() missing 2 required positional arguments: {' and '.join(missing)}")
|
|
elif len(missing) != 0:
|
|
missing[-1] = f"and {missing[-1]}"
|
|
raise TypeError(f"__init__() missing {len(missing)} required positional arguments: {', '.join(missing)}")
|
|
|
|
# Run post init if available
|
|
if hasattr(self, "__post_init__"):
|
|
self.__post_init__()
|
|
|
|
|
|
@dataclass
|
|
class TrackStatus:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
concept_exercises: bool = False
|
|
test_runner: bool = False
|
|
representer: bool = False
|
|
analyzer: bool = False
|
|
|
|
|
|
class IndentStyle(str, Enum):
|
|
Space = "space"
|
|
Tab = "tab"
|
|
|
|
|
|
@dataclass
|
|
class TestRunnerSettings:
|
|
average_run_time: float = -1
|
|
|
|
|
|
@dataclass
|
|
class EditorSettings:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
indent_style: IndentStyle = IndentStyle.Space
|
|
indent_size: int = 4
|
|
ace_editor_language: str = "python"
|
|
highlightjs_language: str = "python"
|
|
|
|
def __post_init__(self):
|
|
if isinstance(self.indent_style, str):
|
|
self.indent_style = IndentStyle(self.indent_style)
|
|
|
|
|
|
class ExerciseStatus(str, Enum):
|
|
Active = "active"
|
|
WIP = "wip"
|
|
Beta = "beta"
|
|
Deprecated = "deprecated"
|
|
|
|
|
|
@dataclass
|
|
class ExerciseFiles:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
solution: List[str]
|
|
test: List[str]
|
|
editor: List[str] = None
|
|
exemplar: List[str] = None
|
|
|
|
|
|
# practice exercises are different
|
|
example: List[str] = None
|
|
|
|
def __post_init__(self):
|
|
if self.exemplar is None:
|
|
if self.example is None:
|
|
raise ValueError(
|
|
"exercise config must have either files.exemplar or files.example"
|
|
)
|
|
else:
|
|
self.exemplar = self.example
|
|
delattr(self, "example")
|
|
elif self.example is not None:
|
|
raise ValueError(
|
|
"exercise config must have either files.exemplar or files.example, but not both"
|
|
)
|
|
|
|
|
|
@dataclass
|
|
class ExerciseConfig:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
files: ExerciseFiles
|
|
authors: List[str] = None
|
|
forked_from: str = None
|
|
contributors: List[str] = None
|
|
language_versions: List[str] = None
|
|
test_runner: bool = True
|
|
source: str = None
|
|
source_url: str = None
|
|
blurb: str = None
|
|
icon: str = None
|
|
|
|
def __post_init__(self):
|
|
if isinstance(self.files, dict):
|
|
self.files = ExerciseFiles(**self.files)
|
|
for attr in ["authors", "contributors", "language_versions"]:
|
|
if getattr(self, attr) is None:
|
|
setattr(self, attr, [])
|
|
|
|
@classmethod
|
|
def load(cls, config_file: Path) -> "ExerciseConfig":
|
|
with config_file.open() as f:
|
|
return cls(**json.load(f))
|
|
|
|
|
|
@dataclass
|
|
class ExerciseInfo:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
path: Path
|
|
slug: str
|
|
name: str
|
|
uuid: str
|
|
prerequisites: List[str]
|
|
type: str = "practice"
|
|
status: ExerciseStatus = ExerciseStatus.Active
|
|
|
|
# concept only
|
|
concepts: List[str] = None
|
|
|
|
# practice only
|
|
difficulty: int = 1
|
|
topics: List[str] = None
|
|
practices: List[str] = None
|
|
|
|
def __post_init__(self):
|
|
if self.concepts is None:
|
|
self.concepts = []
|
|
if self.topics is None:
|
|
self.topics = []
|
|
if self.practices is None:
|
|
self.practices = []
|
|
if isinstance(self.status, str):
|
|
self.status = ExerciseStatus(self.status)
|
|
|
|
@property
|
|
def solution_stub(self):
|
|
return next(
|
|
(
|
|
p
|
|
for p in self.path.glob("*.py")
|
|
if not p.name.endswith("_test.py") and p.name != "example.py"
|
|
),
|
|
None,
|
|
)
|
|
|
|
@property
|
|
def helper_file(self):
|
|
return next(self.path.glob("*_data.py"), None)
|
|
|
|
@property
|
|
def test_file(self):
|
|
return next(self.path.glob("*_test.py"), None)
|
|
|
|
@property
|
|
def meta_dir(self):
|
|
return self.path / ".meta"
|
|
|
|
@property
|
|
def exemplar_file(self):
|
|
if self.type == "concept":
|
|
return self.meta_dir / "exemplar.py"
|
|
return self.meta_dir / "example.py"
|
|
|
|
@property
|
|
def template_path(self):
|
|
return self.meta_dir / "template.j2"
|
|
|
|
@property
|
|
def config_file(self):
|
|
return self.meta_dir / "config.json"
|
|
|
|
def load_config(self) -> ExerciseConfig:
|
|
return ExerciseConfig.load(self.config_file)
|
|
|
|
|
|
@dataclass
|
|
class Exercises:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
concept: List[ExerciseInfo]
|
|
practice: List[ExerciseInfo]
|
|
foregone: List[str] = None
|
|
|
|
def __post_init__(self):
|
|
if self.foregone is None:
|
|
self.foregone = []
|
|
for attr_name in ["concept", "practice"]:
|
|
base_path = Path("exercises") / attr_name
|
|
setattr(
|
|
self,
|
|
attr_name,
|
|
[
|
|
(
|
|
ExerciseInfo(path=(base_path / e["slug"]), type=attr_name, **e)
|
|
if isinstance(e, dict)
|
|
else e
|
|
)
|
|
for e in getattr(self, attr_name)
|
|
],
|
|
)
|
|
|
|
def all(self, status_filter={ExerciseStatus.Active, ExerciseStatus.Beta}):
|
|
return [
|
|
e for e in chain(self.concept, self.practice) if e.status in status_filter
|
|
]
|
|
|
|
|
|
@dataclass
|
|
class Concept:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
uuid: str
|
|
slug: str
|
|
name: str
|
|
|
|
|
|
@dataclass
|
|
class Feature:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
title: str
|
|
content: str
|
|
icon: str
|
|
|
|
|
|
@dataclass
|
|
class FilePatterns:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
solution: List[str]
|
|
test: List[str]
|
|
example: List[str]
|
|
exemplar: List[str]
|
|
editor: List[str] = None
|
|
|
|
|
|
|
|
@dataclass
|
|
class Config:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
language: str
|
|
slug: str
|
|
active: bool
|
|
status: TrackStatus
|
|
blurb: str
|
|
version: int
|
|
online_editor: EditorSettings
|
|
exercises: Exercises
|
|
concepts: List[Concept]
|
|
key_features: List[Feature] = None
|
|
tags: List[Any] = None
|
|
test_runner: TestRunnerSettings = None
|
|
files: FilePatterns = None
|
|
|
|
def __post_init__(self):
|
|
if isinstance(self.status, dict):
|
|
self.status = TrackStatus(**self.status)
|
|
if isinstance(self.online_editor, dict):
|
|
self.online_editor = EditorSettings(**self.online_editor)
|
|
if isinstance(self.test_runner, dict):
|
|
self.test_runner = TestRunnerSettings(**self.test_runner)
|
|
if isinstance(self.exercises, dict):
|
|
self.exercises = Exercises(**self.exercises)
|
|
if isinstance(self.files, dict):
|
|
self.files = FilePatterns(**self.files)
|
|
self.concepts = [
|
|
(Concept(**c) if isinstance(c, dict) else c) for c in self.concepts
|
|
]
|
|
if self.key_features is None:
|
|
self.key_features = []
|
|
if self.tags is None:
|
|
self.tags = []
|
|
|
|
@classmethod
|
|
def load(cls, path="config.json"):
|
|
try:
|
|
with Path(path).open() as f:
|
|
return cls(**json.load(f))
|
|
except IOError:
|
|
print(f"FAIL: {path} file not found")
|
|
raise SystemExit(1)
|
|
except TypeError as ex:
|
|
print(f"FAIL: {ex}")
|
|
raise SystemExit(1)
|
|
|
|
|
|
@dataclass
|
|
class TestCaseTOML:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
uuid: str
|
|
description: str
|
|
include: bool = True
|
|
comment: str = ''
|
|
|
|
|
|
@dataclass
|
|
class TestsTOML:
|
|
__init__ = _custom_dataclass_init
|
|
|
|
cases: Dict[str, TestCaseTOML]
|
|
|
|
@classmethod
|
|
def load(cls, toml_path: Path):
|
|
with toml_path.open("rb") as f:
|
|
data = tomllib.load(f)
|
|
return cls({uuid: TestCaseTOML(uuid, *opts) for
|
|
uuid, opts in
|
|
data.items() if
|
|
opts.get('include', None) is not False})
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
class CustomEncoder(json.JSONEncoder):
|
|
def default(self, obj):
|
|
if isinstance(obj, Path):
|
|
return str(obj)
|
|
return json.JSONEncoder.default(self, obj)
|
|
|
|
config = Config.load()
|
|
print(json.dumps(asdict(config), cls=CustomEncoder, indent=2))
|