regiments.core.Regiment.__init__() - Code Metrics - Inspection of "Upgrade package to v1.1.0" - IL2HorusTeam/il2fb-regiments - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f4c0a2...4a0808 )

by Oleksandr

created 2020-10-11 18:21 UTC

regiments.core.Regiment.init() A

↳ Parent: regiments.core

Complexity

Conditions

Size

Total Lines	13
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	13
rs	9.85
c	0
b	0
f	0
cc	1
nop	4

from pathlib import Path

from typing import Any
from typing import Callable
from typing import Dict
from typing import List
from typing import Optional
from typing import Text

from verboselib import get_language

from il2fb.commons import SupportedLanguages
from il2fb.commons.organization import AirForce
from il2fb.commons.organization import AirForces


__here__ = Path(__file__).absolute().parent
__all__  = []


DEFAULT_LANGUAGE_NAME = SupportedLanguages.get_default().name

DEFAULT_DATA_DIR_PATH = __here__ / "data"
DEFAULT_DATA_MISSING_VALUE = None
DEFAULT_DATA_FILE_ENCODING = "cp1251"
DEFAULT_VALUE_ENCODING = "unicode-escape"

DEFAULT_CATALOG_FILE_NAME = "regiments.ini"

DEFAULT_NAMES_FILE_NAME_FORMAT        = "regShort_{language}.properties"
DEFAULT_DESCRIPTIONS_FILE_NAME_FORMAT = "regInfo_{language}.properties"

FLIGHT_PREFIXES = set(AirForces.get_flight_prefixes())


def export(target: Any) -> Any:
  __all__.append(target.__name__)
  return target


@export
class RegimentInfoLoader:

  def __init__(
    self,
    data_dir_path: Path=DEFAULT_DATA_DIR_PATH,
    data_file_encoding: Text=DEFAULT_DATA_FILE_ENCODING,
    data_value_encoding: Text=DEFAULT_VALUE_ENCODING,
    data_missing_value: Text=DEFAULT_DATA_MISSING_VALUE,
    names_file_name_format: Text=DEFAULT_NAMES_FILE_NAME_FORMAT,
    descriptions_file_name_format: Text=DEFAULT_DESCRIPTIONS_FILE_NAME_FORMAT,
  ):
    self._data_dir_path = data_dir_path
    self._data_file_encoding = data_file_encoding
    self._data_value_encoding = data_value_encoding
    self._data_missing_value = data_missing_value
    self._names_file_name_format = names_file_name_format
    self._descriptions_file_name_format = descriptions_file_name_format

  def get_name(self, code_name: Text, language: Any) -> Text:
    file_name = self._names_file_name_format.format(language=language)
    return self._get_value(code_name, file_name)

  def get_description(self, code_name: Text, language: Any) -> Text:
    file_name = self._descriptions_file_name_format.format(language=language)
    return self._get_value(code_name, file_name)

  def _get_value(self, code_name: Text, file_name: Text) -> Text:
    file_path = self._data_dir_path / file_name
    try:
      return self._load_value_or_raise(code_name, file_path)
    except ValueError:
      return self._data_missing_value

  def _load_value_or_raise(self, code_name: Text, file_path: Path) -> Text:
    if not file_path.exists():
      raise ValueError

    with file_path.open(mode="rb") as f:
      code_name = code_name.encode(self._data_file_encoding)
      for line in f:
        if line.startswith(code_name):
          key, value = line.split(maxsplit=1)
          return value.decode(self._data_value_encoding).strip()
      else:
        raise ValueError


