NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

basePropertyHandler.py (4751B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\localization\propertyHandlers\basePropertyHandler.py
      2 from __future__ import print_function
      3 from future.utils import raise_
      4 import re
      5 from localization import const as locconst
      6 from localization.logger import LogError
      7 from localization.uiutil import PrepareLocalizationSafeString
      8 methodNameRE = re.compile('[A-Z][^A-Z]*|[^A-Z]+')
      9 
     10 class Singleton(object):
     11     _instance = None
     12 
     13     def __new__(cls, *args, **kwargs):
     14         if not cls._instance:
     15             cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
     16         return cls._instance
     17 
     18 
     19 class BasePropertyHandler(Singleton):
     20     PROPERTIES = {}
     21 
     22     def __init__(self):
     23         self._SetUpProperties()
     24 
     25     def GetProperty(self, propertyName, identifierID, languageID, *args, **kwargs):
     26         if propertyName is None:
     27             method = self._GetDefault
     28             isUniversal = True
     29         else:
     30             isUniversal = False
     31             method = self._propertyMethods.get((languageID, propertyName), None)
     32             if method is None:
     33                 method = self._propertyMethods.get((locconst.CODE_UNIVERSAL, propertyName), None)
     34                 isUniversal = True
     35         if method is None:
     36             expectedUniversalMethodName = self._GeneratePropertyMethodName(propertyName, locconst.CODE_UNIVERSAL)
     37             expectedLangaugeSpecificMethodName = self._GeneratePropertyMethodName(propertyName, languageID)
     38             message = ''.join(("No method defined on '",
     39              str(self.__class__),
     40              "' to handle property '",
     41              propertyName,
     42              "'.  Tried methods'",
     43              expectedUniversalMethodName,
     44              "' and '",
     45              expectedLangaugeSpecificMethodName,
     46              "'."))
     47             raise AttributeError(message)
     48         try:
     49             if isUniversal:
     50                 return method(identifierID, languageID, *args, **kwargs)
     51             return method(identifierID, *args, **kwargs)
     52         except TypeError:
     53             print('---- TYPE ERROR ----')
     54             print(method)
     55             print(propertyName, identifierID, languageID)
     56             print(args)
     57             print(kwargs)
     58 
     59     def _PrepareLocalizationSafeString(self, textString, messageID = None):
     60         return PrepareLocalizationSafeString(textString, messageID=messageID)
     61 
     62     def _SetUpProperties(self):
     63         self._propertyMethods = {}
     64         for languageID in self.PROPERTIES:
     65             propertyNames = self.PROPERTIES[languageID]
     66             for propertyName in propertyNames:
     67                 methodName = self._GeneratePropertyMethodName(propertyName, languageID)
     68                 isUniversal = True if languageID == locconst.CODE_UNIVERSAL else False
     69                 if not hasattr(self, methodName):
     70                     if isUniversal:
     71                         LogError("Class '", self.__class__.__name__, "' must implement the function '", methodName, "' to use the property '", propertyName, "'.")
     72                         setattr(self, methodName, BasePropertyHandler._NotImplementedUniversalPropertyFactory(methodName))
     73                     else:
     74                         LogError("Class '", self.__class__.__name__, "' must implement the function '", methodName, "' to use the property '", propertyName, "' in language '", languageID, "'.")
     75                         setattr(self, methodName, BasePropertyHandler._NotImplementedPropertyFactory(methodName))
     76                 method = getattr(self, methodName)
     77                 self._propertyMethods[languageID, propertyName] = method
     78 
     79     @staticmethod
     80     def _NotImplementedUniversalPropertyFactory(methodName):
     81         return lambda identifierID, languageID, *args, **kwargs: BasePropertyHandler._NotImplementedProperty(methodName)
     82 
     83     @staticmethod
     84     def _NotImplementedPropertyFactory(methodName):
     85         return lambda identifierID, *args, **kwargs: BasePropertyHandler._NotImplementedProperty(methodName)
     86 
     87     @staticmethod
     88     def _NotImplementedProperty(methodName):
     89         raise_(NotImplementedError, 'The property method (%s) is missing an implementation.' % methodName)
     90 
     91     def _GeneratePropertyMethodName(self, propertyName, languageID):
     92         methodName = '_Get' + ''.join([ part.title() for part in methodNameRE.findall(propertyName) ])
     93         if languageID != locconst.CODE_UNIVERSAL:
     94             methodName = methodName + languageID.replace('-', '_').upper()
     95         return methodName
     96 
     97     def _GetDefault(self, value, languageID, *args, **kwargs):
     98         return value
     99 
    100     def Linkify(self, value, linkText):
    101         raise NotImplementedError('This variable type cannot be converted into a link until a Linkify function is defined in its property handler.')