Adjust the names of some type variables to recent pylint changes (see p…

…ylint-dev/pylint#5981).

hydpy/__init__.py

@@ -310,7 +310,7 @@
  "start_server",
 ]
 
-sequence2alias: Dict[sequencetools.TypesInOutSequence, str] = {}
+sequence2alias: Dict[sequencetools.InOutSequenceTypes, str] = {}
 
 if config.USEAUTODOC:
  with warnings.catch_warnings():

hydpy/auxs/anntools.py

@@ -24,8 +24,8 @@
 
 class _ANNArrayProperty(
  propertytools.DependentProperty[
- propertytools.InputType,
- propertytools.OutputType,
+ propertytools.TypeInput,
+ propertytools.TypeOutput,
  ],
 ):
 
@@ -53,11 +53,11 @@ def add_cann(cls, obj: Any, cann: annutils.ANN) -> None:
  def _shape(self) -> str:
  return f"shape_{self.name}"
 
- def _fget(self, obj: "ANN") -> propertytools.OutputType:
+ def _fget(self, obj: "ANN") -> propertytools.TypeOutput:
  cann = self._obj2cann[obj]
  return numpy.asarray(getattr(cann, self.name))
 
- def _fset(self, obj: "ANN", value: Optional[propertytools.InputType]) -> None:
+ def _fset(self, obj: "ANN", value: Optional[propertytools.TypeInput]) -> None:
  if value is None:
  self.fdel(obj)
  else:

hydpy/auxs/calibtools.py

@@ -37,16 +37,16 @@
 from hydpy.models.arma import arma_control
 from hydpy.core.typingtools import *
 
