with context.temp_override(area=context.area) doesn't restore original area or region after with scope. #110632

New Issue

chaos · 2023-07-30T16:58:39+02:00

chaos commented

2023-07-30 16:58:39 +02:00

System Information
Operating system: Linux-5.4.0-149-generic-x86_64-with-glibc2.31 64 Bits, X11 UI
Graphics card: NVIDIA GeForce RTX 3080 Ti/PCIe/SSE2 NVIDIA Corporation 4.5.0 NVIDIA 525.116.04

Blender Version
Broken: version: 3.6.0, branch: blender-v3.6-release, commit date: 2023-06-27 08:08, hash: c7fc78b81ecb

Short description of error
The context-manager from context.temp_override doesn't restore the original area or region objects when those are the current ones in context. As result, the original context is invalidated. This doesn't happen for all kinds of data matching the original context, for example, the current window is correctly restored, and other data such as screen, space_data or active_object seems to be unaffected by this.

Exact steps for others to reproduce the error
Here's a code snippet to try this out.
Run this in the Text editor and then call the operator from the 3D View with F3 > test.test

import bpy

class TEST_OT_test(bpy.types.Operator):
    bl_idname = 'test.test'
    bl_label = 'Test'

    def invoke(self, context, event):
        print("Area before:", context.area)
        with context.temp_override(area=context.area):
            pass
        print("Area after:", context.area)
        return {'FINISHED'}

bpy.utils.register_class(TEST_OT_test)

When calling the operator, we get

Area before: <bpy_struct, Area at 0x7ff4def1b488>
Area after: None

if the script was written in this way:

        print("Area before:", context.area)
        context.temp_override(area=context.area)
        print("Area after:", context.area)

Then the output is expected:

Area before: <bpy_struct, Area at 0x7f0186d24448>
Area after: <bpy_struct, Area at 0x7f0186d24448>

The area gets invalidated, so from now on all script attempts to use context.area in the same invoke scope will fail.
As you can see, we are overriding the original context with its own data, which is the only exception to use temp_override. If we pass data which is different than the current context, everything's restored properly.

temp_override should restore or just plain ignore the overridden element when it matches the current one in context. This allows to programatically pass overrides without having to worry or check if the overridden data is part of the current context. This way, things like if area_override == context.area: # avoid calling temp_override can be safely ignored.

context.window works ok, while context.area and context.region don't.

**System Information** Operating system: Linux-5.4.0-149-generic-x86_64-with-glibc2.31 64 Bits, X11 UI Graphics card: NVIDIA GeForce RTX 3080 Ti/PCIe/SSE2 NVIDIA Corporation 4.5.0 NVIDIA 525.116.04 **Blender Version** Broken: version: 3.6.0, branch: blender-v3.6-release, commit date: 2023-06-27 08:08, hash: `c7fc78b81ecb` **Short description of error** The context-manager from `context.temp_override` doesn't restore the original `area` or `region` objects when those are the current ones in context. As result, the original context is invalidated. This doesn't happen for all kinds of data matching the original context, for example, the current `window` is correctly restored, and other data such as `screen`, `space_data` or `active_object` seems to be unaffected by this. **Exact steps for others to reproduce the error** Here's a code snippet to try this out. Run this in the Text editor and then call the operator from the 3D View with F3 > test.test ``` import bpy class TEST_OT_test(bpy.types.Operator): bl_idname = 'test.test' bl_label = 'Test' def invoke(self, context, event): print("Area before:", context.area) with context.temp_override(area=context.area): pass print("Area after:", context.area) return {'FINISHED'} bpy.utils.register_class(TEST_OT_test) ``` When calling the operator, we get ``` Area before: <bpy_struct, Area at 0x7ff4def1b488> Area after: None ``` if the script was written in this way: ``` print("Area before:", context.area) context.temp_override(area=context.area) print("Area after:", context.area) ``` Then the output is expected: ``` Area before: <bpy_struct, Area at 0x7f0186d24448> Area after: <bpy_struct, Area at 0x7f0186d24448> ``` The area gets invalidated, so from now on all script attempts to use `context.area` in the same invoke scope will fail. As you can see, we are overriding the original context with its own data, which is the only exception to use temp_override. If we pass data which is different than the current context, everything's restored properly. `temp_override` should restore or just plain ignore the overridden element when it matches the current one in context. This allows to programatically pass overrides without having to worry or check if the overridden data is part of the current context. This way, things like `if area_override == context.area: # avoid calling temp_override` can be safely ignored. `context.window` works ok, while `context.area` and `context.region` don't.

