Skip to content

SET

Set

Bases: Command

Set Shell Variables and update config.ini via configparser.

Parameters:

Name Type Description Default
config_path str

The path to the config. Defaults to the user's home directory or the current working directory.

 required

Examples:

set

# sets the variable in the section to the value.

Source code in src/textual_shell/commands/set.py 
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
class Set(Command):
    """
    Set Shell Variables and update config.ini via configparser.

    Args:
        config_path (str): The path to the config. Defaults to the user's 
            home directory or the current working directory.

    Examples:
        set <section> <setting> <value> # sets the variable in the section to the value.
    """

    DEFINITION = {
        'set': CommandNode(
            name='set',
            description='Set shell variables and update the config file.'
        ) 
    }

    def __init__(
        self,
        config_path: Annotated[str, "Path to the config"]
    ) -> None:
        super().__init__()
        self.config_path = config_path
        self.load_sections()

    def load_sections(self) -> None:
        """Load the settings from the config file 
        into the command definition."""
        root = self.get_root()
        data = configure.get_config(self.config_path)

        for key in data:
            node = CommandNode(
                name=key,
                description=data[key]['description']
            )
            root.children[key] = node

            for setting in data[key]:
                if setting == 'description':
                    continue

                node.children[setting] = CommandNode(
                    name=setting,
                    description=data[key][setting]['description'],
                    value=data[key][setting]['value'],
                    options=data[key][setting].get('options', None)
                )

    def create_job(self, *args) -> 'SetJob':
        """
        Create a job to handle the execution.

        Args:
            args (tuple[str]): Should contain the section, setting, and value.

        Returns:
            set_job (SetJob): The job to handle the execution.
        """
        if len(args) != 3:
            self.shell.notify(
                message='Invalid Arguments',
                title='Command: set',
                severity='error'
            )
            return

        return SetJob(
            *args,
            config=self.config_path,
            shell=self.shell,
            cmd=self.name
        )

create_job(*args)

Create a job to handle the execution.

Parameters:

Name Type Description Default
args tuple[str]

Should contain the section, setting, and value.

 ()

Returns:

Name Type Description
set_job SetJob

The job to handle the execution.
Source code in src/textual_shell/commands/set.py 
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
def create_job(self, *args) -> 'SetJob':
    """
    Create a job to handle the execution.

    Args:
        args (tuple[str]): Should contain the section, setting, and value.

    Returns:
        set_job (SetJob): The job to handle the execution.
    """
    if len(args) != 3:
        self.shell.notify(
            message='Invalid Arguments',
            title='Command: set',
            severity='error'
        )
        return

    return SetJob(
        *args,
        config=self.config_path,
        shell=self.shell,
        cmd=self.name
    )

load_sections()

Load the settings from the config file into the command definition.

Source code in src/textual_shell/commands/set.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
def load_sections(self) -> None:
    """Load the settings from the config file 
    into the command definition."""
    root = self.get_root()
    data = configure.get_config(self.config_path)

    for key in data:
        node = CommandNode(
            name=key,
            description=data[key]['description']
        )
        root.children[key] = node

        for setting in data[key]:
            if setting == 'description':
                continue

            node.children[setting] = CommandNode(
                name=setting,
                description=data[key][setting]['description'],
                value=data[key][setting]['value'],
                options=data[key][setting].get('options', None)
            )

SetJob

Bases: Job

Job for handling setting shell variables.

Parameters:

Name Type Description Default
section_name str

The name of the section.

 required
setting_name str

The name of the setting.

 required
value str

The value the setting was set to.

 required
config str

The path to the config.

 required
Source code in src/textual_shell/commands/set.py 
 11
 12
 13
 14
 15
 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
class SetJob(Job):
    """
    Job for handling setting shell variables.

    Args:
        section_name (str): The name of the section.
        setting_name (str): The name of the setting.
        value (str): The value the setting was set to.
        config (str): The path to the config.
    """

    class SettingsChanged(Message):
        """
        Event for when a setting has been changed.

        Args:
            section_name (str): The name of the section.
            setting_name (str): The name of the setting.
            value (str): The value the setting was set to.
        """

        def __init__(
            self,
            section_name: Annotated[str, 'The name of the section.'],
            setting_name: Annotated[str, 'The name of the setting that was changed.'],
            value: Annotated[str, 'The value the setting was set to.']
        ) -> None:
            super().__init__()
            self.section_name = section_name
            self.setting_name = setting_name
            self.value = value


    def __init__(
        self,
        section_name: Annotated[str, 'Section name'],
        setting_name: Annotated[str, 'Setting name'],
        value: Annotated[str, 'value for the setting'],
        config: Annotated[str, 'Path to the config.'],
        *args, **kwargs
    ) -> None:
        super().__init__(*args, **kwargs)
        self.config = config
        self.section = section_name
        self.setting = setting_name
        self.value = value

    async def execute(self) -> None:
        """
        Update the setting in the config.
        """
        self.running()
        try:
            options = configure.get_setting_options(
                self.section, self.setting, self.config
            )

        except configure.MissingSection as e:
            self.send_log(
                e,
                logging.ERROR
            )
            self.error()
            return

        except configure.MissingSetting as e:
            self.send_log(
                e,
                logging.ERROR
            )
            self.error()
            return

        if options is not None:

            if self.value is not None and self.value not in options:
                self.send_log(
                    f'Invalid value: {self.value} for {self.section}.{self.setting}',
                    logging.ERROR
                )
                return

        self.send_log(
            f'Updating setting: {self.section}.{self.setting}',
            logging.INFO
        )
        configure.update_setting(
            self.section,
            self.setting,
            self.config, 
            self.value
        )
        self.shell.post_message(
            self.SettingsChanged(
                self.section,
                self.setting,
                self.value
            )
        )
        self.completed()

SettingsChanged

Bases: Message

Event for when a setting has been changed.

Parameters:

Name Type Description Default
section_name str

The name of the section.

 required
setting_name str

The name of the setting.

 required
value str

The value the setting was set to.

 required
Source code in src/textual_shell/commands/set.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class SettingsChanged(Message):
    """
    Event for when a setting has been changed.

    Args:
        section_name (str): The name of the section.
        setting_name (str): The name of the setting.
        value (str): The value the setting was set to.
    """

    def __init__(
        self,
        section_name: Annotated[str, 'The name of the section.'],
        setting_name: Annotated[str, 'The name of the setting that was changed.'],
        value: Annotated[str, 'The value the setting was set to.']
    ) -> None:
        super().__init__()
        self.section_name = section_name
        self.setting_name = setting_name
        self.value = value

execute() async

Update the setting in the config.

Source code in src/textual_shell/commands/set.py 
 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
async def execute(self) -> None:
    """
    Update the setting in the config.
    """
    self.running()
    try:
        options = configure.get_setting_options(
            self.section, self.setting, self.config
        )

    except configure.MissingSection as e:
        self.send_log(
            e,
            logging.ERROR
        )
        self.error()
        return

    except configure.MissingSetting as e:
        self.send_log(
            e,
            logging.ERROR
        )
        self.error()
        return

    if options is not None:

        if self.value is not None and self.value not in options:
            self.send_log(
                f'Invalid value: {self.value} for {self.section}.{self.setting}',
                logging.ERROR
            )
            return

    self.send_log(
        f'Updating setting: {self.section}.{self.setting}',
        logging.INFO
    )
    configure.update_setting(
        self.section,
        self.setting,
        self.config, 
        self.value
    )
    self.shell.post_message(
        self.SettingsChanged(
            self.section,
            self.setting,
            self.value
        )
    )
    self.completed()