1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
import json
import os
from enum import Enum
from typing import Any, Dict, List, NamedTuple, Optional, Tuple
JSON = Dict[str, Any]
DEFAULT_MAP_FILE = "projects.json"
class DownloadType(str, Enum):
GIT = "git"
ZIP = "zip"
SCRIPT = "script"
class ProjectInfo(NamedTuple):
"""
Information about a project to analyze.
"""
name: str
mode: int
source: DownloadType = DownloadType.SCRIPT
origin: str = ""
commit: str = ""
enabled: bool = True
def with_fields(self, **kwargs) -> "ProjectInfo":
"""
Create a copy of this project info with customized fields.
NamedTuple is immutable and this is a way to create modified copies.
info.enabled = True
info.mode = 1
can be done as follows:
modified = info.with_fields(enbled=True, mode=1)
"""
return ProjectInfo(**{**self._asdict(), **kwargs})
class ProjectMap:
"""
Project map stores info about all the "registered" projects.
"""
def __init__(self, path: Optional[str] = None, should_exist: bool = True):
"""
:param path: optional path to a project JSON file, when None defaults
to DEFAULT_MAP_FILE.
:param should_exist: flag to tell if it's an exceptional situation when
the project file doesn't exist, creates an empty
project list instead if we are not expecting it to
exist.
"""
if path is None:
path = os.path.join(os.path.abspath(os.curdir), DEFAULT_MAP_FILE)
if not os.path.exists(path):
if should_exist:
raise ValueError(
f"Cannot find the project map file {path}"
f"\nRunning script for the wrong directory?\n")
else:
self._create_empty(path)
self.path = path
self._load_projects()
def save(self):
"""
Save project map back to its original file.
"""
self._save(self.projects, self.path)
def _load_projects(self):
with open(self.path) as raw_data:
raw_projects = json.load(raw_data)
if not isinstance(raw_projects, list):
raise ValueError(
"Project map should be a list of JSON objects")
self.projects = self._parse(raw_projects)
@staticmethod
def _parse(raw_projects: List[JSON]) -> List[ProjectInfo]:
return [ProjectMap._parse_project(raw_project)
for raw_project in raw_projects]
@staticmethod
def _parse_project(raw_project: JSON) -> ProjectInfo:
try:
name: str = raw_project["name"]
build_mode: int = raw_project["mode"]
enabled: bool = raw_project.get("enabled", True)
source: DownloadType = raw_project.get("source", "zip")
if source == DownloadType.GIT:
origin, commit = ProjectMap._get_git_params(raw_project)
else:
origin, commit = "", ""
return ProjectInfo(name, build_mode, source, origin, commit,
enabled)
except KeyError as e:
raise ValueError(
f"Project info is required to have a '{e.args[0]}' field")
@staticmethod
def _get_git_params(raw_project: JSON) -> Tuple[str, str]:
try:
return raw_project["origin"], raw_project["commit"]
except KeyError as e:
raise ValueError(
f"Profect info is required to have a '{e.args[0]}' field "
f"if it has a 'git' source")
@staticmethod
def _create_empty(path: str):
ProjectMap._save([], path)
@staticmethod
def _save(projects: List[ProjectInfo], path: str):
with open(path, "w") as output:
json.dump(ProjectMap._convert_infos_to_dicts(projects),
output, indent=2)
@staticmethod
def _convert_infos_to_dicts(projects: List[ProjectInfo]) -> List[JSON]:
return [ProjectMap._convert_info_to_dict(project)
for project in projects]
@staticmethod
def _convert_info_to_dict(project: ProjectInfo) -> JSON:
whole_dict = project._asdict()
defaults = project._field_defaults
# there is no need in serializing fields with default values
for field, default_value in defaults.items():
if whole_dict[field] == default_value:
del whole_dict[field]
return whole_dict
|