chaos added the

labels 2023-07-30 16:58:40 +02:00

YimingWu changed title from ~~context.temp_override doesn't restore 'area' or 'region' when provided with its own context~~ to `with context.temp_override(area=context.area) doesn't restore 'area' or 'region' after `with` scope.

2023-07-31 04:59:17 +02:00

YimingWu changed title from ~~`with context.temp_override(area=context.area) doesn't restore 'area' or 'region' after `with` scope.~~ to `with context.temp_override(area=context.area)` doesn't restore original `area` or `region` after `with` scope.

2023-07-31 04:59:37 +02:00

YimingWu commented

2023-07-31 05:02:33 +02:00

I don't know python that well to see if the with keyword is behaving as expected, but it feels like a bug to me.

I don't know python that well to see if the `with` keyword is behaving as expected, but it feels like a bug to me.

YimingWu added

and removed

labels 2023-07-31 05:02:58 +02:00

chaos commented

2023-07-31 12:36:04 +02:00

@ChengduLittleA Sorry if I sound rude, but in my opinion, if you weren't sure about what the with statement does, you shouldn't have edited the report that way.

print("Area before:", context.area)
context.temp_override(area=context.area)
print("Area after:", context.area)

This part of the code doesn't make sense, since this way you are not really making use of the context-manager.
temp_override returns the context-manager object containing the __enter__ and __exit__ methods which are automatically called by the with statement to open and close a certain context throughout the duration of the with scope.

This is certainly not a problem about the with statement, which is being used canonically here.
The problem relies on what the context-manager object does on __exit__
Here's an example showing the same symptom without having to use the with statement. We get the same problem as before.

print("Area before:", context.area)
context_manager = context.temp_override(area=context.area)
context_manager.__enter__()
# do something inside the temporary context 
context_manager.__exit__()
print("Area after:", context.area)

Area before: <bpy_struct, Area at 0x7f5ba786ec48>
Area after: None

@ChengduLittleA Sorry if I sound rude, but in my opinion, if you weren't sure about what the `with` statement does, you shouldn't have edited the report that way. ``` print("Area before:", context.area) context.temp_override(area=context.area) print("Area after:", context.area) ``` This part of the code doesn't make sense, since this way you are not really making use of the context-manager. `temp_override` returns the context-manager object containing the `__enter__` and `__exit__` methods which are automatically called by the `with` statement to open and close a certain context throughout the duration of the `with` scope. This is certainly not a problem about the `with` statement, which is being used canonically here. The problem relies on what the context-manager object does on `__exit__` Here's an example showing the same symptom without having to use the `with` statement. We get the same problem as before. ``` print("Area before:", context.area) context_manager = context.temp_override(area=context.area) context_manager.__enter__() # do something inside the temporary context context_manager.__exit__() print("Area after:", context.area) ``` ``` Area before: <bpy_struct, Area at 0x7f5ba786ec48> Area after: None ```

YimingWu commented

2023-07-31 12:57:56 +02:00

temp_override returns the context-manager object containing the enter and exit methods which are automatically called by the with statement to open and close a certain context throughout the duration of the with scope.

I see... Then the problem is now apparent, that __exit__() somehow did not run or failed to do the job. Thanks for clarifying!

> temp_override returns the context-manager object containing the __enter__ and __exit__ methods which are automatically called by the with statement to open and close a certain context throughout the duration of the with scope. I see... Then the problem is now apparent, that `__exit__()` somehow did not run or failed to do the job. Thanks for clarifying!

👍 1

Bastien Montagne referenced a pull request that will close this issue

2023-08-04 10:56:20 +02:00

Fix #110632: temp context doesn't always restore original area or region at exit. #110787

Campbell Barton referenced this issue from a commit

2023-08-09 08:53:25 +02:00

Fix #110632: context.temp_override(area=context.area) fails to restore

Campbell Barton closed this issue

2023-08-09 08:53:26 +02:00

Blender Bot added

Status

Resolved