@export
class Regiment:

  def __init__(
    self,
    air_force:   AirForce,
    code_name:   Text,
    info_loader: Optional[RegimentInfoLoader]=None,
  ):
    self.air_force = air_force
    self.code_name = code_name

    self._info_loader = info_loader or RegimentInfoLoader()
    self._text_attribute_loaders = {
      'verbose_name': self._info_loader.get_name,
      'help_text':    self._info_loader.get_description,
    }

  def __getattr__(self, name: Text) -> Text:
    loader = self._text_attribute_loaders.get(name)
    if not loader:
      raise AttributeError(
        f"'{self.__class__}' object has no attribute '{name}'"
      )

    language  = get_language()
    if language not in SupportedLanguages:
      language = DEFAULT_LANGUAGE_NAME

    full_name = f"{name}_{language}"

    value = getattr(self, full_name, None)

    if not value:
      value = self._load_value(loader, language)
      setattr(self, full_name, value)

    return value

  def _load_value(
    self,
    loader:   Callable[[Text, Any], Text],
    language: Any,
  ) -> Text:

    value = loader(code_name=self.code_name, language=language)

    if not value and language != DEFAULT_LANGUAGE_NAME:
      value = loader(code_name=self.code_name, language=DEFAULT_LANGUAGE_NAME)

    return value

  def to_primitive(self, context: Any=None) -> Dict[Text, Any]:
    return {
      'air_force':    self.air_force.to_primitive(context),
      'code_name':    self.code_name,
      'verbose_name': self.verbose_name,
      'help_text':    self.help_text,
    }

  def __repr__(self) -> Text:
    return f"<{self.__class__.__name__} '{self.code_name}'>"


@export
class Regiments:

  def __init__(
    self,
    data_dir_path:      Path=DEFAULT_DATA_DIR_PATH,
    data_file_name:     Text=DEFAULT_CATALOG_FILE_NAME,
    data_file_encoding: Text=DEFAULT_DATA_FILE_ENCODING,
    info_loader:        RegimentInfoLoader=None,
  ):
    self._data_file_path = data_dir_path / data_file_name
    if not self._data_file_path.exists():
      raise ValueError(
        f"Data file '{str(self._data_file_path)}' does not exist"
      )

    self._data_file_encoding = data_file_encoding

    self._info_loader = info_loader or RegimentInfoLoader(
      data_dir_path=data_dir_path,
      data_file_encoding=data_file_encoding,
    )

    self._cache = dict()

  def get_by_code_name(self, code_name: Text) -> Regiment:
    regiment = self._cache.get(code_name)

    if not regiment:
      regiment = self._load_by_code_name_or_raise(code_name)
      self._cache[code_name] = regiment

    return regiment

  def _load_by_code_name_or_raise(self, code_name: Text) -> Regiment:
    flight_prefix = self._get_flight_prefix_for_existing_regiment(code_name)
    if not flight_prefix:
      raise ValueError(f"Regiment with code name '{code_name}' not found")

    air_force = AirForces.get_by_flight_prefix(flight_prefix)

    return Regiment(
      air_force=air_force,
      code_name=code_name,
      info_loader=self._info_loader,
    )

  def _get_flight_prefix_for_existing_regiment(self, code_name: Text) -> Optional[Text]:
    with self._data_file_path.open(
      mode="rt",
      encoding=self._data_file_encoding,
      buffering=1,
    ) as f:

      flight_prefix = None

      for line in f:
        line = line.strip()
        if not line:
          continue

        if line in FLIGHT_PREFIXES:
          flight_prefix = line

        elif line == code_name:
          return flight_prefix

  def filter_by_air_force(self, air_force: AirForce) -> List[Regiment]:
    result = []

    with self._data_file_path.open(
      mode="rt",
      encoding=self._data_file_encoding,
      buffering=1,
    ) as f:

      default_flight_prefix = air_force.default_flight_prefix
      air_force_is_found = False

      for line in f:
        line = line.strip()

        if not line:
          continue

        if line == default_flight_prefix:
          air_force_is_found = True

        elif air_force_is_found:
          if (
             line in FLIGHT_PREFIXES or
            (line.startswith('[') and line.endswith(']'))
          ):
            # Next section was found. Fullstop.
            break

          regiment = self._cache.get(line)
          if not regiment:
            regiment = Regiment(
              air_force=air_force,
              code_name=line,
              info_loader=self._info_loader,
            )
            self._cache[line] = regiment

          result.append(regiment)

    return result


