def load_all_parametrizations(self) -> Dict[str, Parametrization]:
query = 'SELECT am_id, data FROM parametrization;'
tuples = self._exectute_select_query(query, ())
return {
am_id: Parametrization.from_dict(json.loads(json_))
for am_id, json_ in tuples or {}
}
def upsert_new_parametrization(self, am_id: str,
parametrization: Parametrization) -> None:
data = json.dumps(parametrization.to_dict())
query = (
'INSERT INTO parametrization(am_id, data) VALUES(%s, %s) ON CONFLICT (am_id)'
' DO UPDATE SET data = %s WHERE parametrization.am_id = %s;')
self._exectute_update_query(query, (am_id, data, data, am_id))
def load_parametrization(self, am_id: str) -> Optional[Parametrization]:
query = 'SELECT data FROM parametrization WHERE am_id = %s;'
json_am = self._exectute_select_query(query, (am_id, ))
if json_am:
return Parametrization.from_dict(
json.loads(_ensure_one_variable(json_am)))
return None
def test_extract_conditions():
date_ = ParameterEnum.DATE_INSTALLATION.value
dt_1 = datetime.now()
dt_2 = dt_1 + timedelta(days=1)
cd_1 = Range(date_, dt_1, dt_2)
cd_2 = Greater(date_, dt_2)
parametrization = Parametrization([], [], [])
assert parametrization.extract_conditions() == []
parametrization = Parametrization([_simple_nac(cd_1)], [], [])
assert parametrization.extract_conditions() == [cd_1]
parametrization = Parametrization(
[_simple_nac(cd_1), _simple_nac(cd_2)], [], [])
assert parametrization.extract_conditions() == [cd_1, cd_2]
def build_enriched_ams(self,
with_deleted_ams: bool = False,
with_fake: bool = False) -> List[ArreteMinisteriel]:
metadata = self.load_all_am_metadata(with_deleted_ams, with_fake)
id_to_am = self.load_id_to_am()
parametizations = self._load_validated_parametrizations()
return [
_enrich_and_add_parametrization(
id_to_am[am_id], am_md,
parametizations.get(am_id) or Parametrization([], [], []))
for am_id, am_md in metadata.items() if am_id in id_to_am
]
def _load_parametrization(self, am_id: str) -> Optional[Parametrization]:
query = 'SELECT data FROM parametrization where am_id = %s LIMIT 1;'
tuples = self._exectute_select_query(query, (am_id, ))
if len(tuples) > 1:
raise ValueError(
'Parametrization not found, which should not happen.')
if not tuples:
return None
if len(tuples[0]) != 1:
raise ValueError(
f'Expecting one value, received {len(tuples[0])}.')
return Parametrization.from_dict(json.loads(tuples[0][0]))
def _recreate_with_removed_parameter(
object_type: Type[ParameterElement], parameter_id: str,
parametrization: Parametrization) -> Parametrization:
new_inapplicabilities = parametrization.inapplicable_sections.copy()
new_sections = parametrization.alternative_sections.copy()
new_warnings = parametrization.warnings.copy()
if object_type == InapplicableSection:
new_inapplicabilities = [
i for i in new_inapplicabilities if i.id != parameter_id
]
if object_type == AlternativeSection:
new_sections = [s for s in new_sections if s.id != parameter_id]
if object_type == AMWarning:
new_warnings = [w for w in new_warnings if w.id != parameter_id]
return Parametrization(new_inapplicabilities, new_sections, new_warnings)
def test_check_parametrization_consistency():
date_ = ParameterEnum.DATE_INSTALLATION.value
dt_1 = datetime.now()
dt_2 = dt_1 + timedelta(days=1)
cd_1 = Range(date_, dt_1, dt_2)
cd_3 = Littler(date_, dt_1)
cd_4 = Greater(date_, dt_2)
cd_5 = Littler(date_, dt_2)
cd_6 = Greater(date_, dt_1)
new_text = StructuredText(_str('Art. 2'), [_str('version modifiée')], [],
None)
Parametrization(
[_NAC('', None, cd_1), _NAC('', None, cd_3)],
[AlternativeSection('', new_text, cd_4)], []).check_consistency()
Parametrization([_NAC('', None, cd_3)], [], []).check_consistency()
with pytest.raises(ParametrizationError):
Parametrization(
[_NAC('', None, cd_1), _NAC('', None, cd_5)],
[AlternativeSection('', new_text, cd_6)], []).check_consistency()
with pytest.raises(ParametrizationError):
Parametrization(
[_NAC('', None, cd_1), _NAC('', None, cd_1)], [],
[]).check_consistency()
def _recreate_with_upserted_parameter(
new_parameter: ParameterElement, parameter_id: Optional[str],
parametrization: Parametrization) -> Parametrization:
new_sections = parametrization.alternative_sections
new_conditions = parametrization.inapplicable_sections
new_warnings = parametrization.warnings
if isinstance(new_parameter, InapplicableSection):
new_conditions = _upsert_element(new_parameter, new_conditions,
parameter_id)
elif isinstance(new_parameter, AlternativeSection):
new_sections = _upsert_element(new_parameter, new_sections,
parameter_id)
else:
new_warnings = _upsert_element(new_parameter, new_warnings,
parameter_id)
return Parametrization(new_conditions, new_sections, new_warnings)
def load_or_init_parametrization(self, am_id: str) -> Parametrization:
return self.load_parametrization(am_id) or Parametrization([], [], [])
applicability=None,
reference=None,
annotations=None,
id='d16d0fE7C7fc',
)
_PARAMETRIZATION = Parametrization(
inapplicable_sections=[
InapplicableSection(
section_id='abcdef',
alineas=None,
condition=AndCondition(
conditions=frozenset([Littler(parameter=_DATE, target=date(2021, 1, 1), strict=True)])
),
)
],
alternative_sections=[
AlternativeSection(
section_id='123456',
new_text=_NEW_TEXT,
condition=AndCondition(
conditions=frozenset([Range(parameter=_DATE, left=date(2020, 1, 1), right=date(2021, 1, 1))])
),
)
],
warnings=[AMWarning('ABCDEF', 'AM warning')],
)
def test_generate_exhaustive_combinations():
res = generate_exhaustive_combinations(_PARAMETRIZATION)
assert len(res) == 4