-ParameterType = TypeVar("ParameterType", bound=parametertools.Parameter)
-RuleType1 = TypeVar(
- "RuleType1",
+TypeParameter = TypeVar("TypeParameter", bound=parametertools.Parameter)
+TypeRule1 = TypeVar(
+ "TypeRule1",
  bound=Union["Replace", "Add", "Multiply", "ReplaceIUH", "MultiplyIUH"],
 )
-RuleType2 = TypeVar(
- "RuleType2",
+TypeRule2 = TypeVar(
+ "TypeRule2",
  bound=Union["Replace", "Add", "Multiply", "ReplaceIUH", "MultiplyIUH"],
 )
-RuleType = TypeVar("RuleType", "Replace", "Add", "Multiply")
+TypeRule = TypeVar("TypeRule", "Replace", "Add", "Multiply")
 Target = Optional[str]
 
 
@@ -298,7 +298,7 @@ def __call__(
  target.value = self._rule.value * ref.value
 
 
-class Rule(abc.ABC, Generic[ParameterType]):
+class Rule(abc.ABC, Generic[TypeParameter]):
  """Base class for defining calibration rules.
 
  Each |Rule| object relates one calibration parameter with some model parameters.
@@ -532,7 +532,7 @@ class Rule(abc.ABC, Generic[ParameterType]):
  parametername: str
  """The name of the addressed |Parameter| objects."""
 
- parametertype: Type[ParameterType]
+ parametertype: Type[TypeParameter]
  """The type of the addressed |Parameter| objects."""
 
  keyword: Optional[str]
@@ -554,7 +554,7 @@ def __init__(
  self,
  *,
  name: str,
- parameter: Union[Type[ParameterType], ParameterType, str],
+ parameter: Union[Type[TypeParameter], TypeParameter, str],
  value: float,
  lower: float = -numpy.inf,
  upper: float = numpy.inf,
@@ -785,7 +785,7 @@ def __repr__(self) -> str:
  def __str__(self) -> str:
  return self.name
 
- def __iter__(self) -> Iterator[ParameterType]:
+ def __iter__(self) -> Iterator[TypeParameter]:
  for element in self.elements:
  yield getattr(
  element.model.parameters.control,
@@ -1007,7 +1007,7 @@ def apply_value(self) -> None:
  self._update_parameter(parameter, self.value * orig)
 
 
-class CalibrationInterface(Generic[RuleType1]):
+class CalibrationInterface(Generic[TypeRule1]):
  """Interface for the coupling of *HydPy* to optimisation libraries like `NLopt`_.
 
  Essentially, class |CalibrationInterface| is supposed for the structured handling
@@ -1482,7 +1482,7 @@ class CalibrationInterface(Generic[RuleType1]):
  _logfilelines: Deque[str]
  _hp: hydpytools.HydPy
  _targetfunction: TargetFunction
- _rules: Dict[str, RuleType1]
+ _rules: Dict[str, TypeRule1]
  _elements: devicetools.Elements
 
  def __init__(self, hp: hydpytools.HydPy, targetfunction: TargetFunction):
@@ -1495,7 +1495,7 @@ def __init__(self, hp: hydpytools.HydPy, targetfunction: TargetFunction):
  self._logfilelines = collections.deque()
  self.result = None
 
- def add_rules(self, *rules: RuleType1) -> None:
+ def add_rules(self, *rules: TypeRule1) -> None:
  """Add some |Rule| objects to the actual |CalibrationInterface| object.
 
  >>> from hydpy.examples import prepare_full_example_2
@@ -1531,16 +1531,16 @@ def add_rules(self, *rules: RuleType1) -> None:
  self._update_elements_when_adding_a_rule(rule)
 
  @overload
- def get_rule(self, name: str) -> RuleType1:
+ def get_rule(self, name: str) -> TypeRule1:
  ...
 
  @overload
- def get_rule(self, name: str, type_: Type[RuleType2]) -> RuleType2:
+ def get_rule(self, name: str, type_: Type[TypeRule2]) -> TypeRule2:
  ...
 
  def get_rule(
- self, name: str, type_: Optional[Type[RuleType2]] = None
- ) -> Union[RuleType1, RuleType2]:
+ self, name: str, type_: Optional[Type[TypeRule2]] = None
+ ) -> Union[TypeRule1, TypeRule2]:
  """Return a |Rule| object (of a specific type).
 
  Method |CalibrationInterface.get_rule| is a more typesafe alternative to simple
@@ -1596,7 +1596,7 @@ def get_rule(
  f"`{name}` of type `{type_.__name__}`."
  )
 
- def remove_rules(self, *rules: Union[str, RuleType1]) -> None:
+ def remove_rules(self, *rules: Union[str, TypeRule1]) -> None:
  """Remove some |Rule| objects from the actual |CalibrationInterface| object.
 
  >>> from hydpy.examples import prepare_full_example_2
@@ -1792,7 +1792,7 @@ def read_logfile(
  idx2rule[idx].value = float(value)
  self.result = result_best
 
- def _update_elements_when_adding_a_rule(self, rule: RuleType1) -> None:
+ def _update_elements_when_adding_a_rule(self, rule: TypeRule1) -> None:
  self._elements += rule.elements
 
  def _update_elements_when_deleting_a_rule(self) -> None:
@@ -2151,11 +2151,11 @@ def print_table(
  def __len__(self) -> int:
  return len(self._rules)
 
- def __iter__(self) -> Iterator[RuleType1]:
+ def __iter__(self) -> Iterator[TypeRule1]:
  for rule in self._rules.values():
  yield rule
 
- def __getattr__(self, item: str) -> RuleType1:
+ def __getattr__(self, item: str) -> TypeRule1:
  try:
  return self._rules[item]
  except KeyError:
@@ -2164,7 +2164,7 @@ def __getattr__(self, item: str) -> RuleType1:
  f"attribute nor a rule object named `{item}`."
  ) from None
 
- def __getitem__(self, key: str) -> RuleType1:
+ def __getitem__(self, key: str) -> TypeRule1:
  try:
  return self._rules[key]
  except KeyError:
@@ -2928,7 +2928,7 @@ def __dir__(self) -> List[str]:
 @overload
 def make_rules(
  *,
- rule: Type[RuleType],
+ rule: Type[TypeRule],
  names: Sequence[str],
  parameters: Sequence[Union[parametertools.Parameter, str]],
  values: Sequence[float],
@@ -2937,14 +2937,14 @@ def make_rules(
  parametersteps: Sequence1[Optional[timetools.PeriodConstrArg]] = None,
  model: Optional[Union[types.ModuleType, str]] = None,
  selections: Literal[None] = None,
-) -> List[RuleType]:
+) -> List[TypeRule]:
  ...
 
 
 @overload
 def make_rules(
  *,
- rule: Type[RuleType],
+ rule: Type[TypeRule],
  names: Sequence[str],
  parameters: Sequence[Union[parametertools.Parameter, str]],
  values: Sequence[float],
@@ -2955,14 +2955,14 @@ def make_rules(
  model: Optional[Union[types.ModuleType, str]] = None,
  selections: Iterable[Union[selectiontools.Selection, str]],
  product: bool = False,
-) -> List[RuleType]:
+) -> List[TypeRule]:
  ...
 
 
 @overload
 def make_rules(
  *,
- rule: Type[RuleType],
+ rule: Type[TypeRule],
  calibspecs: "CalibSpecs",
  names: Optional[Sequence[str]] = None,
  parameters: Optional[Sequence[Union[parametertools.Parameter, str]]] = None,
@@ -2972,14 +2972,14 @@ def make_rules(
  uppers: Optional[Sequence[float]] = None,
  model: Optional[Union[types.ModuleType, str]] = None,
  selections: Literal[None] = None,
-) -> List[RuleType]:
+) -> List[TypeRule]:
  ...
 
 
 @overload
 def make_rules(
  *,
- rule: Type[RuleType],
+ rule: Type[TypeRule],
  calibspecs: "CalibSpecs",
  names: Optional[Sequence[str]] = None,
  parameters: Optional[Sequence[Union[parametertools.Parameter, str]]] = None,
@@ -2990,13 +2990,13 @@ def make_rules(
  model: Optional[Union[types.ModuleType, str]] = None,
  selections: Iterable[Union[selectiontools.Selection, str]],
  product: bool = False,
-) -> List[RuleType]:
+) -> List[TypeRule]:
  ...
 
 
 def make_rules(
  *,
- rule: Type[RuleType],
+ rule: Type[TypeRule],
  calibspecs: Optional["CalibSpecs"] = None,
  names: Optional[Sequence[str]] = None,
  parameters: Optional[Sequence[Union[parametertools.Parameter, str]]] = None,
@@ -3008,7 +3008,7 @@ def make_rules(
  model: Optional[Union[types.ModuleType, str]] = None,
  selections: Optional[Iterable[Union[selectiontools.Selection, str]]] = None,
  product: bool = False,
-) -> List[RuleType]:
+) -> List[TypeRule]:
  """Conveniently create multiple |Rule| objects at once.
 
  Please see the main documentation on class |CalibrationInterface| first, from

hydpy/auxs/xmltools.py

@@ -129,14 +129,14 @@
  )
  xmlschema = exceptiontools.OptionalImport("xmlschema", ["xmlschema"], locals())
 
-_SetOrAddOrMultiplyItem = TypeVar(
- "_SetOrAddOrMultiplyItem",
+_TypeSetOrAddOrMultiplyItem = TypeVar(
+ "_TypeSetOrAddOrMultiplyItem",
  itemtools.SetItem,
  itemtools.AddItem,
  itemtools.MultiplyItem,
 )
-_GetOrChangeItem = TypeVar(
- "_GetOrChangeItem",
+_TypeGetOrChangeItem = TypeVar(
+ "_TypeSetOrAddOrMultiplyItem",
  itemtools.GetItem,
  itemtools.ChangeItem,
  itemtools.SetItem,
@@ -1719,10 +1719,10 @@ def __init__(self, master: XMLInterface, root: ElementTree.Element) -> None:
  self.root: ElementTree.Element = root
 
  def _get_items_of_certain_item_types(
- self, itemgroups: Iterable[str], itemtype: Type[_GetOrChangeItem]
- ) -> List[_GetOrChangeItem]:
+ self, itemgroups: Iterable[str], itemtype: Type[_TypeGetOrChangeItem]
+ ) -> List[_TypeGetOrChangeItem]:
  """Return either all |GetItem| or all |ChangeItem| objects."""
- items: List[_GetOrChangeItem] = []
+ items: List[_TypeGetOrChangeItem] = []
  for itemgroup in self.itemgroups:
  if (
  issubclass(itemtype, itemtools.GetItem)
@@ -2200,13 +2200,13 @@ def _get_getitem(
  return item
 
  def _get_changeitem(
- self, target: str, master: str, itemtype: Type[_SetOrAddOrMultiplyItem]
- ) -> _SetOrAddOrMultiplyItem:
+ self, target: str, master: str, itemtype: Type[_TypeSetOrAddOrMultiplyItem]
+ ) -> _TypeSetOrAddOrMultiplyItem:
  name = cast(Name, self.find("name", optional=False).text)
  assert name is not None
  level = self.find("level", optional=False).text
  assert level is not None
- item: _SetOrAddOrMultiplyItem
+ item: _TypeSetOrAddOrMultiplyItem
  # Simplify the following if-clauses after Mypy issue 10989 is fixed?
  if not issubclass(itemtype, itemtools.SetItem):
  item = itemtype(

hydpy/core/aliastools.py

@@ -103,7 +103,7 @@ def __init__(
  self._alias = alias
  self._namespace = namespace
 
- def _get_sequencetype(self) -> sequencetools.TypesInOutSequence:
+ def _get_sequencetype(self) -> sequencetools.InOutSequenceTypes:
  dict_ = object.__getattribute__(self, "__dict__")
  module = importlib.import_module(dict_["_modulename"])
  return getattr(module, dict_["_classname"]) # type: ignore[no-any-return]
@@ -165,7 +165,7 @@ def write_sequencealiases() -> None:
  "outputs.py",
  ),
  ):
- sequence2alias: Dict[sqt.TypesInOutSequence, str] = {}
+ sequence2alias: Dict[sqt.InOutSequenceTypes, str] = {}
  for moduleinfo in pkgutil.walk_packages([modelpath]):
  if not moduleinfo.ispkg:
  continue