1			from pathlib import Path
2
3			from typing import Any
4			from typing import Callable
5			from typing import Dict
6			from typing import List
7			from typing import Optional
8			from typing import Text
9
10			from verboselib import get_language
11
12			from il2fb.commons import SupportedLanguages
13			from il2fb.commons.organization import AirForce
14			from il2fb.commons.organization import AirForces
15
16
17			__here__ = Path(__file__).absolute().parent
18			__all__ = []
19
20
21			DEFAULT_LANGUAGE_NAME = SupportedLanguages.get_default().name
22
23			DEFAULT_DATA_DIR_PATH = __here__ / "data"
24			DEFAULT_DATA_MISSING_VALUE = None
25			DEFAULT_DATA_FILE_ENCODING = "cp1251"
26			DEFAULT_VALUE_ENCODING = "unicode-escape"
27
28			DEFAULT_CATALOG_FILE_NAME = "regiments.ini"
29
30			DEFAULT_NAMES_FILE_NAME_FORMAT = "regShort_{language}.properties"
31			DEFAULT_DESCRIPTIONS_FILE_NAME_FORMAT = "regInfo_{language}.properties"
32
33			FLIGHT_PREFIXES = set(AirForces.get_flight_prefixes())
34
35
36			def export(target: Any) -> Any:
37			__all__.append(target.__name__)
38			return target
39
40
41			@export
42			class RegimentInfoLoader:
43
44			def __init__(
45			self,
46			data_dir_path: Path=DEFAULT_DATA_DIR_PATH,
47			data_file_encoding: Text=DEFAULT_DATA_FILE_ENCODING,
48			data_value_encoding: Text=DEFAULT_VALUE_ENCODING,
49			data_missing_value: Text=DEFAULT_DATA_MISSING_VALUE,
50			names_file_name_format: Text=DEFAULT_NAMES_FILE_NAME_FORMAT,
51			descriptions_file_name_format: Text=DEFAULT_DESCRIPTIONS_FILE_NAME_FORMAT,
52			):
53			self._data_dir_path = data_dir_path
54			self._data_file_encoding = data_file_encoding
55			self._data_value_encoding = data_value_encoding
56			self._data_missing_value = data_missing_value
57			self._names_file_name_format = names_file_name_format
58			self._descriptions_file_name_format = descriptions_file_name_format
59
60			def get_name(self, code_name: Text, language: Any) -> Text:
61			file_name = self._names_file_name_format.format(language=language)
62			return self._get_value(code_name, file_name)
63
64			def get_description(self, code_name: Text, language: Any) -> Text:
65			file_name = self._descriptions_file_name_format.format(language=language)
66			return self._get_value(code_name, file_name)
67
68			def _get_value(self, code_name: Text, file_name: Text) -> Text:
69			file_path = self._data_dir_path / file_name
70			try:
71			return self._load_value_or_raise(code_name, file_path)
72			except ValueError:
73			return self._data_missing_value
74
75			def _load_value_or_raise(self, code_name: Text, file_path: Path) -> Text:
76			if not file_path.exists():
77			raise ValueError
78
79			with file_path.open(mode="rb") as f:
80			code_name = code_name.encode(self._data_file_encoding)
81			for line in f:
82			if line.startswith(code_name):
83			key, value = line.split(maxsplit=1)
84			return value.decode(self._data_value_encoding).strip()
85			else:
86			raise ValueError
87
88
89			@export
90			class Regiment:
91
92			def __init__(
93			self,
94			air_force: AirForce,
95			code_name: Text,
96			info_loader: Optional[RegimentInfoLoader]=None,
97			):
98			self.air_force = air_force
99			self.code_name = code_name
100
101			self._info_loader = info_loader or RegimentInfoLoader()
102			self._text_attribute_loaders = {
103			'verbose_name': self._info_loader.get_name,
104			'help_text': self._info_loader.get_description,
105			}
106
107			def __getattr__(self, name: Text) -> Text:
108			loader = self._text_attribute_loaders.get(name)
109			if not loader:
110			raise AttributeError(
111			f"'{self.__class__}' object has no attribute '{name}'"
112			)
113
114			language = get_language()
115			if language not in SupportedLanguages:
116			language = DEFAULT_LANGUAGE_NAME
117
118			full_name = f"{name}_{language}"
119
120			value = getattr(self, full_name, None)
121
122			if not value:
123			value = self._load_value(loader, language)
124			setattr(self, full_name, value)
125
126			return value
127
128			def _load_value(
129			self,
130			loader: Callable[[Text, Any], Text],
131			language: Any,
132			) -> Text:
133
134			value = loader(code_name=self.code_name, language=language)
135
136			if not value and language != DEFAULT_LANGUAGE_NAME:
137			value = loader(code_name=self.code_name, language=DEFAULT_LANGUAGE_NAME)
138
139			return value
140
141			def to_primitive(self, context: Any=None) -> Dict[Text, Any]:
142			return {
143			'air_force': self.air_force.to_primitive(context),
144			'code_name': self.code_name,
145			'verbose_name': self.verbose_name,
146			'help_text': self.help_text,
147			}
148
149			def __repr__(self) -> Text:
150			return f"<{self.__class__.__name__} '{self.code_name}'>"
151
152
153			@export
154			class Regiments:
155
156			def __init__(
157			self,
158			data_dir_path: Path=DEFAULT_DATA_DIR_PATH,
159			data_file_name: Text=DEFAULT_CATALOG_FILE_NAME,
160			data_file_encoding: Text=DEFAULT_DATA_FILE_ENCODING,
161			info_loader: RegimentInfoLoader=None,
162			):
163			self._data_file_path = data_dir_path / data_file_name
164			if not self._data_file_path.exists():
165			raise ValueError(
166			f"Data file '{str(self._data_file_path)}' does not exist"
167			)
168
169			self._data_file_encoding = data_file_encoding
170
171			self._info_loader = info_loader or RegimentInfoLoader(
172			data_dir_path=data_dir_path,
173			data_file_encoding=data_file_encoding,
174			)
175
176			self._cache = dict()
177
178			def get_by_code_name(self, code_name: Text) -> Regiment:
179			regiment = self._cache.get(code_name)
180
181			if not regiment:
182			regiment = self._load_by_code_name_or_raise(code_name)
183			self._cache[code_name] = regiment
184
185			return regiment
186
187			def _load_by_code_name_or_raise(self, code_name: Text) -> Regiment:
188			flight_prefix = self._get_flight_prefix_for_existing_regiment(code_name)
189			if not flight_prefix:
190			raise ValueError(f"Regiment with code name '{code_name}' not found")
191
192			air_force = AirForces.get_by_flight_prefix(flight_prefix)
193
194			return Regiment(
195			air_force=air_force,
196			code_name=code_name,
197			info_loader=self._info_loader,
198			)
199
200			def _get_flight_prefix_for_existing_regiment(self, code_name: Text) -> Optional[Text]:
201			with self._data_file_path.open(
202			mode="rt",
203			encoding=self._data_file_encoding,
204			buffering=1,
205			) as f:
206
207			flight_prefix = None
208
209			for line in f:
210			line = line.strip()
211			if not line:
212			continue
213
214			if line in FLIGHT_PREFIXES:
215			flight_prefix = line
216
217			elif line == code_name:
218			return flight_prefix
219
220			def filter_by_air_force(self, air_force: AirForce) -> List[Regiment]:
221			result = []
222
223			with self._data_file_path.open(
224			mode="rt",
225			encoding=self._data_file_encoding,
226			buffering=1,
227			) as f:
228
229			default_flight_prefix = air_force.default_flight_prefix
230			air_force_is_found = False
231
232			for line in f:
233			line = line.strip()
234
235			if not line:
236			continue
237
238			if line == default_flight_prefix:
239			air_force_is_found = True
240
241			elif air_force_is_found:
242			if (
243			line in FLIGHT_PREFIXES or
244			(line.startswith('[') and line.endswith(']'))
245			):
246			# Next section was found. Fullstop.
247			break
248
249			regiment = self._cache.get(line)
250			if not regiment:
251			regiment = Regiment(
252			air_force=air_force,
253			code_name=line,
254			info_loader=self._info_loader,
255			)
256			self._cache[line] = regiment
257
258			result.append(regiment)
259
260			return result
261

IL2HorusTeam / il2fb-regiments

Push — master ( f4c0a2...4a0808 )

regiments.core.Regiment.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

regiments.core.Regiment.init() A