Skip to content

配置

lazyllm.Config

Bases: object

Config是LazyLLM提供的配置类，可以支持通过加载配置文件、设置环境变量、编码写入默认值等方式设置LazyLLM框架的相关配置，以及导出当前所有的配置项和对应的值。 Config模块自动生成一个config对象，其中包含所有的配置。

Parameters:

  • prefix (str, default: 'LAZYLLM' ) –

    环境变量前缀。默认为 'LAZYLLM'

  • home (str, default: join(expanduser('~'), '.lazyllm') ) –

    配置文件目录路径。默认为 '~/.lazyllm'

Source code in lazyllm/configs.py 
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
class Config(object):
    """Config是LazyLLM提供的配置类，可以支持通过加载配置文件、设置环境变量、编码写入默认值等方式设置LazyLLM框架的相关配置，以及导出当前所有的配置项和对应的值。
Config模块自动生成一个config对象，其中包含所有的配置。

Args:
    prefix (str, optional): 环境变量前缀。默认为 'LAZYLLM'
    home (str, optional): 配置文件目录路径。默认为 '~/.lazyllm'
"""
    def __init__(self, prefix='LAZYLLM', home=os.path.join(os.path.expanduser('~'), '.lazyllm')):  # noqa B008
        self._config_params = dict()
        self._env_map_name = dict()
        self.prefix = prefix
        self.impl, self.cfgs = dict(), dict()
        self.add('home', str, os.path.expanduser(home), 'HOME')
        os.makedirs(home, exist_ok=True)
        self.cgf_path = os.path.join(self['home'], 'config.json')
        if os.path.exists(self.cgf_path):
            with open(self.cgf_path, 'r+') as f:
                self.cfgs = Config.get_config(json.loads(f))

    def done(self):
        """用于检查config.json配置文件中是否还有没有通过add方法载入的配置项
"""
        assert len(self.cfgs) == 0, f'Invalid cfgs ({"".join(self.cfgs.keys())}) are given in {self.cgf_path}'
        return self

    def getenv(self, name, type, default=None):
        """用于检查config.json配置文件中是否还有没有通过add方法载入的配置项
Config.getenv(name, type, default): -> str

获取LazyLLM相关环境变量的值

Args:
    name (str): 不包含前缀的环境变量名字，不区分大小写。函数将从拼接了前缀和此名字的全大写的环境变量中获取对应的值。
    type (type): 指定该配置的类型，例如str。对于bool型，函数会将'TRUE', 'True', 1, 'ON', '1'这5种输入转换为True。
    default (可选): 若无法获取到环境变量的值，将返回此变量。
"""
        r = os.getenv(f'{self.prefix}_{name.upper()}', default)
        if type == bool:
            return r in (True, 'TRUE', 'True', 1, 'ON', '1')
        return type(r)

    @staticmethod
    def get_config(cfg):
        """\ 
静态方法：从配置字典中获取配置。
这是一个简单的配置获取方法，主要用于从已加载的配置字典中提取配置信息。

Args:
    cfg (dict): 从配置文件中读取的配置字典。
"""
        return cfg

    def get_all_configs(self):
        """获取config中所有的配置


Examples:
    >>> import lazyllm
    >>> from lazyllm.configs import config
    >>> config['launcher']
    'empty'
    >>> config.get_all_configs()
    {'home': '~/.lazyllm/', 'mode': <Mode.Normal: (1,)>, 'repr_ml': False, 'rag_store': 'None', 'redis_url': 'None', ...}
    """
        return self.impl

    @contextmanager
    def temp(self, name, value):
        """
临时修改配置项的上下文管理器。

在with语句块内临时修改指定配置项的值，退出语句块后自动恢复原值。

Args:
    name (str): 要临时修改的配置项名称。
    value (Any): 临时设置的值。
"""
        old_value = self[name]
        self.impl[name] = value
        yield
        self.impl[name] = old_value

    def add(self, name: str, type: type, default: Optional[Union[int, str, bool]] = None, env: Union[str, dict] = None,
            *, options: Optional[List] = None):
        """将值加载至LazyLLM的配置项中。函数首先尝试从加载自config.json的字典中查找名字为name的值。若找到则从该字典中删去名为name的键。并将对应的值写入config。
若env是一个字符串，函数会调用getenv寻找env对应的LazyLLM环境变量，若找到则写入config。如果env为一个字典，函数将尝试调用getenv寻找字典中的key对于的环境变量并转换为bool型。
若转换完成的bool值是True，则将字典中当前的key对应的值写入config。

Args:
    name (str): 配置项名称
    type (type): 该配置的类型
    default (可选): 若无法获取到任何值，该配置的默认值
    env (可选): 不包含前缀的环境变量名称，或者一个字典，其中的key是不包含前缀的环境变量名称，value是要加入配置的值。
"""
        update_params = (type, default, env)
        if name not in self._config_params or self._config_params[name] != update_params:
            if name in self._config_params:
                logging.warning(f'The default configuration parameter {name}({self._config_params[name]}) '
                                f'has been added, but a new {name}({update_params}) has been added repeatedly.')
            self._config_params.update({name: update_params})
            if isinstance(env, str):
                self._env_map_name[('lazyllm_' + env).upper()] = name
            elif isinstance(env, dict):
                for k in env.keys():
                    self._env_map_name[('lazyllm_' + k).upper()] = name
        self._update_impl(name, type, default, env)
        return self

    def _update_impl(self, name: str, type: type, default: Optional[Union[int, str, bool]] = None,
                     env: Union[str, dict] = None):
        self.impl[name] = self.cfgs.pop(name) if name in self.cfgs else default
        if isinstance(env, dict):
            for k, v in env.items():
                if self.getenv(k, bool):
                    self.impl[name] = v
                    break
        elif env:
            self.impl[name] = self.getenv(env, type, self.impl[name])
        if not isinstance(self.impl[name], type): raise TypeError(
            f'Invalid config type for {name}, type is {type}')

    def __getitem__(self, name):
        try:
            if isinstance(name, bytes): name = name.decode('utf-8')
            return self.impl[name]
        except KeyError:
            raise RuntimeError(f'Key `{name}` is not in lazyllm global config')

    def __str__(self):
        return str(self.impl)

    def refresh(self, targets: Union[bytes, str, List[str]] = None) -> None:
        """
根据环境变量的最新值刷新配置项。如果传入 targets 为字符串，则按单个配置项更新；如果为列表，则批量更新；如果为 None，则扫描所有已映射到环境变量的配置项并更新。

Args:
    targets (str | list[str] | None): 要刷新的配置项名称或列表，传 None 表示刷新所有可从环境变量读取的项。
"""
        names = targets
        if isinstance(targets, bytes): targets = targets.decode('utf-8')
        if isinstance(targets, str):
            names = targets.lower()
            if names.startswith('lazyllm_'):
                names = names[8:]
            names = [names]
        elif targets is None:
            curr_envs = [key for key in os.environ.keys() if key.startswith('LAZYLLM_')]
            names = list(set([self._env_map_name[key] for key in curr_envs if key in self._env_map_name]))
        assert isinstance(names, list)
        for name in names:
            if name in self.impl: self._update_impl(name, *self._config_params[name])

