Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use _get_model_attrs method in pandera

Best Python code snippet using pandera_python

model_interfaces.py

Source:model_interfaces.py

...90        self._file_name = val91    @abstractmethod92    def loadmodel(self, path):93        pass94    def _get_model_attrs(self):95        model_attrs = []96        for attr in dir(self):97            if attr.startswith(self._MODEL_ATTR_PREFIX):98                model_attrs.append(attr)99        return model_attrs100    @abstractmethod101    def predict(self, input_):102        pass103def load_models(self, path, neural=True, model_attrs=None):104    dir_path = self.unzip_model(path)105    if model_attrs is None:106        model_attrs = self._get_model_attrs()107    if len(os.listdir(dir_path)) < len(model_attrs):108        raise Exception(f'Ð§Ð¸ÑÐ»Ð¾ Ð¼Ð¾Ð´ÐµÐ»ÐµÐ¹ < {len(model_attrs)}.')109    for model_attr in model_attrs:110        model_filename = model_attr[1:]111        if not neural:112            model_filename += '.pkl'113        full_path = os.path.join(dir_path, model_filename)114        print(full_path)115        if not os.path.exists(full_path):116            shutil.rmtree(dir_path)117            raise Exception(f'ÐÐ¾Ð´ÐµÐ»Ñ {model_filename} Ð¾ÑÑÑÑÑÑÐ²ÑÐµÑ Ð² ÑÐ°Ð¹Ð»Ðµ {self.filename}.')118        try:119            if neural:120                model_val = load_model(full_path)121            else:122                with open(full_path, 'rb') as file:123                    model_val = pickle.load(file)124            setattr(self, model_attr, model_val)125            print(getattr(self, model_attr))126        except Exception:127            print(traceback.format_exc())128            shutil.rmtree(dir_path)129            raise Exception(f'ÐÐµ ÑÐ´Ð°ÑÑÑÑ ÑÐ¾Ð·Ð´Ð°ÑÑ Ð¼Ð¾Ð´ÐµÐ»Ñ {model_filename}.')130    shutil.rmtree(dir_path)131def load_VA_and_FACS_model(self, path):132    dir_path = self.unzip_model(path)133    model_attrs = self._get_model_attrs()134    try:135        for model_attr in model_attrs:136            model_filename = model_attr[1:] + '.tar.gz'137            full_path = os.path.join(dir_path, model_filename)138            print(full_path)139            model_type_file = tools.get_model_type(model_filename, full_path)140            print(model_type_file)141            model_attr_val = getattr(sys.modules[__name__],142                                     type_model_interface_dict[model_type_file])(model_filename, full_path)143            setattr(self, model_attr, model_attr_val)144            print(model_attr, model_attr_val)145    except Exception:146        print(traceback.format_exc())147        shutil.rmtree(dir_path)148        raise149    shutil.rmtree(dir_path)150class ModelVAClearNeural(AbstractModel):151    @classmethod152    @property153    def type_(cls):154        return '2->7 (Neural)'155    def loadmodel(self, path):156        load_models(self, path)157    def predict(self, df_VA):158        seven_vals = self._model.predict(df_VA.values)159        df_seven = pd.DataFrame(seven_vals, columns=tools.seven_fields)160        df_seven = tools.change_df_accuracy(df_seven)161        return df_seven162class ModelVAClearStat(AbstractModel):163    _model_neutral = None164    _model_happy = None165    _model_sad = None166    _model_angry = None167    _model_surprised = None168    _model_scared = None169    _model_disgusted = None170    _MODEL_ATTR_PREFIX = '_model_'171    @classmethod172    @property173    def type_(cls):174        return '2->7 (Stat)'175    def loadmodel(self, path):176        load_models(self, path, neural=False)177    def predict(self, df_VA):178        model_attrs = self._get_model_attrs()179        seven_dict = {}180        for model_attr in model_attrs:181            field = model_attr[len(self._MODEL_ATTR_PREFIX):].capitalize()182            seven_dict[field] = getattr(self, model_attr).predict(df_VA.values)183        seven_vals = [[seven_dict[field][0][i] for i, field in enumerate(tools.seven_fields)]] # N Ð±ÐµÐ· [0][i] Ð´Ð»Ñ correct184        #seven_dict = {field: seven_dict[field][0][i] for i, field in enumerate(tools.seven_fields)} # Ð¿Ð¾ ÑÑÑÐ¸, Ð½Ðµ Ð½ÑÐ¶Ð½Ð¾ ÑÐ¶Ðµ185        df_seven = pd.DataFrame(seven_vals, columns=tools.seven_fields)186        df_seven = tools.change_df_accuracy(df_seven)187        return df_seven188class ModelClearVANeural(AbstractModel):189    @classmethod190    @property191    def type_(cls):192        return '7->2 (Neural)'...

base_model.py

Source:base_model.py