done()

用于检查config.json配置文件中是否还有没有通过add方法载入的配置项

Source code in lazyllm/configs.py 
36
37
38
39
40
    def done(self):
        """用于检查config.json配置文件中是否还有没有通过add方法载入的配置项
"""
        assert len(self.cfgs) == 0, f'Invalid cfgs ({"".join(self.cfgs.keys())}) are given in {self.cgf_path}'
        return self

getenv(name, type, default=None)

用于检查config.json配置文件中是否还有没有通过add方法载入的配置项 Config.getenv(name, type, default): -> str

获取LazyLLM相关环境变量的值

Parameters:

  • name (str) –

    不包含前缀的环境变量名字，不区分大小写。函数将从拼接了前缀和此名字的全大写的环境变量中获取对应的值。

  • type (type) –

    指定该配置的类型，例如str。对于bool型，函数会将'TRUE', 'True', 1, 'ON', '1'这5种输入转换为True。

  • default (可选, default: None ) –

    若无法获取到环境变量的值，将返回此变量。

Source code in lazyllm/configs.py 
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
    def getenv(self, name, type, default=None):
        """用于检查config.json配置文件中是否还有没有通过add方法载入的配置项
Config.getenv(name, type, default): -> str

获取LazyLLM相关环境变量的值

Args:
    name (str): 不包含前缀的环境变量名字，不区分大小写。函数将从拼接了前缀和此名字的全大写的环境变量中获取对应的值。
    type (type): 指定该配置的类型，例如str。对于bool型，函数会将'TRUE', 'True', 1, 'ON', '1'这5种输入转换为True。
    default (可选): 若无法获取到环境变量的值，将返回此变量。
"""
        r = os.getenv(f'{self.prefix}_{name.upper()}', default)
        if type == bool:
            return r in (True, 'TRUE', 'True', 1, 'ON', '1')
        return type(r)

add(name, type, default=None, env=None, *, options=None)

将值加载至LazyLLM的配置项中。函数首先尝试从加载自config.json的字典中查找名字为name的值。若找到则从该字典中删去名为name的键。并将对应的值写入config。 若env是一个字符串，函数会调用getenv寻找env对应的LazyLLM环境变量，若找到则写入config。如果env为一个字典，函数将尝试调用getenv寻找字典中的key对于的环境变量并转换为bool型。 若转换完成的bool值是True，则将字典中当前的key对应的值写入config。

Parameters:

  • name (str) –

    配置项名称

  • type (type) –

    该配置的类型

  • default (可选, default: None ) –

    若无法获取到任何值，该配置的默认值

  • env (可选, default: None ) –

    不包含前缀的环境变量名称，或者一个字典，其中的key是不包含前缀的环境变量名称，value是要加入配置的值。