...21    def _is_pymodelio_model(cls) -> bool:22        return True23    @overrides_child_always24    def _set_attributes(self, kwargs: dict) -> None:25        for attr_name, model_attr in self._get_model_attrs().items():26            if not model_attr.initable:27                if attr_name in kwargs:28                    raise NameError(f'{attr_name} attribute is not initable for class {self.__class__.__name__}')29                continue30            exposed_attr_name = self._get_exposed_attr_name(attr_name)31            attr_value = kwargs.get(exposed_attr_name, model_attr.default_factory())32            if attr_value == UNDEFINED:33                attr_value = model_attr.default_factory()34            setattr(self, attr_name, attr_value)35    @classmethod36    @overrides_child_if_not_implemented37    def __before_init__(cls, *args, **kwargs) -> None:38        pass39    @classmethod40    @overrides_child_if_not_implemented41    def __before_validate__(cls) -> None:42        pass43    @classmethod44    @overrides_child_if_not_implemented45    def __once_validated__(cls) -> None:46        pass47    @overrides_child_always48    def _get_annotations(self) -> dict:49        annotations = self.__annotations__ if hasattr(self, '__annotations__') else {}50        for parent in self.__class__.__bases__:51            if hasattr(parent, '__annotations__'):52                annotations = {**annotations, **parent.__annotations__}53        return annotations54    @overrides_child_always55    def _get_model_attrs(self) -> dict:56        validated_attrs = {}57        annotations = self._get_annotations()58        for k, v in annotations.items():59            if isinstance(v, Attribute):60                validated_attrs[k] = v61            # If Validated is a type and not an instance, it instantiates it using default values default62            elif v.__origin__ == Attribute:63                validated_attrs[k] = v()64        return validated_attrs65    @overrides_child_always66    def _generate_private_attr_prefix(self, cls: type) -> str:67        return f'_{cls.__name__}__'68    @overrides_child_always69    def _get_parent_private_attr_prefixes(self) -> List[str]:70        # Iterate all the parents71        prefixes = []72        for cls in self.__class__.__bases__:73            prefixes.append(self._generate_private_attr_prefix(cls))74        return prefixes75    @overrides_child_always76    def _get_exposed_attr_name(self, attr_name: str) -> str:77        # Private attributes78        private_attr_prefixes = [self._generate_private_attr_prefix(79            self.__class__)] + self._get_parent_private_attr_prefixes()80        for private_attr_prefix in private_attr_prefixes:81            if attr_name.startswith(private_attr_prefix):82                exposed_attr_name = attr_name[len(private_attr_prefix):]83                if exposed_attr_name.endswith('__'):84                    exposed_attr_name = exposed_attr_name[:2]85                return exposed_attr_name86        # Protected attributes87        if attr_name.startswith('_'):88            exposed_attr_name = attr_name[1:]89            if exposed_attr_name.endswith('_'):90                exposed_attr_name = exposed_attr_name[:1]91            return exposed_attr_name92        # Public attributes93        return attr_name94    @overrides_child_always95    def validate(self, path: str = None) -> None:96        """97        It must raise ModelValidationException in case of an invalid attribute98        """99        for attr_name, pymodel_attribute in self._get_model_attrs().items():100            attr_value = getattr(self, attr_name)101            exposed_attr_name = self._get_exposed_attr_name(attr_name)102            parent_path = path or self.__class__.__name__103            attr_path = f'{parent_path}.{exposed_attr_name}'104            self._when_validating_attr(attr_name, exposed_attr_name, attr_value, attr_path, parent_path,105                                       pymodel_attribute)106            pymodel_attribute.validate(attr_value, path=attr_path)107    @overrides_child_if_not_implemented108    def _when_validating_attr(self, internal_attr_name: str, exposed_attr_name: str, attr_value: Any, attr_path: str,109                              parent_path: str, pymodel_attribute: Attribute) -> None:110        pass111    @overrides_child_if_not_implemented112    @classmethod113    def from_dict(cls, data: dict, auto_validate: bool = True) -> Any:114        instance = cls(from_dict=True)115        attrs = {}116        for attr_name, model_attr in instance._get_model_attrs().items():117            exposed_attr_name = instance._get_exposed_attr_name(attr_name)118            if model_attr.initable:119                attrs[exposed_attr_name] = cls._map_attribute(data, exposed_attr_name, model_attr)120        return cls(**attrs, auto_validate=auto_validate)121    @overrides_child_always122    @classmethod123    def _map_attribute(cls, data: dict, exposed_attr_name: str, model_attr: Attribute) -> Any:124        attr_value = data.get(exposed_attr_name, model_attr.default_factory())125        if attr_value == UNDEFINED:126            return model_attr.default_factory()127        if isinstance(attr_value, dict) and (128                hasattr(model_attr.attr_type, '_is_pymodelio_model') and model_attr.attr_type._is_pymodelio_model()129        ):130            return model_attr.attr_type.from_dict(attr_value, auto_validate=False)...

model_serializer.py

Source:model_serializer.py

...9        return value10    @classmethod11    def _serialize_model(cls, model: Any) -> dict:12        serialized = {}13        for attr_name in cls._get_model_attrs(model):14            attr_value = getattr(model, attr_name)15            # If it is a function, we ignore it16            if callable(attr_value):17                continue18            serialized[attr_name] = cls.serialize(attr_value)19        return serialized20    @classmethod21    def _get_model_attrs(cls, model: Any) -> dict:22        return [attr_name for attr_name in dir(model) if not attr_name.startswith('_')]23    @classmethod24    def _is_model(cls, attr_value: Any) -> bool:...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.