Source code in lazyllm/configs.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
    def add(self, name: str, type: type, default: Optional[Union[int, str, bool]] = None, env: Union[str, dict] = None,
            *, options: Optional[List] = None):
        """将值加载至LazyLLM的配置项中。函数首先尝试从加载自config.json的字典中查找名字为name的值。若找到则从该字典中删去名为name的键。并将对应的值写入config。
若env是一个字符串，函数会调用getenv寻找env对应的LazyLLM环境变量，若找到则写入config。如果env为一个字典，函数将尝试调用getenv寻找字典中的key对于的环境变量并转换为bool型。
若转换完成的bool值是True，则将字典中当前的key对应的值写入config。

Args:
    name (str): 配置项名称
    type (type): 该配置的类型
    default (可选): 若无法获取到任何值，该配置的默认值
    env (可选): 不包含前缀的环境变量名称，或者一个字典，其中的key是不包含前缀的环境变量名称，value是要加入配置的值。
"""
        update_params = (type, default, env)
        if name not in self._config_params or self._config_params[name] != update_params:
            if name in self._config_params:
                logging.warning(f'The default configuration parameter {name}({self._config_params[name]}) '
                                f'has been added, but a new {name}({update_params}) has been added repeatedly.')
            self._config_params.update({name: update_params})
            if isinstance(env, str):
                self._env_map_name[('lazyllm_' + env).upper()] = name
            elif isinstance(env, dict):
                for k in env.keys():
                    self._env_map_name[('lazyllm_' + k).upper()] = name
        self._update_impl(name, type, default, env)
        return self

get_all_configs()

获取config中所有的配置

Examples:

>>> import lazyllm
>>> from lazyllm.configs import config
>>> config['launcher']
'empty'
>>> config.get_all_configs()
{'home': '~/.lazyllm/', 'mode': <Mode.Normal: (1,)>, 'repr_ml': False, 'rag_store': 'None', 'redis_url': 'None', ...}
Source code in lazyllm/configs.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
    def get_all_configs(self):
        """获取config中所有的配置


Examples:
    >>> import lazyllm
    >>> from lazyllm.configs import config
    >>> config['launcher']
    'empty'
    >>> config.get_all_configs()
    {'home': '~/.lazyllm/', 'mode': <Mode.Normal: (1,)>, 'repr_ml': False, 'rag_store': 'None', 'redis_url': 'None', ...}
    """
        return self.impl

get_config(cfg) staticmethod

\ 静态方法：从配置字典中获取配置。 这是一个简单的配置获取方法，主要用于从已加载的配置字典中提取配置信息。

Parameters:

  • cfg (dict) –

    从配置文件中读取的配置字典。

Source code in lazyllm/configs.py 
58
59
60
61
62
63
64
65
66
67
    @staticmethod
    def get_config(cfg):
        """\ 
静态方法：从配置字典中获取配置。
这是一个简单的配置获取方法，主要用于从已加载的配置字典中提取配置信息。

Args:
    cfg (dict): 从配置文件中读取的配置字典。
"""
        return cfg

temp(name, value)

临时修改配置项的上下文管理器。

在with语句块内临时修改指定配置项的值，退出语句块后自动恢复原值。

Parameters:

  • name (str) –

    要临时修改的配置项名称。

  • value (Any) –

    临时设置的值。

Source code in lazyllm/configs.py 
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
    @contextmanager
    def temp(self, name, value):
        """
临时修改配置项的上下文管理器。

在with语句块内临时修改指定配置项的值，退出语句块后自动恢复原值。

Args:
    name (str): 要临时修改的配置项名称。
    value (Any): 临时设置的值。
"""
        old_value = self[name]
        self.impl[name] = value
        yield
        self.impl[name] = old_value

refresh(targets=None)

根据环境变量的最新值刷新配置项。如果传入 targets 为字符串，则按单个配置项更新；如果为列表，则批量更新；如果为 None，则扫描所有已映射到环境变量的配置项并更新。

Parameters:

  • targets (str | list[str] | None, default: None ) –

    要刷新的配置项名称或列表，传 None 表示刷新所有可从环境变量读取的项。

Source code in lazyllm/configs.py 
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
    def refresh(self, targets: Union[bytes, str, List[str]] = None) -> None:
        """
根据环境变量的最新值刷新配置项。如果传入 targets 为字符串，则按单个配置项更新；如果为列表，则批量更新；如果为 None，则扫描所有已映射到环境变量的配置项并更新。

Args:
    targets (str | list[str] | None): 要刷新的配置项名称或列表，传 None 表示刷新所有可从环境变量读取的项。
"""
        names = targets
        if isinstance(targets, bytes): targets = targets.decode('utf-8')
        if isinstance(targets, str):
            names = targets.lower()
            if names.startswith('lazyllm_'):
                names = names[8:]
            names = [names]
        elif targets is None:
            curr_envs = [key for key in os.environ.keys() if key.startswith('LAZYLLM_')]
            names = list(set([self._env_map_name[key] for key in curr_envs if key in self._env_map_name]))
        assert isinstance(names, list)
        for name in names:
            if name in self.impl: self._update_impl(name, *self._config_params[name])