file_path
stringlengths
21
202
content
stringlengths
12
1.02M
size
int64
12
1.02M
lang
stringclasses
9 values
avg_line_length
float64
3.33
100
max_line_length
int64
10
993
alphanum_fraction
float64
0.27
0.93
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/combobox_menu_delegate.py
from typing import Optional from attr import has from omni import ui from omni.ui import constant as fl from ..model.combobox_model import ComboBoxModel from .abstract_widget_menu_delegate import AbstractWidgetMenuDelegate __all__ = ["ComboBoxMenuDelegate"] class ComboBoxMenuDelegate(AbstractWidgetMenuDelegate): """Generic menu delegate with combo box""" def __init__( self, model: Optional[ComboBoxModel] = None, height=0, width=300, enabled: bool = True, text: bool = True, icon_name: Optional[str] = None, icon_width: ui.Length = 30, icon_height: ui.Length = 30, tooltip: Optional[str] = None, use_in_menubar: bool = False, has_reset: bool = False, ): super().__init__( model=model, height=height, width=width, enabled=enabled, has_reset=has_reset, use_in_menubar=use_in_menubar ) self.__combo_width = 90 self.__text = text self.__icon_name = icon_name self.__icon_width = icon_width self.__icon_height = icon_height self.__tooltip = tooltip def __del__(self): if self._model: self._model.destroy() self.destroy() def destroy(self): # TODO: We don't have to destroy the model here. We should do it in the # object created the model. But since the model is not stored anywhere, # it's destroyed here. if self._model: self._model.destroy() self._model = None super().destroy() def build_widget(self, item: ui.MenuHelper): if self.__icon_name: ui.ImageWithProvider( style_type_name_override="Menu.Item.Icon", tooltip=self.__tooltip, name=self.__icon_name, width=self.__icon_width, height=self.__icon_height, ) if self.__text: ui.Label(item.text, style_type_name_override="Menu.Item.Label") with ui.VStack(width=self.__combo_width): ui.Spacer() ui.ComboBox(self._model, height=0) ui.Spacer()
2,166
Python
30.405797
120
0.575716
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_button_item.py
from pathlib import Path import omni.ui as ui from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.ui_test.query import MenuRef, WidgetRef, WindowStub import omni.kit.app from ..viewport_menu_model import ViewportMenuModel from .style import UI_STYLE from .example_button import ButtonExample CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class TestButtonItem(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._btn_menu_1 = ButtonExample(id=1, name="General", text="General") self._btn_menu_2 = ButtonExample(id=2, name="has_triangle", text="has_triangle", has_triangle=True) self._btn_menu_3 = ButtonExample(id=3, name="invisible", text="invisible") self._btn_menu_4 = ButtonExample(id=4, name="disabled", text="disabled") self._btn_menu_5 = ButtonExample(id=5, name="selected", text="selected") def _build_window(): window = ui.Window("Button Menu Window", width=200, height=200) with window.frame: ui.Label("This is a test") return window self._btn_menu_6 = ButtonExample(id=8, name="window left", text="window left", build_window_fn=_build_window, alignment=ui.Alignment.LEFT_BOTTOM) self._btn_menu_7 = ButtonExample(id=6, name="window", text="window", build_window_fn=_build_window) self._btn_menu_8 = ButtonExample(id=7, name="left alignment", text="left alignment", alignment=ui.Alignment.LEFT_BOTTOM) for _ in range(4): await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._btn_menu_3.visible = True self._btn_menu_1.destroy() self._btn_menu_1 = None self._btn_menu_2.destroy() self._btn_menu_2 = None self._btn_menu_3.destroy() self._btn_menu_3 = None self._btn_menu_4.destroy() self._btn_menu_4 = None self._btn_menu_5.destroy() self._btn_menu_5 = None self._btn_menu_6.destroy() self._btn_menu_6 = None self._btn_menu_7.destroy() self._btn_menu_7 = None self._btn_menu_8.destroy() self._btn_menu_8 = None await super().tearDown() async def test_item(self): self.assertEqual(self._btn_menu_1.name, "General") self.assertFalse(self._btn_menu_2.checked) self._btn_menu_2.checked = True self.assertTrue(self._btn_menu_3.visible) self._btn_menu_3.visible = False self.assertTrue(self._btn_menu_4.enabled) self._btn_menu_4.enabled = False self.assertFalse(self._btn_menu_5.selected) self._btn_menu_5.selected = True for _ in range(4): await omni.kit.app.get_app().next_update_async() widget_ref = WidgetRef(self._btn_menu_8._button, "", window=WindowStub()) self.assertFalse(self._btn_menu_8._clicked) await widget_ref.click() self.assertTrue(self._btn_menu_8._clicked) await widget_ref.click(right_click=True) self.assertIsNotNone(self._btn_menu_8.menu_item) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_button_item_left_alignment.png" ) widget_ref = WidgetRef(self._btn_menu_7._button, "", window=WindowStub()) await widget_ref.click(right_click=True) self.assertIsNotNone(self._btn_menu_7.window) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_button_item_window.png" ) widget_ref = WidgetRef(self._btn_menu_6._button, "", window=WindowStub()) await widget_ref.click(right_click=True) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_button_item_window_left_alignment.png" )
4,424
Python
39.972222
153
0.643761
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/abstract_test_container.py
__all__ = ["AbstractTestContainer"] import copy from typing import Dict import carb from omni.kit.viewport.menubar.core import ViewportMenuContainer, IconMenuDelegate import omni.ui as ui from ..style import VIEWPORT_MENUBAR_STYLE from .style import UI_STYLE class AbstractTestContainer(ViewportMenuContainer): def __init__(self): self._settings = carb.settings.get_settings() self._settings.set("/exts/omni.kit.viewport.menubar.delegate/visible", True) self._settings.set("/exts/omni.kit.viewport.menubar.delegate/order", -100) self._triggered = 0 self._right_clicked = 0 TEST_UI_STYLE = copy.copy(VIEWPORT_MENUBAR_STYLE) TEST_UI_STYLE.update(UI_STYLE) super().__init__( name="Icon", delegate=IconMenuDelegate("Sample", triggered_fn=self._on_trigger, right_clicked_fn=self._on_right_click), visible_setting_path="/exts/omni.kit.viewport.menubar.delegate/visible", order_setting_path="/exts/omni.kit.viewport.menubar.delegate/order", style=TEST_UI_STYLE ) self._settings = carb.settings.get_settings() def destroy(self): self._delegate.destroy() super().destroy() def _on_trigger(self) -> None: self._triggered += 1 def _on_right_click(self) -> None: self._right_clicked += 1 def build_fn(self, factory: Dict): self._root_menu = ui.Menu( self.name, delegate=self._delegate, on_build_fn=self._build_menu_items, style=self._style ) def _build_menu_items(self): pass
1,610
Python
30.588235
118
0.643478
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_viewport_menu_model.py
## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. ## ## NVIDIA CORPORATION and its licensors retain all intellectual property ## and proprietary rights in and to this software, related documentation ## and any modifications thereto. Any use, reproduction, disclosure or ## distribution of this software and related documentation without an express ## license agreement from NVIDIA CORPORATION is strictly prohibited. ## __all__ = ['TestViewportMenuModel'] from omni.kit.test import AsyncTestCase from omni.kit.viewport.menubar.core import ViewportMenuSpacer, ViewportMenubar from ..viewport_menu_model import ViewportMenuModel from .left_example_menu_container import LeftExampleMenuContainer from .right_example_menu_container import RightExampleMenuContainer from .example_button import ButtonExample class ViewportBottomBar(ViewportMenubar): def __init__(self): super().__init__("BOTTOM_BAR") def build_fn(self, menu_items, factory): pass class TestViewportMenuModel(AsyncTestCase): async def setUp(self): pass async def tearDown(self): pass def get_setting_path(self, setting): return f'/app/test/omni.kit.viewport.menubar.core/test_root/{setting}' async def test_model(self): model = ViewportMenuModel() self.assertEqual(model.get_item_value_model_count(None), 1) self._bottom_bar = ViewportBottomBar() self._left_menu = LeftExampleMenuContainer() self._right_menu = RightExampleMenuContainer() self._button_menu = ButtonExample() menubar_items = model.get_item_children(None) # One default menubar + bottom bar self.assertEqual(len(menubar_items), 2) self.assertEqual(menubar_items[1].name, self._bottom_bar.name) default_bar_item = menubar_items[0] bottom_bar_item = menubar_items[1] items = model.get_item_children(menubar_items[0]) # Actually there are 4 items (left+button+spacer+right) in default bat self.assertEqual(len(items), 4) self.assertEqual(items[0].name, self._left_menu.name) self.assertEqual(items[1].name, self._button_menu.name) self.assertTrue(isinstance(items[2], ViewportMenuSpacer)) self.assertEqual(items[3].name, self._right_menu.name) self.assertEqual(model.get_drag_mime_data(bottom_bar_item), self._bottom_bar.name) drop_accepted = model.drop_accepted(bottom_bar_item, default_bar_item) self.assertTrue(drop_accepted) drop_accepted = model.drop_accepted(None, default_bar_item) self.assertFalse(drop_accepted) # Drop default to behind bottom bar model.drop(bottom_bar_item, default_bar_item) menubar_items = model.get_item_children(None) self.assertEqual(menubar_items[0], bottom_bar_item) self.assertEqual(menubar_items[1], default_bar_item) # Drop default to in front of bottom bar model.drop(bottom_bar_item, default_bar_item) menubar_items = model.get_item_children(None) self.assertEqual(menubar_items[0], default_bar_item) self.assertEqual(menubar_items[1], bottom_bar_item)
3,198
Python
36.197674
90
0.698874
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/example_button.py
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["ButtonExample"] from omni.kit.viewport.menubar.core import ( ViewportMenuDelegate, ViewportButtonItem, ) from .style import UI_STYLE import copy from typing import Dict, List, Optional from functools import partial import carb import carb.settings import omni.ui as ui import omni.kit.app import omni.usd from ..style import VIEWPORT_MENUBAR_STYLE from .style import UI_STYLE class ButtonExample(ViewportButtonItem): """The button for screenshot""" def __init__(self, id: int = 0, **kwargs): self._settings = carb.settings.get_settings() setting_root = f"/exts/omni.kit.viewport.menubar.example/button/{id}" setting_visible = f"{setting_root}/visible" setting_order = f"{setting_root}/order" self._settings.set(setting_visible, True) self._settings.set(setting_order, -90) self._clicked = False TEST_UI_STYLE = copy.copy(VIEWPORT_MENUBAR_STYLE) TEST_UI_STYLE.update(UI_STYLE) super().__init__( text=kwargs.pop("text", None) or f"Button With Flyout Menu", name=kwargs.pop("name", None) or f"Sample", visible_setting_path=setting_visible, order_setting_path=setting_order, onclick_fn=self._on_click, build_menu_fn=self._build_menu_items if not kwargs.get("build_window_fn", None) else None, style=TEST_UI_STYLE, **kwargs, ) def destroy(self): super().destroy() def _build_menu_items(self) -> List[ui.MenuItem]: return [ ui.MenuItem( "Button Menu Item 0", delegate=ViewportMenuDelegate(), ), ui.MenuItem( "Button Menu Item 1", delegate=ViewportMenuDelegate(), ), ] def _on_click(self): self._clicked = True
2,332
Python
29.697368
103
0.63765
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/style.py
from pathlib import Path CURRENT_PATH = Path(__file__).parent ICON_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") UI_STYLE = { "Menu.Item.Icon::Sample": {"image_url": f"{ICON_PATH}/preferences_dark.svg"}, "Menu.Button.Image::Sample": {"image_url": f"{ICON_PATH}/preferences_dark.svg"}, }
348
Python
33.899997
101
0.695402
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_radio_collection.py
from pathlib import Path from omni.kit.viewport.menubar.core import RadioMenuCollection, ComboBoxModel import omni.ui as ui from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.ui_test.query import MenuRef import omni.kit.app from .abstract_test_container import AbstractTestContainer CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class RadioContainer(AbstractTestContainer): def _build_menu_items(self): self._radio_menu = RadioMenuCollection( "Radio Collection", ComboBoxModel(["First", "Second", "Third"], current_value="Second"), ) def destroy(self): self._radio_menu.destroy() super().destroy() class TestRadioContainer(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._menu = RadioContainer() await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._menu.destroy() self._menu = None await super().tearDown() async def test_delegate(self): menu_ref = MenuRef(self._menu._root_menu, "") await menu_ref.click() menu_ref = MenuRef(self._menu._radio_menu, "") await menu_ref.click() for _ in range(4): await omni.kit.app.get_app().next_update_async() await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_radio_collection.png" ) self.assertEqual(self._menu._radio_menu._model.current_index.as_int, 1) first_ref = menu_ref.find_menu("First") await first_ref.click() self.assertEqual(self._menu._radio_menu._model.current_index.as_int, 0) await self.finalize_test_no_image()
2,299
Python
31.857142
113
0.664202
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/left_example_menu_container.py
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["LeftExampleMenuContainer"] from omni.kit.viewport.menubar.core import ( IconMenuDelegate, SliderMenuDelegate, CheckboxMenuDelegate, ViewportMenuContainer, ViewportMenuItem, ViewportMenuSeparator, FloatArraySettingColorMenuItem, ComboBoxMenuDelegate, SpinnerMenuDelegate, ComboBoxModel, CategoryMenuDelegate, CategoryStatus, ) from .style import UI_STYLE import carb import carb.settings import omni.ui as ui from typing import Dict class LeftExampleMenuContainer(ViewportMenuContainer): """The menu aligned to left""" def __init__(self): self._settings = carb.settings.get_settings() self._settings.set("/exts/omni.kit.viewport.menubar.example/left/visible", True) self._settings.set("/exts/omni.kit.viewport.menubar.example/left/order", -100) super().__init__( name="Left Samples Menu", delegate=IconMenuDelegate("Sample"), visible_setting_path="/exts/omni.kit.viewport.menubar.example/left/visible", order_setting_path="/exts/omni.kit.viewport.menubar.example/left/order", style=UI_STYLE ) self._settings = carb.settings.get_settings() def build_fn(self, factory: Dict): ui.Menu( self.name, delegate=self._delegate, on_build_fn=self._build_menu_items, style=self._style ) def _build_menu_items(self): ui.MenuItem("Text only with clickable", hide_on_click=False, onclick_fn=lambda: print("Text Menu clicked")) ui.MenuItem( "Icon", delegate=IconMenuDelegate("Sample", text=True, has_triangle=False), hide_on_click=False, onclick_fn=lambda: print("Icon Menu clicked") ) ui.Separator() ui.MenuItem( "Float Slider", hide_on_click=False, delegate=SliderMenuDelegate( model=ui.SimpleFloatModel(0.5), min=0.0, max=1.0, tooltip="Float slider Sample", ), ) ui.MenuItem( "Int Slider", hide_on_click=False, delegate=SliderMenuDelegate( model=ui.SimpleIntModel(5), min=1, max=15, slider_class=ui.IntSlider, tooltip="Int slider Sample", ), ) ui.Separator() ui.MenuItem( "CheckBox", hide_on_click=False, delegate=CheckboxMenuDelegate( model=ui.SimpleBoolModel(True), tooltip="CheckBox Sample", ), ) ui.Separator() ui.MenuItem( "ComboBox", delegate=ComboBoxMenuDelegate( model=ComboBoxModel(["This", "is", "a", "test", "combobox"], values=[0, 1, 2, 3, 4]) ), hide_on_click=False, ) ui.Separator() ui.MenuItem( "Spinner", delegate=SpinnerMenuDelegate( model=ui.SimpleIntModel(80), min=50, max=100, ), hide_on_click=False, ) ui.Separator() FloatArraySettingColorMenuItem( "/exts/omni.kit.viewport.menubar.example/left/color", [0.1, 0.2, 0.3], name="Selection Color", start_index=0 ) ui.Separator() ui.MenuItem( "Category All", delegate=CategoryMenuDelegate(CategoryStatus.ALL) ) ui.MenuItem( "Category Mixed", delegate=CategoryMenuDelegate(CategoryStatus.MIXED) ) ui.MenuItem( "Category Empty", delegate=CategoryMenuDelegate(CategoryStatus.EMPTY) )
4,218
Python
28.921986
115
0.583926
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/__init__.py
from .test_abstract_delegate import * from .test_button_item import * from .test_icon_delegate import * from .test_models import * from .test_more_menubars import * from .test_radio_collection import * from .test_slider_delegate import * from .test_preference import * from .test_ui import * from .test_viewport_menu_model import *
334
Python
24.769229
39
0.760479
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_ui.py
import omni.kit.test from re import I from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from .left_example_menu_container import LeftExampleMenuContainer from .right_example_menu_container import RightExampleMenuContainer from .example_button import ButtonExample import omni.kit.ui_test as ui_test from omni.kit.ui_test import Vec2 import omni.usd import omni.kit.app from pathlib import Path import carb.input import asyncio CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class TestExampleMenuWindow(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._left_menu = LeftExampleMenuContainer() self._right_menu = RightExampleMenuContainer() self._button_menu = ButtonExample() await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._left_menu.destroy() self._left_menu = None self._right_menu.destroy() self._right_menu = None self._button_menu.destroy() self._button_menu = None await super().tearDown() async def test_left(self): await self._show_popup_menu() await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_example_left.png" ) async def test_right(self): await self._show_popup_menu(pos=Vec2(540, 20)) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_example_right.png" ) async def test_button(self): await self._show_popup_menu(pos=Vec2(60, 20), right_click=True) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_example_button.png" ) async def _show_popup_menu(self, pos=Vec2(20, 20), right_click=False): # Enable mouse input app_window = omni.appwindow.get_default_app_window() for device in [carb.input.DeviceType.MOUSE]: app_window.set_input_blocking_state(device, None) await ui_test.emulate_mouse_move(pos) await ui_test.emulate_mouse_click(right_click=right_click) await omni.kit.app.get_app().next_update_async()
2,722
Python
34.828947
113
0.683688
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_more_menubars.py
import omni.kit.test from re import I from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.viewport.menubar.core import ViewportMenubar, ViewportMenuSpacer, get_instance as get_menubar_instance from .left_example_menu_container import LeftExampleMenuContainer from .right_example_menu_container import RightExampleMenuContainer from .example_button import ButtonExample import omni.kit.ui_test as ui_test from omni.kit.ui_test import Vec2 import omni.usd import omni.kit.app from pathlib import Path import carb.input import omni.ui as ui import asyncio CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class ViewportBottomBar(ViewportMenubar): def __init__(self): super().__init__("BOTTOM_BAR") def build_fn(self, menu_items, factory): with ui.VStack(): ui.Spacer() super().build_fn(menu_items, factory) class TestMoreMenubars(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT) self._bottom_bar = None self._left_bar = None # After running each test async def tearDown(self): self._left_menu.destroy() self._left_menu = None self._right_menu.destroy() self._right_menu = None self._button_menu.destroy() self._button_menu = None if self._bottom_bar is not None: self._bottom_bar.destroy() self._bottom_bar = None if self._left_bar is not None: self._left_bar.destroy() self._left_bar = None await super().tearDown() async def test_bottom_bar(self): self._bottom_bar = ViewportBottomBar() with self._bottom_bar: self._left_menu = LeftExampleMenuContainer() self._right_menu = RightExampleMenuContainer() self._button_menu = ButtonExample() bottom_bar = get_menubar_instance().get_menubar("BOTTOM_BAR") with bottom_bar: ViewportMenuSpacer() await omni.kit.app.get_app().next_update_async() await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="viewport_bottombar.png" ) async def test_left_bar(self): self._left_bar = ViewportMenubar(name="LEFT_BAR", direction=ui.Direction.TOP_TO_BOTTOM) with self._left_bar: self._left_menu = LeftExampleMenuContainer() self._right_menu = RightExampleMenuContainer() self._button_menu = ButtonExample() await omni.kit.app.get_app().next_update_async() await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="viewport_leftbar.png", threshold=.015 )
3,100
Python
31.989361
116
0.659677
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_models.py
## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved. ## ## NVIDIA CORPORATION and its licensors retain all intellectual property ## and proprietary rights in and to this software, related documentation ## and any modifications thereto. Any use, reproduction, disclosure or ## distribution of this software and related documentation without an express ## license agreement from NVIDIA CORPORATION is strictly prohibited. ## __all__ = ['TestModels'] import omni.kit.test from omni.kit.test import AsyncTestCase import omni.usd from pxr import Sdf, UsdGeom import omni.kit.undo import omni.ui as ui import carb from ..model.setting_model import SettingModel from ..model.usd_attribute_model import USDAttributeModel, USDBoolAttributeModel, USDIntAttributeModel, USDFloatAttributeModel, USDStringAttributeModel from ..model.usd_metadata_model import USDMetadataModel from ..model.reset_button import ResetHelper, ResetButton from ..model.combobox_model import ComboBoxModel, SettingComboBoxModel from ..model.list_model import ColorModel, SimpleListModel from ..model.category_model import SimpleCategoryModel, CategoryStateItem, CategoryCustomItem, CategoryStatus class TestModels(AsyncTestCase): async def setUp(self): self.usd_context_name = '' self.usd_context = omni.usd.get_context(self.usd_context_name) await self.usd_context.new_stage_async() self.stage = self.usd_context.get_stage() self.stage.SetDefaultPrim(UsdGeom.Xform.Define(self.stage, '/World').GetPrim()) async def tearDown(self): self.usd_context = None self.stage = None def get_setting_path(self, setting): return f'/app/test/omni.kit.viewport.menubar.core/test_root/{setting}' async def test_setting_model_bool(self): setting = self.get_setting_path('bool_value') settings = carb.settings.get_settings() model = SettingModel(setting) self.assertEqual(model.path, setting) # Should start as None and False self.assertEqual(model.get_value_as_bool(), bool(settings.get(setting))) # Test model -> carb.setting model.set_value(True) self.assertEqual(model.get_value_as_bool(), settings.get(setting)) model.set_value(False) self.assertEqual(model.get_value_as_bool(), settings.get(setting)) # Test carb.setting -> model settings.set(setting, True) self.assertEqual(model.get_value_as_bool(), settings.get(setting)) settings.set(setting, False) self.assertEqual(model.get_value_as_bool(), settings.get(setting)) model.begin_edit() self.assertTrue(model._editing) model.end_edit() self.assertFalse(model._editing) model.destroy() async def test_setting_model_int(self): setting = self.get_setting_path('int_value') settings = carb.settings.get_settings() model = SettingModel(setting) # Test model -> carb.setting model.set_value(1) self.assertEqual(model.get_value_as_int(), settings.get(setting)) model.set_value(2) self.assertEqual(model.get_value_as_int(), settings.get(setting)) # Test carb.setting -> model settings.set(setting, 3) self.assertEqual(model.get_value_as_int(), settings.get(setting)) settings.set(setting, 4) self.assertEqual(model.get_value_as_int(), settings.get(setting)) model.destroy() async def test_setting_model_float(self): setting = self.get_setting_path('float_value') settings = carb.settings.get_settings() model = SettingModel(setting) # Test model -> carb.setting model.set_value(123.0) self.assertEqual(model.get_value_as_float(), settings.get(setting)) model.set_value(456.0) self.assertEqual(model.get_value_as_float(), settings.get(setting)) # Test carb.setting -> model settings.set(setting, 789.0) self.assertEqual(model.get_value_as_float(), settings.get(setting)) settings.set(setting, 101112.0) self.assertEqual(model.get_value_as_float(), settings.get(setting)) model.destroy() async def test_setting_model_string(self): setting = self.get_setting_path('string_value') settings = carb.settings.get_settings() model = SettingModel(setting) # Test model -> carb.setting model.set_value('A') self.assertEqual(model.get_value_as_string(), settings.get(setting)) model.set_value('B') self.assertEqual(model.get_value_as_string(), settings.get(setting)) # Test carb.setting -> model settings.set(setting, 'C') self.assertEqual(model.get_value_as_string(), settings.get(setting)) settings.set(setting, 'D') self.assertEqual(model.get_value_as_string(), settings.get(setting)) model.destroy() async def test_implicit_bool_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDAttributeModel(self.stage, prim.GetPath(), 'implicicit_bool') model.set_value(True) prop = prim.GetProperty('implicicit_bool') self.assertEqual(prop.Get(), True) model.set_value(False) self.assertEqual(prop.Get(), False) self.assertEqual(prop.Get(), model.get_value_as_bool()) prop.Set(True) self.assertEqual(model.get_value_as_bool(), True) self.assertEqual(prop.Get(), model.get_value_as_bool()) prop.Set(False) self.assertEqual(model.get_value_as_bool(), False) self.assertEqual(prop.Get(), model.get_value_as_bool()) async def test_implicit_int_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDAttributeModel(self.stage, prim.GetPath(), 'implicicit_int') model.set_value(1) prop = prim.GetProperty('implicicit_int') self.assertEqual(prop.Get(), 1) model.set_value(2) self.assertEqual(prop.Get(), 2) self.assertEqual(prop.Get(), model.get_value_as_int()) prop.Set(3) self.assertEqual(model.get_value_as_int(), 3) self.assertEqual(prop.Get(), model.get_value_as_int()) prop.Set(4) self.assertEqual(model.get_value_as_int(), 4) self.assertEqual(prop.Get(), model.get_value_as_int()) async def test_implicit_float_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDAttributeModel(self.stage, prim.GetPath(), 'implicicit_float') model.set_value(123.4) prop = prim.GetProperty('implicicit_float') self.assertAlmostEqual(prop.Get(), 123.4, 2) model.set_value(234.5) self.assertAlmostEqual(prop.Get(), 234.5, 1) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) prop.Set(345.6) self.assertAlmostEqual(model.get_value_as_float(), 345.6, 2) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) prop.Set(456.7) self.assertAlmostEqual(model.get_value_as_float(), 456.7, 2) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) async def test_implicit_string_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDAttributeModel(self.stage, prim.GetPath(), 'implicicit_string') model.set_value('A') prop = prim.GetProperty('implicicit_string') self.assertEqual(prop.Get(), 'A') model.set_value('B') self.assertEqual(prop.Get(), 'B') self.assertEqual(prop.Get(), model.get_value_as_string()) prop.Set('C') self.assertEqual(model.get_value_as_string(), 'C') self.assertEqual(prop.Get(), model.get_value_as_string()) prop.Set('D') self.assertEqual(model.get_value_as_string(), 'D') self.assertEqual(prop.Get(), model.get_value_as_string()) async def test_explicit_bool_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDBoolAttributeModel(self.stage, prim.GetPath(), 'explicit_bool') model.set_value(True) prop = prim.GetProperty('explicit_bool') self.assertEqual(prop.Get(), True) self.assertEqual(prop.Get(), model.get_value_as_bool()) model.set_value(False) self.assertEqual(prop.Get(), False) self.assertEqual(prop.Get(), model.get_value_as_bool()) prop.Set(True) self.assertEqual(model.get_value_as_bool(), True) self.assertEqual(prop.Get(), model.get_value_as_bool()) prop.Set(False) self.assertEqual(model.get_value_as_bool(), False) self.assertEqual(prop.Get(), model.get_value_as_bool()) # Test undo works and collapses back to original value omni.kit.undo.undo() self.assertEqual(prop.Get(), True) self.assertEqual(prop.Get(), model.get_value_as_bool()) async def test_explicit_int_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDIntAttributeModel(self.stage, prim.GetPath(), 'explicit_int') model.set_value(1) prop = prim.GetProperty('explicit_int') self.assertEqual(prop.Get(), 1) self.assertEqual(prop.Get(), model.get_value_as_int()) model.set_value(2) self.assertEqual(prop.Get(), 2) self.assertEqual(prop.Get(), model.get_value_as_int()) prop.Set(3) self.assertEqual(model.get_value_as_int(), 3) self.assertEqual(prop.Get(), model.get_value_as_int()) prop.Set(4) self.assertEqual(model.get_value_as_int(), 4) self.assertEqual(prop.Get(), model.get_value_as_int()) # Test undo works and collapses back to original value omni.kit.undo.undo() self.assertEqual(prop.Get(), 1) self.assertEqual(prop.Get(), model.get_value_as_int()) async def test_explicit_float_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDFloatAttributeModel(self.stage, prim.GetPath(), 'explicit_float') model.set_value(123.4) prop = prim.GetProperty('explicit_float') self.assertAlmostEqual(prop.Get(), 123.4, 2) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) model.set_value(234.5) self.assertAlmostEqual(prop.Get(), 234.5, 1) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) prop.Set(345.6) self.assertAlmostEqual(model.get_value_as_float(), 345.6, 2) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) prop.Set(456.7) self.assertAlmostEqual(model.get_value_as_float(), 456.7, 2) self.assertAlmostEqual(prop.Get(), model.get_value_as_float(), 2) # Test undo works and collapses back to original value omni.kit.undo.undo() self.assertAlmostEqual(prop.Get(), 123.4, 2) self.assertEqual(prop.Get(), model.get_value_as_float()) async def test_explicit_string_attribute_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDStringAttributeModel(self.stage, prim.GetPath(), 'explicit_string') model.set_value('A') prop = prim.GetProperty('explicit_string') self.assertEqual(prop.Get(), 'A') self.assertEqual(prop.Get(), model.get_value_as_string()) model.set_value('B') self.assertEqual(prop.Get(), 'B') self.assertEqual(prop.Get(), model.get_value_as_string()) prop.Set('C') self.assertEqual(model.get_value_as_string(), 'C') self.assertEqual(prop.Get(), model.get_value_as_string()) prop.Set('D') self.assertEqual(model.get_value_as_string(), 'D') self.assertEqual(prop.Get(), model.get_value_as_string()) # Test undo works and collapses back to original value omni.kit.undo.undo() self.assertEqual(model.get_value_as_string(), 'A') self.assertEqual(prop.Get(), model.get_value_as_string()) async def test_prim_metadata_model(self): prim = self.stage.GetPrimAtPath('/World') model = USDMetadataModel(self.stage, prim.GetPath(), 'active') model.set_value(True) self.assertEqual(prim.GetMetadata('active'), True) self.assertEqual(prim.GetMetadata('active'), model.get_value_as_bool()) model = USDMetadataModel(self.stage, prim.GetPath(), 'instanceable') model.set_value(False) self.assertEqual(prim.GetMetadata('instanceable'), False) self.assertEqual(prim.GetMetadata('instanceable'), model.get_value_as_bool()) async def test_reset_button(self): class SimpleResetHelper(ResetHelper): def __init__(self, default: bool) -> None: self.value = default self._default = default super().__init__() def get_default(self): return self._default def restore_default(self): self.value = self.get_default() def get_value(self): return self.value def on_reset(): self.__reset = True true_helper = SimpleResetHelper(True) false_helper = SimpleResetHelper(False) reset_btn = ResetButton([true_helper], on_reset_fn=on_reset) reset_btn.add_setting_model(false_helper) self.assertFalse(reset_btn._reset_button.visible) true_helper.value = False reset_btn.refresh() self.assertTrue(reset_btn._reset_button.visible) reset_btn._restore_defaults() self.assertFalse(reset_btn._reset_button.visible) self.assertTrue(true_helper.value) self.assertTrue(self.__reset) async def test_combobox_model(self): model = ComboBoxModel(["First", "Second"], current_value="First") self.assertEqual(model.current_index.as_int, 0) def on_model_changed(model): self._combobox_changed = True model.current_index.subscribe_value_changed_fn(on_model_changed) model.current_index.set_value(1) async def test_setting_combobox_model(self): setting_path = self.get_setting_path('combobox_value') settings = carb.settings.get_settings() settings.set(setting_path, "Second") model = SettingComboBoxModel(setting_path, ["First", "Second"]) self.assertEqual(model.current_index.as_int, 1) model.current_index.set_value(0) self.assertEqual(settings.get(setting_path), "First") model.destroy() async def test_list_model(self): values = [ui.SimpleStringModel("model"), 0.5, 1, "text"] texts = ["model", "float", "int", "string"] model = SimpleListModel(values, texts=texts) self.assertEqual(model.get_item_value_model_count(), 1) items = model.get_item_children() self.assertEqual(len(items), 4) self.assertEqual(model.get_item_value_model(items[0], 0), values[0]) self.assertEqual(model.get_item_value_model(items[1], 0).as_float, values[1]) self.assertEqual(model.get_item_value_model(items[2], 0).as_int, values[2]) self.assertEqual(model.get_item_value_model(items[3], 0).as_string, values[3]) for i in range(4): self.assertEqual(items[i].model.as_string, texts[i]) model.destroy() async def test_color_model(self): def _on_color_changed(color): self.__color = color colors = [0.1, 0.2, 0.3] default = [0, 0, 0] model = ColorModel(colors, default=default, on_color_changed_fn=_on_color_changed) self.assertEqual(model.colors, colors) colors.reverse() model.colors = colors self.assertEqual(model.colors, colors) self.assertEqual(self.__color, colors) self.assertEqual(model.get_default(), default) self.assertEqual(model.get_value(), model.colors) model.restore_default() self.assertEqual(model.colors, default) model.destroy() async def test_category_model(self): setting_path = self.get_setting_path("category_state") settings = carb.settings.get_settings() settings.set(setting_path, True) model = SimpleCategoryModel( "Category Model Test", [ CategoryStateItem("State Setting", setting_path=setting_path), CategoryStateItem("State Model", value_model=ui.SimpleBoolModel(True)), CategoryStateItem("State Empty"), ] ) def _build_fn(): pass # pragma: no cover model.add_item(CategoryCustomItem("Custom", build_fn=_build_fn)) collection_items = model.get_item_children(None) self.assertEqual(len(collection_items), 1) children = model.get_item_children(collection_items[0]) self.assertEqual(len(children), 4) empty = model.get_item_children(children[0]) self.assertEqual(len(empty), 0) empty = model.get_item_children(children[3]) self.assertEqual(len(empty), 0) # Status root = model._root self.assertTrue(children[0].checked) self.assertTrue(children[1].checked) self.assertFalse(children[2].checked) self.assertEqual(root.status, CategoryStatus.MIXED) children[2].checked = True self.assertEqual(root.status, CategoryStatus.ALL) root.status = CategoryStatus.EMPTY self.assertFalse(children[0].checked) self.assertFalse(children[1].checked) self.assertFalse(children[2].checked) root.status = CategoryStatus.ALL self.assertTrue(children[0].checked) self.assertTrue(children[1].checked) self.assertTrue(children[2].checked) model.destroy()
17,929
Python
36.906977
151
0.638407
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_icon_delegate.py
import copy from pathlib import Path from typing import Dict from omni.kit.viewport.menubar.core import ViewportMenuContainer, AbstractWidgetMenuDelegate, IconMenuDelegate import omni.ui as ui from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.ui_test.query import MenuRef import omni.kit.app import carb.settings from ..style import VIEWPORT_MENUBAR_STYLE from .style import UI_STYLE from ..model.reset_button import ResetHelper CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class IconMenuDelegateContainer(ViewportMenuContainer): def __init__(self): self._settings = carb.settings.get_settings() self._settings.set("/exts/omni.kit.viewport.menubar.delegate/visible", True) self._settings.set("/exts/omni.kit.viewport.menubar.delegate/order", -100) self._triggered = 0 self._right_clicked = 0 TEST_UI_STYLE = copy.copy(VIEWPORT_MENUBAR_STYLE) TEST_UI_STYLE.update(UI_STYLE) super().__init__( name="Icon", delegate=IconMenuDelegate("Sample", triggered_fn=self._on_trigger, right_clicked_fn=self._on_right_click), visible_setting_path="/exts/omni.kit.viewport.menubar.delegate/visible", order_setting_path="/exts/omni.kit.viewport.menubar.delegate/order", style=TEST_UI_STYLE ) self._settings = carb.settings.get_settings() def destroy(self): self._delegate.destroy() super().destroy() def _on_trigger(self) -> None: self._triggered += 1 def _on_right_click(self) -> None: self._right_clicked += 1 def build_fn(self, factory: Dict): self._root_menu = ui.Menu( self.name, delegate=self._delegate, on_build_fn=self._build_menu_items, style=self._style ) def _build_menu_items(self): ui.MenuItem( "Icon", delegate=IconMenuDelegate("Sample", text=True, build_custom_widgets=self._build_custom_widgets, has_triangle=False), ) def _build_custom_widgets(self, item: ui.MenuItem): ui.Label("custom widget") class TestIconDelegate(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._menu = IconMenuDelegateContainer() await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._menu.destroy() self._menu = None await super().tearDown() async def test_delegate(self): root_delegate = self._menu._root_menu.delegate self.assertFalse(root_delegate.text_visible) self.assertFalse(root_delegate.checked) self.assertTrue(root_delegate.enabled) self.assertEqual(root_delegate.text, "") menu_ref = MenuRef(self._menu._root_menu, "") await menu_ref.click() await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_icon_delegate.png" ) self.assertEqual(self._menu._triggered, 1) self.assertEqual(self._menu._right_clicked, 0) await menu_ref.click(right_click=True) self.assertEqual(self._menu._triggered, 1) self.assertEqual(self._menu._right_clicked, 1) root_delegate.text = "Test" root_delegate.text_visible = True root_delegate.checked = True root_delegate.enabled = False await self.finalize_test_no_image()
3,992
Python
34.026315
128
0.658567
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_preference.py
import omni.kit.test from omni.ui.tests.test_base import OmniUiTest from pathlib import Path import omni.kit.app import omni.kit.window.preferences from omni.kit.viewport.window import ViewportWindow import omni.ui as ui from omni.kit.viewport.menubar.core import get_instance, ViewportMenuSpacer from .left_example_menu_container import LeftExampleMenuContainer from .right_example_menu_container import RightExampleMenuContainer from .example_button import ButtonExample CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 1280, 600 class TestPreference(OmniUiTest): # Before running each test async def setUp(self): await super().setUp() self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._vw = ViewportWindow('TestWindow', width=TEST_WIDTH, height=TEST_HEIGHT) self._left_menu = LeftExampleMenuContainer() self._right_menu = RightExampleMenuContainer() self._button_menu = ButtonExample() # After running each test async def tearDown(self): self._left_menu.destroy() self._left_menu = None self._right_menu.destroy() self._right_menu = None self._button_menu.destroy() self._button_menu = None self._vw.destroy() self._vw = None await super().tearDown() async def test_viewport_preference(self): await self._test_preference_page("Viewport") async def _test_preference_page(self, title: str): for page in omni.kit.window.preferences.get_page_list(): if page.get_title() == title: omni.kit.window.preferences.select_page(page) omni.kit.window.preferences.rebuild_pages() omni.kit.window.preferences.show_preferences_window() await omni.kit.app.get_app().next_update_async() w = ui.Workspace.get_window("Preferences") await self.docked_test_window( window=w, width=1280, height=600, ) await omni.kit.app.get_app().next_update_async() await self.finalize_test(golden_img_dir=self._golden_img_dir, golden_img_name=f"{title}.png") async def test_preference_model(self): inst = get_instance() page = inst._page model = page._model items = model.get_item_children(None) self.assertEqual(len(items), 4) self.assertEqual(items[0].name, self._left_menu.name) self.assertEqual(items[1].name, self._button_menu.name) self.assertTrue(isinstance(items[2], ViewportMenuSpacer)) self.assertEqual(items[3].name, self._right_menu.name) left_item = items[0] button_item = items[1] self.assertEqual(model.get_drag_mime_data(left_item), self._left_menu.name) drop_accepted = model.drop_accepted(button_item, left_item) self.assertTrue(drop_accepted) drop_accepted = model.drop_accepted(None, left_item) self.assertFalse(drop_accepted) # Drop left to behind button model.drop(button_item, left_item) items = model.get_item_children(None) self.assertEqual(items[0], button_item) self.assertEqual(items[1], left_item) # Drop left to in front of button model.drop(left_item, button_item) items = model.get_item_children(None) self.assertEqual(items[0], left_item) self.assertEqual(items[1], button_item) await self.finalize_test_no_image()
3,703
Python
33.296296
106
0.662706
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_abstract_delegate.py
import copy from pathlib import Path from typing import Dict from omni.kit.viewport.menubar.core import ViewportMenuContainer, AbstractWidgetMenuDelegate, IconMenuDelegate import omni.ui as ui from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.ui_test.query import MenuRef import omni.kit.app import carb.settings from ..style import VIEWPORT_MENUBAR_STYLE from ..model.reset_button import ResetHelper from ..viewport_menu_model import ViewportMenuModel from .style import UI_STYLE CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class SimpleTextDelegate(AbstractWidgetMenuDelegate): def build_widget(self, item: ui.MenuHelper): ui.Label(item.text) class SimpleResetHelper(ResetHelper): def __init__(self, value: bool) -> None: self._value = value super().__init__() def get_default(self): return True def restore_default(self): self._value = self.get_default() def get_value(self): return self._value class AbstractMenuDelegateContainer(ViewportMenuContainer): def __init__(self): self._settings = carb.settings.get_settings() self._settings.set("/exts/omni.kit.viewport.menubar.delegate/visible", True) self._settings.set("/exts/omni.kit.viewport.menubar.delegate/order", -100) TEST_UI_STYLE = copy.copy(VIEWPORT_MENUBAR_STYLE) TEST_UI_STYLE.update(UI_STYLE) super().__init__( name="", delegate=IconMenuDelegate("Sample"), visible_setting_path="/exts/omni.kit.viewport.menubar.delegate/visible", order_setting_path="/exts/omni.kit.viewport.menubar.delegate/order", style=TEST_UI_STYLE ) self._settings = carb.settings.get_settings() def build_fn(self, factory: Dict): self._root_menu = ui.Menu( self.name, delegate=self._delegate, on_build_fn=self._build_menu_items, style=self._style ) def _build_menu_items(self): ui.MenuItem( "General", delegate=SimpleTextDelegate(), ) ui.MenuItem( "Reserve Status", delegate=SimpleTextDelegate(reserve_status=True), ) ui.MenuItem( "Reset Button (True)", delegate=SimpleTextDelegate(model=SimpleResetHelper(True), has_reset=True), ) ui.MenuItem( "Reset Button (False)", delegate=SimpleTextDelegate(model=SimpleResetHelper(False), has_reset=True), ) ui.Menu( "Menu", delegate=SimpleTextDelegate(), ) self._invisible_menuitem = ui.MenuItem( "Invisible", delegate=SimpleTextDelegate(visible=False), ) self._disabled_menuitem = ui.MenuItem( "Disabled", delegate= SimpleTextDelegate(enabled=False), ) class TestAbstractDelegate(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._menu = AbstractMenuDelegateContainer() await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._menu.destroy() self._menu = None await super().tearDown() async def test_delegate(self): menu_ref = MenuRef(self._menu._root_menu, "") await menu_ref.click() self.assertFalse(self._menu._invisible_menuitem.delegate.visible) self.assertFalse(self._menu._disabled_menuitem.delegate.enabled) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_abstract_delegate.png" )
4,180
Python
31.92126
113
0.650478
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/right_example_menu_container.py
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["RightExampleMenuContainer"] from omni.kit.viewport.menubar.core import ( IconMenuDelegate, ViewportMenuContainer, ViewportMenuDelegate, ) from .style import UI_STYLE import carb import carb.settings import omni.ui as ui from typing import Dict from functools import partial class RightExampleMenuContainer(ViewportMenuContainer): """The menu aligned to right""" def __init__(self): self._settings = carb.settings.get_settings() self._settings.set("/exts/omni.kit.viewport.menubar.example/right/visible", True) self._settings.set("/exts/omni.kit.viewport.menubar.example/right/order", 100) super().__init__( name="Right Samples Menu", delegate=IconMenuDelegate("Sample", text=True), visible_setting_path="/exts/omni.kit.viewport.menubar.example/right/visible", order_setting_path="/exts/omni.kit.viewport.menubar.example/right/order", style=UI_STYLE ) self._settings = carb.settings.get_settings() def build_fn(self, factory: Dict): """Entry point for the menu bar""" self.__root_menu = ui.Menu( self.name, delegate=self._delegate, on_build_fn=partial(self._build_menu_items, factory), style=UI_STYLE ) def _build_menu_items(self, factory): ui.MenuItem( "Normal", checkable=False, delegate=ViewportMenuDelegate(), ) ui.MenuItem( "Checked", checkable=True, checked=True, delegate=ViewportMenuDelegate(), ) ui.MenuItem( "Disabled", enabled=False, delegate=ViewportMenuDelegate(), ) ui.MenuItem( "Icon on the right", delegate=ViewportMenuDelegate(icon_name="Sample") ) ui.Separator() with ui.Menu( "Sub menuitems without icon", delegate=ViewportMenuDelegate() ): for i in range(5): ui.MenuItem(f"Sub item {i}", delegate=ViewportMenuDelegate(),) with ui.Menu( "Sub menuitems with icon", delegate=ViewportMenuDelegate(icon_name="Sample"), ): for i in range(5): ui.MenuItem(f"Sub item {i}", delegate=ViewportMenuDelegate(),)
2,837
Python
29.847826
116
0.616849
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/tests/test_slider_delegate.py
from pathlib import Path from omni.kit.viewport.menubar.core import SliderMenuDelegate import omni.ui as ui from omni.ui.tests.test_base import OmniUiTest from omni.kit.viewport.utility import get_active_viewport_and_window from omni.kit.ui_test.query import MenuRef import omni.kit.app from .abstract_test_container import AbstractTestContainer CURRENT_PATH = Path(__file__).parent TEST_DATA_PATH = CURRENT_PATH.parent.parent.parent.parent.parent.parent.joinpath("data").joinpath("tests") TEST_WIDTH, TEST_HEIGHT = 600, 400 class SliderMenuDelegateContainer(AbstractTestContainer): def _build_menu_items(self): ui.MenuItem( "General", delegate=SliderMenuDelegate(), ) ui.MenuItem( "Int Slider", delegate=SliderMenuDelegate(slider_class=ui.IntSlider), ) self._checkbox_item_model = ui.SimpleIntModel(0) self._checkbox_item = ui.MenuItem( "Show checkbox with value is min", delegate=SliderMenuDelegate(model=self._checkbox_item_model, show_checkbox_if_min=True, min=0, max=10), ) ui.MenuItem( "Hide Checkbox", delegate=SliderMenuDelegate(model=ui.SimpleIntModel(3), show_checkbox_if_min=True, min=0, max=10), ) self._drag_min = -100 self._drag_max = 1000 self._drag_step = 10 self._drag_item = ui.MenuItem( "Drag", delegate=SliderMenuDelegate(min=self._drag_min, max=self._drag_max, step=self._drag_step), ) self._drag_item = ui.MenuItem( "Int Drag", delegate=SliderMenuDelegate(min=self._drag_min, max=self._drag_max, step=self._drag_step, slider_class=ui.IntSlider), ) class TestSliderDelegate(OmniUiTest): async def setUp(self): self._golden_img_dir = TEST_DATA_PATH.absolute().joinpath("golden_img").absolute() await self.create_test_area(width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) _, viewport_window = get_active_viewport_and_window() await self.docked_test_window(viewport_window, width=TEST_WIDTH, height=TEST_HEIGHT, block_devices=False) self._menu = SliderMenuDelegateContainer() await omni.kit.app.get_app().next_update_async() # After running each test async def tearDown(self): self._menu.destroy() self._menu = None await super().tearDown() async def test_delegate(self): menu_ref = MenuRef(self._menu._root_menu, "") await menu_ref.click() for _ in range(4): await omni.kit.app.get_app().next_update_async() slider_delegate = self._menu._drag_item.delegate self.assertEqual(slider_delegate.min, self._menu._drag_min) self.assertEqual(slider_delegate.max, self._menu._drag_max) self._menu._checkbox_item_model.set_value(5) checkbox_delegate = self._menu._checkbox_item.delegate checkbox_delegate.min = 5 checkbox_delegate.max = 50 self.assertEqual(checkbox_delegate.min, 5) self.assertEqual(checkbox_delegate.max, 50) checkbox_delegate.set_range(-10, 10) self.assertEqual(checkbox_delegate.min, -10) self.assertEqual(checkbox_delegate.max, 10) self._menu._checkbox_item_model.set_value(-10) await self.finalize_test( golden_img_dir=self._golden_img_dir, golden_img_name="menubar_slider_delegate.png" )
3,510
Python
34.11
129
0.645299
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/utils/usd_watch.py
# Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # __all__ = ["start", "stop", "subscribe"] from collections import defaultdict from dataclasses import dataclass from functools import partial from pxr import Sdf from pxr import Tf from pxr import Trace from pxr import Usd from typing import Callable from typing import Dict from typing import List from typing import Optional, Union import asyncio import omni.kit.app from omni.kit.async_engine import run_coroutine import weakref import concurrent.futures # The watch object is one per session __watch: Optional["_USDWatch"] = None def start(): """Starts watch""" global __watch if not __watch: __watch = _USDWatch() def stop(): """Stops watch""" global __watch if __watch: __watch.destroy() __watch = None def subscribe(stage: Usd.Stage, path: Sdf.Path, callback: Callable[[], None]): """ Lets execute the callback when the given attribute is changed. The callback will be executed while the returned object is alive. If returned object is None, the watch is not started. """ global __watch if __watch: return __watch.subscribe(stage, path, callback) class _USDWatch: """ The object that holds a single Tf.Notice.Listener and executes callbacks when specific attribute is changed. """ @dataclass class _USDWatchCallbackHandler: """Holds the callbacks""" changed_fn: Callable[[], None] def __init__(self): self.__listener: Optional[Tf.Notice.Listener] = None # The storage with all registered callbacks self.__callbacks: Dict[Usd.Stage, Dict[Sdf.Path, Callable[[], None]]] = defaultdict(dict) # The storage with all dirty attributes self.__dirty_attr_paths: Dict[Usd.Stage, List[Sdf.Path]] = defaultdict(list) # The task where the dirty attributes are computed self.__prim_changed_task_or_future: Union[asyncio.Task, concurrent.futures.Future, None] = None def destroy(self): """Should be executed before the object is killed""" self.clear_all() def clear_all(self): """Stop Tf.Notice and clear callbacks""" if self.__listener: self.__listener.Revoke() self.__listener = None self.__callbacks.clear() def subscribe(self, stage: Usd.Stage, path: Sdf.Path, callback: Callable[[], None]): """ Lets execute the callback when the given attribute is changed. The callback will be executed while the returned object is alive. """ if not self.__listener: self.__listener = Tf.Notice.Register(Usd.Notice.ObjectsChanged, self._on_usd_changed, None) handler = self._USDWatchCallbackHandler(callback) self.__callbacks[stage][path] = weakref.proxy(handler, partial(self._unsubscribe, stage, path)) return handler def _unsubscribe(self, stage: Usd.Stage, path: Sdf.Path, dead): """Stop the subscription of the given attribute""" callbacks = self.__callbacks.get(stage, None) if callbacks is None: return callbacks.pop(path) if not callbacks: # Remove the stage if empty self.__callbacks.pop(stage) if not self.__callbacks: # Stop the USD listener if there are no callbacks self.clear_all() def _update_dirty(self): """ Execute the callbacks for the dirty items that was collected from TfNotice. It can be called any time to pump changes. """ dirty_attr_paths = self.__dirty_attr_paths self.__dirty_attr_paths = defaultdict(list) for stage, dirty_paths in dirty_attr_paths.items(): callbacks = self.__callbacks.get(stage, None) if not callbacks: continue for path in set(dirty_paths): callback = callbacks.get(path, None) if callback: callback.changed_fn() @Trace.TraceFunction def _on_usd_changed(self, notice: Tf.Notice, stage: Usd.Stage): """Called by Usd.Notice.ObjectsChanged""" if stage not in self.__callbacks: return dirty_prims_paths: List[Sdf.Path] = [] for p in notice.GetChangedInfoOnlyPaths(): if p.IsPropertyPath(): dirty_prims_paths.append(p) elif p.IsPrimPath(): dirty_prims_paths.append(p) for p in notice.GetResyncedPaths(): if p.IsPropertyPath(): dirty_prims_paths.append(p) elif p.IsPrimPath(): dirty_prims_paths.append(p) if not dirty_prims_paths: return self.__dirty_attr_paths[stage] += dirty_prims_paths # Update in the next frame. We need it because we want to accumulate the affected prims if self.__prim_changed_task_or_future is None or self.__prim_changed_task_or_future.done(): self.__prim_changed_task_or_future = run_coroutine(self.__delayed_prim_changed()) @Trace.TraceFunction async def __delayed_prim_changed(self): await omni.kit.app.get_app().next_update_async() # Pump the changes to the camera list. self._update_dirty() self.__prim_changed_task_or_future = None
5,738
Python
31.607954
103
0.636633
omniverse-code/kit/exts/omni.kit.property.file/config/extension.toml
[package] # Semantic Versioning is used: https://semver.org/ version = "1.0.2" category = "Internal" feature = true # Lists people or organizations that are considered the "authors" of the package. authors = ["NVIDIA"] # The title and description fields are primarly for displaying extension info in UI title = "File Property Window Widgets" description="Property Window widgets that displays file related information." # URL of the extension source repository. repository = "" # Preview image. Folder named "data" automatically goes in git lfs (see .gitattributes file). preview_image = "data/preview.png" # Icon is shown in Extensions window, it is recommended to be square, of size 256x256. icon = "data/icon.png" # Keywords for the extension keywords = ["kit", "file", "property"] # Location of change log file in target (final) folder of extension, relative to the root. # More info on writing changelog: https://keepachangelog.com/en/1.0.0/ changelog="docs/CHANGELOG.md" # Path (relative to the root) or content of readme markdown file for UI. readme = "docs/README.md" [dependencies] "omni.kit.window.content_browser" = { optional=true } "omni.kit.window.property" = {} # Main python module this extension provides, it will be publicly available as "import omni.example.hello". [[python.module]] name = "omni.kit.property.file" # Extension test settings [[test]] args = [ "--/renderer/enabled=pxr", "--/renderer/active=pxr", "--/renderer/multiGpu/enabled=false", "--/renderer/multiGpu/autoEnable=false", # Disable mGPU with PXR due to OM-51026, OM-53611 "--/renderer/multiGpu/maxGpuCount=1", "--/app/asyncRendering=false", "--/app/file/ignoreUnsavedOnExit=true", "--/app/window/dpiScaleOverride=1.0", "--/app/window/scaleToMonitor=false", "--/persistent/app/omniverse/filepicker/options_menu/show_details=false", "--no-window" ] dependencies = [ "omni.hydra.pxr", "omni.usd", "omni.kit.mainwindow", "omni.kit.window.viewport", "omni.kit.window.content_browser", "omni.kit.window.stage", "omni.kit.window.status_bar", "omni.kit.ui_test", "omni.kit.test_suite.helpers", ] stdoutFailPatterns.include = [] stdoutFailPatterns.exclude = []
2,236
TOML
30.069444
107
0.711538
omniverse-code/kit/exts/omni.kit.property.file/omni/kit/property/file/file_widget.py
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # import asyncio import weakref import carb import omni.client import omni.ui as ui from omni.kit.window.property.templates import SimplePropertyWidget class FileWidget(SimplePropertyWidget): def __init__(self): super().__init__(title="File Info", collapsed=False) self._stat_task = None self._created_by_model = ui.SimpleStringModel() self._created_time_model = ui.SimpleStringModel() self._modified_by_model = ui.SimpleStringModel() self._modified_time_model = ui.SimpleStringModel() self._file_size_model = ui.SimpleStringModel() def clean(self): super().clean() self._created_by_model = None self._created_time_model = None self._modified_by_model = None self._modified_time_model = None self._file_size_model = None def on_new_payload(self, payload): if not super().on_new_payload(payload): return False # Only support one selected path if len(payload) != 1: return False return True def reset(self): if self._stat_task: self._stat_task.cancel() self._stat_task = None if self._created_by_model: self._created_by_model.set_value("") if self._created_time_model: self._created_time_model.set_value("") if self._modified_by_model: self._modified_by_model.set_value("") if self._modified_time_model: self._modified_time_model.set_value("") if self._file_size_model: self._file_size_model.set_value("") super().reset() async def _stat_file_async(self): result, entry = await omni.client.stat_async(self._payload[0].path) if not result or not entry: return if result == omni.client.Result.OK: self._created_by_model.set_value(entry.created_by) self._created_time_model.set_value(entry.created_time.strftime("%x %X")) self._modified_by_model.set_value(entry.modified_by) self._modified_time_model.set_value(entry.modified_time.strftime("%x %X")) self._file_size_model.set_value(f"{entry.size:,} " + ("Bytes" if entry.size > 1 else "Byte")) else: carb.log_warn(f"Failed to get file info for {self._payload[0].path}") self._stat_task = None def _stat_file(self): self._stat_task = asyncio.ensure_future(self._stat_file_async()) def build_items(self): self._stat_file() self.add_item_with_model("Date Created", self._created_time_model, identifier="created_time") self.add_item_with_model("Created by", self._created_by_model, identifier="created_by") self.add_item_with_model("Date Modified", self._modified_time_model, identifier="modified_time") self.add_item_with_model("Modified by", self._modified_by_model, identifier="modified_by") self.add_item_with_model("File Size", self._file_size_model, identifier="file_size")
3,469
Python
37.988764
105
0.640819
omniverse-code/kit/exts/omni.kit.property.file/omni/kit/property/file/extension.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # NVIDIA CORPORATION and its licensors retain all intellectual property # and proprietary rights in and to this software, related documentation # and any modifications thereto. Any use, reproduction, disclosure or # distribution of this software and related documentation without an express # license agreement from NVIDIA CORPORATION is strictly prohibited. # import carb import omni.ext import weakref from omni.kit.window.content_browser import get_content_window from .file_widget import FileWidget class FilePropertyWidgets(omni.ext.IExt): def __init__(self): self._registered = False self._selection_notifiers = [] self._content_browser_notifier = None super().__init__() def on_startup(self, ext_id): manager = omni.kit.app.get_app().get_extension_manager() self._hooks = manager.subscribe_to_extension_enable( lambda _: self._add_selection_notifier(), lambda _: self._remove_selection_notifier(), ext_name="omni.kit.window.content_browser", hook_name="file property widget listener", ) self._register_widget() def on_shutdown(self): self._hooks = None for notifier in self._selection_notifiers: notifier.destroy() self._selection_notifiers.clear() if self._registered: self._unregister_widget() def _add_selection_notifier(self): try: self._content_browser_notifier = SelectionNotifier() self._selection_notifiers.append(self._content_browser_notifier) except Exception as e: carb.log_info(f"Could not add file selection notifier: {e}") def _remove_selection_notifier(self): if self._content_browser_notifier: self._selection_notifiers.remove(self._content_browser_notifier) self._content_browser_notifier.destroy() self._content_browser_notifier = None def _register_widget(self): import omni.kit.window.property as p w = p.get_window() if w: w.register_widget("file", "stat", FileWidget()) for notifier in self._selection_notifiers: notifier.start() notifier._notify_property_window([]) # force a refresh self._registered = True def _unregister_widget(self): try: import omni.kit.window.property as p w = p.get_window() if w: for notifier in self._selection_notifiers: notifier.stop() w.unregister_widget("file", "stat") self._registered = False except: pass class SelectionNotifier: def __init__(self, property_window_context_id=""): from omni.kit.window.content_browser import get_content_window self._content_browser_ref = weakref.ref(get_content_window(), lambda ref: self.destroy()) self._property_window_context_id = property_window_context_id def start(self): content_browser = self._content_browser_ref() if content_browser: self._sub = content_browser.subscribe_selection_changed(self._on_content_selection_changed) def stop(self): self._sub = None def destroy(self): self.stop() def _on_content_selection_changed(self, pane: int, selections): self._notify_property_window(selections) def _notify_property_window(self, selections): import omni.kit.window.property as p # TODO _property_window_context_id w = p.get_window() if w: w.notify("file", selections)
3,726
Python
33.19266
103
0.630435
omniverse-code/kit/exts/omni.kit.property.file/omni/kit/property/file/tests/__init__.py
from .test_file import *
25
Python
11.999994
24
0.72
omniverse-code/kit/exts/omni.kit.property.file/omni/kit/property/file/tests/test_file.py
## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. ## ## NVIDIA CORPORATION and its licensors retain all intellectual property ## and proprietary rights in and to this software, related documentation ## and any modifications thereto. Any use, reproduction, disclosure or ## distribution of this software and related documentation without an express ## license agreement from NVIDIA CORPORATION is strictly prohibited. ## import omni.kit.test import omni.client from omni.kit.test.async_unittest import AsyncTestCase from omni.kit import ui_test from omni.kit.test_suite.helpers import get_test_data_path, arrange_windows from omni.kit.window.content_browser.test_helper import ContentBrowserTestHelper class HardRangeUI(AsyncTestCase): # Before running each test async def setUp(self): await arrange_windows("Stage", 64) # After running each test async def tearDown(self): pass async def test_fileinfo_ui(self): await ui_test.find("Content").focus() await ui_test.find("Property").focus() # select file to show info dir_url = get_test_data_path(__name__, "..") async with ContentBrowserTestHelper() as content_browser_helper: await content_browser_helper.select_items_async(dir_url, names=["icon.png"]) await ui_test.human_delay(4) # get file info file_path = f"{dir_url}/icon.png" result, entry = await omni.client.stat_async(str(file_path)) self.assertEqual(result, omni.client.Result.OK) self.assertTrue(entry != None) # get file strings created_by = entry.created_by created_time = entry.created_time.strftime("%x %X") modified_by = entry.modified_by modified_time = entry.modified_time.strftime("%x %X") file_size = f"{entry.size:,} " + ("Bytes" if entry.size > 1 else "Byte") # verify ui strings # widget = ui_test.find("Property//Frame/**/StringField[*].identifier=='created_time'") # self.assertEqual(widget.model.get_value_as_string(), created_time) widget = ui_test.find("Property//Frame/**/StringField[*].identifier=='created_by'") self.assertEqual(widget.model.get_value_as_string(), created_by) # widget = ui_test.find("Property//Frame/**/StringField[*].identifier=='modified_time'") # self.assertEqual(widget.model.get_value_as_string(), modified_time) widget = ui_test.find("Property//Frame/**/StringField[*].identifier=='modified_by'") self.assertEqual(widget.model.get_value_as_string(), modified_by) widget = ui_test.find("Property//Frame/**/StringField[*].identifier=='file_size'") self.assertEqual(widget.model.get_value_as_string(), file_size)
2,770
Python
40.984848
96
0.677978
omniverse-code/kit/exts/omni.kit.property.file/docs/CHANGELOG.md
# Changelog The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [1.0.2] - 2022-07-25 ### Changes - Refactored unittests to make use of content_browser test helpers ## [1.0.1] - 2021-08-18 ### Added - Handled exception on shutdown ## [1.0.0] - 2021-01-20 ### Added - Initial version.
319
Markdown
18.999999
80
0.667712
omniverse-code/kit/exts/omni.kit.property.file/docs/README.md
# omni.kit.property.file ## Introduction This extension adds file selection listener and a File Info property widget.
121
Markdown
16.428569
76
0.785124
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_version.py
# This file was generated by 'versioneer.py' (0.23) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json version_json = ''' { "date": "2023-01-05T13:27:00-0800", "dirty": false, "error": null, "full-revisionid": "6c3dca7918333b21ed91da9e3da42acebd1026d1", "version": "1.6.5" } ''' # END VERSION_JSON def get_versions(): return json.loads(version_json)
497
Python
21.636363
77
0.712274
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/public_api.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. from __future__ import annotations import functools import typing from debugpy import _version # Expose debugpy.server API from subpackage, but do not actually import it unless # and until a member is invoked - we don't want the server package loaded in the # adapter, the tests, or setup.py. # Docstrings for public API members must be formatted according to PEP 8 - no more # than 72 characters per line! - and must be readable when retrieved via help(). Endpoint = typing.Tuple[str, int] def _api(cancelable=False): def apply(f): @functools.wraps(f) def wrapper(*args, **kwargs): from debugpy.server import api wrapped = getattr(api, f.__name__) return wrapped(*args, **kwargs) if cancelable: def cancel(*args, **kwargs): from debugpy.server import api wrapped = getattr(api, f.__name__) return wrapped.cancel(*args, **kwargs) wrapper.cancel = cancel return wrapper return apply @_api() def log_to(__path: str) -> None: """Generate detailed debugpy logs in the specified directory. The directory must already exist. Several log files are generated, one for every process involved in the debug session. """ @_api() def configure(__properties: dict[str, typing.Any] | None = None, **kwargs) -> None: """Sets debug configuration properties that cannot be set in the "attach" request, because they must be applied as early as possible in the process being debugged. For example, a "launch" configuration with subprocess debugging disabled can be defined entirely in JSON:: { "request": "launch", "subProcess": false, ... } But the same cannot be done with "attach", because "subProcess" must be known at the point debugpy starts tracing execution. Thus, it is not available in JSON, and must be omitted:: { "request": "attach", ... } and set from within the debugged process instead:: debugpy.configure(subProcess=False) debugpy.listen(...) Properties to set can be passed either as a single dict argument, or as separate keyword arguments:: debugpy.configure({"subProcess": False}) """ @_api() def listen( __endpoint: Endpoint | int, *, in_process_debug_adapter: bool = False ) -> Endpoint: """Starts a debug adapter debugging this process, that listens for incoming socket connections from clients on the specified address. `__endpoint` must be either a (host, port) tuple as defined by the standard `socket` module for the `AF_INET` address family, or a port number. If only the port is specified, host is "127.0.0.1". `in_process_debug_adapter`: by default a separate python process is spawned and used to communicate with the client as the debug adapter. By setting the value of `in_process_debug_adapter` to True a new python process is not spawned. Note: the con of setting `in_process_debug_adapter` to True is that subprocesses won't be automatically debugged. Returns the interface and the port on which the debug adapter is actually listening, in the same format as `__endpoint`. This may be different from address if port was 0 in the latter, in which case the adapter will pick some unused ephemeral port to listen on. This function does't wait for a client to connect to the debug adapter that it starts. Use `wait_for_client` to block execution until the client connects. """ @_api() def connect(__endpoint: Endpoint | int, *, access_token: str | None = None) -> Endpoint: """Tells an existing debug adapter instance that is listening on the specified address to debug this process. `__endpoint` must be either a (host, port) tuple as defined by the standard `socket` module for the `AF_INET` address family, or a port number. If only the port is specified, host is "127.0.0.1". `access_token` must be the same value that was passed to the adapter via the `--server-access-token` command-line switch. This function does't wait for a client to connect to the debug adapter that it connects to. Use `wait_for_client` to block execution until the client connects. """ @_api(cancelable=True) def wait_for_client() -> None: """If there is a client connected to the debug adapter that is debugging this process, returns immediately. Otherwise, blocks until a client connects to the adapter. While this function is waiting, it can be canceled by calling `wait_for_client.cancel()` from another thread. """ @_api() def is_client_connected() -> bool: """True if a client is connected to the debug adapter that is debugging this process. """ @_api() def breakpoint() -> None: """If a client is connected to the debug adapter that is debugging this process, pauses execution of all threads, and simulates a breakpoint being hit at the line following the call. It is also registered as the default handler for builtins.breakpoint(). """ @_api() def debug_this_thread() -> None: """Makes the debugger aware of the current thread. Must be called on any background thread that is started by means other than the usual Python APIs (i.e. the "threading" module), in order for breakpoints to work on that thread. """ @_api() def trace_this_thread(__should_trace: bool): """Tells the debug adapter to enable or disable tracing on the current thread. When the thread is traced, the debug adapter can detect breakpoints being hit, but execution is slower, especially in functions that have any breakpoints set in them. Disabling tracing when breakpoints are not anticipated to be hit can improve performance. It can also be used to skip breakpoints on a particular thread. Tracing is automatically disabled for all threads when there is no client connected to the debug adapter. """ __version__: str = _version.get_versions()["version"]
6,320
Python
31.415384
88
0.682753
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/__init__.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. """An implementation of the Debug Adapter Protocol (DAP) for Python. https://microsoft.github.io/debug-adapter-protocol/ """ # debugpy stable public API consists solely of members of this module that are # enumerated below. __all__ = [ # noqa "__version__", "breakpoint", "configure", "connect", "debug_this_thread", "is_client_connected", "listen", "log_to", "trace_this_thread", "wait_for_client", ] import sys assert sys.version_info >= (3, 7), ( "Python 3.6 and below is not supported by this version of debugpy; " "use debugpy 1.5.1 or earlier." ) # Actual definitions are in a separate file to work around parsing issues causing # SyntaxError on Python 2 and preventing the above version check from executing. from debugpy.public_api import * # noqa from debugpy.public_api import __version__ del sys
1,018
Python
25.128204
81
0.699411
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/__main__.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. import sys if __name__ == "__main__": # debugpy can also be invoked directly rather than via -m. In this case, the first # entry on sys.path is the one added automatically by Python for the directory # containing this file. This means that import debugpy will not work, since we need # the parent directory of debugpy/ to be in sys.path, rather than debugpy/ itself. # # The other issue is that many other absolute imports will break, because they # will be resolved relative to debugpy/ - e.g. `import debugger` will then try # to import debugpy/debugger.py. # # To fix both, we need to replace the automatically added entry such that it points # at parent directory of debugpy/ instead of debugpy/ itself, import debugpy with that # in sys.path, and then remove the first entry entry altogether, so that it doesn't # affect any further imports we might do. For example, suppose the user did: # # python /foo/bar/debugpy ... # # At the beginning of this script, sys.path will contain "/foo/bar/debugpy" as the # first entry. What we want is to replace it with "/foo/bar', then import debugpy # with that in effect, and then remove the replaced entry before any more # code runs. The imported debugpy module will remain in sys.modules, and thus all # future imports of it or its submodules will resolve accordingly. if "debugpy" not in sys.modules: # Do not use dirname() to walk up - this can be a relative path, e.g. ".". sys.path[0] = sys.path[0] + "/../" import debugpy # noqa del sys.path[0] from debugpy.server import cli cli.main()
1,829
Python
44.749999
90
0.690541
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/_pydevd_packaging.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. from . import VENDORED_ROOT from ._util import cwd, iter_all_files INCLUDES = [ 'setup_pydevd_cython.py', ] def iter_files(): # From the root of pydevd repo, we want only scripts and # subdirectories that constitute the package itself (not helper # scripts, tests etc). But when walking down into those # subdirectories, we want everything below. with cwd(VENDORED_ROOT): return iter_all_files('pydevd', prune_dir, exclude_file) def prune_dir(dirname, basename): if basename == '__pycache__': return True elif dirname != 'pydevd': return False elif basename.startswith('pydev'): return False elif basename.startswith('_pydev'): return False return True def exclude_file(dirname, basename): if dirname == 'pydevd': if basename in INCLUDES: return False elif not basename.endswith('.py'): return True elif 'pydev' not in basename: return True return False if basename.endswith('.pyc'): return True return False
1,245
Python
24.428571
67
0.648193
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/__init__.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. import contextlib from importlib import import_module import os import sys from . import _util VENDORED_ROOT = os.path.dirname(os.path.abspath(__file__)) # TODO: Move the "pydevd" git submodule to the debugpy/_vendored directory # and then drop the following fallback. if "pydevd" not in os.listdir(VENDORED_ROOT): VENDORED_ROOT = os.path.dirname(VENDORED_ROOT) def list_all(resolve=False): """Return the list of vendored projects.""" # TODO: Derive from os.listdir(VENDORED_ROOT)? projects = ["pydevd"] if not resolve: return projects return [project_root(name) for name in projects] def project_root(project): """Return the path the root dir of the vendored project. If "project" is an empty string then the path prefix for vendored projects (e.g. "debugpy/_vendored/") will be returned. """ if not project: project = "" return os.path.join(VENDORED_ROOT, project) def iter_project_files(project, relative=False, **kwargs): """Yield (dirname, basename, filename) for all files in the project.""" if relative: with _util.cwd(VENDORED_ROOT): for result in _util.iter_all_files(project, **kwargs): yield result else: root = project_root(project) for result in _util.iter_all_files(root, **kwargs): yield result def iter_packaging_files(project): """Yield the filenames for all files in the project. The filenames are relative to "debugpy/_vendored". This is most useful for the "package data" in a setup.py. """ # TODO: Use default filters? __pycache__ and .pyc? prune_dir = None exclude_file = None try: mod = import_module("._{}_packaging".format(project), __name__) except ImportError: pass else: prune_dir = getattr(mod, "prune_dir", prune_dir) exclude_file = getattr(mod, "exclude_file", exclude_file) results = iter_project_files( project, relative=True, prune_dir=prune_dir, exclude_file=exclude_file ) for _, _, filename in results: yield filename def prefix_matcher(*prefixes): """Return a module match func that matches any of the given prefixes.""" assert prefixes def match(name, module): for prefix in prefixes: if name.startswith(prefix): return True else: return False return match def check_modules(project, match, root=None): """Verify that only vendored modules have been imported.""" if root is None: root = project_root(project) extensions = [] unvendored = {} for modname, mod in list(sys.modules.items()): if not match(modname, mod): continue try: filename = getattr(mod, "__file__", None) except: # In theory it's possible that any error is raised when accessing __file__ filename = None if not filename: # extension module extensions.append(modname) elif not filename.startswith(root): unvendored[modname] = filename return unvendored, extensions @contextlib.contextmanager def vendored(project, root=None): """A context manager under which the vendored project will be imported.""" if root is None: root = project_root(project) # Add the vendored project directory, so that it gets tried first. sys.path.insert(0, root) try: yield root finally: sys.path.remove(root) def preimport(project, modules, **kwargs): """Import each of the named modules out of the vendored project.""" with vendored(project, **kwargs): for name in modules: import_module(name)
3,878
Python
29.543307
91
0.645436
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/force_pydevd.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. from importlib import import_module import os import warnings from . import check_modules, prefix_matcher, preimport, vendored # Ensure that pydevd is our vendored copy. _unvendored, _ = check_modules('pydevd', prefix_matcher('pydev', '_pydev')) if _unvendored: _unvendored = sorted(_unvendored.values()) msg = 'incompatible copy of pydevd already imported' # raise ImportError(msg) warnings.warn(msg + ':\n {}'.format('\n '.join(_unvendored))) # If debugpy logging is enabled, enable it for pydevd as well if "DEBUGPY_LOG_DIR" in os.environ: os.environ[str("PYDEVD_DEBUG")] = str("True") os.environ[str("PYDEVD_DEBUG_FILE")] = os.environ["DEBUGPY_LOG_DIR"] + str("/debugpy.pydevd.log") # Constants must be set before importing any other pydevd module # # due to heavy use of "from" in them. with vendored('pydevd'): pydevd_constants = import_module('_pydevd_bundle.pydevd_constants') # We limit representation size in our representation provider when needed. pydevd_constants.MAXIMUM_VARIABLE_REPRESENTATION_SIZE = 2 ** 32 # Now make sure all the top-level modules and packages in pydevd are # loaded. Any pydevd modules that aren't loaded at this point, will # be loaded using their parent package's __path__ (i.e. one of the # following). preimport('pydevd', [ '_pydev_bundle', '_pydev_runfiles', '_pydevd_bundle', '_pydevd_frame_eval', 'pydev_ipython', 'pydevd_plugins', 'pydevd', ]) # When pydevd is imported it sets the breakpoint behavior, but it needs to be # overridden because by default pydevd will connect to the remote debugger using # its own custom protocol rather than DAP. import pydevd # noqa import debugpy # noqa def debugpy_breakpointhook(): debugpy.breakpoint() pydevd.install_breakpointhook(debugpy_breakpointhook) # Ensure that pydevd uses JSON protocol from _pydevd_bundle import pydevd_constants from _pydevd_bundle import pydevd_defaults pydevd_defaults.PydevdCustomization.DEFAULT_PROTOCOL = pydevd_constants.HTTP_JSON_PROTOCOL
2,216
Python
34.190476
101
0.726986
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/_util.py
# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See LICENSE in the project root # for license information. import contextlib import os @contextlib.contextmanager def cwd(dirname): """A context manager for operating in a different directory.""" orig = os.getcwd() os.chdir(dirname) try: yield orig finally: os.chdir(orig) def iter_all_files(root, prune_dir=None, exclude_file=None): """Yield (dirname, basename, filename) for each file in the tree. This is an alternative to os.walk() that flattens out the tree and with filtering. """ pending = [root] while pending: dirname = pending.pop(0) for result in _iter_files(dirname, pending, prune_dir, exclude_file): yield result def iter_tree(root, prune_dir=None, exclude_file=None): """Yield (dirname, files) for each directory in the tree. The list of files is actually a list of (basename, filename). This is an alternative to os.walk() with filtering.""" pending = [root] while pending: dirname = pending.pop(0) files = [] for _, b, f in _iter_files(dirname, pending, prune_dir, exclude_file): files.append((b, f)) yield dirname, files def _iter_files(dirname, subdirs, prune_dir, exclude_file): for basename in os.listdir(dirname): filename = os.path.join(dirname, basename) if os.path.isdir(filename): if prune_dir is not None and prune_dir(dirname, basename): continue subdirs.append(filename) else: # TODO: Use os.path.isfile() to narrow it down? if exclude_file is not None and exclude_file(dirname, basename): continue yield dirname, basename, filename
1,840
Python
29.683333
78
0.636413
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydev_app_engine_debug_startup.py
if False: config = None # See: https://docs.google.com/document/d/1CCSaRiIWCLgbD3OwmuKsRoHHDfBffbROWyVWWL0ZXN4/edit if ':' not in config.version_id: # The default server version_id does not contain ':' import json import os import sys startup = config.python_config.startup_args if not startup: raise AssertionError('Expected --python_startup_args to be passed from the pydev debugger.') setup = json.loads(startup) pydevd_path = setup['pydevd'] sys.path.append(os.path.dirname(pydevd_path)) import pydevd pydevd.settrace(setup['client'], port=setup['port'], suspend=False, trace_only_current_thread=False)
691
Python
30.454544
104
0.683068
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydev_pysrc.py
'''An empty file in pysrc that can be imported (from sitecustomize) to find the location of pysrc'''
100
Python
99.9999
100
0.76
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydevd_tracing.py
from _pydevd_bundle.pydevd_constants import get_frame, IS_CPYTHON, IS_64BIT_PROCESS, IS_WINDOWS, \ IS_LINUX, IS_MAC, DebugInfoHolder, LOAD_NATIVE_LIB_FLAG, \ ENV_FALSE_LOWER_VALUES, ForkSafeLock from _pydev_bundle._pydev_saved_modules import thread, threading from _pydev_bundle import pydev_log, pydev_monkey import os.path import platform import ctypes from io import StringIO import sys import traceback _original_settrace = sys.settrace class TracingFunctionHolder: '''This class exists just to keep some variables (so that we don't keep them in the global namespace). ''' _original_tracing = None _warn = True _traceback_limit = 1 _warnings_shown = {} def get_exception_traceback_str(): exc_info = sys.exc_info() s = StringIO() traceback.print_exception(exc_info[0], exc_info[1], exc_info[2], file=s) return s.getvalue() def _get_stack_str(frame): msg = '\nIf this is needed, please check: ' + \ '\nhttp://pydev.blogspot.com/2007/06/why-cant-pydev-debugger-work-with.html' + \ '\nto see how to restore the debug tracing back correctly.\n' if TracingFunctionHolder._traceback_limit: s = StringIO() s.write('Call Location:\n') traceback.print_stack(f=frame, limit=TracingFunctionHolder._traceback_limit, file=s) msg = msg + s.getvalue() return msg def _internal_set_trace(tracing_func): if TracingFunctionHolder._warn: frame = get_frame() if frame is not None and frame.f_back is not None: filename = frame.f_back.f_code.co_filename.lower() if not filename.endswith('threading.py') and not filename.endswith('pydevd_tracing.py'): message = \ '\nPYDEV DEBUGGER WARNING:' + \ '\nsys.settrace() should not be used when the debugger is being used.' + \ '\nThis may cause the debugger to stop working correctly.' + \ '%s' % _get_stack_str(frame.f_back) if message not in TracingFunctionHolder._warnings_shown: # only warn about each message once... TracingFunctionHolder._warnings_shown[message] = 1 sys.stderr.write('%s\n' % (message,)) sys.stderr.flush() if TracingFunctionHolder._original_tracing: TracingFunctionHolder._original_tracing(tracing_func) _last_tracing_func_thread_local = threading.local() def SetTrace(tracing_func): _last_tracing_func_thread_local.tracing_func = tracing_func if tracing_func is not None: if set_trace_to_threads(tracing_func, thread_idents=[thread.get_ident()], create_dummy_thread=False) == 0: # If we can use our own tracer instead of the one from sys.settrace, do it (the reason # is that this is faster than the Python version because we don't call # PyFrame_FastToLocalsWithError and PyFrame_LocalsToFast at each event! # (the difference can be huge when checking line events on frames as the # time increases based on the number of local variables in the scope) # See: InternalCallTrampoline (on the C side) for details. return # If it didn't work (or if it was None), use the Python version. set_trace = TracingFunctionHolder._original_tracing or sys.settrace set_trace(tracing_func) def reapply_settrace(): try: tracing_func = _last_tracing_func_thread_local.tracing_func except AttributeError: return else: SetTrace(tracing_func) def replace_sys_set_trace_func(): if TracingFunctionHolder._original_tracing is None: TracingFunctionHolder._original_tracing = sys.settrace sys.settrace = _internal_set_trace def restore_sys_set_trace_func(): if TracingFunctionHolder._original_tracing is not None: sys.settrace = TracingFunctionHolder._original_tracing TracingFunctionHolder._original_tracing = None _lock = ForkSafeLock() def _load_python_helper_lib(): try: # If it's already loaded, just return it. return _load_python_helper_lib.__lib__ except AttributeError: pass with _lock: try: return _load_python_helper_lib.__lib__ except AttributeError: pass lib = _load_python_helper_lib_uncached() _load_python_helper_lib.__lib__ = lib return lib def get_python_helper_lib_filename(): # Note: we have an independent (and similar -- but not equal) version of this method in # `add_code_to_python_process.py` which should be kept synchronized with this one (we do a copy # because the `pydevd_attach_to_process` is mostly independent and shouldn't be imported in the # debugger -- the only situation where it's imported is if the user actually does an attach to # process, through `attach_pydevd.py`, but this should usually be called from the IDE directly # and not from the debugger). libdir = os.path.join(os.path.dirname(__file__), 'pydevd_attach_to_process') arch = '' if IS_WINDOWS: # prefer not using platform.machine() when possible (it's a bit heavyweight as it may # spawn a subprocess). arch = os.environ.get("PROCESSOR_ARCHITEW6432", os.environ.get('PROCESSOR_ARCHITECTURE', '')) if not arch: arch = platform.machine() if not arch: pydev_log.info('platform.machine() did not return valid value.') # This shouldn't happen... return None if IS_WINDOWS: extension = '.dll' suffix_64 = 'amd64' suffix_32 = 'x86' elif IS_LINUX: extension = '.so' suffix_64 = 'amd64' suffix_32 = 'x86' elif IS_MAC: extension = '.dylib' suffix_64 = 'x86_64' suffix_32 = 'x86' else: pydev_log.info('Unable to set trace to all threads in platform: %s', sys.platform) return None if arch.lower() not in ('amd64', 'x86', 'x86_64', 'i386', 'x86'): # We don't support this processor by default. Still, let's support the case where the # user manually compiled it himself with some heuristics. # # Ideally the user would provide a library in the format: "attach_<arch>.<extension>" # based on the way it's currently compiled -- see: # - windows/compile_windows.bat # - linux_and_mac/compile_linux.sh # - linux_and_mac/compile_mac.sh try: found = [name for name in os.listdir(libdir) if name.startswith('attach_') and name.endswith(extension)] except: if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1: # There is no need to show this unless debug tracing is enabled. pydev_log.exception('Error listing dir: %s', libdir) return None expected_name = 'attach_' + arch + extension expected_name_linux = 'attach_linux_' + arch + extension filename = None if expected_name in found: # Heuristic: user compiled with "attach_<arch>.<extension>" filename = os.path.join(libdir, expected_name) elif IS_LINUX and expected_name_linux in found: # Heuristic: user compiled with "attach_linux_<arch>.<extension>" filename = os.path.join(libdir, expected_name_linux) elif len(found) == 1: # Heuristic: user removed all libraries and just left his own lib. filename = os.path.join(libdir, found[0]) else: # Heuristic: there's one additional library which doesn't seem to be our own. Find the odd one. filtered = [name for name in found if not name.endswith((suffix_64 + extension, suffix_32 + extension))] if len(filtered) == 1: # If more than one is available we can't be sure... filename = os.path.join(libdir, found[0]) if filename is None: pydev_log.info( 'Unable to set trace to all threads in arch: %s (did not find a %s lib in %s).', arch, expected_name, libdir ) return None pydev_log.info('Using %s lib in arch: %s.', filename, arch) else: # Happy path for which we have pre-compiled binaries. if IS_64BIT_PROCESS: suffix = suffix_64 else: suffix = suffix_32 if IS_WINDOWS or IS_MAC: # just the extension changes prefix = 'attach_' elif IS_LINUX: # prefix = 'attach_linux_' # historically it has a different name else: pydev_log.info('Unable to set trace to all threads in platform: %s', sys.platform) return None filename = os.path.join(libdir, '%s%s%s' % (prefix, suffix, extension)) if not os.path.exists(filename): pydev_log.critical('Expected: %s to exist.', filename) return None return filename def _load_python_helper_lib_uncached(): if (not IS_CPYTHON or sys.version_info[:2] > (3, 11) or hasattr(sys, 'gettotalrefcount') or LOAD_NATIVE_LIB_FLAG in ENV_FALSE_LOWER_VALUES): pydev_log.info('Helper lib to set tracing to all threads not loaded.') return None try: filename = get_python_helper_lib_filename() if filename is None: return None # Load as pydll so that we don't release the gil. lib = ctypes.pydll.LoadLibrary(filename) pydev_log.info('Successfully Loaded helper lib to set tracing to all threads.') return lib except: if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1: # Only show message if tracing is on (we don't have pre-compiled # binaries for all architectures -- i.e.: ARM). pydev_log.exception('Error loading: %s', filename) return None def set_trace_to_threads(tracing_func, thread_idents=None, create_dummy_thread=True): assert tracing_func is not None ret = 0 # Note: use sys._current_frames() keys to get the thread ids because it'll return # thread ids created in C/C++ where there's user code running, unlike the APIs # from the threading module which see only threads created through it (unless # a call for threading.current_thread() was previously done in that thread, # in which case a dummy thread would've been created for it). if thread_idents is None: thread_idents = set(sys._current_frames().keys()) for t in threading.enumerate(): # PY-44778: ignore pydevd threads and also add any thread that wasn't found on # sys._current_frames() as some existing threads may not appear in # sys._current_frames() but may be available through the `threading` module. if getattr(t, 'pydev_do_not_trace', False): thread_idents.discard(t.ident) else: thread_idents.add(t.ident) curr_ident = thread.get_ident() curr_thread = threading._active.get(curr_ident) if curr_ident in thread_idents and len(thread_idents) != 1: # The current thread must be updated first (because we need to set # the reference to `curr_thread`). thread_idents = list(thread_idents) thread_idents.remove(curr_ident) thread_idents.insert(0, curr_ident) for thread_ident in thread_idents: # If that thread is not available in the threading module we also need to create a # dummy thread for it (otherwise it'll be invisible to the debugger). if create_dummy_thread: if thread_ident not in threading._active: class _DummyThread(threading._DummyThread): def _set_ident(self): # Note: Hack to set the thread ident that we want. self._ident = thread_ident t = _DummyThread() # Reset to the base class (don't expose our own version of the class). t.__class__ = threading._DummyThread if thread_ident == curr_ident: curr_thread = t with threading._active_limbo_lock: # On Py2 it'll put in active getting the current indent, not using the # ident that was set, so, we have to update it (should be harmless on Py3 # so, do it always). threading._active[thread_ident] = t threading._active[curr_ident] = curr_thread if t.ident != thread_ident: # Check if it actually worked. pydev_log.critical('pydevd: creation of _DummyThread with fixed thread ident did not succeed.') # Some (ptvsd) tests failed because of this, so, leave it always disabled for now. # show_debug_info = 1 if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1 else 0 show_debug_info = 0 # Hack to increase _Py_TracingPossible. # See comments on py_custom_pyeval_settrace.hpp proceed = thread.allocate_lock() proceed.acquire() def dummy_trace(frame, event, arg): return dummy_trace def increase_tracing_count(): set_trace = TracingFunctionHolder._original_tracing or sys.settrace set_trace(dummy_trace) proceed.release() start_new_thread = pydev_monkey.get_original_start_new_thread(thread) start_new_thread(increase_tracing_count, ()) proceed.acquire() # Only proceed after the release() is done. proceed = None # Note: The set_trace_func is not really used anymore in the C side. set_trace_func = TracingFunctionHolder._original_tracing or sys.settrace lib = _load_python_helper_lib() if lib is None: # This is the case if it's not CPython. pydev_log.info('Unable to load helper lib to set tracing to all threads (unsupported python vm).') ret = -1 else: try: result = lib.AttachDebuggerTracing( ctypes.c_int(show_debug_info), ctypes.py_object(set_trace_func), ctypes.py_object(tracing_func), ctypes.c_uint(thread_ident), ctypes.py_object(None), ) except: if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1: # There is no need to show this unless debug tracing is enabled. pydev_log.exception('Error attaching debugger tracing') ret = -1 else: if result != 0: pydev_log.info('Unable to set tracing for existing thread. Result: %s', result) ret = result return ret
14,804
Python
38.375
122
0.613753
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/setup_pydevd_cython.py
''' A simpler setup version just to compile the speedup module. It should be used as: python setup_pydevd_cython build_ext --inplace Note: the .c file and other generated files are regenerated from the .pyx file by running "python build_tools/build.py" ''' import os import sys from setuptools import setup os.chdir(os.path.dirname(os.path.abspath(__file__))) IS_PY36_OR_GREATER = sys.version_info > (3, 6) TODO_PY311 = sys.version_info > (3, 11) def process_args(): extension_folder = None target_pydevd_name = None target_frame_eval = None force_cython = False for i, arg in enumerate(sys.argv[:]): if arg == '--build-lib': extension_folder = sys.argv[i + 1] # It shouldn't be removed from sys.argv (among with --build-temp) because they're passed further to setup() if arg.startswith('--target-pyd-name='): sys.argv.remove(arg) target_pydevd_name = arg[len('--target-pyd-name='):] if arg.startswith('--target-pyd-frame-eval='): sys.argv.remove(arg) target_frame_eval = arg[len('--target-pyd-frame-eval='):] if arg == '--force-cython': sys.argv.remove(arg) force_cython = True return extension_folder, target_pydevd_name, target_frame_eval, force_cython def process_template_lines(template_lines): # Create 2 versions of the template, one for Python 3.8 and another for Python 3.9 for version in ('38', '39'): yield '### WARNING: GENERATED CODE, DO NOT EDIT!' yield '### WARNING: GENERATED CODE, DO NOT EDIT!' yield '### WARNING: GENERATED CODE, DO NOT EDIT!' for line in template_lines: if version == '38': line = line.replace('get_bytecode_while_frame_eval(PyFrameObject * frame_obj, int exc)', 'get_bytecode_while_frame_eval_38(PyFrameObject * frame_obj, int exc)') line = line.replace('CALL_EvalFrameDefault', 'CALL_EvalFrameDefault_38(frame_obj, exc)') else: # 3.9 line = line.replace('get_bytecode_while_frame_eval(PyFrameObject * frame_obj, int exc)', 'get_bytecode_while_frame_eval_39(PyThreadState* tstate, PyFrameObject * frame_obj, int exc)') line = line.replace('CALL_EvalFrameDefault', 'CALL_EvalFrameDefault_39(tstate, frame_obj, exc)') yield line yield '### WARNING: GENERATED CODE, DO NOT EDIT!' yield '### WARNING: GENERATED CODE, DO NOT EDIT!' yield '### WARNING: GENERATED CODE, DO NOT EDIT!' yield '' yield '' def process_template_file(contents): ret = [] template_lines = [] append_to = ret for line in contents.splitlines(keepends=False): if line.strip() == '### TEMPLATE_START': append_to = template_lines elif line.strip() == '### TEMPLATE_END': append_to = ret for line in process_template_lines(template_lines): ret.append(line) else: append_to.append(line) return '\n'.join(ret) def build_extension(dir_name, extension_name, target_pydevd_name, force_cython, extended=False, has_pxd=False, template=False): pyx_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pyx" % (extension_name,)) if template: pyx_template_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.template.pyx" % (extension_name,)) with open(pyx_template_file, 'r') as stream: contents = stream.read() contents = process_template_file(contents) with open(pyx_file, 'w') as stream: stream.write(contents) if target_pydevd_name != extension_name: # It MUST be there in this case! # (otherwise we'll have unresolved externals because the .c file had another name initially). import shutil # We must force cython in this case (but only in this case -- for the regular setup in the user machine, we # should always compile the .c file). force_cython = True new_pyx_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pyx" % (target_pydevd_name,)) new_c_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.c" % (target_pydevd_name,)) shutil.copy(pyx_file, new_pyx_file) pyx_file = new_pyx_file if has_pxd: pxd_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pxd" % (extension_name,)) new_pxd_file = os.path.join(os.path.dirname(__file__), dir_name, "%s.pxd" % (target_pydevd_name,)) shutil.copy(pxd_file, new_pxd_file) assert os.path.exists(pyx_file) try: c_files = [os.path.join(dir_name, "%s.c" % target_pydevd_name), ] if force_cython: for c_file in c_files: try: os.remove(c_file) except: pass from Cython.Build import cythonize # @UnusedImport # Generate the .c files in cythonize (will not compile at this point). target = "%s/%s.pyx" % (dir_name, target_pydevd_name,) cythonize([target]) # Workarounds needed in CPython 3.8 and 3.9 to access PyInterpreterState.eval_frame. for c_file in c_files: with open(c_file, 'r') as stream: c_file_contents = stream.read() if '#include "internal/pycore_gc.h"' not in c_file_contents: c_file_contents = c_file_contents.replace('#include "Python.h"', '''#include "Python.h" #if PY_VERSION_HEX >= 0x03090000 #include "internal/pycore_gc.h" #include "internal/pycore_interp.h" #endif ''') if '#include "internal/pycore_pystate.h"' not in c_file_contents: c_file_contents = c_file_contents.replace('#include "pystate.h"', '''#include "pystate.h" #if PY_VERSION_HEX >= 0x03080000 #include "internal/pycore_pystate.h" #endif ''') # We want the same output on Windows and Linux. c_file_contents = c_file_contents.replace('\r\n', '\n').replace('\r', '\n') c_file_contents = c_file_contents.replace(r'_pydevd_frame_eval\\release_mem.h', '_pydevd_frame_eval/release_mem.h') c_file_contents = c_file_contents.replace(r'_pydevd_frame_eval\\pydevd_frame_evaluator.pyx', '_pydevd_frame_eval/pydevd_frame_evaluator.pyx') c_file_contents = c_file_contents.replace(r'_pydevd_bundle\\pydevd_cython.pxd', '_pydevd_bundle/pydevd_cython.pxd') c_file_contents = c_file_contents.replace(r'_pydevd_bundle\\pydevd_cython.pyx', '_pydevd_bundle/pydevd_cython.pyx') with open(c_file, 'w') as stream: stream.write(c_file_contents) # Always compile the .c (and not the .pyx) file (which we should keep up-to-date by running build_tools/build.py). from distutils.extension import Extension extra_compile_args = [] extra_link_args = [] if 'linux' in sys.platform: # Enabling -flto brings executable from 4MB to 0.56MB and -Os to 0.41MB # Profiling shows an execution around 3-5% slower with -Os vs -O3, # so, kept only -flto. extra_compile_args = ["-flto", "-O3"] extra_link_args = extra_compile_args[:] # Note: also experimented with profile-guided optimization. The executable # size became a bit smaller (from 0.56MB to 0.5MB) but this would add an # extra step to run the debugger to obtain the optimizations # so, skipped it for now (note: the actual benchmarks time was in the # margin of a 0-1% improvement, which is probably not worth it for # speed increments). # extra_compile_args = ["-flto", "-fprofile-generate"] # ... Run benchmarks ... # extra_compile_args = ["-flto", "-fprofile-use", "-fprofile-correction"] elif 'win32' in sys.platform: pass # uncomment to generate pdbs for visual studio. # extra_compile_args=["-Zi", "/Od"] # extra_link_args=["-debug"] kwargs = {} if extra_link_args: kwargs['extra_link_args'] = extra_link_args if extra_compile_args: kwargs['extra_compile_args'] = extra_compile_args ext_modules = [ Extension( "%s%s.%s" % (dir_name, "_ext" if extended else "", target_pydevd_name,), c_files, **kwargs )] # This is needed in CPython 3.8 to be able to include internal/pycore_pystate.h # (needed to set PyInterpreterState.eval_frame). for module in ext_modules: module.define_macros = [('Py_BUILD_CORE_MODULE', '1')] setup( name='Cythonize', ext_modules=ext_modules ) finally: if target_pydevd_name != extension_name: try: os.remove(new_pyx_file) except: import traceback traceback.print_exc() try: os.remove(new_c_file) except: import traceback traceback.print_exc() if has_pxd: try: os.remove(new_pxd_file) except: import traceback traceback.print_exc() extension_folder, target_pydevd_name, target_frame_eval, force_cython = process_args() extension_name = "pydevd_cython" if target_pydevd_name is None: target_pydevd_name = extension_name build_extension("_pydevd_bundle", extension_name, target_pydevd_name, force_cython, extension_folder, True) if IS_PY36_OR_GREATER and not TODO_PY311: extension_name = "pydevd_frame_evaluator" if target_frame_eval is None: target_frame_eval = extension_name build_extension("_pydevd_frame_eval", extension_name, target_frame_eval, force_cython, extension_folder, True, template=True) if extension_folder: os.chdir(extension_folder) for folder in [file for file in os.listdir(extension_folder) if file != 'build' and os.path.isdir(os.path.join(extension_folder, file))]: file = os.path.join(folder, "__init__.py") if not os.path.exists(file): open(file, 'a').close()
10,410
Python
40.478087
199
0.592219
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydevd.py
''' Entry point module (keep at root): This module starts the debugger. ''' import sys # @NoMove if sys.version_info[:2] < (3, 6): raise RuntimeError('The PyDev.Debugger requires Python 3.6 onwards to be run. If you need to use an older Python version, use an older version of the debugger.') import os try: # Just empty packages to check if they're in the PYTHONPATH. import _pydev_bundle except ImportError: # On the first import of a pydevd module, add pydevd itself to the PYTHONPATH # if its dependencies cannot be imported. sys.path.append(os.path.dirname(os.path.abspath(__file__))) import _pydev_bundle # Import this first as it'll check for shadowed modules and will make sure that we import # things as needed for gevent. from _pydevd_bundle import pydevd_constants import atexit import dis import io from collections import defaultdict from contextlib import contextmanager from functools import partial import itertools import traceback import weakref import getpass as getpass_mod import functools import pydevd_file_utils from _pydev_bundle import pydev_imports, pydev_log from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding from _pydev_bundle.pydev_is_thread_alive import is_thread_alive from _pydev_bundle.pydev_override import overrides from _pydev_bundle._pydev_saved_modules import threading, time, thread from _pydevd_bundle import pydevd_extension_utils, pydevd_frame_utils from _pydevd_bundle.pydevd_filtering import FilesFiltering, glob_matches_path from _pydevd_bundle import pydevd_io, pydevd_vm_type from _pydevd_bundle import pydevd_utils from _pydevd_bundle import pydevd_runpy from _pydev_bundle.pydev_console_utils import DebugConsoleStdIn from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info from _pydevd_bundle.pydevd_breakpoints import ExceptionBreakpoint, get_exception_breakpoint from _pydevd_bundle.pydevd_comm_constants import (CMD_THREAD_SUSPEND, CMD_STEP_INTO, CMD_SET_BREAK, CMD_STEP_INTO_MY_CODE, CMD_STEP_OVER, CMD_SMART_STEP_INTO, CMD_RUN_TO_LINE, CMD_SET_NEXT_STATEMENT, CMD_STEP_RETURN, CMD_ADD_EXCEPTION_BREAK, CMD_STEP_RETURN_MY_CODE, CMD_STEP_OVER_MY_CODE, constant_to_str, CMD_STEP_INTO_COROUTINE) from _pydevd_bundle.pydevd_constants import (get_thread_id, get_current_thread_id, DebugInfoHolder, PYTHON_SUSPEND, STATE_SUSPEND, STATE_RUN, get_frame, clear_cached_thread_id, INTERACTIVE_MODE_AVAILABLE, SHOW_DEBUG_INFO_ENV, NULL, NO_FTRACE, IS_IRONPYTHON, JSON_PROTOCOL, IS_CPYTHON, HTTP_JSON_PROTOCOL, USE_CUSTOM_SYS_CURRENT_FRAMES_MAP, call_only_once, ForkSafeLock, IGNORE_BASENAMES_STARTING_WITH, EXCEPTION_TYPE_UNHANDLED, SUPPORT_GEVENT, PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING, PYDEVD_IPYTHON_CONTEXT) from _pydevd_bundle.pydevd_defaults import PydevdCustomization # Note: import alias used on pydev_monkey. from _pydevd_bundle.pydevd_custom_frames import CustomFramesContainer, custom_frames_container_init from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE, PYDEV_FILE, LIB_FILE, DONT_TRACE_DIRS from _pydevd_bundle.pydevd_extension_api import DebuggerEventHandler from _pydevd_bundle.pydevd_frame_utils import add_exception_to_frame, remove_exception_from_frame from _pydevd_bundle.pydevd_net_command_factory_xml import NetCommandFactory from _pydevd_bundle.pydevd_trace_dispatch import ( trace_dispatch as _trace_dispatch, global_cache_skips, global_cache_frame_skips, fix_top_level_trace_and_get_trace_func) from _pydevd_bundle.pydevd_utils import save_main_module, is_current_thread_main_thread, \ import_attr_from_module from _pydevd_frame_eval.pydevd_frame_eval_main import ( frame_eval_func, dummy_trace_dispatch) import pydev_ipython # @UnusedImport from _pydevd_bundle.pydevd_source_mapping import SourceMapping from _pydevd_bundle.pydevd_concurrency_analyser.pydevd_concurrency_logger import ThreadingLogger, AsyncioLogger, send_concurrency_message, cur_time from _pydevd_bundle.pydevd_concurrency_analyser.pydevd_thread_wrappers import wrap_threads from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER from pydevd_file_utils import get_fullname, get_package_dir from os.path import abspath as os_path_abspath import pydevd_tracing from _pydevd_bundle.pydevd_comm import (InternalThreadCommand, InternalThreadCommandForAnyThread, create_server_socket, FSNotifyThread) from _pydevd_bundle.pydevd_comm import(InternalConsoleExec, _queue, ReaderThread, GetGlobalDebugger, get_global_debugger, set_global_debugger, WriterThread, start_client, start_server, InternalGetBreakpointException, InternalSendCurrExceptionTrace, InternalSendCurrExceptionTraceProceeded) from _pydevd_bundle.pydevd_daemon_thread import PyDBDaemonThread, mark_as_pydevd_daemon_thread from _pydevd_bundle.pydevd_process_net_command_json import PyDevJsonCommandProcessor from _pydevd_bundle.pydevd_process_net_command import process_net_command from _pydevd_bundle.pydevd_net_command import NetCommand, NULL_NET_COMMAND from _pydevd_bundle.pydevd_breakpoints import stop_on_unhandled_exception from _pydevd_bundle.pydevd_collect_bytecode_info import collect_try_except_info, collect_return_info, collect_try_except_info_from_source from _pydevd_bundle.pydevd_suspended_frames import SuspendedFramesManager from socket import SHUT_RDWR from _pydevd_bundle.pydevd_api import PyDevdAPI from _pydevd_bundle.pydevd_timeout import TimeoutTracker from _pydevd_bundle.pydevd_thread_lifecycle import suspend_all_threads, mark_thread_suspended pydevd_gevent_integration = None if SUPPORT_GEVENT: try: from _pydevd_bundle import pydevd_gevent_integration except: pydev_log.exception( 'pydevd: GEVENT_SUPPORT is set but gevent is not available in the environment.\n' 'Please unset GEVENT_SUPPORT from the environment variables or install gevent.') else: pydevd_gevent_integration.log_gevent_debug_info() if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP: from _pydevd_bundle.pydevd_constants import constructed_tid_to_last_frame __version_info__ = (2, 8, 0) __version_info_str__ = [] for v in __version_info__: __version_info_str__.append(str(v)) __version__ = '.'.join(__version_info_str__) # IMPORTANT: pydevd_constants must be the 1st thing defined because it'll keep a reference to the original sys._getframe def install_breakpointhook(pydevd_breakpointhook=None): if pydevd_breakpointhook is None: def pydevd_breakpointhook(*args, **kwargs): hookname = os.getenv('PYTHONBREAKPOINT') if ( hookname is not None and len(hookname) > 0 and hasattr(sys, '__breakpointhook__') and sys.__breakpointhook__ != pydevd_breakpointhook ): sys.__breakpointhook__(*args, **kwargs) else: settrace(*args, **kwargs) if sys.version_info[0:2] >= (3, 7): # There are some choices on how to provide the breakpoint hook. Namely, we can provide a # PYTHONBREAKPOINT which provides the import path for a method to be executed or we # can override sys.breakpointhook. # pydevd overrides sys.breakpointhook instead of providing an environment variable because # it's possible that the debugger starts the user program but is not available in the # PYTHONPATH (and would thus fail to be imported if PYTHONBREAKPOINT was set to pydevd.settrace). # Note that the implementation still takes PYTHONBREAKPOINT in account (so, if it was provided # by someone else, it'd still work). sys.breakpointhook = pydevd_breakpointhook else: if sys.version_info[0] >= 3: import builtins as __builtin__ # Py3 noqa else: import __builtin__ # noqa # In older versions, breakpoint() isn't really available, so, install the hook directly # in the builtins. __builtin__.breakpoint = pydevd_breakpointhook sys.__breakpointhook__ = pydevd_breakpointhook # Install the breakpoint hook at import time. install_breakpointhook() from _pydevd_bundle.pydevd_plugin_utils import PluginManager threadingEnumerate = threading.enumerate threadingCurrentThread = threading.current_thread try: 'dummy'.encode('utf-8') # Added because otherwise Jython 2.2.1 wasn't finding the encoding (if it wasn't loaded in the main thread). except: pass _global_redirect_stdout_to_server = False _global_redirect_stderr_to_server = False file_system_encoding = getfilesystemencoding() _CACHE_FILE_TYPE = {} pydev_log.debug('Using GEVENT_SUPPORT: %s', pydevd_constants.SUPPORT_GEVENT) pydev_log.debug('Using GEVENT_SHOW_PAUSED_GREENLETS: %s', pydevd_constants.GEVENT_SHOW_PAUSED_GREENLETS) pydev_log.debug('pydevd __file__: %s', os.path.abspath(__file__)) pydev_log.debug('Using PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING: %s', pydevd_constants.PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING) if pydevd_constants.PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING: pydev_log.debug('PYDEVD_IPYTHON_CONTEXT: %s', pydevd_constants.PYDEVD_IPYTHON_CONTEXT) #======================================================================================================================= # PyDBCommandThread #======================================================================================================================= class PyDBCommandThread(PyDBDaemonThread): def __init__(self, py_db): PyDBDaemonThread.__init__(self, py_db) self._py_db_command_thread_event = py_db._py_db_command_thread_event self.name = 'pydevd.CommandThread' @overrides(PyDBDaemonThread._on_run) def _on_run(self): # Delay a bit this initialization to wait for the main program to start. self._py_db_command_thread_event.wait(0.3) if self._kill_received: return try: while not self._kill_received: try: self.py_db.process_internal_commands() except: pydev_log.info('Finishing debug communication...(2)') self._py_db_command_thread_event.clear() self._py_db_command_thread_event.wait(0.3) except: try: pydev_log.debug(sys.exc_info()[0]) except: # In interpreter shutdown many things can go wrong (any module variables may # be None, streams can be closed, etc). pass # only got this error in interpreter shutdown # pydev_log.info('Finishing debug communication...(3)') @overrides(PyDBDaemonThread.do_kill_pydev_thread) def do_kill_pydev_thread(self): PyDBDaemonThread.do_kill_pydev_thread(self) # Set flag so that it can exit before the usual timeout. self._py_db_command_thread_event.set() #======================================================================================================================= # CheckAliveThread # Non-daemon thread: guarantees that all data is written even if program is finished #======================================================================================================================= class CheckAliveThread(PyDBDaemonThread): def __init__(self, py_db): PyDBDaemonThread.__init__(self, py_db) self.name = 'pydevd.CheckAliveThread' self.daemon = False self._wait_event = threading.Event() @overrides(PyDBDaemonThread._on_run) def _on_run(self): py_db = self.py_db def can_exit(): with py_db._main_lock: # Note: it's important to get the lock besides checking that it's empty (this # means that we're not in the middle of some command processing). writer = py_db.writer writer_empty = writer is not None and writer.empty() return not py_db.has_user_threads_alive() and writer_empty try: while not self._kill_received: self._wait_event.wait(0.3) if can_exit(): break py_db.check_output_redirect() if can_exit(): pydev_log.debug("No threads alive, finishing debug session") py_db.dispose_and_kill_all_pydevd_threads() except: pydev_log.exception() def join(self, timeout=None): # If someone tries to join this thread, mark it to be killed. # This is the case for CherryPy when auto-reload is turned on. self.do_kill_pydev_thread() PyDBDaemonThread.join(self, timeout=timeout) @overrides(PyDBDaemonThread.do_kill_pydev_thread) def do_kill_pydev_thread(self): PyDBDaemonThread.do_kill_pydev_thread(self) # Set flag so that it can exit before the usual timeout. self._wait_event.set() class AbstractSingleNotificationBehavior(object): ''' The basic usage should be: # Increment the request time for the suspend. single_notification_behavior.increment_suspend_time() # Notify that this is a pause request (when a pause, not a breakpoint). single_notification_behavior.on_pause() # Mark threads to be suspended. set_suspend(...) # On do_wait_suspend, use notify_thread_suspended: def do_wait_suspend(...): with single_notification_behavior.notify_thread_suspended(thread_id): ... ''' __slots__ = [ '_last_resume_notification_time', '_last_suspend_notification_time', '_lock', '_next_request_time', '_suspend_time_request', '_suspended_thread_ids', '_pause_requested', '_py_db', ] NOTIFY_OF_PAUSE_TIMEOUT = .5 def __init__(self, py_db): self._py_db = weakref.ref(py_db) self._next_request_time = partial(next, itertools.count()) self._last_suspend_notification_time = -1 self._last_resume_notification_time = -1 self._suspend_time_request = self._next_request_time() self._lock = thread.allocate_lock() self._suspended_thread_ids = set() self._pause_requested = False def send_suspend_notification(self, thread_id, stop_reason): raise AssertionError('abstract: subclasses must override.') def send_resume_notification(self, thread_id): raise AssertionError('abstract: subclasses must override.') def increment_suspend_time(self): with self._lock: self._suspend_time_request = self._next_request_time() def on_pause(self): # Upon a pause, we should force sending new suspend notifications # if no notification is sent after some time and there's some thread already stopped. with self._lock: self._pause_requested = True global_suspend_time = self._suspend_time_request py_db = self._py_db() if py_db is not None: py_db.timeout_tracker.call_on_timeout( self.NOTIFY_OF_PAUSE_TIMEOUT, self._notify_after_timeout, kwargs={'global_suspend_time': global_suspend_time} ) def _notify_after_timeout(self, global_suspend_time): with self._lock: if self._suspended_thread_ids: if global_suspend_time > self._last_suspend_notification_time: self._last_suspend_notification_time = global_suspend_time # Notify about any thread which is currently suspended. pydev_log.info('Sending suspend notification after timeout.') self.send_suspend_notification(next(iter(self._suspended_thread_ids)), CMD_THREAD_SUSPEND) def on_thread_suspend(self, thread_id, stop_reason): with self._lock: pause_requested = self._pause_requested if pause_requested: # When a suspend notification is sent, reset the pause flag. self._pause_requested = False self._suspended_thread_ids.add(thread_id) # CMD_THREAD_SUSPEND should always be a side-effect of a break, so, only # issue for a CMD_THREAD_SUSPEND if a pause is pending. if stop_reason != CMD_THREAD_SUSPEND or pause_requested: if self._suspend_time_request > self._last_suspend_notification_time: pydev_log.info('Sending suspend notification.') self._last_suspend_notification_time = self._suspend_time_request self.send_suspend_notification(thread_id, stop_reason) else: pydev_log.info( 'Suspend not sent (it was already sent). Last suspend % <= Last resume %s', self._last_suspend_notification_time, self._last_resume_notification_time, ) else: pydev_log.info( 'Suspend not sent because stop reason is thread suspend and pause was not requested.', ) def on_thread_resume(self, thread_id): # on resume (step, continue all): with self._lock: self._suspended_thread_ids.remove(thread_id) if self._last_resume_notification_time < self._last_suspend_notification_time: pydev_log.info('Sending resume notification.') self._last_resume_notification_time = self._last_suspend_notification_time self.send_resume_notification(thread_id) else: pydev_log.info( 'Resume not sent (it was already sent). Last resume %s >= Last suspend %s', self._last_resume_notification_time, self._last_suspend_notification_time, ) @contextmanager def notify_thread_suspended(self, thread_id, stop_reason): self.on_thread_suspend(thread_id, stop_reason) try: yield # At this point the thread must be actually suspended. finally: self.on_thread_resume(thread_id) class ThreadsSuspendedSingleNotification(AbstractSingleNotificationBehavior): __slots__ = AbstractSingleNotificationBehavior.__slots__ + [ 'multi_threads_single_notification', '_callbacks', '_callbacks_lock'] def __init__(self, py_db): AbstractSingleNotificationBehavior.__init__(self, py_db) # If True, pydevd will send a single notification when all threads are suspended/resumed. self.multi_threads_single_notification = False self._callbacks_lock = threading.Lock() self._callbacks = [] def add_on_resumed_callback(self, callback): with self._callbacks_lock: self._callbacks.append(callback) @overrides(AbstractSingleNotificationBehavior.send_resume_notification) def send_resume_notification(self, thread_id): py_db = self._py_db() if py_db is not None: py_db.writer.add_command(py_db.cmd_factory.make_thread_resume_single_notification(thread_id)) with self._callbacks_lock: callbacks = self._callbacks self._callbacks = [] for callback in callbacks: callback() @overrides(AbstractSingleNotificationBehavior.send_suspend_notification) def send_suspend_notification(self, thread_id, stop_reason): py_db = self._py_db() if py_db is not None: py_db.writer.add_command(py_db.cmd_factory.make_thread_suspend_single_notification(py_db, thread_id, stop_reason)) @overrides(AbstractSingleNotificationBehavior.notify_thread_suspended) @contextmanager def notify_thread_suspended(self, thread_id, stop_reason): if self.multi_threads_single_notification: with AbstractSingleNotificationBehavior.notify_thread_suspended(self, thread_id, stop_reason): yield else: yield class _Authentication(object): __slots__ = ['access_token', 'client_access_token', '_authenticated', '_wrong_attempts'] def __init__(self): # A token to be send in the command line or through the settrace api -- when such token # is given, the first message sent to the IDE must pass the same token to authenticate. # Note that if a disconnect is sent, the same message must be resent to authenticate. self.access_token = None # This token is the one that the client requires to accept a connection from pydevd # (it's stored here and just passed back when required, it's not used internally # for anything else). self.client_access_token = None self._authenticated = None self._wrong_attempts = 0 def is_authenticated(self): if self._authenticated is None: return self.access_token is None return self._authenticated def login(self, access_token): if self._wrong_attempts >= 10: # A user can fail to authenticate at most 10 times. return self._authenticated = access_token == self.access_token if not self._authenticated: self._wrong_attempts += 1 else: self._wrong_attempts = 0 def logout(self): self._authenticated = None self._wrong_attempts = 0 class PyDB(object): """ Main debugging class Lots of stuff going on here: PyDB starts two threads on startup that connect to remote debugger (RDB) The threads continuously read & write commands to RDB. PyDB communicates with these threads through command queues. Every RDB command is processed by calling process_net_command. Every PyDB net command is sent to the net by posting NetCommand to WriterThread queue Some commands need to be executed on the right thread (suspend/resume & friends) These are placed on the internal command queue. """ # Direct child pids which should not be terminated when terminating processes. # Note: class instance because it should outlive PyDB instances. dont_terminate_child_pids = set() def __init__(self, set_as_global=True): if set_as_global: pydevd_tracing.replace_sys_set_trace_func() self.authentication = _Authentication() self.reader = None self.writer = None self._fsnotify_thread = None self.created_pydb_daemon_threads = {} self._waiting_for_connection_thread = None self._on_configuration_done_event = threading.Event() self.check_alive_thread = None self.py_db_command_thread = None self.quitting = None self.cmd_factory = NetCommandFactory() self._cmd_queue = defaultdict(_queue.Queue) # Key is thread id or '*', value is Queue self.suspended_frames_manager = SuspendedFramesManager() self._files_filtering = FilesFiltering() self.timeout_tracker = TimeoutTracker(self) # Note: when the source mapping is changed we also have to clear the file types cache # (because if a given file is a part of the project or not may depend on it being # defined in the source mapping). self.source_mapping = SourceMapping(on_source_mapping_changed=self._clear_filters_caches) # Determines whether we should terminate child processes when asked to terminate. self.terminate_child_processes = True # These are the breakpoints received by the PyDevdAPI. They are meant to store # the breakpoints in the api -- its actual contents are managed by the api. self.api_received_breakpoints = {} # These are the breakpoints meant to be consumed during runtime. self.breakpoints = {} self.function_breakpoint_name_to_breakpoint = {} # Set communication protocol PyDevdAPI().set_protocol(self, 0, PydevdCustomization.DEFAULT_PROTOCOL) self.variable_presentation = PyDevdAPI.VariablePresentation() # mtime to be raised when breakpoints change self.mtime = 0 self.file_to_id_to_line_breakpoint = {} self.file_to_id_to_plugin_breakpoint = {} # Note: breakpoints dict should not be mutated: a copy should be created # and later it should be assigned back (to prevent concurrency issues). self.break_on_uncaught_exceptions = {} self.break_on_caught_exceptions = {} self.break_on_user_uncaught_exceptions = {} self.ready_to_run = False self._main_lock = thread.allocate_lock() self._lock_running_thread_ids = thread.allocate_lock() self._lock_create_fs_notify = thread.allocate_lock() self._py_db_command_thread_event = threading.Event() if set_as_global: CustomFramesContainer._py_db_command_thread_event = self._py_db_command_thread_event self.pydb_disposed = False self._wait_for_threads_to_finish_called = False self._wait_for_threads_to_finish_called_lock = thread.allocate_lock() self._wait_for_threads_to_finish_called_event = threading.Event() self.terminate_requested = False self._disposed_lock = thread.allocate_lock() self.signature_factory = None self.SetTrace = pydevd_tracing.SetTrace self.skip_on_exceptions_thrown_in_same_context = False self.ignore_exceptions_thrown_in_lines_with_ignore_exception = True # Suspend debugger even if breakpoint condition raises an exception. # May be changed with CMD_PYDEVD_JSON_CONFIG. self.skip_suspend_on_breakpoint_exception = () # By default suspend on any Exception. self.skip_print_breakpoint_exception = () # By default print on any Exception. # By default user can step into properties getter/setter/deleter methods self.disable_property_trace = False self.disable_property_getter_trace = False self.disable_property_setter_trace = False self.disable_property_deleter_trace = False # this is a dict of thread ids pointing to thread ids. Whenever a command is passed to the java end that # acknowledges that a thread was created, the thread id should be passed here -- and if at some time we do not # find that thread alive anymore, we must remove it from this list and make the java side know that the thread # was killed. self._running_thread_ids = {} # Note: also access '_enable_thread_notifications' with '_lock_running_thread_ids' self._enable_thread_notifications = False self._set_breakpoints_with_id = False # This attribute holds the file-> lines which have an @IgnoreException. self.filename_to_lines_where_exceptions_are_ignored = {} # working with plugins (lazily initialized) self.plugin = None self.has_plugin_line_breaks = False self.has_plugin_exception_breaks = False self.thread_analyser = None self.asyncio_analyser = None # The GUI event loop that's going to run. # Possible values: # matplotlib - Whatever GUI backend matplotlib is using. # 'wx'/'qt'/'none'/... - GUI toolkits that have bulitin support. See pydevd_ipython/inputhook.py:24. # Other - A custom function that'll be imported and run. self._gui_event_loop = 'matplotlib' self._installed_gui_support = False self.gui_in_use = False # GUI event loop support in debugger self.activate_gui_function = None # matplotlib support in debugger and debug console self.mpl_hooks_in_debug_console = False self.mpl_modules_for_patching = {} self._filename_to_not_in_scope = {} self.first_breakpoint_reached = False self._exclude_filters_enabled = self._files_filtering.use_exclude_filters() self._is_libraries_filter_enabled = self._files_filtering.use_libraries_filter() self.is_files_filter_enabled = self._exclude_filters_enabled or self._is_libraries_filter_enabled self.show_return_values = False self.remove_return_values_flag = False self.redirect_output = False # Note that besides the `redirect_output` flag, we also need to consider that someone # else is already redirecting (i.e.: debugpy). self.is_output_redirected = False # this flag disables frame evaluation even if it's available self.use_frame_eval = True # If True, pydevd will send a single notification when all threads are suspended/resumed. self._threads_suspended_single_notification = ThreadsSuspendedSingleNotification(self) # If True a step command will do a step in one thread and will also resume all other threads. self.stepping_resumes_all_threads = False self._local_thread_trace_func = threading.local() self._server_socket_ready_event = threading.Event() self._server_socket_name = None # Bind many locals to the debugger because upon teardown those names may become None # in the namespace (and thus can't be relied upon unless the reference was previously # saved). if IS_IRONPYTHON: # A partial() cannot be used in IronPython for sys.settrace. def new_trace_dispatch(frame, event, arg): return _trace_dispatch(self, frame, event, arg) self.trace_dispatch = new_trace_dispatch else: self.trace_dispatch = partial(_trace_dispatch, self) self.fix_top_level_trace_and_get_trace_func = fix_top_level_trace_and_get_trace_func self.frame_eval_func = frame_eval_func self.dummy_trace_dispatch = dummy_trace_dispatch # Note: this is different from pydevd_constants.thread_get_ident because we want Jython # to be None here because it also doesn't have threading._active. try: self.threading_get_ident = threading.get_ident # Python 3 self.threading_active = threading._active except: try: self.threading_get_ident = threading._get_ident # Python 2 noqa self.threading_active = threading._active except: self.threading_get_ident = None # Jython self.threading_active = None self.threading_current_thread = threading.currentThread self.set_additional_thread_info = set_additional_thread_info self.stop_on_unhandled_exception = stop_on_unhandled_exception self.collect_return_info = collect_return_info self.get_exception_breakpoint = get_exception_breakpoint self._dont_trace_get_file_type = DONT_TRACE.get self._dont_trace_dirs_get_file_type = DONT_TRACE_DIRS.get self.PYDEV_FILE = PYDEV_FILE self.LIB_FILE = LIB_FILE self._in_project_scope_cache = {} self._exclude_by_filter_cache = {} self._apply_filter_cache = {} self._ignore_system_exit_codes = set() # DAP related self._dap_messages_listeners = [] if set_as_global: # Set as the global instance only after it's initialized. set_global_debugger(self) # Stop the tracing as the last thing before the actual shutdown for a clean exit. atexit.register(stoptrace) def collect_try_except_info(self, code_obj): filename = code_obj.co_filename try: if os.path.exists(filename): pydev_log.debug('Collecting try..except info from source for %s', filename) try_except_infos = collect_try_except_info_from_source(filename) if try_except_infos: # Filter for the current function max_line = -1 min_line = sys.maxsize for _, line in dis.findlinestarts(code_obj): if line > max_line: max_line = line if line < min_line: min_line = line try_except_infos = [x for x in try_except_infos if min_line <= x.try_line <= max_line] return try_except_infos except: pydev_log.exception('Error collecting try..except info from source (%s)', filename) pydev_log.debug('Collecting try..except info from bytecode for %s', filename) return collect_try_except_info(code_obj) def setup_auto_reload_watcher(self, enable_auto_reload, watch_dirs, poll_target_time, exclude_patterns, include_patterns): try: with self._lock_create_fs_notify: # When setting up, dispose of the previous one (if any). if self._fsnotify_thread is not None: self._fsnotify_thread.do_kill_pydev_thread() self._fsnotify_thread = None if not enable_auto_reload: return exclude_patterns = tuple(exclude_patterns) include_patterns = tuple(include_patterns) def accept_directory(absolute_filename, cache={}): try: return cache[absolute_filename] except: if absolute_filename and absolute_filename[-1] not in ('/', '\\'): # I.e.: for directories we always end with '/' or '\\' so that # we match exclusions such as "**/node_modules/**" absolute_filename += os.path.sep # First include what we want for include_pattern in include_patterns: if glob_matches_path(absolute_filename, include_pattern): cache[absolute_filename] = True return True # Then exclude what we don't want for exclude_pattern in exclude_patterns: if glob_matches_path(absolute_filename, exclude_pattern): cache[absolute_filename] = False return False # By default track all directories not excluded. cache[absolute_filename] = True return True def accept_file(absolute_filename, cache={}): try: return cache[absolute_filename] except: # First include what we want for include_pattern in include_patterns: if glob_matches_path(absolute_filename, include_pattern): cache[absolute_filename] = True return True # Then exclude what we don't want for exclude_pattern in exclude_patterns: if glob_matches_path(absolute_filename, exclude_pattern): cache[absolute_filename] = False return False # By default don't track files not included. cache[absolute_filename] = False return False self._fsnotify_thread = FSNotifyThread(self, PyDevdAPI(), watch_dirs) watcher = self._fsnotify_thread.watcher watcher.accept_directory = accept_directory watcher.accept_file = accept_file watcher.target_time_for_single_scan = poll_target_time watcher.target_time_for_notification = poll_target_time self._fsnotify_thread.start() except: pydev_log.exception('Error setting up auto-reload.') def get_arg_ppid(self): try: setup = SetupHolder.setup if setup: return int(setup.get('ppid', 0)) except: pydev_log.exception('Error getting ppid.') return 0 def wait_for_ready_to_run(self): while not self.ready_to_run: # busy wait until we receive run command self.process_internal_commands() self._py_db_command_thread_event.clear() self._py_db_command_thread_event.wait(0.1) def on_initialize(self): ''' Note: only called when using the DAP (Debug Adapter Protocol). ''' self._on_configuration_done_event.clear() def on_configuration_done(self): ''' Note: only called when using the DAP (Debug Adapter Protocol). ''' self._on_configuration_done_event.set() self._py_db_command_thread_event.set() def is_attached(self): return self._on_configuration_done_event.is_set() def on_disconnect(self): ''' Note: only called when using the DAP (Debug Adapter Protocol). ''' self.authentication.logout() self._on_configuration_done_event.clear() def set_ignore_system_exit_codes(self, ignore_system_exit_codes): assert isinstance(ignore_system_exit_codes, (list, tuple, set)) self._ignore_system_exit_codes = set(ignore_system_exit_codes) def ignore_system_exit_code(self, system_exit_exc): if hasattr(system_exit_exc, 'code'): return system_exit_exc.code in self._ignore_system_exit_codes else: return system_exit_exc in self._ignore_system_exit_codes def block_until_configuration_done(self, cancel=None): if cancel is None: cancel = NULL while not cancel.is_set(): if self._on_configuration_done_event.is_set(): cancel.set() # Set cancel to prevent reuse return self.process_internal_commands() self._py_db_command_thread_event.clear() self._py_db_command_thread_event.wait(1 / 15.) def add_fake_frame(self, thread_id, frame_id, frame): self.suspended_frames_manager.add_fake_frame(thread_id, frame_id, frame) def handle_breakpoint_condition(self, info, pybreakpoint, new_frame): condition = pybreakpoint.condition try: if pybreakpoint.handle_hit_condition(new_frame): return True if not condition: return False return eval(condition, new_frame.f_globals, new_frame.f_locals) except Exception as e: if not isinstance(e, self.skip_print_breakpoint_exception): stack_trace = io.StringIO() etype, value, tb = sys.exc_info() traceback.print_exception(etype, value, tb.tb_next, file=stack_trace) msg = 'Error while evaluating expression in conditional breakpoint: %s\n%s' % ( condition, stack_trace.getvalue()) api = PyDevdAPI() api.send_error_message(self, msg) if not isinstance(e, self.skip_suspend_on_breakpoint_exception): try: # add exception_type and stacktrace into thread additional info etype, value, tb = sys.exc_info() error = ''.join(traceback.format_exception_only(etype, value)) stack = traceback.extract_stack(f=tb.tb_frame.f_back) # On self.set_suspend(thread, CMD_SET_BREAK) this info will be # sent to the client. info.conditional_breakpoint_exception = \ ('Condition:\n' + condition + '\n\nError:\n' + error, stack) except: pydev_log.exception() return True return False finally: etype, value, tb = None, None, None def handle_breakpoint_expression(self, pybreakpoint, info, new_frame): try: try: val = eval(pybreakpoint.expression, new_frame.f_globals, new_frame.f_locals) except: val = sys.exc_info()[1] finally: if val is not None: info.pydev_message = str(val) def _internal_get_file_type(self, abs_real_path_and_basename): basename = abs_real_path_and_basename[-1] if ( basename.startswith(IGNORE_BASENAMES_STARTING_WITH) or abs_real_path_and_basename[0].startswith(IGNORE_BASENAMES_STARTING_WITH) ): # Note: these are the files that are completely ignored (they aren't shown to the user # as user nor library code as it's usually just noise in the frame stack). return self.PYDEV_FILE file_type = self._dont_trace_get_file_type(basename) if file_type is not None: return file_type if basename.startswith('__init__.py'): # i.e.: ignore the __init__ files inside pydevd (the other # files are ignored just by their name). abs_path = abs_real_path_and_basename[0] i = max(abs_path.rfind('/'), abs_path.rfind('\\')) if i: abs_path = abs_path[0:i] i = max(abs_path.rfind('/'), abs_path.rfind('\\')) if i: dirname = abs_path[i + 1:] # At this point, something as: # "my_path\_pydev_runfiles\__init__.py" # is now "_pydev_runfiles". return self._dont_trace_dirs_get_file_type(dirname) return None def dont_trace_external_files(self, abs_path): ''' :param abs_path: The result from get_abs_path_real_path_and_base_from_file or get_abs_path_real_path_and_base_from_frame. :return True : If files should NOT be traced. False: If files should be traced. ''' # By default all external files are traced. Note: this function is expected to # be changed for another function in PyDevdAPI.set_dont_trace_start_end_patterns. return False def get_file_type(self, frame, abs_real_path_and_basename=None, _cache_file_type=_CACHE_FILE_TYPE): ''' :param abs_real_path_and_basename: The result from get_abs_path_real_path_and_base_from_file or get_abs_path_real_path_and_base_from_frame. :return _pydevd_bundle.pydevd_dont_trace_files.PYDEV_FILE: If it's a file internal to the debugger which shouldn't be traced nor shown to the user. _pydevd_bundle.pydevd_dont_trace_files.LIB_FILE: If it's a file in a library which shouldn't be traced. None: If it's a regular user file which should be traced. ''' if abs_real_path_and_basename is None: try: # Make fast path faster! abs_real_path_and_basename = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] except: abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame) # Note 1: we have to take into account that we may have files as '<string>', and that in # this case the cache key can't rely only on the filename. With the current cache, there's # still a potential miss if 2 functions which have exactly the same content are compiled # with '<string>', but in practice as we only separate the one from python -c from the rest # this shouldn't be a problem in practice. # Note 2: firstlineno added to make misses faster in the first comparison. # Note 3: this cache key is repeated in pydevd_frame_evaluator.pyx:get_func_code_info (for # speedups). cache_key = (frame.f_code.co_firstlineno, abs_real_path_and_basename[0], frame.f_code) try: return _cache_file_type[cache_key] except: if abs_real_path_and_basename[0] == '<string>': # Consider it an untraceable file unless there's no back frame (ignoring # internal files and runpy.py). f = frame.f_back while f is not None: if (self.get_file_type(f) != self.PYDEV_FILE and pydevd_file_utils.basename(f.f_code.co_filename) not in ('runpy.py', '<string>')): # We found some back frame that's not internal, which means we must consider # this a library file. # This is done because we only want to trace files as <string> if they don't # have any back frame (which is the case for python -c ...), for all other # cases we don't want to trace them because we can't show the source to the # user (at least for now...). # Note that we return as a LIB_FILE and not PYDEV_FILE because we still want # to show it in the stack. _cache_file_type[cache_key] = LIB_FILE return LIB_FILE f = f.f_back else: # This is a top-level file (used in python -c), so, trace it as usual... we # still won't be able to show the sources, but some tests require this to work. _cache_file_type[cache_key] = None return None file_type = self._internal_get_file_type(abs_real_path_and_basename) if file_type is None: if self.dont_trace_external_files(abs_real_path_and_basename[0]): file_type = PYDEV_FILE _cache_file_type[cache_key] = file_type return file_type def is_cache_file_type_empty(self): return not _CACHE_FILE_TYPE def get_cache_file_type(self, _cache=_CACHE_FILE_TYPE): # i.e.: Make it local. return _cache def get_thread_local_trace_func(self): try: thread_trace_func = self._local_thread_trace_func.thread_trace_func except AttributeError: thread_trace_func = self.trace_dispatch return thread_trace_func def enable_tracing(self, thread_trace_func=None, apply_to_all_threads=False): ''' Enables tracing. If in regular mode (tracing), will set the tracing function to the tracing function for this thread -- by default it's `PyDB.trace_dispatch`, but after `PyDB.enable_tracing` is called with a `thread_trace_func`, the given function will be the default for the given thread. :param bool apply_to_all_threads: If True we'll set the tracing function in all threads, not only in the current thread. If False only the tracing for the current function should be changed. In general apply_to_all_threads should only be true if this is the first time this function is called on a multi-threaded program (either programmatically or attach to pid). ''' if pydevd_gevent_integration is not None: pydevd_gevent_integration.enable_gevent_integration() if self.frame_eval_func is not None: self.frame_eval_func() pydevd_tracing.SetTrace(self.dummy_trace_dispatch) if IS_CPYTHON and apply_to_all_threads: pydevd_tracing.set_trace_to_threads(self.dummy_trace_dispatch) return if apply_to_all_threads: # If applying to all threads, don't use the local thread trace function. assert thread_trace_func is not None else: if thread_trace_func is None: thread_trace_func = self.get_thread_local_trace_func() else: self._local_thread_trace_func.thread_trace_func = thread_trace_func pydevd_tracing.SetTrace(thread_trace_func) if IS_CPYTHON and apply_to_all_threads: pydevd_tracing.set_trace_to_threads(thread_trace_func) def disable_tracing(self): pydevd_tracing.SetTrace(None) def on_breakpoints_changed(self, removed=False): ''' When breakpoints change, we have to re-evaluate all the assumptions we've made so far. ''' if not self.ready_to_run: # No need to do anything if we're still not running. return self.mtime += 1 if not removed: # When removing breakpoints we can leave tracing as was, but if a breakpoint was added # we have to reset the tracing for the existing functions to be re-evaluated. self.set_tracing_for_untraced_contexts() def set_tracing_for_untraced_contexts(self): # Enable the tracing for existing threads (because there may be frames being executed that # are currently untraced). if IS_CPYTHON: # Note: use sys._current_frames instead of threading.enumerate() because this way # we also see C/C++ threads, not only the ones visible to the threading module. tid_to_frame = sys._current_frames() ignore_thread_ids = set( t.ident for t in threadingEnumerate() if getattr(t, 'is_pydev_daemon_thread', False) or getattr(t, 'pydev_do_not_trace', False) ) for thread_id, frame in tid_to_frame.items(): if thread_id not in ignore_thread_ids: self.set_trace_for_frame_and_parents(frame) else: try: threads = threadingEnumerate() for t in threads: if getattr(t, 'is_pydev_daemon_thread', False) or getattr(t, 'pydev_do_not_trace', False): continue additional_info = set_additional_thread_info(t) frame = additional_info.get_topmost_frame(t) try: if frame is not None: self.set_trace_for_frame_and_parents(frame) finally: frame = None finally: frame = None t = None threads = None additional_info = None @property def multi_threads_single_notification(self): return self._threads_suspended_single_notification.multi_threads_single_notification @multi_threads_single_notification.setter def multi_threads_single_notification(self, notify): self._threads_suspended_single_notification.multi_threads_single_notification = notify @property def threads_suspended_single_notification(self): return self._threads_suspended_single_notification def get_plugin_lazy_init(self): if self.plugin is None: self.plugin = PluginManager(self) return self.plugin def in_project_scope(self, frame, absolute_filename=None): ''' Note: in general this method should not be used (apply_files_filter should be used in most cases as it also handles the project scope check). :param frame: The frame we want to check. :param absolute_filename: Must be the result from get_abs_path_real_path_and_base_from_frame(frame)[0] (can be used to speed this function a bit if it's already available to the caller, but in general it's not needed). ''' try: if absolute_filename is None: try: # Make fast path faster! abs_real_path_and_basename = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] except: abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame) absolute_filename = abs_real_path_and_basename[0] cache_key = (frame.f_code.co_firstlineno, absolute_filename, frame.f_code) return self._in_project_scope_cache[cache_key] except KeyError: cache = self._in_project_scope_cache try: abs_real_path_and_basename # If we've gotten it previously, use it again. except NameError: abs_real_path_and_basename = get_abs_path_real_path_and_base_from_frame(frame) # pydevd files are never considered to be in the project scope. file_type = self.get_file_type(frame, abs_real_path_and_basename) if file_type == self.PYDEV_FILE: cache[cache_key] = False elif absolute_filename == '<string>': # Special handling for '<string>' if file_type == self.LIB_FILE: cache[cache_key] = False else: cache[cache_key] = True elif self.source_mapping.has_mapping_entry(absolute_filename): cache[cache_key] = True else: cache[cache_key] = self._files_filtering.in_project_roots(absolute_filename) return cache[cache_key] def in_project_roots_filename_uncached(self, absolute_filename): return self._files_filtering.in_project_roots(absolute_filename) def _clear_filters_caches(self): self._in_project_scope_cache.clear() self._exclude_by_filter_cache.clear() self._apply_filter_cache.clear() self._exclude_filters_enabled = self._files_filtering.use_exclude_filters() self._is_libraries_filter_enabled = self._files_filtering.use_libraries_filter() self.is_files_filter_enabled = self._exclude_filters_enabled or self._is_libraries_filter_enabled def clear_dont_trace_start_end_patterns_caches(self): # When start/end patterns are changed we must clear all caches which would be # affected by a change in get_file_type() and reset the tracing function # as places which were traced may no longer need to be traced and vice-versa. self.on_breakpoints_changed() _CACHE_FILE_TYPE.clear() self._clear_filters_caches() self._clear_skip_caches() def _exclude_by_filter(self, frame, absolute_filename): ''' :return: True if it should be excluded, False if it should be included and None if no rule matched the given file. :note: it'll be normalized as needed inside of this method. ''' cache_key = (absolute_filename, frame.f_code.co_name, frame.f_code.co_firstlineno) try: return self._exclude_by_filter_cache[cache_key] except KeyError: cache = self._exclude_by_filter_cache # pydevd files are always filtered out if self.get_file_type(frame) == self.PYDEV_FILE: cache[cache_key] = True else: module_name = None if self._files_filtering.require_module: module_name = frame.f_globals.get('__name__', '') cache[cache_key] = self._files_filtering.exclude_by_filter(absolute_filename, module_name) return cache[cache_key] def apply_files_filter(self, frame, original_filename, force_check_project_scope): ''' Should only be called if `self.is_files_filter_enabled == True` or `force_check_project_scope == True`. Note that it covers both the filter by specific paths includes/excludes as well as the check which filters out libraries if not in the project scope. :param original_filename: Note can either be the original filename or the absolute version of that filename. :param force_check_project_scope: Check that the file is in the project scope even if the global setting is off. :return bool: True if it should be excluded when stepping and False if it should be included. ''' cache_key = (frame.f_code.co_firstlineno, original_filename, force_check_project_scope, frame.f_code) try: return self._apply_filter_cache[cache_key] except KeyError: if self.plugin is not None and (self.has_plugin_line_breaks or self.has_plugin_exception_breaks): # If it's explicitly needed by some plugin, we can't skip it. if not self.plugin.can_skip(self, frame): pydev_log.debug_once('File traced (included by plugins): %s', original_filename) self._apply_filter_cache[cache_key] = False return False if self._exclude_filters_enabled: absolute_filename = pydevd_file_utils.absolute_path(original_filename) exclude_by_filter = self._exclude_by_filter(frame, absolute_filename) if exclude_by_filter is not None: if exclude_by_filter: # ignore files matching stepping filters pydev_log.debug_once('File not traced (excluded by filters): %s', original_filename) self._apply_filter_cache[cache_key] = True return True else: pydev_log.debug_once('File traced (explicitly included by filters): %s', original_filename) self._apply_filter_cache[cache_key] = False return False if (self._is_libraries_filter_enabled or force_check_project_scope) and not self.in_project_scope(frame): # ignore library files while stepping self._apply_filter_cache[cache_key] = True if force_check_project_scope: pydev_log.debug_once('File not traced (not in project): %s', original_filename) else: pydev_log.debug_once('File not traced (not in project - force_check_project_scope): %s', original_filename) return True if force_check_project_scope: pydev_log.debug_once('File traced: %s (force_check_project_scope)', original_filename) else: pydev_log.debug_once('File traced: %s', original_filename) self._apply_filter_cache[cache_key] = False return False def exclude_exception_by_filter(self, exception_breakpoint, trace): if not exception_breakpoint.ignore_libraries and not self._exclude_filters_enabled: return False if trace is None: return True ignore_libraries = exception_breakpoint.ignore_libraries exclude_filters_enabled = self._exclude_filters_enabled if (ignore_libraries and not self.in_project_scope(trace.tb_frame)) \ or (exclude_filters_enabled and self._exclude_by_filter( trace.tb_frame, pydevd_file_utils.absolute_path(trace.tb_frame.f_code.co_filename))): return True return False def set_project_roots(self, project_roots): self._files_filtering.set_project_roots(project_roots) self._clear_skip_caches() self._clear_filters_caches() def set_exclude_filters(self, exclude_filters): self._files_filtering.set_exclude_filters(exclude_filters) self._clear_skip_caches() self._clear_filters_caches() def set_use_libraries_filter(self, use_libraries_filter): self._files_filtering.set_use_libraries_filter(use_libraries_filter) self._clear_skip_caches() self._clear_filters_caches() def get_use_libraries_filter(self): return self._files_filtering.use_libraries_filter() def get_require_module_for_filters(self): return self._files_filtering.require_module def has_user_threads_alive(self): for t in pydevd_utils.get_non_pydevd_threads(): if isinstance(t, PyDBDaemonThread): pydev_log.error_once( 'Error in debugger: Found PyDBDaemonThread not marked with is_pydev_daemon_thread=True.\n') if is_thread_alive(t): if not t.daemon or hasattr(t, "__pydevd_main_thread"): return True return False def initialize_network(self, sock, terminate_on_socket_close=True): assert sock is not None try: sock.settimeout(None) # infinite, no timeouts from now on - jython does not have it except: pass curr_reader = getattr(self, 'reader', None) curr_writer = getattr(self, 'writer', None) if curr_reader: curr_reader.do_kill_pydev_thread() if curr_writer: curr_writer.do_kill_pydev_thread() self.writer = WriterThread(sock, self, terminate_on_socket_close=terminate_on_socket_close) self.reader = ReaderThread( sock, self, PyDevJsonCommandProcessor=PyDevJsonCommandProcessor, process_net_command=process_net_command, terminate_on_socket_close=terminate_on_socket_close ) self.writer.start() self.reader.start() time.sleep(0.1) # give threads time to start def connect(self, host, port): if host: s = start_client(host, port) else: s = start_server(port) self.initialize_network(s) def create_wait_for_connection_thread(self): if self._waiting_for_connection_thread is not None: raise AssertionError('There is already another thread waiting for a connection.') self._server_socket_ready_event.clear() self._waiting_for_connection_thread = self._WaitForConnectionThread(self) self._waiting_for_connection_thread.start() def set_server_socket_ready(self): self._server_socket_ready_event.set() def wait_for_server_socket_ready(self): self._server_socket_ready_event.wait() @property def dap_messages_listeners(self): return self._dap_messages_listeners def add_dap_messages_listener(self, listener): self._dap_messages_listeners.append(listener) class _WaitForConnectionThread(PyDBDaemonThread): def __init__(self, py_db): PyDBDaemonThread.__init__(self, py_db) self._server_socket = None def run(self): host = SetupHolder.setup['client'] port = SetupHolder.setup['port'] self._server_socket = create_server_socket(host=host, port=port) self.py_db._server_socket_name = self._server_socket.getsockname() self.py_db.set_server_socket_ready() while not self._kill_received: try: s = self._server_socket if s is None: return s.listen(1) new_socket, _addr = s.accept() if self._kill_received: pydev_log.info("Connection (from wait_for_attach) accepted but ignored as kill was already received.") return pydev_log.info("Connection (from wait_for_attach) accepted.") reader = getattr(self.py_db, 'reader', None) if reader is not None: # This is needed if a new connection is done without the client properly # sending a disconnect for the previous connection. api = PyDevdAPI() api.request_disconnect(self.py_db, resume_threads=False) self.py_db.initialize_network(new_socket, terminate_on_socket_close=False) except: if DebugInfoHolder.DEBUG_TRACE_LEVEL > 0: pydev_log.exception() pydev_log.debug("Exiting _WaitForConnectionThread: %s\n", port) def do_kill_pydev_thread(self): PyDBDaemonThread.do_kill_pydev_thread(self) s = self._server_socket if s is not None: try: s.close() except: pass self._server_socket = None def get_internal_queue(self, thread_id): """ returns internal command queue for a given thread. if new queue is created, notify the RDB about it """ if thread_id.startswith('__frame__'): thread_id = thread_id[thread_id.rfind('|') + 1:] return self._cmd_queue[thread_id] def post_method_as_internal_command(self, thread_id, method, *args, **kwargs): if thread_id == '*': internal_cmd = InternalThreadCommandForAnyThread(thread_id, method, *args, **kwargs) else: internal_cmd = InternalThreadCommand(thread_id, method, *args, **kwargs) self.post_internal_command(internal_cmd, thread_id) if thread_id == '*': # Notify so that the command is handled as soon as possible. self._py_db_command_thread_event.set() def post_internal_command(self, int_cmd, thread_id): """ if thread_id is *, post to the '*' queue""" queue = self.get_internal_queue(thread_id) queue.put(int_cmd) def enable_output_redirection(self, redirect_stdout, redirect_stderr): global _global_redirect_stdout_to_server global _global_redirect_stderr_to_server _global_redirect_stdout_to_server = redirect_stdout _global_redirect_stderr_to_server = redirect_stderr self.redirect_output = redirect_stdout or redirect_stderr if _global_redirect_stdout_to_server: _init_stdout_redirect() if _global_redirect_stderr_to_server: _init_stderr_redirect() def check_output_redirect(self): global _global_redirect_stdout_to_server global _global_redirect_stderr_to_server if _global_redirect_stdout_to_server: _init_stdout_redirect() if _global_redirect_stderr_to_server: _init_stderr_redirect() def init_matplotlib_in_debug_console(self): # import hook and patches for matplotlib support in debug console from _pydev_bundle.pydev_import_hook import import_hook_manager if is_current_thread_main_thread(): for module in list(self.mpl_modules_for_patching): import_hook_manager.add_module_name(module, self.mpl_modules_for_patching.pop(module)) def init_gui_support(self): if self._installed_gui_support: return self._installed_gui_support = True # enable_gui and enable_gui_function in activate_matplotlib should be called in main thread. Unlike integrated console, # in the debug console we have no interpreter instance with exec_queue, but we run this code in the main # thread and can call it directly. class _ReturnGuiLoopControlHelper: _return_control_osc = False def return_control(): # Some of the input hooks (e.g. Qt4Agg) check return control without doing # a single operation, so we don't return True on every # call when the debug hook is in place to allow the GUI to run _ReturnGuiLoopControlHelper._return_control_osc = not _ReturnGuiLoopControlHelper._return_control_osc return _ReturnGuiLoopControlHelper._return_control_osc from pydev_ipython.inputhook import set_return_control_callback, enable_gui set_return_control_callback(return_control) if self._gui_event_loop == 'matplotlib': # prepare debugger for matplotlib integration with GUI event loop from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot, do_enable_gui self.mpl_modules_for_patching = {"matplotlib": lambda: activate_matplotlib(do_enable_gui), "matplotlib.pyplot": activate_pyplot, "pylab": activate_pylab } else: self.activate_gui_function = enable_gui def _activate_gui_if_needed(self): if self.gui_in_use: return if len(self.mpl_modules_for_patching) > 0: if is_current_thread_main_thread(): # Note that we call only in the main thread. for module in list(self.mpl_modules_for_patching): if module in sys.modules: activate_function = self.mpl_modules_for_patching.pop(module, None) if activate_function is not None: activate_function() self.gui_in_use = True if self.activate_gui_function: if is_current_thread_main_thread(): # Only call enable_gui in the main thread. try: # First try to activate builtin GUI event loops. self.activate_gui_function(self._gui_event_loop) self.activate_gui_function = None self.gui_in_use = True except ValueError: # The user requested a custom GUI event loop, try to import it. from pydev_ipython.inputhook import set_inputhook try: inputhook_function = import_attr_from_module(self._gui_event_loop) set_inputhook(inputhook_function) self.gui_in_use = True except Exception as e: pydev_log.debug("Cannot activate custom GUI event loop {}: {}".format(self._gui_event_loop, e)) finally: self.activate_gui_function = None def _call_input_hook(self): try: from pydev_ipython.inputhook import get_inputhook inputhook = get_inputhook() if inputhook: inputhook() except: pass def notify_skipped_step_in_because_of_filters(self, frame): self.writer.add_command(self.cmd_factory.make_skipped_step_in_because_of_filters(self, frame)) def notify_thread_created(self, thread_id, thread, use_lock=True): if self.writer is None: # Protect about threads being created before the communication structure is in place # (note that they will appear later on anyways as pydevd does reconcile live/dead threads # when processing internal commands, albeit it may take longer and in general this should # not be usual as it's expected that the debugger is live before other threads are created). return with self._lock_running_thread_ids if use_lock else NULL: if not self._enable_thread_notifications: return if thread_id in self._running_thread_ids: return additional_info = set_additional_thread_info(thread) if additional_info.pydev_notify_kill: # After we notify it should be killed, make sure we don't notify it's alive (on a racing condition # this could happen as we may notify before the thread is stopped internally). return self._running_thread_ids[thread_id] = thread self.writer.add_command(self.cmd_factory.make_thread_created_message(thread)) def notify_thread_not_alive(self, thread_id, use_lock=True): """ if thread is not alive, cancel trace_dispatch processing """ if self.writer is None: return with self._lock_running_thread_ids if use_lock else NULL: if not self._enable_thread_notifications: return thread = self._running_thread_ids.pop(thread_id, None) if thread is None: return additional_info = set_additional_thread_info(thread) was_notified = additional_info.pydev_notify_kill if not was_notified: additional_info.pydev_notify_kill = True self.writer.add_command(self.cmd_factory.make_thread_killed_message(thread_id)) def set_enable_thread_notifications(self, enable): with self._lock_running_thread_ids: if self._enable_thread_notifications != enable: self._enable_thread_notifications = enable if enable: # As it was previously disabled, we have to notify about existing threads again # (so, clear the cache related to that). self._running_thread_ids = {} def process_internal_commands(self): ''' This function processes internal commands. ''' # If this method is being called before the debugger is ready to run we should not notify # about threads and should only process commands sent to all threads. ready_to_run = self.ready_to_run dispose = False with self._main_lock: program_threads_alive = {} if ready_to_run: self.check_output_redirect() all_threads = threadingEnumerate() program_threads_dead = [] with self._lock_running_thread_ids: reset_cache = not self._running_thread_ids for t in all_threads: if getattr(t, 'is_pydev_daemon_thread', False): pass # I.e.: skip the DummyThreads created from pydev daemon threads elif isinstance(t, PyDBDaemonThread): pydev_log.error_once('Error in debugger: Found PyDBDaemonThread not marked with is_pydev_daemon_thread=True.') elif is_thread_alive(t): if reset_cache: # Fix multiprocessing debug with breakpoints in both main and child processes # (https://youtrack.jetbrains.com/issue/PY-17092) When the new process is created, the main # thread in the new process already has the attribute 'pydevd_id', so the new thread doesn't # get new id with its process number and the debugger loses access to both threads. # Therefore we should update thread_id for every main thread in the new process. clear_cached_thread_id(t) thread_id = get_thread_id(t) program_threads_alive[thread_id] = t self.notify_thread_created(thread_id, t, use_lock=False) # Compute and notify about threads which are no longer alive. thread_ids = list(self._running_thread_ids.keys()) for thread_id in thread_ids: if thread_id not in program_threads_alive: program_threads_dead.append(thread_id) for thread_id in program_threads_dead: self.notify_thread_not_alive(thread_id, use_lock=False) cmds_to_execute = [] # Without self._lock_running_thread_ids if len(program_threads_alive) == 0 and ready_to_run: dispose = True else: # Actually process the commands now (make sure we don't have a lock for _lock_running_thread_ids # acquired at this point as it could lead to a deadlock if some command evaluated tried to # create a thread and wait for it -- which would try to notify about it getting that lock). curr_thread_id = get_current_thread_id(threadingCurrentThread()) if ready_to_run: process_thread_ids = (curr_thread_id, '*') else: process_thread_ids = ('*',) for thread_id in process_thread_ids: queue = self.get_internal_queue(thread_id) # some commands must be processed by the thread itself... if that's the case, # we will re-add the commands to the queue after executing. cmds_to_add_back = [] try: while True: int_cmd = queue.get(False) if not self.mpl_hooks_in_debug_console and isinstance(int_cmd, InternalConsoleExec) and not self.gui_in_use: # add import hooks for matplotlib patches if only debug console was started try: self.init_matplotlib_in_debug_console() self.gui_in_use = True except: pydev_log.debug("Matplotlib support in debug console failed", traceback.format_exc()) self.mpl_hooks_in_debug_console = True if int_cmd.can_be_executed_by(curr_thread_id): cmds_to_execute.append(int_cmd) else: pydev_log.verbose("NOT processing internal command: %s ", int_cmd) cmds_to_add_back.append(int_cmd) except _queue.Empty: # @UndefinedVariable # this is how we exit for int_cmd in cmds_to_add_back: queue.put(int_cmd) if dispose: # Note: must be called without the main lock to avoid deadlocks. self.dispose_and_kill_all_pydevd_threads() else: # Actually execute the commands without the main lock! for int_cmd in cmds_to_execute: pydev_log.verbose("processing internal command: %s", int_cmd) try: int_cmd.do_it(self) except: pydev_log.exception('Error processing internal command.') def consolidate_breakpoints(self, canonical_normalized_filename, id_to_breakpoint, file_to_line_to_breakpoints): break_dict = {} for _breakpoint_id, pybreakpoint in id_to_breakpoint.items(): break_dict[pybreakpoint.line] = pybreakpoint file_to_line_to_breakpoints[canonical_normalized_filename] = break_dict self._clear_skip_caches() def _clear_skip_caches(self): global_cache_skips.clear() global_cache_frame_skips.clear() def add_break_on_exception( self, exception, condition, expression, notify_on_handled_exceptions, notify_on_unhandled_exceptions, notify_on_user_unhandled_exceptions, notify_on_first_raise_only, ignore_libraries=False ): try: eb = ExceptionBreakpoint( exception, condition, expression, notify_on_handled_exceptions, notify_on_unhandled_exceptions, notify_on_user_unhandled_exceptions, notify_on_first_raise_only, ignore_libraries ) except ImportError: pydev_log.critical("Error unable to add break on exception for: %s (exception could not be imported).", exception) return None if eb.notify_on_unhandled_exceptions: cp = self.break_on_uncaught_exceptions.copy() cp[exception] = eb if DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS > 0: pydev_log.critical("Exceptions to hook on terminate: %s.", cp) self.break_on_uncaught_exceptions = cp if eb.notify_on_handled_exceptions: cp = self.break_on_caught_exceptions.copy() cp[exception] = eb if DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS > 0: pydev_log.critical("Exceptions to hook always: %s.", cp) self.break_on_caught_exceptions = cp if eb.notify_on_user_unhandled_exceptions: cp = self.break_on_user_uncaught_exceptions.copy() cp[exception] = eb if DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS > 0: pydev_log.critical("Exceptions to hook on user uncaught code: %s.", cp) self.break_on_user_uncaught_exceptions = cp return eb def set_suspend(self, thread, stop_reason, suspend_other_threads=False, is_pause=False, original_step_cmd=-1): ''' :param thread: The thread which should be suspended. :param stop_reason: Reason why the thread was suspended. :param suspend_other_threads: Whether to force other threads to be suspended (i.e.: when hitting a breakpoint with a suspend all threads policy). :param is_pause: If this is a pause to suspend all threads, any thread can be considered as the 'main' thread paused. :param original_step_cmd: If given we may change the stop reason to this. ''' self._threads_suspended_single_notification.increment_suspend_time() if is_pause: self._threads_suspended_single_notification.on_pause() info = mark_thread_suspended(thread, stop_reason, original_step_cmd=original_step_cmd) if is_pause: # Must set tracing after setting the state to suspend. frame = info.get_topmost_frame(thread) if frame is not None: try: self.set_trace_for_frame_and_parents(frame) finally: frame = None # If conditional breakpoint raises any exception during evaluation send the details to the client. if stop_reason == CMD_SET_BREAK and info.conditional_breakpoint_exception is not None: conditional_breakpoint_exception_tuple = info.conditional_breakpoint_exception info.conditional_breakpoint_exception = None self._send_breakpoint_condition_exception(thread, conditional_breakpoint_exception_tuple) if not suspend_other_threads and self.multi_threads_single_notification: # In the mode which gives a single notification when all threads are # stopped, stop all threads whenever a set_suspend is issued. suspend_other_threads = True if suspend_other_threads: # Suspend all except the current one (which we're currently suspending already). suspend_all_threads(self, except_thread=thread) def _send_breakpoint_condition_exception(self, thread, conditional_breakpoint_exception_tuple): """If conditional breakpoint raises an exception during evaluation send exception details to java """ thread_id = get_thread_id(thread) # conditional_breakpoint_exception_tuple - should contain 2 values (exception_type, stacktrace) if conditional_breakpoint_exception_tuple and len(conditional_breakpoint_exception_tuple) == 2: exc_type, stacktrace = conditional_breakpoint_exception_tuple int_cmd = InternalGetBreakpointException(thread_id, exc_type, stacktrace) self.post_internal_command(int_cmd, thread_id) def send_caught_exception_stack(self, thread, arg, curr_frame_id): """Sends details on the exception which was caught (and where we stopped) to the java side. arg is: exception type, description, traceback object """ thread_id = get_thread_id(thread) int_cmd = InternalSendCurrExceptionTrace(thread_id, arg, curr_frame_id) self.post_internal_command(int_cmd, thread_id) def send_caught_exception_stack_proceeded(self, thread): """Sends that some thread was resumed and is no longer showing an exception trace. """ thread_id = get_thread_id(thread) int_cmd = InternalSendCurrExceptionTraceProceeded(thread_id) self.post_internal_command(int_cmd, thread_id) self.process_internal_commands() def send_process_created_message(self): """Sends a message that a new process has been created. """ if self.writer is None or self.cmd_factory is None: return cmd = self.cmd_factory.make_process_created_message() self.writer.add_command(cmd) def send_process_about_to_be_replaced(self): """Sends a message that a new process has been created. """ if self.writer is None or self.cmd_factory is None: return cmd = self.cmd_factory.make_process_about_to_be_replaced_message() if cmd is NULL_NET_COMMAND: return sent = [False] def after_sent(*args, **kwargs): sent[0] = True cmd.call_after_send(after_sent) self.writer.add_command(cmd) timeout = 5 # Wait up to 5 seconds initial_time = time.time() while not sent[0]: time.sleep(.05) if (time.time() - initial_time) > timeout: pydev_log.critical('pydevd: Sending message related to process being replaced timed-out after %s seconds', timeout) break def set_next_statement(self, frame, event, func_name, next_line): stop = False response_msg = "" old_line = frame.f_lineno if event == 'line' or event == 'exception': # If we're already in the correct context, we have to stop it now, because we can act only on # line events -- if a return was the next statement it wouldn't work (so, we have this code # repeated at pydevd_frame). curr_func_name = frame.f_code.co_name # global context is set with an empty name if curr_func_name in ('?', '<module>'): curr_func_name = '' if func_name == '*' or curr_func_name == func_name: line = next_line frame.f_trace = self.trace_dispatch frame.f_lineno = line stop = True else: response_msg = "jump is available only within the bottom frame" return stop, old_line, response_msg def cancel_async_evaluation(self, thread_id, frame_id): with self._main_lock: try: all_threads = threadingEnumerate() for t in all_threads: if getattr(t, 'is_pydev_daemon_thread', False) and hasattr(t, 'cancel_event') and t.thread_id == thread_id and \ t.frame_id == frame_id: t.cancel_event.set() except: pydev_log.exception() def find_frame(self, thread_id, frame_id): """ returns a frame on the thread that has a given frame_id """ return self.suspended_frames_manager.find_frame(thread_id, frame_id) def do_wait_suspend(self, thread, frame, event, arg, exception_type=None): # @UnusedVariable """ busy waits until the thread state changes to RUN it expects thread's state as attributes of the thread. Upon running, processes any outstanding Stepping commands. :param exception_type: If pausing due to an exception, its type. """ if USE_CUSTOM_SYS_CURRENT_FRAMES_MAP: constructed_tid_to_last_frame[thread.ident] = sys._getframe() self.process_internal_commands() thread_id = get_current_thread_id(thread) # print('do_wait_suspend %s %s %s %s %s %s (%s)' % (frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename, event, arg, constant_to_str(thread.additional_info.pydev_step_cmd), constant_to_str(thread.additional_info.pydev_original_step_cmd))) # print('--- stack ---') # print(traceback.print_stack(file=sys.stdout)) # print('--- end stack ---') # Send the suspend message message = thread.additional_info.pydev_message suspend_type = thread.additional_info.trace_suspend_type thread.additional_info.trace_suspend_type = 'trace' # Reset to trace mode for next call. stop_reason = thread.stop_reason frames_list = None if arg is not None and event == 'exception': # arg must be the exception info (tuple(exc_type, exc, traceback)) exc_type, exc_desc, trace_obj = arg if trace_obj is not None: frames_list = pydevd_frame_utils.create_frames_list_from_traceback(trace_obj, frame, exc_type, exc_desc, exception_type=exception_type) if frames_list is None: frames_list = pydevd_frame_utils.create_frames_list_from_frame(frame) if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2: pydev_log.debug( 'PyDB.do_wait_suspend\nname: %s (line: %s)\n file: %s\n event: %s\n arg: %s\n step: %s (original step: %s)\n thread: %s, thread id: %s, id(thread): %s', frame.f_code.co_name, frame.f_lineno, frame.f_code.co_filename, event, arg, constant_to_str(thread.additional_info.pydev_step_cmd), constant_to_str(thread.additional_info.pydev_original_step_cmd), thread, thread_id, id(thread), ) for f in frames_list: pydev_log.debug(' Stack: %s, %s, %s', f.f_code.co_filename, f.f_code.co_name, f.f_lineno) with self.suspended_frames_manager.track_frames(self) as frames_tracker: frames_tracker.track(thread_id, frames_list) cmd = frames_tracker.create_thread_suspend_command(thread_id, stop_reason, message, suspend_type) self.writer.add_command(cmd) with CustomFramesContainer.custom_frames_lock: # @UndefinedVariable from_this_thread = [] for frame_custom_thread_id, custom_frame in CustomFramesContainer.custom_frames.items(): if custom_frame.thread_id == thread.ident: frames_tracker.track(thread_id, pydevd_frame_utils.create_frames_list_from_frame(custom_frame.frame), frame_custom_thread_id=frame_custom_thread_id) # print('Frame created as thread: %s' % (frame_custom_thread_id,)) self.writer.add_command(self.cmd_factory.make_custom_frame_created_message( frame_custom_thread_id, custom_frame.name)) self.writer.add_command( frames_tracker.create_thread_suspend_command(frame_custom_thread_id, CMD_THREAD_SUSPEND, "", suspend_type)) from_this_thread.append(frame_custom_thread_id) with self._threads_suspended_single_notification.notify_thread_suspended(thread_id, stop_reason): keep_suspended = self._do_wait_suspend(thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker) frames_list = None if keep_suspended: # This means that we should pause again after a set next statement. self._threads_suspended_single_notification.increment_suspend_time() self.do_wait_suspend(thread, frame, event, arg, exception_type) if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2: pydev_log.debug('Leaving PyDB.do_wait_suspend: %s (%s) %s', thread, thread_id, id(thread)) def _do_wait_suspend(self, thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker): info = thread.additional_info info.step_in_initial_location = None keep_suspended = False with self._main_lock: # Use lock to check if suspended state changed activate_gui = info.pydev_state == STATE_SUSPEND and not self.pydb_disposed in_main_thread = is_current_thread_main_thread() if activate_gui and in_main_thread: # before every stop check if matplotlib modules were imported inside script code # or some GUI event loop needs to be activated self._activate_gui_if_needed() while True: with self._main_lock: # Use lock to check if suspended state changed if info.pydev_state != STATE_SUSPEND or (self.pydb_disposed and not self.terminate_requested): # Note: we can't exit here if terminate was requested while a breakpoint was hit. break if in_main_thread and self.gui_in_use: # call input hooks if only GUI is in use self._call_input_hook() self.process_internal_commands() time.sleep(0.01) self.cancel_async_evaluation(get_current_thread_id(thread), str(id(frame))) # process any stepping instructions if info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE): info.step_in_initial_location = (frame, frame.f_lineno) if frame.f_code.co_flags & 0x80: # CO_COROUTINE = 0x80 # When in a coroutine we switch to CMD_STEP_INTO_COROUTINE. info.pydev_step_cmd = CMD_STEP_INTO_COROUTINE info.pydev_step_stop = frame self.set_trace_for_frame_and_parents(frame) else: info.pydev_step_stop = None self.set_trace_for_frame_and_parents(frame) elif info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_SMART_STEP_INTO): info.pydev_step_stop = frame self.set_trace_for_frame_and_parents(frame) elif info.pydev_step_cmd == CMD_RUN_TO_LINE or info.pydev_step_cmd == CMD_SET_NEXT_STATEMENT: info.pydev_step_stop = None self.set_trace_for_frame_and_parents(frame) stop = False response_msg = "" try: stop, _old_line, response_msg = self.set_next_statement(frame, event, info.pydev_func_name, info.pydev_next_line) except ValueError as e: response_msg = "%s" % e finally: seq = info.pydev_message cmd = self.cmd_factory.make_set_next_stmnt_status_message(seq, stop, response_msg) self.writer.add_command(cmd) info.pydev_message = '' if stop: # Uninstall the current frames tracker before running it. frames_tracker.untrack_all() cmd = self.cmd_factory.make_thread_run_message(get_current_thread_id(thread), info.pydev_step_cmd) self.writer.add_command(cmd) info.pydev_state = STATE_SUSPEND thread.stop_reason = CMD_SET_NEXT_STATEMENT keep_suspended = True else: # Set next did not work... info.pydev_original_step_cmd = -1 info.pydev_step_cmd = -1 info.pydev_state = STATE_SUSPEND thread.stop_reason = CMD_THREAD_SUSPEND # return to the suspend state and wait for other command (without sending any # additional notification to the client). return self._do_wait_suspend(thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker) elif info.pydev_step_cmd in (CMD_STEP_RETURN, CMD_STEP_RETURN_MY_CODE): back_frame = frame.f_back force_check_project_scope = info.pydev_step_cmd == CMD_STEP_RETURN_MY_CODE if force_check_project_scope or self.is_files_filter_enabled: while back_frame is not None: if self.apply_files_filter(back_frame, back_frame.f_code.co_filename, force_check_project_scope): frame = back_frame back_frame = back_frame.f_back else: break if back_frame is not None: # steps back to the same frame (in a return call it will stop in the 'back frame' for the user) info.pydev_step_stop = frame self.set_trace_for_frame_and_parents(frame) else: # No back frame?!? -- this happens in jython when we have some frame created from an awt event # (the previous frame would be the awt event, but this doesn't make part of 'jython', only 'java') # so, if we're doing a step return in this situation, it's the same as just making it run info.pydev_step_stop = None info.pydev_original_step_cmd = -1 info.pydev_step_cmd = -1 info.pydev_state = STATE_RUN if PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING: info.pydev_use_scoped_step_frame = False if info.pydev_step_cmd in ( CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE, CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE ): # i.e.: We're stepping: check if the stepping should be scoped (i.e.: in ipython # each line is executed separately in a new frame, in which case we need to consider # the next line as if it was still in the same frame). f = frame.f_back if f and f.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[1]: f = f.f_back if f and f.f_code.co_name == PYDEVD_IPYTHON_CONTEXT[2]: info.pydev_use_scoped_step_frame = True pydev_log.info('Using (ipython) scoped stepping.') del f del frame cmd = self.cmd_factory.make_thread_run_message(get_current_thread_id(thread), info.pydev_step_cmd) self.writer.add_command(cmd) with CustomFramesContainer.custom_frames_lock: # The ones that remained on last_running must now be removed. for frame_id in from_this_thread: # print('Removing created frame: %s' % (frame_id,)) self.writer.add_command(self.cmd_factory.make_thread_killed_message(frame_id)) return keep_suspended def do_stop_on_unhandled_exception(self, thread, frame, frames_byid, arg): pydev_log.debug("We are stopping in unhandled exception.") try: add_exception_to_frame(frame, arg) self.send_caught_exception_stack(thread, arg, id(frame)) try: self.set_suspend(thread, CMD_ADD_EXCEPTION_BREAK) self.do_wait_suspend(thread, frame, 'exception', arg, EXCEPTION_TYPE_UNHANDLED) except: self.send_caught_exception_stack_proceeded(thread) except: pydev_log.exception("We've got an error while stopping in unhandled exception: %s.", arg[0]) finally: remove_exception_from_frame(frame) frame = None def set_trace_for_frame_and_parents(self, frame, **kwargs): disable = kwargs.pop('disable', False) assert not kwargs while frame is not None: # Don't change the tracing on debugger-related files file_type = self.get_file_type(frame) if file_type is None: if disable: pydev_log.debug('Disable tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name) if frame.f_trace is not None and frame.f_trace is not NO_FTRACE: frame.f_trace = NO_FTRACE elif frame.f_trace is not self.trace_dispatch: pydev_log.debug('Set tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name) frame.f_trace = self.trace_dispatch else: pydev_log.debug('SKIP set tracing of frame: %s - %s', frame.f_code.co_filename, frame.f_code.co_name) frame = frame.f_back del frame def _create_pydb_command_thread(self): curr_pydb_command_thread = self.py_db_command_thread if curr_pydb_command_thread is not None: curr_pydb_command_thread.do_kill_pydev_thread() new_pydb_command_thread = self.py_db_command_thread = PyDBCommandThread(self) new_pydb_command_thread.start() def _create_check_output_thread(self): curr_output_checker_thread = self.check_alive_thread if curr_output_checker_thread is not None: curr_output_checker_thread.do_kill_pydev_thread() check_alive_thread = self.check_alive_thread = CheckAliveThread(self) check_alive_thread.start() def start_auxiliary_daemon_threads(self): self._create_pydb_command_thread() self._create_check_output_thread() def __wait_for_threads_to_finish(self, timeout): try: with self._wait_for_threads_to_finish_called_lock: wait_for_threads_to_finish_called = self._wait_for_threads_to_finish_called self._wait_for_threads_to_finish_called = True if wait_for_threads_to_finish_called: # Make sure that we wait for the previous call to be finished. self._wait_for_threads_to_finish_called_event.wait(timeout=timeout) else: try: def get_pydb_daemon_threads_to_wait(): pydb_daemon_threads = set(self.created_pydb_daemon_threads) pydb_daemon_threads.discard(self.check_alive_thread) pydb_daemon_threads.discard(threading.current_thread()) return pydb_daemon_threads pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads waiting for pydb daemon threads to finish") started_at = time.time() # Note: we wait for all except the check_alive_thread (which is not really a daemon # thread and it can call this method itself). while time.time() < started_at + timeout: if len(get_pydb_daemon_threads_to_wait()) == 0: break time.sleep(1 / 10.) else: thread_names = [t.name for t in get_pydb_daemon_threads_to_wait()] if thread_names: pydev_log.debug("The following pydb threads may not have finished correctly: %s", ', '.join(thread_names)) finally: self._wait_for_threads_to_finish_called_event.set() except: pydev_log.exception() def dispose_and_kill_all_pydevd_threads(self, wait=True, timeout=.5): ''' When this method is called we finish the debug session, terminate threads and if this was registered as the global instance, unregister it -- afterwards it should be possible to create a new instance and set as global to start a new debug session. :param bool wait: If True we'll wait for the threads to be actually finished before proceeding (based on the available timeout). Note that this must be thread-safe and if one thread is waiting the other thread should also wait. ''' try: back_frame = sys._getframe().f_back pydev_log.debug( 'PyDB.dispose_and_kill_all_pydevd_threads (called from: File "%s", line %s, in %s)', back_frame.f_code.co_filename, back_frame.f_lineno, back_frame.f_code.co_name ) back_frame = None with self._disposed_lock: disposed = self.pydb_disposed self.pydb_disposed = True if disposed: if wait: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (already disposed - wait)") self.__wait_for_threads_to_finish(timeout) else: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (already disposed - no wait)") return pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads (first call)") # Wait until a time when there are no commands being processed to kill the threads. started_at = time.time() while time.time() < started_at + timeout: with self._main_lock: writer = self.writer if writer is None or writer.empty(): pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads no commands being processed.") break else: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads timed out waiting for writer to be empty.") pydb_daemon_threads = set(self.created_pydb_daemon_threads) for t in pydb_daemon_threads: if hasattr(t, 'do_kill_pydev_thread'): pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads killing thread: %s", t) t.do_kill_pydev_thread() if wait: self.__wait_for_threads_to_finish(timeout) else: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: no wait") py_db = get_global_debugger() if py_db is self: set_global_debugger(None) except: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: exception") try: if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3: pydev_log.exception() except: pass finally: pydev_log.debug("PyDB.dispose_and_kill_all_pydevd_threads: finished") def prepare_to_run(self): ''' Shared code to prepare debugging by installing traces and registering threads ''' self.patch_threads() self.start_auxiliary_daemon_threads() def patch_threads(self): try: # not available in jython! threading.settrace(self.trace_dispatch) # for all future threads except: pass from _pydev_bundle.pydev_monkey import patch_thread_modules patch_thread_modules() def run(self, file, globals=None, locals=None, is_module=False, set_trace=True): module_name = None entry_point_fn = '' if is_module: # When launching with `python -m <module>`, python automatically adds # an empty path to the PYTHONPATH which resolves files in the current # directory, so, depending how pydevd itself is launched, we may need # to manually add such an entry to properly resolve modules in the # current directory (see: https://github.com/Microsoft/ptvsd/issues/1010). if '' not in sys.path: sys.path.insert(0, '') file, _, entry_point_fn = file.partition(':') module_name = file filename = get_fullname(file) if filename is None: mod_dir = get_package_dir(module_name) if mod_dir is None: sys.stderr.write("No module named %s\n" % file) return else: filename = get_fullname("%s.__main__" % module_name) if filename is None: sys.stderr.write("No module named %s\n" % file) return else: file = filename else: file = filename mod_dir = os.path.dirname(filename) main_py = os.path.join(mod_dir, '__main__.py') main_pyc = os.path.join(mod_dir, '__main__.pyc') if filename.endswith('__init__.pyc'): if os.path.exists(main_pyc): filename = main_pyc elif os.path.exists(main_py): filename = main_py elif filename.endswith('__init__.py'): if os.path.exists(main_pyc) and not os.path.exists(main_py): filename = main_pyc elif os.path.exists(main_py): filename = main_py sys.argv[0] = filename if os.path.isdir(file): new_target = os.path.join(file, '__main__.py') if os.path.isfile(new_target): file = new_target m = None if globals is None: m = save_main_module(file, 'pydevd') globals = m.__dict__ try: globals['__builtins__'] = __builtins__ except NameError: pass # Not there on Jython... if locals is None: locals = globals # Predefined (writable) attributes: __name__ is the module's name; # __doc__ is the module's documentation string, or None if unavailable; # __file__ is the pathname of the file from which the module was loaded, # if it was loaded from a file. The __file__ attribute is not present for # C modules that are statically linked into the interpreter; for extension modules # loaded dynamically from a shared library, it is the pathname of the shared library file. # I think this is an ugly hack, bug it works (seems to) for the bug that says that sys.path should be the same in # debug and run. if sys.path[0] != '' and m is not None and m.__file__.startswith(sys.path[0]): # print >> sys.stderr, 'Deleting: ', sys.path[0] del sys.path[0] if not is_module: # now, the local directory has to be added to the pythonpath # sys.path.insert(0, os.getcwd()) # Changed: it's not the local directory, but the directory of the file launched # The file being run must be in the pythonpath (even if it was not before) sys.path.insert(0, os.path.split(os_path_abspath(file))[0]) if set_trace: self.wait_for_ready_to_run() # call prepare_to_run when we already have all information about breakpoints self.prepare_to_run() t = threadingCurrentThread() thread_id = get_current_thread_id(t) if self.thread_analyser is not None: wrap_threads() self.thread_analyser.set_start_time(cur_time()) send_concurrency_message("threading_event", 0, t.name, thread_id, "thread", "start", file, 1, None, parent=thread_id) if self.asyncio_analyser is not None: # we don't have main thread in asyncio graph, so we should add a fake event send_concurrency_message("asyncio_event", 0, "Task", "Task", "thread", "stop", file, 1, frame=None, parent=None) try: if INTERACTIVE_MODE_AVAILABLE: self.init_gui_support() except: pydev_log.exception("Matplotlib support in debugger failed") if hasattr(sys, 'exc_clear'): # we should clean exception information in Python 2, before user's code execution sys.exc_clear() # Notify that the main thread is created. self.notify_thread_created(thread_id, t) # Note: important: set the tracing right before calling _exec. if set_trace: self.enable_tracing() return self._exec(is_module, entry_point_fn, module_name, file, globals, locals) def _exec(self, is_module, entry_point_fn, module_name, file, globals, locals): ''' This function should have frames tracked by unhandled exceptions (the `_exec` name is important). ''' if not is_module: globals = pydevd_runpy.run_path(file, globals, '__main__') else: # treat ':' as a separator between module and entry point function # if there is no entry point we run we same as with -m switch. Otherwise we perform # an import and execute the entry point if entry_point_fn: mod = __import__(module_name, level=0, fromlist=[entry_point_fn], globals=globals, locals=locals) func = getattr(mod, entry_point_fn) func() else: # Run with the -m switch globals = pydevd_runpy._run_module_as_main(module_name, alter_argv=False) return globals def wait_for_commands(self, globals): self._activate_gui_if_needed() thread = threading.current_thread() from _pydevd_bundle import pydevd_frame_utils frame = pydevd_frame_utils.Frame(None, -1, pydevd_frame_utils.FCode("Console", os.path.abspath(os.path.dirname(__file__))), globals, globals) thread_id = get_current_thread_id(thread) self.add_fake_frame(thread_id, id(frame), frame) cmd = self.cmd_factory.make_show_console_message(self, thread_id, frame) if self.writer is not None: self.writer.add_command(cmd) while True: if self.gui_in_use: # call input hooks if only GUI is in use self._call_input_hook() self.process_internal_commands() time.sleep(0.01) class IDAPMessagesListener(object): def before_send(self, message_as_dict): ''' Called just before a message is sent to the IDE. :type message_as_dict: dict ''' def after_receive(self, message_as_dict): ''' Called just after a message is received from the IDE. :type message_as_dict: dict ''' def add_dap_messages_listener(dap_messages_listener): ''' Adds a listener for the DAP (debug adapter protocol) messages. :type dap_messages_listener: IDAPMessagesListener :note: messages from the xml backend are not notified through this API. :note: the notifications are sent from threads and they are not synchronized (so, it's possible that a message is sent and received from different threads at the same time). ''' py_db = get_global_debugger() if py_db is None: raise AssertionError('PyDB is still not setup.') py_db.add_dap_messages_listener(dap_messages_listener) def send_json_message(msg): ''' API to send some custom json message. :param dict|pydevd_schema.BaseSchema msg: The custom message to be sent. :return bool: True if the message was added to the queue to be sent and False otherwise. ''' py_db = get_global_debugger() if py_db is None: return False writer = py_db.writer if writer is None: return False cmd = NetCommand(-1, 0, msg, is_json=True) writer.add_command(cmd) return True def set_debug(setup): setup['DEBUG_RECORD_SOCKET_READS'] = True setup['DEBUG_TRACE_BREAKPOINTS'] = 1 setup['DEBUG_TRACE_LEVEL'] = 3 def enable_qt_support(qt_support_mode): from _pydev_bundle import pydev_monkey_qt pydev_monkey_qt.patch_qt(qt_support_mode) def start_dump_threads_thread(filename_template, timeout, recurrent): ''' Helper to dump threads after a timeout. :param filename_template: A template filename, such as 'c:/temp/thread_dump_%s.txt', where the %s will be replaced by the time for the dump. :param timeout: The timeout (in seconds) for the dump. :param recurrent: If True we'll keep on doing thread dumps. ''' assert filename_template.count('%s') == 1, \ 'Expected one %%s to appear in: %s' % (filename_template,) def _threads_on_timeout(): try: while True: time.sleep(timeout) filename = filename_template % (time.time(),) try: os.makedirs(os.path.dirname(filename)) except Exception: pass with open(filename, 'w') as stream: dump_threads(stream) if not recurrent: return except Exception: pydev_log.exception() t = threading.Thread(target=_threads_on_timeout) mark_as_pydevd_daemon_thread(t) t.start() def dump_threads(stream=None): ''' Helper to dump thread info (default is printing to stderr). ''' pydevd_utils.dump_threads(stream) def usage(doExit=0): sys.stdout.write('Usage:\n') sys.stdout.write('pydevd.py --port N [(--client hostname) | --server] --file executable [file_options]\n') if doExit: sys.exit(0) def _init_stdout_redirect(): pydevd_io.redirect_stream_to_pydb_io_messages(std='stdout') def _init_stderr_redirect(): pydevd_io.redirect_stream_to_pydb_io_messages(std='stderr') def _enable_attach( address, dont_trace_start_patterns=(), dont_trace_end_patterns=(), patch_multiprocessing=False, access_token=None, client_access_token=None, ): ''' Starts accepting connections at the given host/port. The debugger will not be initialized nor configured, it'll only start accepting connections (and will have the tracing setup in this thread). Meant to be used with the DAP (Debug Adapter Protocol) with _wait_for_attach(). :param address: (host, port) :type address: tuple(str, int) ''' host = address[0] port = int(address[1]) if SetupHolder.setup is not None: if port != SetupHolder.setup['port']: raise AssertionError('Unable to listen in port: %s (already listening in port: %s)' % (port, SetupHolder.setup['port'])) settrace( host=host, port=port, suspend=False, wait_for_ready_to_run=False, block_until_connected=False, dont_trace_start_patterns=dont_trace_start_patterns, dont_trace_end_patterns=dont_trace_end_patterns, patch_multiprocessing=patch_multiprocessing, access_token=access_token, client_access_token=client_access_token, ) py_db = get_global_debugger() py_db.wait_for_server_socket_ready() return py_db._server_socket_name def _wait_for_attach(cancel=None): ''' Meant to be called after _enable_attach() -- the current thread will only unblock after a connection is in place and the DAP (Debug Adapter Protocol) sends the ConfigurationDone request. ''' py_db = get_global_debugger() if py_db is None: raise AssertionError('Debugger still not created. Please use _enable_attach() before using _wait_for_attach().') py_db.block_until_configuration_done(cancel=cancel) def _is_attached(): ''' Can be called any time to check if the connection was established and the DAP (Debug Adapter Protocol) has sent the ConfigurationDone request. ''' py_db = get_global_debugger() return (py_db is not None) and py_db.is_attached() #======================================================================================================================= # settrace #======================================================================================================================= def settrace( host=None, stdout_to_server=False, stderr_to_server=False, port=5678, suspend=True, trace_only_current_thread=False, overwrite_prev_trace=False, patch_multiprocessing=False, stop_at_frame=None, block_until_connected=True, wait_for_ready_to_run=True, dont_trace_start_patterns=(), dont_trace_end_patterns=(), access_token=None, client_access_token=None, notify_stdin=True, **kwargs ): '''Sets the tracing function with the pydev debug function and initializes needed facilities. :param host: the user may specify another host, if the debug server is not in the same machine (default is the local host) :param stdout_to_server: when this is true, the stdout is passed to the debug server :param stderr_to_server: when this is true, the stderr is passed to the debug server so that they are printed in its console and not in this process console. :param port: specifies which port to use for communicating with the server (note that the server must be started in the same port). @note: currently it's hard-coded at 5678 in the client :param suspend: whether a breakpoint should be emulated as soon as this function is called. :param trace_only_current_thread: determines if only the current thread will be traced or all current and future threads will also have the tracing enabled. :param overwrite_prev_trace: deprecated :param patch_multiprocessing: if True we'll patch the functions which create new processes so that launched processes are debugged. :param stop_at_frame: if passed it'll stop at the given frame, otherwise it'll stop in the function which called this method. :param wait_for_ready_to_run: if True settrace will block until the ready_to_run flag is set to True, otherwise, it'll set ready_to_run to True and this function won't block. Note that if wait_for_ready_to_run == False, there are no guarantees that the debugger is synchronized with what's configured in the client (IDE), the only guarantee is that when leaving this function the debugger will be already connected. :param dont_trace_start_patterns: if set, then any path that starts with one fo the patterns in the collection will not be traced :param dont_trace_end_patterns: if set, then any path that ends with one fo the patterns in the collection will not be traced :param access_token: token to be sent from the client (i.e.: IDE) to the debugger when a connection is established (verified by the debugger). :param client_access_token: token to be sent from the debugger to the client (i.e.: IDE) when a connection is established (verified by the client). :param notify_stdin: If True sys.stdin will be patched to notify the client when a message is requested from the IDE. This is done so that when reading the stdin the client is notified. Clients may need this to know when something that is being written should be interpreted as an input to the process or as a command to be evaluated. Note that parallel-python has issues with this (because it tries to assert that sys.stdin is of a given type instead of just checking that it has what it needs). ''' stdout_to_server = stdout_to_server or kwargs.get('stdoutToServer', False) # Backward compatibility stderr_to_server = stderr_to_server or kwargs.get('stderrToServer', False) # Backward compatibility # Internal use (may be used to set the setup info directly for subprocesess). __setup_holder__ = kwargs.get('__setup_holder__') with _set_trace_lock: _locked_settrace( host, stdout_to_server, stderr_to_server, port, suspend, trace_only_current_thread, patch_multiprocessing, stop_at_frame, block_until_connected, wait_for_ready_to_run, dont_trace_start_patterns, dont_trace_end_patterns, access_token, client_access_token, __setup_holder__=__setup_holder__, notify_stdin=notify_stdin, ) _set_trace_lock = ForkSafeLock() def _locked_settrace( host, stdout_to_server, stderr_to_server, port, suspend, trace_only_current_thread, patch_multiprocessing, stop_at_frame, block_until_connected, wait_for_ready_to_run, dont_trace_start_patterns, dont_trace_end_patterns, access_token, client_access_token, __setup_holder__, notify_stdin, ): if patch_multiprocessing: try: from _pydev_bundle import pydev_monkey except: pass else: pydev_monkey.patch_new_process_functions() if host is None: from _pydev_bundle import pydev_localhost host = pydev_localhost.get_localhost() global _global_redirect_stdout_to_server global _global_redirect_stderr_to_server py_db = get_global_debugger() if __setup_holder__: SetupHolder.setup = __setup_holder__ if py_db is None: py_db = PyDB() pydevd_vm_type.setup_type() if SetupHolder.setup is None: setup = { 'client': host, # dispatch expects client to be set to the host address when server is False 'server': False, 'port': int(port), 'multiprocess': patch_multiprocessing, 'skip-notify-stdin': not notify_stdin, } SetupHolder.setup = setup if access_token is not None: py_db.authentication.access_token = access_token SetupHolder.setup['access-token'] = access_token if client_access_token is not None: py_db.authentication.client_access_token = client_access_token SetupHolder.setup['client-access-token'] = client_access_token if block_until_connected: py_db.connect(host, port) # Note: connect can raise error. else: # Create a dummy writer and wait for the real connection. py_db.writer = WriterThread(NULL, py_db, terminate_on_socket_close=False) py_db.create_wait_for_connection_thread() if dont_trace_start_patterns or dont_trace_end_patterns: PyDevdAPI().set_dont_trace_start_end_patterns(py_db, dont_trace_start_patterns, dont_trace_end_patterns) _global_redirect_stdout_to_server = stdout_to_server _global_redirect_stderr_to_server = stderr_to_server if _global_redirect_stdout_to_server: _init_stdout_redirect() if _global_redirect_stderr_to_server: _init_stderr_redirect() if notify_stdin: patch_stdin() t = threadingCurrentThread() additional_info = set_additional_thread_info(t) if not wait_for_ready_to_run: py_db.ready_to_run = True py_db.wait_for_ready_to_run() py_db.start_auxiliary_daemon_threads() try: if INTERACTIVE_MODE_AVAILABLE: py_db.init_gui_support() except: pydev_log.exception("Matplotlib support in debugger failed") if trace_only_current_thread: py_db.enable_tracing() else: # Trace future threads. py_db.patch_threads() py_db.enable_tracing(py_db.trace_dispatch, apply_to_all_threads=True) # As this is the first connection, also set tracing for any untraced threads py_db.set_tracing_for_untraced_contexts() py_db.set_trace_for_frame_and_parents(get_frame().f_back) with CustomFramesContainer.custom_frames_lock: # @UndefinedVariable for _frameId, custom_frame in CustomFramesContainer.custom_frames.items(): py_db.set_trace_for_frame_and_parents(custom_frame.frame) else: # ok, we're already in debug mode, with all set, so, let's just set the break if access_token is not None: py_db.authentication.access_token = access_token if client_access_token is not None: py_db.authentication.client_access_token = client_access_token py_db.set_trace_for_frame_and_parents(get_frame().f_back) t = threadingCurrentThread() additional_info = set_additional_thread_info(t) if trace_only_current_thread: py_db.enable_tracing() else: # Trace future threads. py_db.patch_threads() py_db.enable_tracing(py_db.trace_dispatch, apply_to_all_threads=True) # Suspend as the last thing after all tracing is in place. if suspend: if stop_at_frame is not None: # If the step was set we have to go to run state and # set the proper frame for it to stop. additional_info.pydev_state = STATE_RUN additional_info.pydev_original_step_cmd = CMD_STEP_OVER additional_info.pydev_step_cmd = CMD_STEP_OVER additional_info.pydev_step_stop = stop_at_frame additional_info.suspend_type = PYTHON_SUSPEND else: # Ask to break as soon as possible. py_db.set_suspend(t, CMD_SET_BREAK) def stoptrace(): pydev_log.debug("pydevd.stoptrace()") pydevd_tracing.restore_sys_set_trace_func() sys.settrace(None) try: # not available in jython! threading.settrace(None) # for all future threads except: pass from _pydev_bundle.pydev_monkey import undo_patch_thread_modules undo_patch_thread_modules() # Either or both standard streams can be closed at this point, # in which case flush() will fail. try: sys.stdout.flush() except: pass try: sys.stderr.flush() except: pass py_db = get_global_debugger() if py_db is not None: py_db.dispose_and_kill_all_pydevd_threads() class Dispatcher(object): def __init__(self): self.port = None def connect(self, host, port): self.host = host self.port = port self.client = start_client(self.host, self.port) self.reader = DispatchReader(self) self.reader.pydev_do_not_trace = False # we run reader in the same thread so we don't want to loose tracing self.reader.run() def close(self): try: self.reader.do_kill_pydev_thread() except: pass class DispatchReader(ReaderThread): def __init__(self, dispatcher): self.dispatcher = dispatcher ReaderThread.__init__( self, get_global_debugger(), self.dispatcher.client, PyDevJsonCommandProcessor=PyDevJsonCommandProcessor, process_net_command=process_net_command, ) @overrides(ReaderThread._on_run) def _on_run(self): dummy_thread = threading.current_thread() dummy_thread.is_pydev_daemon_thread = False return ReaderThread._on_run(self) @overrides(PyDBDaemonThread.do_kill_pydev_thread) def do_kill_pydev_thread(self): if not self._kill_received: ReaderThread.do_kill_pydev_thread(self) try: self.sock.shutdown(SHUT_RDWR) except: pass try: self.sock.close() except: pass def process_command(self, cmd_id, seq, text): if cmd_id == 99: self.dispatcher.port = int(text) self._kill_received = True DISPATCH_APPROACH_NEW_CONNECTION = 1 # Used by PyDev DISPATCH_APPROACH_EXISTING_CONNECTION = 2 # Used by PyCharm DISPATCH_APPROACH = DISPATCH_APPROACH_NEW_CONNECTION def dispatch(): setup = SetupHolder.setup host = setup['client'] port = setup['port'] if DISPATCH_APPROACH == DISPATCH_APPROACH_EXISTING_CONNECTION: dispatcher = Dispatcher() try: dispatcher.connect(host, port) port = dispatcher.port finally: dispatcher.close() return host, port def settrace_forked(setup_tracing=True): ''' When creating a fork from a process in the debugger, we need to reset the whole debugger environment! ''' from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder py_db = GlobalDebuggerHolder.global_dbg if py_db is not None: py_db.created_pydb_daemon_threads = {} # Just making sure we won't touch those (paused) threads. py_db = None GlobalDebuggerHolder.global_dbg = None threading.current_thread().additional_info = None # Make sure that we keep the same access tokens for subprocesses started through fork. setup = SetupHolder.setup if setup is None: setup = {} else: # i.e.: Get the ppid at this point as it just changed. # If we later do an exec() it should remain the same ppid. setup[pydevd_constants.ARGUMENT_PPID] = PyDevdAPI().get_ppid() access_token = setup.get('access-token') client_access_token = setup.get('client-access-token') if setup_tracing: from _pydevd_frame_eval.pydevd_frame_eval_main import clear_thread_local_info host, port = dispatch() import pydevd_tracing pydevd_tracing.restore_sys_set_trace_func() if setup_tracing: if port is not None: custom_frames_container_init() if clear_thread_local_info is not None: clear_thread_local_info() settrace( host, port=port, suspend=False, trace_only_current_thread=False, overwrite_prev_trace=True, patch_multiprocessing=True, access_token=access_token, client_access_token=client_access_token, ) @contextmanager def skip_subprocess_arg_patch(): ''' May be used to skip the monkey-patching that pydevd does to skip changing arguments to embed the debugger into child processes. i.e.: with pydevd.skip_subprocess_arg_patch(): subprocess.call(...) ''' from _pydev_bundle import pydev_monkey with pydev_monkey.skip_subprocess_arg_patch(): yield def add_dont_terminate_child_pid(pid): ''' May be used to ask pydevd to skip the termination of some process when it's asked to terminate (debug adapter protocol only). :param int pid: The pid to be ignored. i.e.: process = subprocess.Popen(...) pydevd.add_dont_terminate_child_pid(process.pid) ''' py_db = get_global_debugger() if py_db is not None: py_db.dont_terminate_child_pids.add(pid) class SetupHolder: setup = None def apply_debugger_options(setup_options): """ :type setup_options: dict[str, bool] """ default_options = {'save-signatures': False, 'qt-support': ''} default_options.update(setup_options) setup_options = default_options debugger = get_global_debugger() if setup_options['save-signatures']: if pydevd_vm_type.get_vm_type() == pydevd_vm_type.PydevdVmType.JYTHON: sys.stderr.write("Collecting run-time type information is not supported for Jython\n") else: # Only import it if we're going to use it! from _pydevd_bundle.pydevd_signature import SignatureFactory debugger.signature_factory = SignatureFactory() if setup_options['qt-support']: enable_qt_support(setup_options['qt-support']) @call_only_once def patch_stdin(): _internal_patch_stdin(None, sys, getpass_mod) def _internal_patch_stdin(py_db=None, sys=None, getpass_mod=None): ''' Note: don't use this function directly, use `patch_stdin()` instead. (this function is only meant to be used on test-cases to avoid patching the actual globals). ''' # Patch stdin so that we notify when readline() is called. original_sys_stdin = sys.stdin debug_console_stdin = DebugConsoleStdIn(py_db, original_sys_stdin) sys.stdin = debug_console_stdin _original_getpass = getpass_mod.getpass @functools.wraps(_original_getpass) def getpass(*args, **kwargs): with DebugConsoleStdIn.notify_input_requested(debug_console_stdin): try: curr_stdin = sys.stdin if curr_stdin is debug_console_stdin: sys.stdin = original_sys_stdin return _original_getpass(*args, **kwargs) finally: sys.stdin = curr_stdin getpass_mod.getpass = getpass # Dispatch on_debugger_modules_loaded here, after all primary py_db modules are loaded for handler in pydevd_extension_utils.extensions_of_type(DebuggerEventHandler): handler.on_debugger_modules_loaded(debugger_version=__version__) #======================================================================================================================= # main #======================================================================================================================= def main(): # parse the command line. --file is our last argument that is required pydev_log.debug("Initial arguments: %s", (sys.argv,)) pydev_log.debug("Current pid: %s", os.getpid()) try: from _pydevd_bundle.pydevd_command_line_handling import process_command_line setup = process_command_line(sys.argv) SetupHolder.setup = setup except ValueError: pydev_log.exception() usage(1) if setup['print-in-debugger-startup']: try: pid = ' (pid: %s)' % os.getpid() except: pid = '' sys.stderr.write("pydev debugger: starting%s\n" % pid) pydev_log.debug("Executing file %s", setup['file']) pydev_log.debug("arguments: %s", (sys.argv,)) pydevd_vm_type.setup_type(setup.get('vm_type', None)) if SHOW_DEBUG_INFO_ENV: set_debug(setup) DebugInfoHolder.DEBUG_RECORD_SOCKET_READS = setup.get('DEBUG_RECORD_SOCKET_READS', DebugInfoHolder.DEBUG_RECORD_SOCKET_READS) DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS = setup.get('DEBUG_TRACE_BREAKPOINTS', DebugInfoHolder.DEBUG_TRACE_BREAKPOINTS) DebugInfoHolder.DEBUG_TRACE_LEVEL = setup.get('DEBUG_TRACE_LEVEL', DebugInfoHolder.DEBUG_TRACE_LEVEL) port = setup['port'] host = setup['client'] f = setup['file'] fix_app_engine_debug = False debugger = get_global_debugger() if debugger is None: debugger = PyDB() try: from _pydev_bundle import pydev_monkey except: pass # Not usable on jython 2.1 else: if setup['multiprocess']: # PyDev pydev_monkey.patch_new_process_functions() elif setup['multiproc']: # PyCharm pydev_log.debug("Started in multiproc mode\n") global DISPATCH_APPROACH DISPATCH_APPROACH = DISPATCH_APPROACH_EXISTING_CONNECTION dispatcher = Dispatcher() try: dispatcher.connect(host, port) if dispatcher.port is not None: port = dispatcher.port pydev_log.debug("Received port %d\n", port) pydev_log.info("pydev debugger: process %d is connecting\n" % os.getpid()) try: pydev_monkey.patch_new_process_functions() except: pydev_log.exception("Error patching process functions.") else: pydev_log.critical("pydev debugger: couldn't get port for new debug process.") finally: dispatcher.close() else: try: pydev_monkey.patch_new_process_functions_with_warning() except: pydev_log.exception("Error patching process functions.") # Only do this patching if we're not running with multiprocess turned on. if f.find('dev_appserver.py') != -1: if os.path.basename(f).startswith('dev_appserver.py'): appserver_dir = os.path.dirname(f) version_file = os.path.join(appserver_dir, 'VERSION') if os.path.exists(version_file): try: stream = open(version_file, 'r') try: for line in stream.read().splitlines(): line = line.strip() if line.startswith('release:'): line = line[8:].strip() version = line.replace('"', '') version = version.split('.') if int(version[0]) > 1: fix_app_engine_debug = True elif int(version[0]) == 1: if int(version[1]) >= 7: # Only fix from 1.7 onwards fix_app_engine_debug = True break finally: stream.close() except: pydev_log.exception() try: # In the default run (i.e.: run directly on debug mode), we try to patch stackless as soon as possible # on a run where we have a remote debug, we may have to be more careful because patching stackless means # that if the user already had a stackless.set_schedule_callback installed, he'd loose it and would need # to call it again (because stackless provides no way of getting the last function which was registered # in set_schedule_callback). # # So, ideally, if there's an application using stackless and the application wants to use the remote debugger # and benefit from stackless debugging, the application itself must call: # # import pydevd_stackless # pydevd_stackless.patch_stackless() # # itself to be able to benefit from seeing the tasklets created before the remote debugger is attached. from _pydevd_bundle import pydevd_stackless pydevd_stackless.patch_stackless() except: # It's ok not having stackless there... try: if hasattr(sys, 'exc_clear'): sys.exc_clear() # the exception information should be cleaned in Python 2 except: pass is_module = setup['module'] if not setup['skip-notify-stdin']: patch_stdin() if setup[pydevd_constants.ARGUMENT_JSON_PROTOCOL]: PyDevdAPI().set_protocol(debugger, 0, JSON_PROTOCOL) elif setup[pydevd_constants.ARGUMENT_HTTP_JSON_PROTOCOL]: PyDevdAPI().set_protocol(debugger, 0, HTTP_JSON_PROTOCOL) elif setup[pydevd_constants.ARGUMENT_HTTP_PROTOCOL]: PyDevdAPI().set_protocol(debugger, 0, pydevd_constants.HTTP_PROTOCOL) elif setup[pydevd_constants.ARGUMENT_QUOTED_LINE_PROTOCOL]: PyDevdAPI().set_protocol(debugger, 0, pydevd_constants.QUOTED_LINE_PROTOCOL) access_token = setup['access-token'] if access_token: debugger.authentication.access_token = access_token client_access_token = setup['client-access-token'] if client_access_token: debugger.authentication.client_access_token = client_access_token if fix_app_engine_debug: sys.stderr.write("pydev debugger: google app engine integration enabled\n") curr_dir = os.path.dirname(__file__) app_engine_startup_file = os.path.join(curr_dir, 'pydev_app_engine_debug_startup.py') sys.argv.insert(1, '--python_startup_script=' + app_engine_startup_file) import json setup['pydevd'] = __file__ sys.argv.insert(2, '--python_startup_args=%s' % json.dumps(setup),) sys.argv.insert(3, '--automatic_restart=no') sys.argv.insert(4, '--max_module_instances=1') # Run the dev_appserver debugger.run(setup['file'], None, None, is_module, set_trace=False) else: if setup['save-threading']: debugger.thread_analyser = ThreadingLogger() if setup['save-asyncio']: debugger.asyncio_analyser = AsyncioLogger() apply_debugger_options(setup) try: debugger.connect(host, port) except: sys.stderr.write("Could not connect to %s: %s\n" % (host, port)) pydev_log.exception() sys.exit(1) globals = debugger.run(setup['file'], None, None, is_module) if setup['cmd-line']: debugger.wait_for_commands(globals) if __name__ == '__main__': main()
144,860
Python
41.184333
257
0.600152
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydevd_file_utils.py
r''' This module provides utilities to get the absolute filenames so that we can be sure that: - The case of a file will match the actual file in the filesystem (otherwise breakpoints won't be hit). - Providing means for the user to make path conversions when doing a remote debugging session in one machine and debugging in another. To do that, the PATHS_FROM_ECLIPSE_TO_PYTHON constant must be filled with the appropriate paths. @note: in this context, the server is where your python process is running and the client is where eclipse is running. E.g.: If the server (your python process) has the structure /user/projects/my_project/src/package/module1.py and the client has: c:\my_project\src\package\module1.py the PATHS_FROM_ECLIPSE_TO_PYTHON would have to be: PATHS_FROM_ECLIPSE_TO_PYTHON = [(r'c:\my_project\src', r'/user/projects/my_project/src')] alternatively, this can be set with an environment variable from the command line: set PATHS_FROM_ECLIPSE_TO_PYTHON=[['c:\my_project\src','/user/projects/my_project/src']] @note: DEBUG_CLIENT_SERVER_TRANSLATION can be set to True to debug the result of those translations @note: the case of the paths is important! Note that this can be tricky to get right when one machine uses a case-independent filesystem and the other uses a case-dependent filesystem (if the system being debugged is case-independent, 'normcase()' should be used on the paths defined in PATHS_FROM_ECLIPSE_TO_PYTHON). @note: all the paths with breakpoints must be translated (otherwise they won't be found in the server) @note: to enable remote debugging in the target machine (pydev extensions in the eclipse installation) import pydevd;pydevd.settrace(host, stdoutToServer, stderrToServer, port, suspend) see parameter docs on pydevd.py @note: for doing a remote debugging session, all the pydevd_ files must be on the server accessible through the PYTHONPATH (and the PATHS_FROM_ECLIPSE_TO_PYTHON only needs to be set on the target machine for the paths that'll actually have breakpoints). ''' from _pydev_bundle import pydev_log from _pydevd_bundle.pydevd_constants import DebugInfoHolder, IS_WINDOWS, IS_JYTHON, \ DISABLE_FILE_VALIDATION, is_true_in_env from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding from _pydevd_bundle.pydevd_comm_constants import file_system_encoding, filesystem_encoding_is_utf8 from _pydev_bundle.pydev_log import error_once import json import os.path import sys import itertools import ntpath from functools import partial _nt_os_normcase = ntpath.normcase os_path_basename = os.path.basename os_path_exists = os.path.exists join = os.path.join try: FileNotFoundError except NameError: FileNotFoundError = IOError # noqa try: os_path_real_path = os.path.realpath # @UndefinedVariable except: # jython does not support os.path.realpath # realpath is a no-op on systems without islink support os_path_real_path = os.path.abspath def _get_library_dir(): library_dir = None try: import sysconfig library_dir = sysconfig.get_path('purelib') except ImportError: pass # i.e.: Only 2.7 onwards if library_dir is None or not os_path_exists(library_dir): for path in sys.path: if os_path_exists(path) and os.path.basename(path) == 'site-packages': library_dir = path break if library_dir is None or not os_path_exists(library_dir): library_dir = os.path.dirname(os.__file__) return library_dir # Note: we can't call sysconfig.get_path from _apply_func_and_normalize_case (it deadlocks on Python 2.7) so, we # need to get the library dir during module loading. _library_dir = _get_library_dir() # defined as a list of tuples where the 1st element of the tuple is the path in the client machine # and the 2nd element is the path in the server machine. # see module docstring for more details. try: PATHS_FROM_ECLIPSE_TO_PYTHON = json.loads(os.environ.get('PATHS_FROM_ECLIPSE_TO_PYTHON', '[]')) except Exception: pydev_log.critical('Error loading PATHS_FROM_ECLIPSE_TO_PYTHON from environment variable.') pydev_log.exception() PATHS_FROM_ECLIPSE_TO_PYTHON = [] else: if not isinstance(PATHS_FROM_ECLIPSE_TO_PYTHON, list): pydev_log.critical('Expected PATHS_FROM_ECLIPSE_TO_PYTHON loaded from environment variable to be a list.') PATHS_FROM_ECLIPSE_TO_PYTHON = [] else: # Converting json lists to tuple PATHS_FROM_ECLIPSE_TO_PYTHON = [tuple(x) for x in PATHS_FROM_ECLIPSE_TO_PYTHON] # example: # PATHS_FROM_ECLIPSE_TO_PYTHON = [ # (r'd:\temp\temp_workspace_2\test_python\src\yyy\yyy', # r'd:\temp\temp_workspace_2\test_python\src\hhh\xxx') # ] convert_to_long_pathname = lambda filename:filename convert_to_short_pathname = lambda filename:filename get_path_with_real_case = lambda filename:filename if sys.platform == 'win32': try: import ctypes from ctypes.wintypes import MAX_PATH, LPCWSTR, LPWSTR, DWORD GetLongPathName = ctypes.windll.kernel32.GetLongPathNameW # noqa GetLongPathName.argtypes = [LPCWSTR, LPWSTR, DWORD] GetLongPathName.restype = DWORD GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW # noqa GetShortPathName.argtypes = [LPCWSTR, LPWSTR, DWORD] GetShortPathName.restype = DWORD def _convert_to_long_pathname(filename): buf = ctypes.create_unicode_buffer(MAX_PATH) rv = GetLongPathName(filename, buf, MAX_PATH) if rv != 0 and rv <= MAX_PATH: filename = buf.value return filename def _convert_to_short_pathname(filename): buf = ctypes.create_unicode_buffer(MAX_PATH) rv = GetShortPathName(filename, buf, MAX_PATH) if rv != 0 and rv <= MAX_PATH: filename = buf.value return filename # Note that we have a cache for previous list dirs... the only case where this may be an # issue is if the user actually changes the case of an existing file on windows while # the debugger is executing (as this seems very unlikely and the cache can save a # reasonable time -- especially on mapped drives -- it seems nice to have it). _listdir_cache = {} def _resolve_listing(resolved, iter_parts, cache=_listdir_cache): while True: # Note: while True to make iterative and not recursive try: resolve_lowercase = next(iter_parts) # must be lowercase already except StopIteration: return resolved resolved_lower = resolved.lower() resolved_joined = cache.get((resolved_lower, resolve_lowercase)) if resolved_joined is None: dir_contents = cache.get(resolved_lower) if dir_contents is None: dir_contents = cache[resolved_lower] = os.listdir(resolved) for filename in dir_contents: if filename.lower() == resolve_lowercase: resolved_joined = os.path.join(resolved, filename) cache[(resolved_lower, resolve_lowercase)] = resolved_joined break else: raise FileNotFoundError('Unable to find: %s in %s' % ( resolve_lowercase, resolved)) resolved = resolved_joined def _get_path_with_real_case(filename): # Note: this previously made: # convert_to_long_pathname(convert_to_short_pathname(filename)) # but this is no longer done because we can't rely on getting the shortname # consistently (there are settings to disable it on Windows). # So, using approach which resolves by listing the dir. if '~' in filename: filename = convert_to_long_pathname(filename) if filename.startswith('<') or not os_path_exists(filename): return filename # Not much we can do. drive, parts = os.path.splitdrive(os.path.normpath(filename)) drive = drive.upper() while parts.startswith(os.path.sep): parts = parts[1:] drive += os.path.sep parts = parts.lower().split(os.path.sep) try: if parts == ['']: return drive return _resolve_listing(drive, iter(parts)) except FileNotFoundError: _listdir_cache.clear() # Retry once after clearing the cache we have. try: return _resolve_listing(drive, iter(parts)) except FileNotFoundError: if os_path_exists(filename): # This is really strange, ask the user to report as error. pydev_log.critical( 'pydev debugger: critical: unable to get real case for file. Details:\n' 'filename: %s\ndrive: %s\nparts: %s\n' '(please create a ticket in the tracker to address this).', filename, drive, parts ) pydev_log.exception() # Don't fail, just return the original file passed. return filename # Check that it actually works _get_path_with_real_case(__file__) except: # Something didn't quite work out, leave no-op conversions in place. if DebugInfoHolder.DEBUG_TRACE_LEVEL > 2: pydev_log.exception() else: convert_to_long_pathname = _convert_to_long_pathname convert_to_short_pathname = _convert_to_short_pathname get_path_with_real_case = _get_path_with_real_case elif IS_JYTHON and IS_WINDOWS: def get_path_with_real_case(filename): from java.io import File # noqa f = File(filename) ret = f.getCanonicalPath() return ret if IS_JYTHON: def _normcase_windows(filename): return filename.lower() else: def _normcase_windows(filename): # `normcase` doesn't lower case on Python 2 for non-English locale, so we should do it manually. if '~' in filename: filename = convert_to_long_pathname(filename) filename = _nt_os_normcase(filename) return filename.lower() def _normcase_linux(filename): return filename # no-op _filename_normalization = os.environ.get('PYDEVD_FILENAME_NORMALIZATION', '').lower() if _filename_normalization == 'lower': # Note: this is mostly for testing (forcing to always lower-case all contents # internally -- used to mimick Windows normalization on Linux). def _normcase_lower(filename): return filename.lower() _default_normcase = _normcase_lower elif _filename_normalization == 'none': # Disable any filename normalization may be an option on Windows if the # user is having issues under some circumstances. _default_normcase = _normcase_linux elif IS_WINDOWS: _default_normcase = _normcase_windows else: _default_normcase = _normcase_linux def normcase(s, NORMCASE_CACHE={}): try: return NORMCASE_CACHE[s] except: normalized = NORMCASE_CACHE[s] = _default_normcase(s) return normalized _ide_os = 'WINDOWS' if IS_WINDOWS else 'UNIX' _normcase_from_client = normcase def normcase_from_client(s): return _normcase_from_client(s) DEBUG_CLIENT_SERVER_TRANSLATION = os.environ.get('DEBUG_PYDEVD_PATHS_TRANSLATION', 'False').lower() in ('1', 'true') def set_ide_os(os): ''' We need to set the IDE os because the host where the code is running may be actually different from the client (and the point is that we want the proper paths to translate from the client to the server). :param os: 'UNIX' or 'WINDOWS' ''' global _ide_os global _normcase_from_client prev = _ide_os if os == 'WIN': # Apparently PyCharm uses 'WIN' (https://github.com/fabioz/PyDev.Debugger/issues/116) os = 'WINDOWS' assert os in ('WINDOWS', 'UNIX') if DEBUG_CLIENT_SERVER_TRANSLATION: print('pydev debugger: client OS: %s' % (os,)) _normcase_from_client = normcase if os == 'WINDOWS': # Client in Windows and server in Unix, we need to normalize the case. if not IS_WINDOWS: _normcase_from_client = _normcase_windows else: # Client in Unix and server in Windows, we can't normalize the case. if IS_WINDOWS: _normcase_from_client = _normcase_linux if prev != os: _ide_os = os # We need to (re)setup how the client <-> server translation works to provide proper separators. setup_client_server_paths(_last_client_server_paths_set) # Caches filled as requested during the debug session. NORM_PATHS_CONTAINER = {} NORM_PATHS_AND_BASE_CONTAINER = {} def canonical_normalized_path(filename): ''' This returns a filename that is canonical and it's meant to be used internally to store information on breakpoints and see if there's any hit on it. Note that this version is only internal as it may not match the case and may have symlinks resolved (and thus may not match what the user expects in the editor). ''' return get_abs_path_real_path_and_base_from_file(filename)[1] def absolute_path(filename): ''' Provides a version of the filename that's absolute (and NOT normalized). ''' return get_abs_path_real_path_and_base_from_file(filename)[0] def basename(filename): ''' Provides the basename for a file. ''' return get_abs_path_real_path_and_base_from_file(filename)[2] # Returns tuple of absolute path and real path for given filename def _abs_and_canonical_path(filename, NORM_PATHS_CONTAINER=NORM_PATHS_CONTAINER): try: return NORM_PATHS_CONTAINER[filename] except: if filename.__class__ != str: raise AssertionError('Paths passed to _abs_and_canonical_path must be str. Found: %s (%s)' % (filename, type(filename))) if os is None: # Interpreter shutdown return filename, filename os_path = os.path if os_path is None: # Interpreter shutdown return filename, filename os_path_abspath = os_path.abspath os_path_isabs = os_path.isabs if os_path_abspath is None or os_path_isabs is None or os_path_real_path is None: # Interpreter shutdown return filename, filename isabs = os_path_isabs(filename) if _global_resolve_symlinks: os_path_abspath = os_path_real_path normalize = False abs_path = _apply_func_and_normalize_case(filename, os_path_abspath, isabs, normalize) normalize = True real_path = _apply_func_and_normalize_case(filename, os_path_real_path, isabs, normalize) # cache it for fast access later NORM_PATHS_CONTAINER[filename] = abs_path, real_path return abs_path, real_path def _get_relative_filename_abs_path(filename, func, os_path_exists=os_path_exists): # If we have a relative path and the file does not exist when made absolute, try to # resolve it based on the sys.path entries. for p in sys.path: r = func(os.path.join(p, filename)) if os_path_exists(r): return r # We couldn't find the real file for the relative path. Resolve it as if it was in # a library (so that it's considered a library file and not a project file). r = func(os.path.join(_library_dir, filename)) return r def _apply_func_and_normalize_case(filename, func, isabs, normalize_case, os_path_exists=os_path_exists, join=join): if filename.startswith('<'): # Not really a file, rather a synthetic name like <string> or <ipython-...>; # shouldn't be normalized. return filename r = func(filename) if not isabs: if not os_path_exists(r): r = _get_relative_filename_abs_path(filename, func) ind = r.find('.zip') if ind == -1: ind = r.find('.egg') if ind != -1: ind += 4 zip_path = r[:ind] inner_path = r[ind:] if inner_path.startswith('!'): # Note (fabioz): although I can replicate this by creating a file ending as # .zip! or .egg!, I don't really know what's the real-world case for this # (still kept as it was added by @jetbrains, but it should probably be reviewed # later on). # Note 2: it goes hand-in-hand with 'exists'. inner_path = inner_path[1:] zip_path = zip_path + '!' if inner_path.startswith('/') or inner_path.startswith('\\'): inner_path = inner_path[1:] if inner_path: if normalize_case: r = join(normcase(zip_path), inner_path) else: r = join(zip_path, inner_path) return r if normalize_case: r = normcase(r) return r _ZIP_SEARCH_CACHE = {} _NOT_FOUND_SENTINEL = object() def exists(filename): if os_path_exists(filename): return True if not os.path.isabs(filename): filename = _get_relative_filename_abs_path(filename, os.path.abspath) if os_path_exists(filename): return True ind = filename.find('.zip') if ind == -1: ind = filename.find('.egg') if ind != -1: ind += 4 zip_path = filename[:ind] inner_path = filename[ind:] if inner_path.startswith("!"): # Note (fabioz): although I can replicate this by creating a file ending as # .zip! or .egg!, I don't really know what's the real-world case for this # (still kept as it was added by @jetbrains, but it should probably be reviewed # later on). # Note 2: it goes hand-in-hand with '_apply_func_and_normalize_case'. inner_path = inner_path[1:] zip_path = zip_path + '!' zip_file_obj = _ZIP_SEARCH_CACHE.get(zip_path, _NOT_FOUND_SENTINEL) if zip_file_obj is None: return False elif zip_file_obj is _NOT_FOUND_SENTINEL: try: import zipfile zip_file_obj = zipfile.ZipFile(zip_path, 'r') _ZIP_SEARCH_CACHE[zip_path] = zip_file_obj except: _ZIP_SEARCH_CACHE[zip_path] = _NOT_FOUND_SENTINEL return False try: if inner_path.startswith('/') or inner_path.startswith('\\'): inner_path = inner_path[1:] _info = zip_file_obj.getinfo(inner_path.replace('\\', '/')) return join(zip_path, inner_path) except KeyError: return False else: pydev_log.debug('os.path.exists(%r) returned False.', filename) return False try: report = pydev_log.critical if DISABLE_FILE_VALIDATION: report = pydev_log.debug try: code = os_path_real_path.func_code except AttributeError: code = os_path_real_path.__code__ if code.co_filename.startswith('<frozen'): # See: https://github.com/fabioz/PyDev.Debugger/issues/213 report('Debugger warning: It seems that frozen modules are being used, which may') report('make the debugger miss breakpoints. Please pass -Xfrozen_modules=off') report('to python to disable frozen modules.') report('Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.') elif not os.path.isabs(code.co_filename): report('Debugger warning: The os.path.realpath.__code__.co_filename (%s)', code.co_filename) report('is not absolute, which may make the debugger miss breakpoints.') report('Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.') elif not exists(code.co_filename): # Note: checks for files inside .zip containers. report('Debugger warning: It seems the debugger cannot find os.path.realpath.__code__.co_filename (%s).', code.co_filename) report('This may make the debugger miss breakpoints in the standard library.') report('Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation.') except: # Don't fail if there's something not correct here -- but at least print it to the user so that we can correct that pydev_log.exception() # Note: as these functions may be rebound, users should always import # pydevd_file_utils and then use: # # pydevd_file_utils.map_file_to_client # pydevd_file_utils.map_file_to_server # # instead of importing any of those names to a given scope. def _path_to_expected_str(filename): if isinstance(filename, bytes): filename = filename.decode(file_system_encoding) return filename def _original_file_to_client(filename, cache={}): try: return cache[filename] except KeyError: translated = _path_to_expected_str(get_path_with_real_case(absolute_path(filename))) cache[filename] = (translated, False) return cache[filename] def _original_map_file_to_server(filename): # By default just mapping to the server does nothing if there are no mappings (usually # afterwards the debugger must do canonical_normalized_path to get a normalized version). return filename map_file_to_client = _original_file_to_client map_file_to_server = _original_map_file_to_server def _fix_path(path, sep, add_end_sep=False): if add_end_sep: if not path.endswith('/') and not path.endswith('\\'): path += '/' else: if path.endswith('/') or path.endswith('\\'): path = path[:-1] if sep != '/': path = path.replace('/', sep) return path _last_client_server_paths_set = [] _source_reference_to_frame_id = {} _source_reference_to_server_filename = {} _line_cache_source_reference_to_server_filename = {} _client_filename_in_utf8_to_source_reference = {} _next_source_reference = partial(next, itertools.count(1)) def get_client_filename_source_reference(client_filename): return _client_filename_in_utf8_to_source_reference.get(client_filename, 0) def get_server_filename_from_source_reference(source_reference): return _source_reference_to_server_filename.get(source_reference, '') def create_source_reference_for_linecache(server_filename): source_reference = _next_source_reference() pydev_log.debug('Created linecache id source reference: %s for server filename: %s', source_reference, server_filename) _line_cache_source_reference_to_server_filename[source_reference] = server_filename return source_reference def get_source_reference_filename_from_linecache(source_reference): return _line_cache_source_reference_to_server_filename.get(source_reference) def create_source_reference_for_frame_id(frame_id, original_filename): source_reference = _next_source_reference() pydev_log.debug('Created frame id source reference: %s for frame id: %s (%s)', source_reference, frame_id, original_filename) _source_reference_to_frame_id[source_reference] = frame_id return source_reference def get_frame_id_from_source_reference(source_reference): return _source_reference_to_frame_id.get(source_reference) _global_resolve_symlinks = is_true_in_env('PYDEVD_RESOLVE_SYMLINKS') def set_resolve_symlinks(resolve_symlinks): global _global_resolve_symlinks _global_resolve_symlinks = resolve_symlinks def setup_client_server_paths(paths): '''paths is the same format as PATHS_FROM_ECLIPSE_TO_PYTHON''' global map_file_to_client global map_file_to_server global _last_client_server_paths_set global _next_source_reference _last_client_server_paths_set = paths[:] _source_reference_to_server_filename.clear() _client_filename_in_utf8_to_source_reference.clear() _next_source_reference = partial(next, itertools.count(1)) # Work on the client and server slashes. python_sep = '\\' if IS_WINDOWS else '/' eclipse_sep = '\\' if _ide_os == 'WINDOWS' else '/' norm_filename_to_server_container = {} norm_filename_to_client_container = {} initial_paths = [] initial_paths_with_end_sep = [] paths_from_eclipse_to_python = [] paths_from_eclipse_to_python_with_end_sep = [] # Apply normcase to the existing paths to follow the os preferences. for i, (path0, path1) in enumerate(paths): force_only_slash = path0.endswith(('/', '\\')) and path1.endswith(('/', '\\')) if not force_only_slash: path0 = _fix_path(path0, eclipse_sep, False) path1 = _fix_path(path1, python_sep, False) initial_paths.append((path0, path1)) paths_from_eclipse_to_python.append((_normcase_from_client(path0), normcase(path1))) # Now, make a version with a slash in the end. path0 = _fix_path(path0, eclipse_sep, True) path1 = _fix_path(path1, python_sep, True) initial_paths_with_end_sep.append((path0, path1)) paths_from_eclipse_to_python_with_end_sep.append((_normcase_from_client(path0), normcase(path1))) # Fix things so that we always match the versions with a slash in the end first. initial_paths = initial_paths_with_end_sep + initial_paths paths_from_eclipse_to_python = paths_from_eclipse_to_python_with_end_sep + paths_from_eclipse_to_python if not paths_from_eclipse_to_python: # no translation step needed (just inline the calls) map_file_to_client = _original_file_to_client map_file_to_server = _original_map_file_to_server return # only setup translation functions if absolutely needed! def _map_file_to_server(filename, cache=norm_filename_to_server_container): # Eclipse will send the passed filename to be translated to the python process # So, this would be 'NormFileFromEclipseToPython' try: return cache[filename] except KeyError: if eclipse_sep != python_sep: # Make sure that the separators are what we expect from the IDE. filename = filename.replace(python_sep, eclipse_sep) # used to translate a path from the client to the debug server translated = filename translated_normalized = _normcase_from_client(filename) for eclipse_prefix, server_prefix in paths_from_eclipse_to_python: if translated_normalized.startswith(eclipse_prefix): found_translation = True if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical('pydev debugger: replacing to server: %s', filename) translated = server_prefix + filename[len(eclipse_prefix):] if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical('pydev debugger: sent to server: %s - matched prefix: %s', translated, eclipse_prefix) break else: found_translation = False # Note that when going to the server, we do the replace first and only later do the norm file. if eclipse_sep != python_sep: translated = translated.replace(eclipse_sep, python_sep) if found_translation: # Note: we don't normalize it here, this must be done as a separate # step by the caller. translated = absolute_path(translated) else: if not os_path_exists(translated): if not translated.startswith('<'): # This is a configuration error, so, write it always so # that the user can fix it. error_once('pydev debugger: unable to find translation for: "%s" in [%s] (please revise your path mappings).\n', filename, ', '.join(['"%s"' % (x[0],) for x in paths_from_eclipse_to_python])) else: # It's possible that we had some round trip (say, we sent /usr/lib and received # it back, so, having no translation is ok too). # Note: we don't normalize it here, this must be done as a separate # step by the caller. translated = absolute_path(translated) cache[filename] = translated return translated def _map_file_to_client(filename, cache=norm_filename_to_client_container): # The result of this method will be passed to eclipse # So, this would be 'NormFileFromPythonToEclipse' try: return cache[filename] except KeyError: abs_path = absolute_path(filename) translated_proper_case = get_path_with_real_case(abs_path) translated_normalized = normcase(abs_path) path_mapping_applied = False if translated_normalized.lower() != translated_proper_case.lower(): if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical( 'pydev debugger: translated_normalized changed path (from: %s to %s)', translated_proper_case, translated_normalized) for i, (eclipse_prefix, python_prefix) in enumerate(paths_from_eclipse_to_python): if translated_normalized.startswith(python_prefix): if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical('pydev debugger: replacing to client: %s', translated_normalized) # Note: use the non-normalized version. eclipse_prefix = initial_paths[i][0] translated = eclipse_prefix + translated_proper_case[len(python_prefix):] if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical('pydev debugger: sent to client: %s - matched prefix: %s', translated, python_prefix) path_mapping_applied = True break else: if DEBUG_CLIENT_SERVER_TRANSLATION: pydev_log.critical('pydev debugger: to client: unable to find matching prefix for: %s in %s', translated_normalized, [x[1] for x in paths_from_eclipse_to_python]) translated = translated_proper_case if eclipse_sep != python_sep: translated = translated.replace(python_sep, eclipse_sep) translated = _path_to_expected_str(translated) # The resulting path is not in the python process, so, we cannot do a normalize the path here, # only at the beginning of this method. cache[filename] = (translated, path_mapping_applied) if translated not in _client_filename_in_utf8_to_source_reference: if path_mapping_applied: source_reference = 0 else: source_reference = _next_source_reference() pydev_log.debug('Created source reference: %s for untranslated path: %s', source_reference, filename) _client_filename_in_utf8_to_source_reference[translated] = source_reference _source_reference_to_server_filename[source_reference] = filename return (translated, path_mapping_applied) map_file_to_server = _map_file_to_server map_file_to_client = _map_file_to_client setup_client_server_paths(PATHS_FROM_ECLIPSE_TO_PYTHON) # For given file f returns tuple of its absolute path, real path and base name def get_abs_path_real_path_and_base_from_file( filename, NORM_PATHS_AND_BASE_CONTAINER=NORM_PATHS_AND_BASE_CONTAINER): try: return NORM_PATHS_AND_BASE_CONTAINER[filename] except: f = filename if not f: # i.e.: it's possible that the user compiled code with an empty string (consider # it as <string> in this case). f = '<string>' if f.startswith('<'): return f, normcase(f), f if _abs_and_canonical_path is None: # Interpreter shutdown i = max(f.rfind('/'), f.rfind('\\')) return (f, f, f[i + 1:]) if f is not None: if f.endswith('.pyc'): f = f[:-1] elif f.endswith('$py.class'): f = f[:-len('$py.class')] + '.py' abs_path, canonical_normalized_filename = _abs_and_canonical_path(f) try: base = os_path_basename(canonical_normalized_filename) except AttributeError: # Error during shutdown. i = max(f.rfind('/'), f.rfind('\\')) base = f[i + 1:] ret = abs_path, canonical_normalized_filename, base NORM_PATHS_AND_BASE_CONTAINER[filename] = ret return ret def get_abs_path_real_path_and_base_from_frame(frame, NORM_PATHS_AND_BASE_CONTAINER=NORM_PATHS_AND_BASE_CONTAINER): try: return NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] except: # This one is just internal (so, does not need any kind of client-server translation) f = frame.f_code.co_filename if f is not None and f.startswith (('build/bdist.', 'build\\bdist.')): # files from eggs in Python 2.7 have paths like build/bdist.linux-x86_64/egg/<path-inside-egg> f = frame.f_globals['__file__'] if get_abs_path_real_path_and_base_from_file is None: # Interpreter shutdown if not f: # i.e.: it's possible that the user compiled code with an empty string (consider # it as <string> in this case). f = '<string>' i = max(f.rfind('/'), f.rfind('\\')) return f, f, f[i + 1:] ret = get_abs_path_real_path_and_base_from_file(f) # Also cache based on the frame.f_code.co_filename (if we had it inside build/bdist it can make a difference). NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] = ret return ret def get_fullname(mod_name): import pkgutil try: loader = pkgutil.get_loader(mod_name) except: return None if loader is not None: for attr in ("get_filename", "_get_filename"): meth = getattr(loader, attr, None) if meth is not None: return meth(mod_name) return None def get_package_dir(mod_name): for path in sys.path: mod_path = join(path, mod_name.replace('.', '/')) if os.path.isdir(mod_path): return mod_path return None
35,201
Python
37.598684
136
0.626431
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydevconsole.py
''' Entry point module to start the interactive console. ''' from _pydev_bundle._pydev_saved_modules import thread, _code from _pydevd_bundle.pydevd_constants import IS_JYTHON start_new_thread = thread.start_new_thread from _pydevd_bundle.pydevconsole_code import InteractiveConsole compile_command = _code.compile_command InteractiveInterpreter = _code.InteractiveInterpreter import os import sys from _pydev_bundle._pydev_saved_modules import threading from _pydevd_bundle.pydevd_constants import INTERACTIVE_MODE_AVAILABLE import traceback from _pydev_bundle import pydev_log from _pydevd_bundle import pydevd_save_locals from _pydev_bundle.pydev_imports import Exec, _queue import builtins as __builtin__ from _pydev_bundle.pydev_console_utils import BaseInterpreterInterface, BaseStdIn # @UnusedImport from _pydev_bundle.pydev_console_utils import CodeFragment class Command: def __init__(self, interpreter, code_fragment): """ :type code_fragment: CodeFragment :type interpreter: InteractiveConsole """ self.interpreter = interpreter self.code_fragment = code_fragment self.more = None def symbol_for_fragment(code_fragment): if code_fragment.is_single_line: symbol = 'single' else: if IS_JYTHON: symbol = 'single' # Jython doesn't support exec else: symbol = 'exec' return symbol symbol_for_fragment = staticmethod(symbol_for_fragment) def run(self): text = self.code_fragment.text symbol = self.symbol_for_fragment(self.code_fragment) self.more = self.interpreter.runsource(text, '<input>', symbol) try: from _pydev_bundle.pydev_imports import execfile __builtin__.execfile = execfile except: pass # Pull in runfile, the interface to UMD that wraps execfile from _pydev_bundle.pydev_umd import runfile, _set_globals_function if sys.version_info[0] >= 3: __builtin__.runfile = runfile else: __builtin__.runfile = runfile #======================================================================================================================= # InterpreterInterface #======================================================================================================================= class InterpreterInterface(BaseInterpreterInterface): ''' The methods in this class should be registered in the xml-rpc server. ''' def __init__(self, host, client_port, mainThread, connect_status_queue=None): BaseInterpreterInterface.__init__(self, mainThread, connect_status_queue) self.client_port = client_port self.host = host self.namespace = {} self.interpreter = InteractiveConsole(self.namespace) self._input_error_printed = False def do_add_exec(self, codeFragment): command = Command(self.interpreter, codeFragment) command.run() return command.more def get_namespace(self): return self.namespace def getCompletions(self, text, act_tok): try: from _pydev_bundle._pydev_completer import Completer completer = Completer(self.namespace, None) return completer.complete(act_tok) except: pydev_log.exception() return [] def close(self): sys.exit(0) def get_greeting_msg(self): return 'PyDev console: starting.\n' class _ProcessExecQueueHelper: _debug_hook = None _return_control_osc = False def set_debug_hook(debug_hook): _ProcessExecQueueHelper._debug_hook = debug_hook def activate_mpl_if_already_imported(interpreter): if interpreter.mpl_modules_for_patching: for module in list(interpreter.mpl_modules_for_patching): if module in sys.modules: activate_function = interpreter.mpl_modules_for_patching.pop(module) activate_function() def init_set_return_control_back(interpreter): from pydev_ipython.inputhook import set_return_control_callback def return_control(): ''' A function that the inputhooks can call (via inputhook.stdin_ready()) to find out if they should cede control and return ''' if _ProcessExecQueueHelper._debug_hook: # Some of the input hooks check return control without doing # a single operation, so we don't return True on every # call when the debug hook is in place to allow the GUI to run # XXX: Eventually the inputhook code will have diverged enough # from the IPython source that it will be worthwhile rewriting # it rather than pretending to maintain the old API _ProcessExecQueueHelper._return_control_osc = not _ProcessExecQueueHelper._return_control_osc if _ProcessExecQueueHelper._return_control_osc: return True if not interpreter.exec_queue.empty(): return True return False set_return_control_callback(return_control) def init_mpl_in_console(interpreter): init_set_return_control_back(interpreter) if not INTERACTIVE_MODE_AVAILABLE: return activate_mpl_if_already_imported(interpreter) from _pydev_bundle.pydev_import_hook import import_hook_manager for mod in list(interpreter.mpl_modules_for_patching): import_hook_manager.add_module_name(mod, interpreter.mpl_modules_for_patching.pop(mod)) if sys.platform != 'win32': if not hasattr(os, 'kill'): # Jython may not have it. def pid_exists(pid): return True else: def pid_exists(pid): # Note that this function in the face of errors will conservatively consider that # the pid is still running (because we'll exit the current process when it's # no longer running, so, we need to be 100% sure it actually exited). import errno if pid == 0: # According to "man 2 kill" PID 0 has a special meaning: # it refers to <<every process in the process group of the # calling process>> so we don't want to go any further. # If we get here it means this UNIX platform *does* have # a process with id 0. return True try: os.kill(pid, 0) except OSError as err: if err.errno == errno.ESRCH: # ESRCH == No such process return False elif err.errno == errno.EPERM: # EPERM clearly means there's a process to deny access to return True else: # According to "man 2 kill" possible error values are # (EINVAL, EPERM, ESRCH) therefore we should never get # here. If we do, although it's an error, consider it # exists (see first comment in this function). return True else: return True else: def pid_exists(pid): # Note that this function in the face of errors will conservatively consider that # the pid is still running (because we'll exit the current process when it's # no longer running, so, we need to be 100% sure it actually exited). import ctypes kernel32 = ctypes.windll.kernel32 PROCESS_QUERY_INFORMATION = 0x0400 PROCESS_QUERY_LIMITED_INFORMATION = 0x1000 ERROR_INVALID_PARAMETER = 0x57 STILL_ACTIVE = 259 process = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) if not process: err = kernel32.GetLastError() if err == ERROR_INVALID_PARAMETER: # Means it doesn't exist (pid parameter is wrong). return False # There was some unexpected error (such as access denied), so # consider it exists (although it could be something else, but we don't want # to raise any errors -- so, just consider it exists). return True try: zero = ctypes.c_int(0) exit_code = ctypes.pointer(zero) exit_code_suceeded = kernel32.GetExitCodeProcess(process, exit_code) if not exit_code_suceeded: # There was some unexpected error (such as access denied), so # consider it exists (although it could be something else, but we don't want # to raise any errors -- so, just consider it exists). return True elif bool(exit_code.contents.value) and int(exit_code.contents.value) != STILL_ACTIVE: return False finally: kernel32.CloseHandle(process) return True def process_exec_queue(interpreter): init_mpl_in_console(interpreter) from pydev_ipython.inputhook import get_inputhook try: kill_if_pid_not_alive = int(os.environ.get('PYDEV_ECLIPSE_PID', '-1')) except: kill_if_pid_not_alive = -1 while 1: if kill_if_pid_not_alive != -1: if not pid_exists(kill_if_pid_not_alive): exit() # Running the request may have changed the inputhook in use inputhook = get_inputhook() if _ProcessExecQueueHelper._debug_hook: _ProcessExecQueueHelper._debug_hook() if inputhook: try: # Note: it'll block here until return_control returns True. inputhook() except: pydev_log.exception() try: try: code_fragment = interpreter.exec_queue.get(block=True, timeout=1 / 20.) # 20 calls/second except _queue.Empty: continue if callable(code_fragment): # It can be a callable (i.e.: something that must run in the main # thread can be put in the queue for later execution). code_fragment() else: more = interpreter.add_exec(code_fragment) except KeyboardInterrupt: interpreter.buffer = None continue except SystemExit: raise except: pydev_log.exception('Error processing queue on pydevconsole.') exit() if 'IPYTHONENABLE' in os.environ: IPYTHON = os.environ['IPYTHONENABLE'] == 'True' else: # By default, don't use IPython because occasionally changes # in IPython break pydevd. IPYTHON = False try: try: exitfunc = sys.exitfunc except AttributeError: exitfunc = None if IPYTHON: from _pydev_bundle.pydev_ipython_console import InterpreterInterface if exitfunc is not None: sys.exitfunc = exitfunc else: try: delattr(sys, 'exitfunc') except: pass except: IPYTHON = False pass #======================================================================================================================= # _DoExit #======================================================================================================================= def do_exit(*args): ''' We have to override the exit because calling sys.exit will only actually exit the main thread, and as we're in a Xml-rpc server, that won't work. ''' try: import java.lang.System java.lang.System.exit(1) except ImportError: if len(args) == 1: os._exit(args[0]) else: os._exit(0) #======================================================================================================================= # start_console_server #======================================================================================================================= def start_console_server(host, port, interpreter): try: if port == 0: host = '' # I.e.: supporting the internal Jython version in PyDev to create a Jython interactive console inside Eclipse. from _pydev_bundle.pydev_imports import SimpleXMLRPCServer as XMLRPCServer # @Reimport try: server = XMLRPCServer((host, port), logRequests=False, allow_none=True) except: sys.stderr.write('Error starting server with host: "%s", port: "%s", client_port: "%s"\n' % (host, port, interpreter.client_port)) sys.stderr.flush() raise # Tell UMD the proper default namespace _set_globals_function(interpreter.get_namespace) server.register_function(interpreter.execLine) server.register_function(interpreter.execMultipleLines) server.register_function(interpreter.getCompletions) server.register_function(interpreter.getFrame) server.register_function(interpreter.getVariable) server.register_function(interpreter.changeVariable) server.register_function(interpreter.getDescription) server.register_function(interpreter.close) server.register_function(interpreter.interrupt) server.register_function(interpreter.handshake) server.register_function(interpreter.connectToDebugger) server.register_function(interpreter.hello) server.register_function(interpreter.getArray) server.register_function(interpreter.evaluate) server.register_function(interpreter.ShowConsole) server.register_function(interpreter.loadFullValue) # Functions for GUI main loop integration server.register_function(interpreter.enableGui) if port == 0: (h, port) = server.socket.getsockname() print(port) print(interpreter.client_port) while True: try: server.serve_forever() except: # Ugly code to be py2/3 compatible # https://sw-brainwy.rhcloud.com/tracker/PyDev/534: # Unhandled "interrupted system call" error in the pydevconsol.py e = sys.exc_info()[1] retry = False try: retry = e.args[0] == 4 # errno.EINTR except: pass if not retry: raise # Otherwise, keep on going return server except: pydev_log.exception() # Notify about error to avoid long waiting connection_queue = interpreter.get_connect_status_queue() if connection_queue is not None: connection_queue.put(False) def start_server(host, port, client_port): # replace exit (see comments on method) # note that this does not work in jython!!! (sys method can't be replaced). sys.exit = do_exit interpreter = InterpreterInterface(host, client_port, threading.current_thread()) start_new_thread(start_console_server, (host, port, interpreter)) process_exec_queue(interpreter) def get_ipython_hidden_vars(): if IPYTHON and hasattr(__builtin__, 'interpreter'): interpreter = get_interpreter() return interpreter.get_ipython_hidden_vars_dict() def get_interpreter(): try: interpreterInterface = getattr(__builtin__, 'interpreter') except AttributeError: interpreterInterface = InterpreterInterface(None, None, threading.current_thread()) __builtin__.interpreter = interpreterInterface sys.stderr.write(interpreterInterface.get_greeting_msg()) sys.stderr.flush() return interpreterInterface def get_completions(text, token, globals, locals): interpreterInterface = get_interpreter() interpreterInterface.interpreter.update(globals, locals) return interpreterInterface.getCompletions(text, token) #=============================================================================== # Debugger integration #=============================================================================== def exec_code(code, globals, locals, debugger): interpreterInterface = get_interpreter() interpreterInterface.interpreter.update(globals, locals) res = interpreterInterface.need_more(code) if res: return True interpreterInterface.add_exec(code, debugger) return False class ConsoleWriter(InteractiveInterpreter): skip = 0 def __init__(self, locals=None): InteractiveInterpreter.__init__(self, locals) def write(self, data): # if (data.find("global_vars") == -1 and data.find("pydevd") == -1): if self.skip > 0: self.skip -= 1 else: if data == "Traceback (most recent call last):\n": self.skip = 1 sys.stderr.write(data) def showsyntaxerror(self, filename=None): """Display the syntax error that just occurred.""" # Override for avoid using sys.excepthook PY-12600 type, value, tb = sys.exc_info() sys.last_type = type sys.last_value = value sys.last_traceback = tb if filename and type is SyntaxError: # Work hard to stuff the correct filename in the exception try: msg, (dummy_filename, lineno, offset, line) = value.args except ValueError: # Not the format we expect; leave it alone pass else: # Stuff in the right filename value = SyntaxError(msg, (filename, lineno, offset, line)) sys.last_value = value list = traceback.format_exception_only(type, value) sys.stderr.write(''.join(list)) def showtraceback(self, *args, **kwargs): """Display the exception that just occurred.""" # Override for avoid using sys.excepthook PY-12600 try: type, value, tb = sys.exc_info() sys.last_type = type sys.last_value = value sys.last_traceback = tb tblist = traceback.extract_tb(tb) del tblist[:1] lines = traceback.format_list(tblist) if lines: lines.insert(0, "Traceback (most recent call last):\n") lines.extend(traceback.format_exception_only(type, value)) finally: tblist = tb = None sys.stderr.write(''.join(lines)) def console_exec(thread_id, frame_id, expression, dbg): """returns 'False' in case expression is partially correct """ frame = dbg.find_frame(thread_id, frame_id) is_multiline = expression.count('@LINE@') > 1 expression = str(expression.replace('@LINE@', '\n')) # Not using frame.f_globals because of https://sourceforge.net/tracker2/?func=detail&aid=2541355&group_id=85796&atid=577329 # (Names not resolved in generator expression in method) # See message: http://mail.python.org/pipermail/python-list/2009-January/526522.html updated_globals = {} updated_globals.update(frame.f_globals) updated_globals.update(frame.f_locals) # locals later because it has precedence over the actual globals if IPYTHON: need_more = exec_code(CodeFragment(expression), updated_globals, frame.f_locals, dbg) if not need_more: pydevd_save_locals.save_locals(frame) return need_more interpreter = ConsoleWriter() if not is_multiline: try: code = compile_command(expression) except (OverflowError, SyntaxError, ValueError): # Case 1 interpreter.showsyntaxerror() return False if code is None: # Case 2 return True else: code = expression # Case 3 try: Exec(code, updated_globals, frame.f_locals) except SystemExit: raise except: interpreter.showtraceback() else: pydevd_save_locals.save_locals(frame) return False #======================================================================================================================= # main #======================================================================================================================= if __name__ == '__main__': # Important: don't use this module directly as the __main__ module, rather, import itself as pydevconsole # so that we don't get multiple pydevconsole modules if it's executed directly (otherwise we'd have multiple # representations of its classes). # See: https://sw-brainwy.rhcloud.com/tracker/PyDev/446: # 'Variables' and 'Expressions' views stopped working when debugging interactive console import pydevconsole sys.stdin = pydevconsole.BaseStdIn(sys.stdin) port, client_port = sys.argv[1:3] from _pydev_bundle import pydev_localhost if int(port) == 0 and int(client_port) == 0: (h, p) = pydev_localhost.get_socket_name() client_port = p pydevconsole.start_server(pydev_localhost.get_localhost(), int(port), int(client_port))
21,094
Python
33.925497
142
0.589504
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydev_run_in_console.py
''' Entry point module to run a file in the interactive console. ''' import os import sys import traceback from pydevconsole import InterpreterInterface, process_exec_queue, start_console_server, init_mpl_in_console from _pydev_bundle._pydev_saved_modules import threading, _queue from _pydev_bundle import pydev_imports from _pydevd_bundle.pydevd_utils import save_main_module from _pydev_bundle.pydev_console_utils import StdIn from pydevd_file_utils import get_fullname def run_file(file, globals=None, locals=None, is_module=False): module_name = None entry_point_fn = None if is_module: file, _, entry_point_fn = file.partition(':') module_name = file filename = get_fullname(file) if filename is None: sys.stderr.write("No module named %s\n" % file) return else: file = filename if os.path.isdir(file): new_target = os.path.join(file, '__main__.py') if os.path.isfile(new_target): file = new_target if globals is None: m = save_main_module(file, 'pydev_run_in_console') globals = m.__dict__ try: globals['__builtins__'] = __builtins__ except NameError: pass # Not there on Jython... if locals is None: locals = globals if not is_module: sys.path.insert(0, os.path.split(file)[0]) print('Running %s' % file) try: if not is_module: pydev_imports.execfile(file, globals, locals) # execute the script else: # treat ':' as a seperator between module and entry point function # if there is no entry point we run we same as with -m switch. Otherwise we perform # an import and execute the entry point if entry_point_fn: mod = __import__(module_name, level=0, fromlist=[entry_point_fn], globals=globals, locals=locals) func = getattr(mod, entry_point_fn) func() else: # Run with the -m switch from _pydevd_bundle import pydevd_runpy pydevd_runpy._run_module_as_main(module_name) except: traceback.print_exc() return globals def skip_successful_exit(*args): """ System exit in file shouldn't kill interpreter (i.e. in `timeit`)""" if len(args) == 1 and args[0] in (0, None): pass else: raise SystemExit(*args) def process_args(argv): setup_args = {'file': '', 'module': False} setup_args['port'] = argv[1] del argv[1] setup_args['client_port'] = argv[1] del argv[1] module_flag = "--module" if module_flag in argv: i = argv.index(module_flag) if i != -1: setup_args['module'] = True setup_args['file'] = argv[i + 1] del sys.argv[i] else: setup_args['file'] = argv[1] del argv[0] return setup_args #======================================================================================================================= # main #======================================================================================================================= if __name__ == '__main__': setup = process_args(sys.argv) port = setup['port'] client_port = setup['client_port'] file = setup['file'] is_module = setup['module'] from _pydev_bundle import pydev_localhost if int(port) == 0 and int(client_port) == 0: (h, p) = pydev_localhost.get_socket_name() client_port = p host = pydev_localhost.get_localhost() # replace exit (see comments on method) # note that this does not work in jython!!! (sys method can't be replaced). sys.exit = skip_successful_exit connect_status_queue = _queue.Queue() interpreter = InterpreterInterface(host, int(client_port), threading.current_thread(), connect_status_queue=connect_status_queue) server_thread = threading.Thread(target=start_console_server, name='ServerThread', args=(host, int(port), interpreter)) server_thread.daemon = True server_thread.start() sys.stdin = StdIn(interpreter, host, client_port, sys.stdin) init_mpl_in_console(interpreter) try: success = connect_status_queue.get(True, 60) if not success: raise ValueError() except: sys.stderr.write("Console server didn't start\n") sys.stderr.flush() sys.exit(1) globals = run_file(file, None, None, is_module) interpreter.get_namespace().update(globals) interpreter.ShowConsole() process_exec_queue(interpreter)
4,709
Python
29.584415
133
0.568061
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/pydev_coverage.py
''' Entry point module to run code-coverage. ''' def is_valid_py_file(path): ''' Checks whether the file can be read by the coverage module. This is especially needed for .pyx files and .py files with syntax errors. ''' import os is_valid = False if os.path.isfile(path) and not os.path.splitext(path)[1] == '.pyx': try: with open(path, 'rb') as f: compile(f.read(), path, 'exec') is_valid = True except: pass return is_valid def execute(): import os import sys files = None if 'combine' not in sys.argv: if '--pydev-analyze' in sys.argv: # Ok, what we want here is having the files passed through stdin (because # there may be too many files for passing in the command line -- we could # just pass a dir and make the find files here, but as that's already # given in the java side, let's just gather that info here). sys.argv.remove('--pydev-analyze') s = input() s = s.replace('\r', '') s = s.replace('\n', '') files = [] invalid_files = [] for v in s.split('|'): if is_valid_py_file(v): files.append(v) else: invalid_files.append(v) if invalid_files: sys.stderr.write('Invalid files not passed to coverage: %s\n' % ', '.join(invalid_files)) # Note that in this case we'll already be in the working dir with the coverage files, # so, the coverage file location is not passed. else: # For all commands, the coverage file is configured in pydev, and passed as the first # argument in the command line, so, let's make sure this gets to the coverage module. os.environ['COVERAGE_FILE'] = sys.argv[1] del sys.argv[1] try: import coverage # @UnresolvedImport except: sys.stderr.write('Error: coverage module could not be imported\n') sys.stderr.write('Please make sure that the coverage module ' '(http://nedbatchelder.com/code/coverage/)\n') sys.stderr.write('is properly installed in your interpreter: %s\n' % (sys.executable,)) import traceback;traceback.print_exc() return if hasattr(coverage, '__version__'): version = tuple(map(int, coverage.__version__.split('.')[:2])) if version < (4, 3): sys.stderr.write('Error: minimum supported coverage version is 4.3.' '\nFound: %s\nLocation: %s\n' % ('.'.join(str(x) for x in version), coverage.__file__)) sys.exit(1) else: sys.stderr.write('Warning: Could not determine version of python module coverage.' '\nEnsure coverage version is >= 4.3\n') from coverage.cmdline import main # @UnresolvedImport if files is not None: sys.argv.append('xml') sys.argv += files main() if __name__ == '__main__': execute()
3,200
Python
32.694736
97
0.545312
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel.py
import unittest from _pydev_bundle._pydev_saved_modules import thread import queue as Queue from _pydev_runfiles import pydev_runfiles_xml_rpc import time import os import threading import sys #======================================================================================================================= # flatten_test_suite #======================================================================================================================= def flatten_test_suite(test_suite, ret): if isinstance(test_suite, unittest.TestSuite): for t in test_suite._tests: flatten_test_suite(t, ret) elif isinstance(test_suite, unittest.TestCase): ret.append(test_suite) #======================================================================================================================= # execute_tests_in_parallel #======================================================================================================================= def execute_tests_in_parallel(tests, jobs, split, verbosity, coverage_files, coverage_include): ''' @param tests: list(PydevTestSuite) A list with the suites to be run @param split: str Either 'module' or the number of tests that should be run in each batch @param coverage_files: list(file) A list with the files that should be used for giving coverage information (if empty, coverage information should not be gathered). @param coverage_include: str The pattern that should be included in the coverage. @return: bool Returns True if the tests were actually executed in parallel. If the tests were not executed because only 1 should be used (e.g.: 2 jobs were requested for running 1 test), False will be returned and no tests will be run. It may also return False if in debug mode (in which case, multi-processes are not accepted) ''' try: from _pydevd_bundle.pydevd_comm import get_global_debugger if get_global_debugger() is not None: return False except: pass # Ignore any error here. # This queue will receive the tests to be run. Each entry in a queue is a list with the tests to be run together When # split == 'tests', each list will have a single element, when split == 'module', each list will have all the tests # from a given module. tests_queue = [] queue_elements = [] if split == 'module': module_to_tests = {} for test in tests: lst = [] flatten_test_suite(test, lst) for test in lst: key = (test.__pydev_pyfile__, test.__pydev_module_name__) module_to_tests.setdefault(key, []).append(test) for key, tests in module_to_tests.items(): queue_elements.append(tests) if len(queue_elements) < jobs: # Don't create jobs we will never use. jobs = len(queue_elements) elif split == 'tests': for test in tests: lst = [] flatten_test_suite(test, lst) for test in lst: queue_elements.append([test]) if len(queue_elements) < jobs: # Don't create jobs we will never use. jobs = len(queue_elements) else: raise AssertionError('Do not know how to handle: %s' % (split,)) for test_cases in queue_elements: test_queue_elements = [] for test_case in test_cases: try: test_name = test_case.__class__.__name__ + "." + test_case._testMethodName except AttributeError: # Support for jython 2.1 (__testMethodName is pseudo-private in the test case) test_name = test_case.__class__.__name__ + "." + test_case._TestCase__testMethodName test_queue_elements.append(test_case.__pydev_pyfile__ + '|' + test_name) tests_queue.append(test_queue_elements) if jobs < 2: return False sys.stdout.write('Running tests in parallel with: %s jobs.\n' % (jobs,)) queue = Queue.Queue() for item in tests_queue: queue.put(item, block=False) providers = [] clients = [] for i in range(jobs): test_cases_provider = CommunicationThread(queue) providers.append(test_cases_provider) test_cases_provider.start() port = test_cases_provider.port if coverage_files: clients.append(ClientThread(i, port, verbosity, coverage_files.pop(0), coverage_include)) else: clients.append(ClientThread(i, port, verbosity)) for client in clients: client.start() client_alive = True while client_alive: client_alive = False for client in clients: # Wait for all the clients to exit. if not client.finished: client_alive = True time.sleep(.2) break for provider in providers: provider.shutdown() return True #======================================================================================================================= # CommunicationThread #======================================================================================================================= class CommunicationThread(threading.Thread): def __init__(self, tests_queue): threading.Thread.__init__(self) self.daemon = True self.queue = tests_queue self.finished = False from _pydev_bundle.pydev_imports import SimpleXMLRPCServer from _pydev_bundle import pydev_localhost # Create server server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), 0), logRequests=False) server.register_function(self.GetTestsToRun) server.register_function(self.notifyStartTest) server.register_function(self.notifyTest) server.register_function(self.notifyCommands) self.port = server.socket.getsockname()[1] self.server = server def GetTestsToRun(self, job_id): ''' @param job_id: @return: list(str) Each entry is a string in the format: filename|Test.testName ''' try: ret = self.queue.get(block=False) return ret except: # Any exception getting from the queue (empty or not) means we finished our work on providing the tests. self.finished = True return [] def notifyCommands(self, job_id, commands): # Batch notification. for command in commands: getattr(self, command[0])(job_id, *command[1], **command[2]) return True def notifyStartTest(self, job_id, *args, **kwargs): pydev_runfiles_xml_rpc.notifyStartTest(*args, **kwargs) return True def notifyTest(self, job_id, *args, **kwargs): pydev_runfiles_xml_rpc.notifyTest(*args, **kwargs) return True def shutdown(self): if hasattr(self.server, 'shutdown'): self.server.shutdown() else: self._shutdown = True def run(self): if hasattr(self.server, 'shutdown'): self.server.serve_forever() else: self._shutdown = False while not self._shutdown: self.server.handle_request() #======================================================================================================================= # Client #======================================================================================================================= class ClientThread(threading.Thread): def __init__(self, job_id, port, verbosity, coverage_output_file=None, coverage_include=None): threading.Thread.__init__(self) self.daemon = True self.port = port self.job_id = job_id self.verbosity = verbosity self.finished = False self.coverage_output_file = coverage_output_file self.coverage_include = coverage_include def _reader_thread(self, pipe, target): while True: target.write(pipe.read(1)) def run(self): try: from _pydev_runfiles import pydev_runfiles_parallel_client # TODO: Support Jython: # # For jython, instead of using sys.executable, we should use: # r'D:\bin\jdk_1_5_09\bin\java.exe', # '-classpath', # 'D:/bin/jython-2.2.1/jython.jar', # 'org.python.util.jython', args = [ sys.executable, pydev_runfiles_parallel_client.__file__, str(self.job_id), str(self.port), str(self.verbosity), ] if self.coverage_output_file and self.coverage_include: args.append(self.coverage_output_file) args.append(self.coverage_include) import subprocess if False: proc = subprocess.Popen(args, env=os.environ, shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE) thread.start_new_thread(self._reader_thread, (proc.stdout, sys.stdout)) thread.start_new_thread(target=self._reader_thread, args=(proc.stderr, sys.stderr)) else: proc = subprocess.Popen(args, env=os.environ, shell=False) proc.wait() finally: self.finished = True
9,472
Python
34.347015
122
0.537162
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_xml_rpc.py
import sys import threading import traceback import warnings from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding from _pydev_bundle.pydev_imports import xmlrpclib, _queue from _pydevd_bundle.pydevd_constants import Null Queue = _queue.Queue # This may happen in IronPython (in Python it shouldn't happen as there are # 'fast' replacements that are used in xmlrpclib.py) warnings.filterwarnings( 'ignore', 'The xmllib module is obsolete.*', DeprecationWarning) file_system_encoding = getfilesystemencoding() #======================================================================================================================= # _ServerHolder #======================================================================================================================= class _ServerHolder: ''' Helper so that we don't have to use a global here. ''' SERVER = None #======================================================================================================================= # set_server #======================================================================================================================= def set_server(server): _ServerHolder.SERVER = server #======================================================================================================================= # ParallelNotification #======================================================================================================================= class ParallelNotification(object): def __init__(self, method, args): self.method = method self.args = args def to_tuple(self): return self.method, self.args #======================================================================================================================= # KillServer #======================================================================================================================= class KillServer(object): pass #======================================================================================================================= # ServerFacade #======================================================================================================================= class ServerFacade(object): def __init__(self, notifications_queue): self.notifications_queue = notifications_queue def notifyTestsCollected(self, *args): self.notifications_queue.put_nowait(ParallelNotification('notifyTestsCollected', args)) def notifyConnected(self, *args): self.notifications_queue.put_nowait(ParallelNotification('notifyConnected', args)) def notifyTestRunFinished(self, *args): self.notifications_queue.put_nowait(ParallelNotification('notifyTestRunFinished', args)) def notifyStartTest(self, *args): self.notifications_queue.put_nowait(ParallelNotification('notifyStartTest', args)) def notifyTest(self, *args): new_args = [] for arg in args: new_args.append(_encode_if_needed(arg)) args = tuple(new_args) self.notifications_queue.put_nowait(ParallelNotification('notifyTest', args)) #======================================================================================================================= # ServerComm #======================================================================================================================= class ServerComm(threading.Thread): def __init__(self, notifications_queue, port, daemon=False): threading.Thread.__init__(self) self.setDaemon(daemon) # If False, wait for all the notifications to be passed before exiting! self.finished = False self.notifications_queue = notifications_queue from _pydev_bundle import pydev_localhost # It is necessary to specify an encoding, that matches # the encoding of all bytes-strings passed into an # XMLRPC call: "All 8-bit strings in the data structure are assumed to use the # packet encoding. Unicode strings are automatically converted, # where necessary." # Byte strings most likely come from file names. encoding = file_system_encoding if encoding == "mbcs": # Windos symbolic name for the system encoding CP_ACP. # We need to convert it into a encoding that is recognized by Java. # Unfortunately this is not always possible. You could use # GetCPInfoEx and get a name similar to "windows-1251". Then # you need a table to translate on a best effort basis. Much to complicated. # ISO-8859-1 is good enough. encoding = "ISO-8859-1" self.server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), port), encoding=encoding) def run(self): while True: kill_found = False commands = [] command = self.notifications_queue.get(block=True) if isinstance(command, KillServer): kill_found = True else: assert isinstance(command, ParallelNotification) commands.append(command.to_tuple()) try: while True: command = self.notifications_queue.get(block=False) # No block to create a batch. if isinstance(command, KillServer): kill_found = True else: assert isinstance(command, ParallelNotification) commands.append(command.to_tuple()) except: pass # That's OK, we're getting it until it becomes empty so that we notify multiple at once. if commands: try: self.server.notifyCommands(commands) except: traceback.print_exc() if kill_found: self.finished = True return #======================================================================================================================= # initialize_server #======================================================================================================================= def initialize_server(port, daemon=False): if _ServerHolder.SERVER is None: if port is not None: notifications_queue = Queue() _ServerHolder.SERVER = ServerFacade(notifications_queue) _ServerHolder.SERVER_COMM = ServerComm(notifications_queue, port, daemon) _ServerHolder.SERVER_COMM.start() else: # Create a null server, so that we keep the interface even without any connection. _ServerHolder.SERVER = Null() _ServerHolder.SERVER_COMM = Null() try: _ServerHolder.SERVER.notifyConnected() except: traceback.print_exc() #======================================================================================================================= # notifyTest #======================================================================================================================= def notifyTestsCollected(tests_count): assert tests_count is not None try: _ServerHolder.SERVER.notifyTestsCollected(tests_count) except: traceback.print_exc() #======================================================================================================================= # notifyStartTest #======================================================================================================================= def notifyStartTest(file, test): ''' @param file: the tests file (c:/temp/test.py) @param test: the test ran (i.e.: TestCase.test1) ''' assert file is not None if test is None: test = '' # Could happen if we have an import error importing module. try: _ServerHolder.SERVER.notifyStartTest(file, test) except: traceback.print_exc() def _encode_if_needed(obj): # In the java side we expect strings to be ISO-8859-1 (org.python.pydev.debug.pyunit.PyUnitServer.initializeDispatches().new Dispatch() {...}.getAsStr(Object)) if isinstance(obj, str): # Unicode in py3 return xmlrpclib.Binary(obj.encode('ISO-8859-1', 'xmlcharrefreplace')) elif isinstance(obj, bytes): try: return xmlrpclib.Binary(obj.decode(sys.stdin.encoding).encode('ISO-8859-1', 'xmlcharrefreplace')) except: return xmlrpclib.Binary(obj) # bytes already return obj #======================================================================================================================= # notifyTest #======================================================================================================================= def notifyTest(cond, captured_output, error_contents, file, test, time): ''' @param cond: ok, fail, error @param captured_output: output captured from stdout @param captured_output: output captured from stderr @param file: the tests file (c:/temp/test.py) @param test: the test ran (i.e.: TestCase.test1) @param time: float with the number of seconds elapsed ''' assert cond is not None assert captured_output is not None assert error_contents is not None assert file is not None if test is None: test = '' # Could happen if we have an import error importing module. assert time is not None try: captured_output = _encode_if_needed(captured_output) error_contents = _encode_if_needed(error_contents) _ServerHolder.SERVER.notifyTest(cond, captured_output, error_contents, file, test, time) except: traceback.print_exc() #======================================================================================================================= # notifyTestRunFinished #======================================================================================================================= def notifyTestRunFinished(total_time): assert total_time is not None try: _ServerHolder.SERVER.notifyTestRunFinished(total_time) except: traceback.print_exc() #======================================================================================================================= # force_server_kill #======================================================================================================================= def force_server_kill(): _ServerHolder.SERVER_COMM.notifications_queue.put_nowait(KillServer())
10,594
Python
40.065891
163
0.46885
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles.py
from __future__ import nested_scopes import fnmatch import os.path from _pydev_runfiles.pydev_runfiles_coverage import start_coverage_support from _pydevd_bundle.pydevd_constants import * # @UnusedWildImport import re import time #======================================================================================================================= # Configuration #======================================================================================================================= class Configuration: def __init__( self, files_or_dirs='', verbosity=2, include_tests=None, tests=None, port=None, files_to_tests=None, jobs=1, split_jobs='tests', coverage_output_dir=None, coverage_include=None, coverage_output_file=None, exclude_files=None, exclude_tests=None, include_files=None, django=False, ): self.files_or_dirs = files_or_dirs self.verbosity = verbosity self.include_tests = include_tests self.tests = tests self.port = port self.files_to_tests = files_to_tests self.jobs = jobs self.split_jobs = split_jobs self.django = django if include_tests: assert isinstance(include_tests, (list, tuple)) if exclude_files: assert isinstance(exclude_files, (list, tuple)) if exclude_tests: assert isinstance(exclude_tests, (list, tuple)) self.exclude_files = exclude_files self.include_files = include_files self.exclude_tests = exclude_tests self.coverage_output_dir = coverage_output_dir self.coverage_include = coverage_include self.coverage_output_file = coverage_output_file def __str__(self): return '''Configuration - files_or_dirs: %s - verbosity: %s - tests: %s - port: %s - files_to_tests: %s - jobs: %s - split_jobs: %s - include_files: %s - include_tests: %s - exclude_files: %s - exclude_tests: %s - coverage_output_dir: %s - coverage_include_dir: %s - coverage_output_file: %s - django: %s ''' % ( self.files_or_dirs, self.verbosity, self.tests, self.port, self.files_to_tests, self.jobs, self.split_jobs, self.include_files, self.include_tests, self.exclude_files, self.exclude_tests, self.coverage_output_dir, self.coverage_include, self.coverage_output_file, self.django, ) #======================================================================================================================= # parse_cmdline #======================================================================================================================= def parse_cmdline(argv=None): """ Parses command line and returns test directories, verbosity, test filter and test suites usage: runfiles.py -v|--verbosity <level> -t|--tests <Test.test1,Test2> dirs|files Multiprocessing options: jobs=number (with the number of jobs to be used to run the tests) split_jobs='module'|'tests' if == module, a given job will always receive all the tests from a module if == tests, the tests will be split independently of their originating module (default) --exclude_files = comma-separated list of patterns with files to exclude (fnmatch style) --include_files = comma-separated list of patterns with files to include (fnmatch style) --exclude_tests = comma-separated list of patterns with test names to exclude (fnmatch style) Note: if --tests is given, --exclude_files, --include_files and --exclude_tests are ignored! """ if argv is None: argv = sys.argv verbosity = 2 include_tests = None tests = None port = None jobs = 1 split_jobs = 'tests' files_to_tests = {} coverage_output_dir = None coverage_include = None exclude_files = None exclude_tests = None include_files = None django = False from _pydev_bundle._pydev_getopt import gnu_getopt optlist, dirs = gnu_getopt( argv[1:], "", [ "verbosity=", "tests=", "port=", "config_file=", "jobs=", "split_jobs=", "include_tests=", "include_files=", "exclude_files=", "exclude_tests=", "coverage_output_dir=", "coverage_include=", "django=" ] ) for opt, value in optlist: if opt in ("-v", "--verbosity"): verbosity = value elif opt in ("-p", "--port"): port = int(value) elif opt in ("-j", "--jobs"): jobs = int(value) elif opt in ("-s", "--split_jobs"): split_jobs = value if split_jobs not in ('module', 'tests'): raise AssertionError('Expected split to be either "module" or "tests". Was :%s' % (split_jobs,)) elif opt in ("-d", "--coverage_output_dir",): coverage_output_dir = value.strip() elif opt in ("-i", "--coverage_include",): coverage_include = value.strip() elif opt in ("-I", "--include_tests"): include_tests = value.split(',') elif opt in ("-E", "--exclude_files"): exclude_files = value.split(',') elif opt in ("-F", "--include_files"): include_files = value.split(',') elif opt in ("-e", "--exclude_tests"): exclude_tests = value.split(',') elif opt in ("-t", "--tests"): tests = value.split(',') elif opt in ("--django",): django = value.strip() in ['true', 'True', '1'] elif opt in ("-c", "--config_file"): config_file = value.strip() if os.path.exists(config_file): f = open(config_file, 'r') try: config_file_contents = f.read() finally: f.close() if config_file_contents: config_file_contents = config_file_contents.strip() if config_file_contents: for line in config_file_contents.splitlines(): file_and_test = line.split('|') if len(file_and_test) == 2: file, test = file_and_test if file in files_to_tests: files_to_tests[file].append(test) else: files_to_tests[file] = [test] else: sys.stderr.write('Could not find config file: %s\n' % (config_file,)) if type([]) != type(dirs): dirs = [dirs] ret_dirs = [] for d in dirs: if '|' in d: # paths may come from the ide separated by | ret_dirs.extend(d.split('|')) else: ret_dirs.append(d) verbosity = int(verbosity) if tests: if verbosity > 4: sys.stdout.write('--tests provided. Ignoring --exclude_files, --exclude_tests and --include_files\n') exclude_files = exclude_tests = include_files = None config = Configuration( ret_dirs, verbosity, include_tests, tests, port, files_to_tests, jobs, split_jobs, coverage_output_dir, coverage_include, exclude_files=exclude_files, exclude_tests=exclude_tests, include_files=include_files, django=django, ) if verbosity > 5: sys.stdout.write(str(config) + '\n') return config #======================================================================================================================= # PydevTestRunner #======================================================================================================================= class PydevTestRunner(object): """ finds and runs a file or directory of files as a unit test """ __py_extensions = ["*.py", "*.pyw"] __exclude_files = ["__init__.*"] # Just to check that only this attributes will be written to this file __slots__ = [ 'verbosity', # Always used 'files_to_tests', # If this one is given, the ones below are not used 'files_or_dirs', # Files or directories received in the command line 'include_tests', # The filter used to collect the tests 'tests', # Strings with the tests to be run 'jobs', # Integer with the number of jobs that should be used to run the test cases 'split_jobs', # String with 'tests' or 'module' (how should the jobs be split) 'configuration', 'coverage', ] def __init__(self, configuration): self.verbosity = configuration.verbosity self.jobs = configuration.jobs self.split_jobs = configuration.split_jobs files_to_tests = configuration.files_to_tests if files_to_tests: self.files_to_tests = files_to_tests self.files_or_dirs = list(files_to_tests.keys()) self.tests = None else: self.files_to_tests = {} self.files_or_dirs = configuration.files_or_dirs self.tests = configuration.tests self.configuration = configuration self.__adjust_path() def __adjust_path(self): """ add the current file or directory to the python path """ path_to_append = None for n in range(len(self.files_or_dirs)): dir_name = self.__unixify(self.files_or_dirs[n]) if os.path.isdir(dir_name): if not dir_name.endswith("/"): self.files_or_dirs[n] = dir_name + "/" path_to_append = os.path.normpath(dir_name) elif os.path.isfile(dir_name): path_to_append = os.path.dirname(dir_name) else: if not os.path.exists(dir_name): block_line = '*' * 120 sys.stderr.write('\n%s\n* PyDev test runner error: %s does not exist.\n%s\n' % (block_line, dir_name, block_line)) return msg = ("unknown type. \n%s\nshould be file or a directory.\n" % (dir_name)) raise RuntimeError(msg) if path_to_append is not None: # Add it as the last one (so, first things are resolved against the default dirs and # if none resolves, then we try a relative import). sys.path.append(path_to_append) def __is_valid_py_file(self, fname): """ tests that a particular file contains the proper file extension and is not in the list of files to exclude """ is_valid_fname = 0 for invalid_fname in self.__class__.__exclude_files: is_valid_fname += int(not fnmatch.fnmatch(fname, invalid_fname)) if_valid_ext = 0 for ext in self.__class__.__py_extensions: if_valid_ext += int(fnmatch.fnmatch(fname, ext)) return is_valid_fname > 0 and if_valid_ext > 0 def __unixify(self, s): """ stupid windows. converts the backslash to forwardslash for consistency """ return os.path.normpath(s).replace(os.sep, "/") def __importify(self, s, dir=False): """ turns directory separators into dots and removes the ".py*" extension so the string can be used as import statement """ if not dir: dirname, fname = os.path.split(s) if fname.count('.') > 1: # if there's a file named xxx.xx.py, it is not a valid module, so, let's not load it... return imp_stmt_pieces = [dirname.replace("\\", "/").replace("/", "."), os.path.splitext(fname)[0]] if len(imp_stmt_pieces[0]) == 0: imp_stmt_pieces = imp_stmt_pieces[1:] return ".".join(imp_stmt_pieces) else: # handle dir return s.replace("\\", "/").replace("/", ".") def __add_files(self, pyfiles, root, files): """ if files match, appends them to pyfiles. used by os.path.walk fcn """ for fname in files: if self.__is_valid_py_file(fname): name_without_base_dir = self.__unixify(os.path.join(root, fname)) pyfiles.append(name_without_base_dir) def find_import_files(self): """ return a list of files to import """ if self.files_to_tests: pyfiles = self.files_to_tests.keys() else: pyfiles = [] for base_dir in self.files_or_dirs: if os.path.isdir(base_dir): for root, dirs, files in os.walk(base_dir): # Note: handling directories that should be excluded from the search because # they don't have __init__.py exclude = {} for d in dirs: for init in ['__init__.py', '__init__.pyo', '__init__.pyc', '__init__.pyw', '__init__$py.class']: if os.path.exists(os.path.join(root, d, init).replace('\\', '/')): break else: exclude[d] = 1 if exclude: new = [] for d in dirs: if d not in exclude: new.append(d) dirs[:] = new self.__add_files(pyfiles, root, files) elif os.path.isfile(base_dir): pyfiles.append(base_dir) if self.configuration.exclude_files or self.configuration.include_files: ret = [] for f in pyfiles: add = True basename = os.path.basename(f) if self.configuration.include_files: add = False for pat in self.configuration.include_files: if fnmatch.fnmatchcase(basename, pat): add = True break if not add: if self.verbosity > 3: sys.stdout.write('Skipped file: %s (did not match any include_files pattern: %s)\n' % (f, self.configuration.include_files)) elif self.configuration.exclude_files: for pat in self.configuration.exclude_files: if fnmatch.fnmatchcase(basename, pat): if self.verbosity > 3: sys.stdout.write('Skipped file: %s (matched exclude_files pattern: %s)\n' % (f, pat)) elif self.verbosity > 2: sys.stdout.write('Skipped file: %s\n' % (f,)) add = False break if add: if self.verbosity > 3: sys.stdout.write('Adding file: %s for test discovery.\n' % (f,)) ret.append(f) pyfiles = ret return pyfiles def __get_module_from_str(self, modname, print_exception, pyfile): """ Import the module in the given import path. * Returns the "final" module, so importing "coilib40.subject.visu" returns the "visu" module, not the "coilib40" as returned by __import__ """ try: mod = __import__(modname) for part in modname.split('.')[1:]: mod = getattr(mod, part) return mod except: if print_exception: from _pydev_runfiles import pydev_runfiles_xml_rpc from _pydevd_bundle import pydevd_io buf_err = pydevd_io.start_redirect(keep_original_redirection=True, std='stderr') buf_out = pydevd_io.start_redirect(keep_original_redirection=True, std='stdout') try: import traceback;traceback.print_exc() sys.stderr.write('ERROR: Module: %s could not be imported (file: %s).\n' % (modname, pyfile)) finally: pydevd_io.end_redirect('stderr') pydevd_io.end_redirect('stdout') pydev_runfiles_xml_rpc.notifyTest( 'error', buf_out.getvalue(), buf_err.getvalue(), pyfile, modname, 0) return None def remove_duplicates_keeping_order(self, seq): seen = set() seen_add = seen.add return [x for x in seq if not (x in seen or seen_add(x))] def find_modules_from_files(self, pyfiles): """ returns a list of modules given a list of files """ # let's make sure that the paths we want are in the pythonpath... imports = [(s, self.__importify(s)) for s in pyfiles] sys_path = [os.path.normpath(path) for path in sys.path] sys_path = self.remove_duplicates_keeping_order(sys_path) system_paths = [] for s in sys_path: system_paths.append(self.__importify(s, True)) ret = [] for pyfile, imp in imports: if imp is None: continue # can happen if a file is not a valid module choices = [] for s in system_paths: if imp.startswith(s): add = imp[len(s) + 1:] if add: choices.append(add) # sys.stdout.write(' ' + add + ' ') if not choices: sys.stdout.write('PYTHONPATH not found for file: %s\n' % imp) else: for i, import_str in enumerate(choices): print_exception = i == len(choices) - 1 mod = self.__get_module_from_str(import_str, print_exception, pyfile) if mod is not None: ret.append((pyfile, mod, import_str)) break return ret #=================================================================================================================== # GetTestCaseNames #=================================================================================================================== class GetTestCaseNames: """Yes, we need a class for that (cannot use outer context on jython 2.1)""" def __init__(self, accepted_classes, accepted_methods): self.accepted_classes = accepted_classes self.accepted_methods = accepted_methods def __call__(self, testCaseClass): """Return a sorted sequence of method names found within testCaseClass""" testFnNames = [] className = testCaseClass.__name__ if className in self.accepted_classes: for attrname in dir(testCaseClass): # If a class is chosen, we select all the 'test' methods' if attrname.startswith('test') and hasattr(getattr(testCaseClass, attrname), '__call__'): testFnNames.append(attrname) else: for attrname in dir(testCaseClass): # If we have the class+method name, we must do a full check and have an exact match. if className + '.' + attrname in self.accepted_methods: if hasattr(getattr(testCaseClass, attrname), '__call__'): testFnNames.append(attrname) # sorted() is not available in jython 2.1 testFnNames.sort() return testFnNames def _decorate_test_suite(self, suite, pyfile, module_name): import unittest if isinstance(suite, unittest.TestSuite): add = False suite.__pydev_pyfile__ = pyfile suite.__pydev_module_name__ = module_name for t in suite._tests: t.__pydev_pyfile__ = pyfile t.__pydev_module_name__ = module_name if self._decorate_test_suite(t, pyfile, module_name): add = True return add elif isinstance(suite, unittest.TestCase): return True else: return False def find_tests_from_modules(self, file_and_modules_and_module_name): """ returns the unittests given a list of modules """ # Use our own suite! from _pydev_runfiles import pydev_runfiles_unittest import unittest unittest.TestLoader.suiteClass = pydev_runfiles_unittest.PydevTestSuite loader = unittest.TestLoader() ret = [] if self.files_to_tests: for pyfile, m, module_name in file_and_modules_and_module_name: accepted_classes = {} accepted_methods = {} tests = self.files_to_tests[pyfile] for t in tests: accepted_methods[t] = t loader.getTestCaseNames = self.GetTestCaseNames(accepted_classes, accepted_methods) suite = loader.loadTestsFromModule(m) if self._decorate_test_suite(suite, pyfile, module_name): ret.append(suite) return ret if self.tests: accepted_classes = {} accepted_methods = {} for t in self.tests: splitted = t.split('.') if len(splitted) == 1: accepted_classes[t] = t elif len(splitted) == 2: accepted_methods[t] = t loader.getTestCaseNames = self.GetTestCaseNames(accepted_classes, accepted_methods) for pyfile, m, module_name in file_and_modules_and_module_name: suite = loader.loadTestsFromModule(m) if self._decorate_test_suite(suite, pyfile, module_name): ret.append(suite) return ret def filter_tests(self, test_objs, internal_call=False): """ based on a filter name, only return those tests that have the test case names that match """ import unittest if not internal_call: if not self.configuration.include_tests and not self.tests and not self.configuration.exclude_tests: # No need to filter if we have nothing to filter! return test_objs if self.verbosity > 1: if self.configuration.include_tests: sys.stdout.write('Tests to include: %s\n' % (self.configuration.include_tests,)) if self.tests: sys.stdout.write('Tests to run: %s\n' % (self.tests,)) if self.configuration.exclude_tests: sys.stdout.write('Tests to exclude: %s\n' % (self.configuration.exclude_tests,)) test_suite = [] for test_obj in test_objs: if isinstance(test_obj, unittest.TestSuite): # Note: keep the suites as they are and just 'fix' the tests (so, don't use the iter_tests). if test_obj._tests: test_obj._tests = self.filter_tests(test_obj._tests, True) if test_obj._tests: # Only add the suite if we still have tests there. test_suite.append(test_obj) elif isinstance(test_obj, unittest.TestCase): try: testMethodName = test_obj._TestCase__testMethodName except AttributeError: # changed in python 2.5 testMethodName = test_obj._testMethodName add = True if self.configuration.exclude_tests: for pat in self.configuration.exclude_tests: if fnmatch.fnmatchcase(testMethodName, pat): if self.verbosity > 3: sys.stdout.write('Skipped test: %s (matched exclude_tests pattern: %s)\n' % (testMethodName, pat)) elif self.verbosity > 2: sys.stdout.write('Skipped test: %s\n' % (testMethodName,)) add = False break if add: if self.__match_tests(self.tests, test_obj, testMethodName): include = True if self.configuration.include_tests: include = False for pat in self.configuration.include_tests: if fnmatch.fnmatchcase(testMethodName, pat): include = True break if include: test_suite.append(test_obj) else: if self.verbosity > 3: sys.stdout.write('Skipped test: %s (did not match any include_tests pattern %s)\n' % ( testMethodName, self.configuration.include_tests,)) return test_suite def iter_tests(self, test_objs): # Note: not using yield because of Jython 2.1. import unittest tests = [] for test_obj in test_objs: if isinstance(test_obj, unittest.TestSuite): tests.extend(self.iter_tests(test_obj._tests)) elif isinstance(test_obj, unittest.TestCase): tests.append(test_obj) return tests def list_test_names(self, test_objs): names = [] for tc in self.iter_tests(test_objs): try: testMethodName = tc._TestCase__testMethodName except AttributeError: # changed in python 2.5 testMethodName = tc._testMethodName names.append(testMethodName) return names def __match_tests(self, tests, test_case, test_method_name): if not tests: return 1 for t in tests: class_and_method = t.split('.') if len(class_and_method) == 1: # only class name if class_and_method[0] == test_case.__class__.__name__: return 1 elif len(class_and_method) == 2: if class_and_method[0] == test_case.__class__.__name__ and class_and_method[1] == test_method_name: return 1 return 0 def __match(self, filter_list, name): """ returns whether a test name matches the test filter """ if filter_list is None: return 1 for f in filter_list: if re.match(f, name): return 1 return 0 def run_tests(self, handle_coverage=True): """ runs all tests """ sys.stdout.write("Finding files... ") files = self.find_import_files() if self.verbosity > 3: sys.stdout.write('%s ... done.\n' % (self.files_or_dirs)) else: sys.stdout.write('done.\n') sys.stdout.write("Importing test modules ... ") if handle_coverage: coverage_files, coverage = start_coverage_support(self.configuration) file_and_modules_and_module_name = self.find_modules_from_files(files) sys.stdout.write("done.\n") all_tests = self.find_tests_from_modules(file_and_modules_and_module_name) all_tests = self.filter_tests(all_tests) from _pydev_runfiles import pydev_runfiles_unittest test_suite = pydev_runfiles_unittest.PydevTestSuite(all_tests) from _pydev_runfiles import pydev_runfiles_xml_rpc pydev_runfiles_xml_rpc.notifyTestsCollected(test_suite.countTestCases()) start_time = time.time() def run_tests(): executed_in_parallel = False if self.jobs > 1: from _pydev_runfiles import pydev_runfiles_parallel # What may happen is that the number of jobs needed is lower than the number of jobs requested # (e.g.: 2 jobs were requested for running 1 test) -- in which case execute_tests_in_parallel will # return False and won't run any tests. executed_in_parallel = pydev_runfiles_parallel.execute_tests_in_parallel( all_tests, self.jobs, self.split_jobs, self.verbosity, coverage_files, self.configuration.coverage_include) if not executed_in_parallel: # If in coverage, we don't need to pass anything here (coverage is already enabled for this execution). runner = pydev_runfiles_unittest.PydevTextTestRunner(stream=sys.stdout, descriptions=1, verbosity=self.verbosity) sys.stdout.write('\n') runner.run(test_suite) if self.configuration.django: get_django_test_suite_runner()(run_tests).run_tests([]) else: run_tests() if handle_coverage: coverage.stop() coverage.save() total_time = 'Finished in: %.2f secs.' % (time.time() - start_time,) pydev_runfiles_xml_rpc.notifyTestRunFinished(total_time) DJANGO_TEST_SUITE_RUNNER = None def get_django_test_suite_runner(): global DJANGO_TEST_SUITE_RUNNER if DJANGO_TEST_SUITE_RUNNER: return DJANGO_TEST_SUITE_RUNNER try: # django >= 1.8 import django from django.test.runner import DiscoverRunner class MyDjangoTestSuiteRunner(DiscoverRunner): def __init__(self, on_run_suite): django.setup() DiscoverRunner.__init__(self) self.on_run_suite = on_run_suite def build_suite(self, *args, **kwargs): pass def suite_result(self, *args, **kwargs): pass def run_suite(self, *args, **kwargs): self.on_run_suite() except: # django < 1.8 try: from django.test.simple import DjangoTestSuiteRunner except: class DjangoTestSuiteRunner: def __init__(self): pass def run_tests(self, *args, **kwargs): raise AssertionError("Unable to run suite with django.test.runner.DiscoverRunner nor django.test.simple.DjangoTestSuiteRunner because it couldn't be imported.") class MyDjangoTestSuiteRunner(DjangoTestSuiteRunner): def __init__(self, on_run_suite): DjangoTestSuiteRunner.__init__(self) self.on_run_suite = on_run_suite def build_suite(self, *args, **kwargs): pass def suite_result(self, *args, **kwargs): pass def run_suite(self, *args, **kwargs): self.on_run_suite() DJANGO_TEST_SUITE_RUNNER = MyDjangoTestSuiteRunner return DJANGO_TEST_SUITE_RUNNER #======================================================================================================================= # main #======================================================================================================================= def main(configuration): PydevTestRunner(configuration).run_tests()
31,550
Python
35.772727
180
0.513217
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_coverage.py
import os.path import sys from _pydevd_bundle.pydevd_constants import Null #======================================================================================================================= # get_coverage_files #======================================================================================================================= def get_coverage_files(coverage_output_dir, number_of_files): base_dir = coverage_output_dir ret = [] i = 0 while len(ret) < number_of_files: while True: f = os.path.join(base_dir, '.coverage.%s' % i) i += 1 if not os.path.exists(f): ret.append(f) break #Break only inner for. return ret #======================================================================================================================= # start_coverage_support #======================================================================================================================= def start_coverage_support(configuration): return start_coverage_support_from_params( configuration.coverage_output_dir, configuration.coverage_output_file, configuration.jobs, configuration.coverage_include, ) #======================================================================================================================= # start_coverage_support_from_params #======================================================================================================================= def start_coverage_support_from_params(coverage_output_dir, coverage_output_file, jobs, coverage_include): coverage_files = [] coverage_instance = Null() if coverage_output_dir or coverage_output_file: try: import coverage #@UnresolvedImport except: sys.stderr.write('Error: coverage module could not be imported\n') sys.stderr.write('Please make sure that the coverage module (http://nedbatchelder.com/code/coverage/)\n') sys.stderr.write('is properly installed in your interpreter: %s\n' % (sys.executable,)) import traceback;traceback.print_exc() else: if coverage_output_dir: if not os.path.exists(coverage_output_dir): sys.stderr.write('Error: directory for coverage output (%s) does not exist.\n' % (coverage_output_dir,)) elif not os.path.isdir(coverage_output_dir): sys.stderr.write('Error: expected (%s) to be a directory.\n' % (coverage_output_dir,)) else: n = jobs if n <= 0: n += 1 n += 1 #Add 1 more for the current process (which will do the initial import). coverage_files = get_coverage_files(coverage_output_dir, n) os.environ['COVERAGE_FILE'] = coverage_files.pop(0) coverage_instance = coverage.coverage(source=[coverage_include]) coverage_instance.start() elif coverage_output_file: #Client of parallel run. os.environ['COVERAGE_FILE'] = coverage_output_file coverage_instance = coverage.coverage(source=[coverage_include]) coverage_instance.start() return coverage_files, coverage_instance
3,499
Python
44.454545
124
0.452415
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel_client.py
from _pydev_bundle.pydev_imports import xmlrpclib, _queue Queue = _queue.Queue import traceback import sys from _pydev_runfiles.pydev_runfiles_coverage import start_coverage_support_from_params import threading #======================================================================================================================= # ParallelNotification #======================================================================================================================= class ParallelNotification(object): def __init__(self, method, args, kwargs): self.method = method self.args = args self.kwargs = kwargs def to_tuple(self): return self.method, self.args, self.kwargs #======================================================================================================================= # KillServer #======================================================================================================================= class KillServer(object): pass #======================================================================================================================= # ServerComm #======================================================================================================================= class ServerComm(threading.Thread): def __init__(self, job_id, server): self.notifications_queue = Queue() threading.Thread.__init__(self) self.setDaemon(False) #Wait for all the notifications to be passed before exiting! assert job_id is not None assert port is not None self.job_id = job_id self.finished = False self.server = server def run(self): while True: kill_found = False commands = [] command = self.notifications_queue.get(block=True) if isinstance(command, KillServer): kill_found = True else: assert isinstance(command, ParallelNotification) commands.append(command.to_tuple()) try: while True: command = self.notifications_queue.get(block=False) #No block to create a batch. if isinstance(command, KillServer): kill_found = True else: assert isinstance(command, ParallelNotification) commands.append(command.to_tuple()) except: pass #That's OK, we're getting it until it becomes empty so that we notify multiple at once. if commands: try: #Batch notification. self.server.lock.acquire() try: self.server.notifyCommands(self.job_id, commands) finally: self.server.lock.release() except: traceback.print_exc() if kill_found: self.finished = True return #======================================================================================================================= # ServerFacade #======================================================================================================================= class ServerFacade(object): def __init__(self, notifications_queue): self.notifications_queue = notifications_queue def notifyTestsCollected(self, *args, **kwargs): pass #This notification won't be passed def notifyTestRunFinished(self, *args, **kwargs): pass #This notification won't be passed def notifyStartTest(self, *args, **kwargs): self.notifications_queue.put_nowait(ParallelNotification('notifyStartTest', args, kwargs)) def notifyTest(self, *args, **kwargs): self.notifications_queue.put_nowait(ParallelNotification('notifyTest', args, kwargs)) #======================================================================================================================= # run_client #======================================================================================================================= def run_client(job_id, port, verbosity, coverage_output_file, coverage_include): job_id = int(job_id) from _pydev_bundle import pydev_localhost server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), port)) server.lock = threading.Lock() server_comm = ServerComm(job_id, server) server_comm.start() try: server_facade = ServerFacade(server_comm.notifications_queue) from _pydev_runfiles import pydev_runfiles from _pydev_runfiles import pydev_runfiles_xml_rpc pydev_runfiles_xml_rpc.set_server(server_facade) #Starts None and when the 1st test is gotten, it's started (because a server may be initiated and terminated #before receiving any test -- which would mean a different process got all the tests to run). coverage = None try: tests_to_run = [1] while tests_to_run: #Investigate: is it dangerous to use the same xmlrpclib server from different threads? #It seems it should be, as it creates a new connection for each request... server.lock.acquire() try: tests_to_run = server.GetTestsToRun(job_id) finally: server.lock.release() if not tests_to_run: break if coverage is None: _coverage_files, coverage = start_coverage_support_from_params( None, coverage_output_file, 1, coverage_include) files_to_tests = {} for test in tests_to_run: filename_and_test = test.split('|') if len(filename_and_test) == 2: files_to_tests.setdefault(filename_and_test[0], []).append(filename_and_test[1]) configuration = pydev_runfiles.Configuration( '', verbosity, None, None, None, files_to_tests, 1, #Always single job here None, #The coverage is handled in this loop. coverage_output_file=None, coverage_include=None, ) test_runner = pydev_runfiles.PydevTestRunner(configuration) sys.stdout.flush() test_runner.run_tests(handle_coverage=False) finally: if coverage is not None: coverage.stop() coverage.save() except: traceback.print_exc() server_comm.notifications_queue.put_nowait(KillServer()) #======================================================================================================================= # main #======================================================================================================================= if __name__ == '__main__': if len(sys.argv) -1 == 3: job_id, port, verbosity = sys.argv[1:] coverage_output_file, coverage_include = None, None elif len(sys.argv) -1 == 5: job_id, port, verbosity, coverage_output_file, coverage_include = sys.argv[1:] else: raise AssertionError('Could not find out how to handle the parameters: '+sys.argv[1:]) job_id = int(job_id) port = int(port) verbosity = int(verbosity) run_client(job_id, port, verbosity, coverage_output_file, coverage_include)
7,722
Python
34.92093
120
0.460891
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_pytest2.py
from _pydev_runfiles import pydev_runfiles_xml_rpc import pickle import zlib import base64 import os from pydevd_file_utils import canonical_normalized_path import pytest import sys import time from pathlib import Path #========================================================================= # Load filters with tests we should skip #========================================================================= py_test_accept_filter = None def _load_filters(): global py_test_accept_filter if py_test_accept_filter is None: py_test_accept_filter = os.environ.get('PYDEV_PYTEST_SKIP') if py_test_accept_filter: py_test_accept_filter = pickle.loads( zlib.decompress(base64.b64decode(py_test_accept_filter))) # Newer versions of pytest resolve symlinks, so, we # may need to filter with a resolved path too. new_dct = {} for filename, value in py_test_accept_filter.items(): new_dct[canonical_normalized_path(str(Path(filename).resolve()))] = value py_test_accept_filter.update(new_dct) else: py_test_accept_filter = {} def is_in_xdist_node(): main_pid = os.environ.get('PYDEV_MAIN_PID') if main_pid and main_pid != str(os.getpid()): return True return False connected = False def connect_to_server_for_communication_to_xml_rpc_on_xdist(): global connected if connected: return connected = True if is_in_xdist_node(): port = os.environ.get('PYDEV_PYTEST_SERVER') if not port: sys.stderr.write( 'Error: no PYDEV_PYTEST_SERVER environment variable defined.\n') else: pydev_runfiles_xml_rpc.initialize_server(int(port), daemon=True) PY2 = sys.version_info[0] <= 2 PY3 = not PY2 class State: start_time = time.time() buf_err = None buf_out = None def start_redirect(): if State.buf_out is not None: return from _pydevd_bundle import pydevd_io State.buf_err = pydevd_io.start_redirect(keep_original_redirection=True, std='stderr') State.buf_out = pydevd_io.start_redirect(keep_original_redirection=True, std='stdout') def get_curr_output(): buf_out = State.buf_out buf_err = State.buf_err return buf_out.getvalue() if buf_out is not None else '', buf_err.getvalue() if buf_err is not None else '' def pytest_unconfigure(): if is_in_xdist_node(): return # Only report that it finished when on the main node (we don't want to report # the finish on each separate node). pydev_runfiles_xml_rpc.notifyTestRunFinished( 'Finished in: %.2f secs.' % (time.time() - State.start_time,)) def pytest_collection_modifyitems(session, config, items): # A note: in xdist, this is not called on the main process, only in the # secondary nodes, so, we'll actually make the filter and report it multiple # times. connect_to_server_for_communication_to_xml_rpc_on_xdist() _load_filters() if not py_test_accept_filter: pydev_runfiles_xml_rpc.notifyTestsCollected(len(items)) return # Keep on going (nothing to filter) new_items = [] for item in items: f = canonical_normalized_path(str(item.parent.fspath)) name = item.name if f not in py_test_accept_filter: # print('Skip file: %s' % (f,)) continue # Skip the file i = name.find('[') name_without_parametrize = None if i > 0: name_without_parametrize = name[:i] accept_tests = py_test_accept_filter[f] if item.cls is not None: class_name = item.cls.__name__ else: class_name = None for test in accept_tests: if test == name: # Direct match of the test (just go on with the default # loading) new_items.append(item) break if name_without_parametrize is not None and test == name_without_parametrize: # This happens when parameterizing pytest tests on older versions # of pytest where the test name doesn't include the fixture name # in it. new_items.append(item) break if class_name is not None: if test == class_name + '.' + name: new_items.append(item) break if name_without_parametrize is not None and test == class_name + '.' + name_without_parametrize: new_items.append(item) break if class_name == test: new_items.append(item) break else: pass # print('Skip test: %s.%s. Accept: %s' % (class_name, name, accept_tests)) # Modify the original list items[:] = new_items pydev_runfiles_xml_rpc.notifyTestsCollected(len(items)) try: """ pytest > 5.4 uses own version of TerminalWriter based on py.io.TerminalWriter and assumes there is a specific method TerminalWriter._write_source so try load pytest version first or fallback to default one """ from _pytest._io import TerminalWriter except ImportError: from py.io import TerminalWriter def _get_error_contents_from_report(report): if report.longrepr is not None: try: tw = TerminalWriter(stringio=True) stringio = tw.stringio except TypeError: import io stringio = io.StringIO() tw = TerminalWriter(file=stringio) tw.hasmarkup = False report.toterminal(tw) exc = stringio.getvalue() s = exc.strip() if s: return s return '' def pytest_collectreport(report): error_contents = _get_error_contents_from_report(report) if error_contents: report_test('fail', '<collect errors>', '<collect errors>', '', error_contents, 0.0) def append_strings(s1, s2): if s1.__class__ == s2.__class__: return s1 + s2 # Prefer str if isinstance(s1, bytes): s1 = s1.decode('utf-8', 'replace') if isinstance(s2, bytes): s2 = s2.decode('utf-8', 'replace') return s1 + s2 def pytest_runtest_logreport(report): if is_in_xdist_node(): # When running with xdist, we don't want the report to be called from the node, only # from the main process. return report_duration = report.duration report_when = report.when report_outcome = report.outcome if hasattr(report, 'wasxfail'): if report_outcome != 'skipped': report_outcome = 'passed' if report_outcome == 'passed': # passed on setup/teardown: no need to report if in setup or teardown # (only on the actual test if it passed). if report_when in ('setup', 'teardown'): return status = 'ok' elif report_outcome == 'skipped': status = 'skip' else: # It has only passed, skipped and failed (no error), so, let's consider # error if not on call. if report_when in ('setup', 'teardown'): status = 'error' else: # any error in the call (not in setup or teardown) is considered a # regular failure. status = 'fail' # This will work if pytest is not capturing it, if it is, nothing will # come from here... captured_output, error_contents = getattr(report, 'pydev_captured_output', ''), getattr(report, 'pydev_error_contents', '') for type_section, value in report.sections: if value: if type_section in ('err', 'stderr', 'Captured stderr call'): error_contents = append_strings(error_contents, value) else: captured_output = append_strings(error_contents, value) filename = getattr(report, 'pydev_fspath_strpath', '<unable to get>') test = report.location[2] if report_outcome != 'skipped': # On skipped, we'll have a traceback for the skip, which is not what we # want. exc = _get_error_contents_from_report(report) if exc: if error_contents: error_contents = append_strings(error_contents, '----------------------------- Exceptions -----------------------------\n') error_contents = append_strings(error_contents, exc) report_test(status, filename, test, captured_output, error_contents, report_duration) def report_test(status, filename, test, captured_output, error_contents, duration): ''' @param filename: 'D:\\src\\mod1\\hello.py' @param test: 'TestCase.testMet1' @param status: fail, error, ok ''' time_str = '%.2f' % (duration,) pydev_runfiles_xml_rpc.notifyTest( status, captured_output, error_contents, filename, test, time_str) if not hasattr(pytest, 'hookimpl'): raise AssertionError('Please upgrade pytest (the current version of pytest: %s is unsupported)' % (pytest.__version__,)) @pytest.hookimpl(hookwrapper=True) def pytest_runtest_makereport(item, call): outcome = yield report = outcome.get_result() report.pydev_fspath_strpath = item.fspath.strpath report.pydev_captured_output, report.pydev_error_contents = get_curr_output() @pytest.mark.tryfirst def pytest_runtest_setup(item): ''' Note: with xdist will be on a secondary process. ''' # We have our own redirection: if xdist does its redirection, we'll have # nothing in our contents (which is OK), but if it does, we'll get nothing # from pytest but will get our own here. start_redirect() filename = item.fspath.strpath test = item.location[2] pydev_runfiles_xml_rpc.notifyStartTest(filename, test)
9,845
Python
31.071661
139
0.600914
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_unittest.py
import unittest as python_unittest from _pydev_runfiles import pydev_runfiles_xml_rpc import time from _pydevd_bundle import pydevd_io import traceback from _pydevd_bundle.pydevd_constants import * # @UnusedWildImport from io import StringIO #======================================================================================================================= # PydevTextTestRunner #======================================================================================================================= class PydevTextTestRunner(python_unittest.TextTestRunner): def _makeResult(self): return PydevTestResult(self.stream, self.descriptions, self.verbosity) _PythonTextTestResult = python_unittest.TextTestRunner()._makeResult().__class__ #======================================================================================================================= # PydevTestResult #======================================================================================================================= class PydevTestResult(_PythonTextTestResult): def addSubTest(self, test, subtest, err): """Called at the end of a subtest. 'err' is None if the subtest ended successfully, otherwise it's a tuple of values as returned by sys.exc_info(). """ _PythonTextTestResult.addSubTest(self, test, subtest, err) if err is not None: subdesc = subtest._subDescription() error = (test, self._exc_info_to_string(err, test)) self._reportErrors([error], [], '', '%s %s' % (self.get_test_name(test), subdesc)) def startTest(self, test): _PythonTextTestResult.startTest(self, test) self.buf = pydevd_io.start_redirect(keep_original_redirection=True, std='both') self.start_time = time.time() self._current_errors_stack = [] self._current_failures_stack = [] try: test_name = test.__class__.__name__ + "." + test._testMethodName except AttributeError: # Support for jython 2.1 (__testMethodName is pseudo-private in the test case) test_name = test.__class__.__name__ + "." + test._TestCase__testMethodName pydev_runfiles_xml_rpc.notifyStartTest( test.__pydev_pyfile__, test_name) def get_test_name(self, test): try: try: test_name = test.__class__.__name__ + "." + test._testMethodName except AttributeError: # Support for jython 2.1 (__testMethodName is pseudo-private in the test case) try: test_name = test.__class__.__name__ + "." + test._TestCase__testMethodName # Support for class/module exceptions (test is instance of _ErrorHolder) except: test_name = test.description.split()[1][1:-1] + ' <' + test.description.split()[0] + '>' except: traceback.print_exc() return '<unable to get test name>' return test_name def stopTest(self, test): end_time = time.time() pydevd_io.end_redirect(std='both') _PythonTextTestResult.stopTest(self, test) captured_output = self.buf.getvalue() del self.buf error_contents = '' test_name = self.get_test_name(test) diff_time = '%.2f' % (end_time - self.start_time) skipped = False outcome = getattr(test, '_outcome', None) if outcome is not None: skipped = bool(getattr(outcome, 'skipped', None)) if skipped: pydev_runfiles_xml_rpc.notifyTest( 'skip', captured_output, error_contents, test.__pydev_pyfile__, test_name, diff_time) elif not self._current_errors_stack and not self._current_failures_stack: pydev_runfiles_xml_rpc.notifyTest( 'ok', captured_output, error_contents, test.__pydev_pyfile__, test_name, diff_time) else: self._reportErrors(self._current_errors_stack, self._current_failures_stack, captured_output, test_name) def _reportErrors(self, errors, failures, captured_output, test_name, diff_time=''): error_contents = [] for test, s in errors + failures: if type(s) == type((1,)): # If it's a tuple (for jython 2.1) sio = StringIO() traceback.print_exception(s[0], s[1], s[2], file=sio) s = sio.getvalue() error_contents.append(s) sep = '\n' + self.separator1 error_contents = sep.join(error_contents) if errors and not failures: try: pydev_runfiles_xml_rpc.notifyTest( 'error', captured_output, error_contents, test.__pydev_pyfile__, test_name, diff_time) except: file_start = error_contents.find('File "') file_end = error_contents.find('", ', file_start) if file_start != -1 and file_end != -1: file = error_contents[file_start + 6:file_end] else: file = '<unable to get file>' pydev_runfiles_xml_rpc.notifyTest( 'error', captured_output, error_contents, file, test_name, diff_time) elif failures and not errors: pydev_runfiles_xml_rpc.notifyTest( 'fail', captured_output, error_contents, test.__pydev_pyfile__, test_name, diff_time) else: # Ok, we got both, errors and failures. Let's mark it as an error in the end. pydev_runfiles_xml_rpc.notifyTest( 'error', captured_output, error_contents, test.__pydev_pyfile__, test_name, diff_time) def addError(self, test, err): _PythonTextTestResult.addError(self, test, err) # Support for class/module exceptions (test is instance of _ErrorHolder) if not hasattr(self, '_current_errors_stack') or test.__class__.__name__ == '_ErrorHolder': # Not in start...end, so, report error now (i.e.: django pre/post-setup) self._reportErrors([self.errors[-1]], [], '', self.get_test_name(test)) else: self._current_errors_stack.append(self.errors[-1]) def addFailure(self, test, err): _PythonTextTestResult.addFailure(self, test, err) if not hasattr(self, '_current_failures_stack'): # Not in start...end, so, report error now (i.e.: django pre/post-setup) self._reportErrors([], [self.failures[-1]], '', self.get_test_name(test)) else: self._current_failures_stack.append(self.failures[-1]) class PydevTestSuite(python_unittest.TestSuite): pass
6,685
Python
43.278145
120
0.551832
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_nose.py
from nose.plugins.multiprocess import MultiProcessTestRunner # @UnresolvedImport from nose.plugins.base import Plugin # @UnresolvedImport import sys from _pydev_runfiles import pydev_runfiles_xml_rpc import time from _pydev_runfiles.pydev_runfiles_coverage import start_coverage_support from contextlib import contextmanager from io import StringIO import traceback #======================================================================================================================= # PydevPlugin #======================================================================================================================= class PydevPlugin(Plugin): def __init__(self, configuration): self.configuration = configuration Plugin.__init__(self) def begin(self): # Called before any test is run (it's always called, with multiprocess or not) self.start_time = time.time() self.coverage_files, self.coverage = start_coverage_support(self.configuration) def finalize(self, result): # Called after all tests are run (it's always called, with multiprocess or not) self.coverage.stop() self.coverage.save() pydev_runfiles_xml_rpc.notifyTestRunFinished('Finished in: %.2f secs.' % (time.time() - self.start_time,)) #=================================================================================================================== # Methods below are not called with multiprocess (so, we monkey-patch MultiProcessTestRunner.consolidate # so that they're called, but unfortunately we loose some info -- i.e.: the time for each test in this # process). #=================================================================================================================== class Sentinel(object): pass @contextmanager def _without_user_address(self, test): # #PyDev-1095: Conflict between address in test and test.address() in PydevPlugin().report_cond() user_test_instance = test.test user_address = self.Sentinel user_class_address = self.Sentinel try: if 'address' in user_test_instance.__dict__: user_address = user_test_instance.__dict__.pop('address') except: # Just ignore anything here. pass try: user_class_address = user_test_instance.__class__.address del user_test_instance.__class__.address except: # Just ignore anything here. pass try: yield finally: if user_address is not self.Sentinel: user_test_instance.__dict__['address'] = user_address if user_class_address is not self.Sentinel: user_test_instance.__class__.address = user_class_address def _get_test_address(self, test): try: if hasattr(test, 'address'): with self._without_user_address(test): address = test.address() # test.address() is something as: # ('D:\\workspaces\\temp\\test_workspace\\pytesting1\\src\\mod1\\hello.py', 'mod1.hello', 'TestCase.testMet1') # # and we must pass: location, test # E.g.: ['D:\\src\\mod1\\hello.py', 'TestCase.testMet1'] address = address[0], address[2] else: # multiprocess try: address = test[0], test[1] except TypeError: # It may be an error at setup, in which case it's not really a test, but a Context object. f = test.context.__file__ if f.endswith('.pyc'): f = f[:-1] elif f.endswith('$py.class'): f = f[:-len('$py.class')] + '.py' address = f, '?' except: sys.stderr.write("PyDev: Internal pydev error getting test address. Please report at the pydev bug tracker\n") traceback.print_exc() sys.stderr.write("\n\n\n") address = '?', '?' return address def report_cond(self, cond, test, captured_output, error=''): ''' @param cond: fail, error, ok ''' address = self._get_test_address(test) error_contents = self.get_io_from_error(error) try: time_str = '%.2f' % (time.time() - test._pydev_start_time) except: time_str = '?' pydev_runfiles_xml_rpc.notifyTest(cond, captured_output, error_contents, address[0], address[1], time_str) def startTest(self, test): test._pydev_start_time = time.time() file, test = self._get_test_address(test) pydev_runfiles_xml_rpc.notifyStartTest(file, test) def get_io_from_error(self, err): if type(err) == type(()): if len(err) != 3: if len(err) == 2: return err[1] # multiprocess s = StringIO() etype, value, tb = err if isinstance(value, str): return value traceback.print_exception(etype, value, tb, file=s) return s.getvalue() return err def get_captured_output(self, test): if hasattr(test, 'capturedOutput') and test.capturedOutput: return test.capturedOutput return '' def addError(self, test, err): self.report_cond( 'error', test, self.get_captured_output(test), err, ) def addFailure(self, test, err): self.report_cond( 'fail', test, self.get_captured_output(test), err, ) def addSuccess(self, test): self.report_cond( 'ok', test, self.get_captured_output(test), '', ) PYDEV_NOSE_PLUGIN_SINGLETON = None def start_pydev_nose_plugin_singleton(configuration): global PYDEV_NOSE_PLUGIN_SINGLETON PYDEV_NOSE_PLUGIN_SINGLETON = PydevPlugin(configuration) return PYDEV_NOSE_PLUGIN_SINGLETON original = MultiProcessTestRunner.consolidate #======================================================================================================================= # new_consolidate #======================================================================================================================= def new_consolidate(self, result, batch_result): ''' Used so that it can work with the multiprocess plugin. Monkeypatched because nose seems a bit unsupported at this time (ideally the plugin would have this support by default). ''' ret = original(self, result, batch_result) parent_frame = sys._getframe().f_back # addr is something as D:\pytesting1\src\mod1\hello.py:TestCase.testMet4 # so, convert it to what report_cond expects addr = parent_frame.f_locals['addr'] i = addr.rindex(':') addr = [addr[:i], addr[i + 1:]] output, testsRun, failures, errors, errorClasses = batch_result if failures or errors: for failure in failures: PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('fail', addr, output, failure) for error in errors: PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('error', addr, output, error) else: PYDEV_NOSE_PLUGIN_SINGLETON.report_cond('ok', addr, output) return ret MultiProcessTestRunner.consolidate = new_consolidate
7,549
Python
35.298077
126
0.527355
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_override.py
def overrides(method): ''' Meant to be used as class B: @overrides(A.m1) def m1(self): pass ''' def wrapper(func): if func.__name__ != method.__name__: msg = "Wrong @override: %r expected, but overwriting %r." msg = msg % (func.__name__, method.__name__) raise AssertionError(msg) if func.__doc__ is None: func.__doc__ = method.__doc__ return func return wrapper def implements(method): def wrapper(func): if func.__name__ != method.__name__: msg = "Wrong @implements: %r expected, but implementing %r." msg = msg % (func.__name__, method.__name__) raise AssertionError(msg) if func.__doc__ is None: func.__doc__ = method.__doc__ return func return wrapper
872
Python
23.942856
72
0.497706
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_umd.py
""" The UserModuleDeleter and runfile methods are copied from Spyder and carry their own license agreement. http://code.google.com/p/spyderlib/source/browse/spyderlib/widgets/externalshell/sitecustomize.py Spyder License Agreement (MIT License) -------------------------------------- Copyright (c) 2009-2012 Pierre Raybaut Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import sys import os from _pydev_bundle._pydev_execfile import execfile # The following classes and functions are mainly intended to be used from # an interactive Python session class UserModuleDeleter: """ User Module Deleter (UMD) aims at deleting user modules to force Python to deeply reload them during import pathlist [list]: ignore list in terms of module path namelist [list]: ignore list in terms of module name """ def __init__(self, namelist=None, pathlist=None): if namelist is None: namelist = [] self.namelist = namelist if pathlist is None: pathlist = [] self.pathlist = pathlist try: # ignore all files in org.python.pydev/pysrc import pydev_pysrc, inspect self.pathlist.append(os.path.dirname(pydev_pysrc.__file__)) except: pass self.previous_modules = list(sys.modules.keys()) def is_module_ignored(self, modname, modpath): for path in [sys.prefix] + self.pathlist: if modpath.startswith(path): return True else: return set(modname.split('.')) & set(self.namelist) def run(self, verbose=False): """ Del user modules to force Python to deeply reload them Do not del modules which are considered as system modules, i.e. modules installed in subdirectories of Python interpreter's binary Do not del C modules """ log = [] modules_copy = dict(sys.modules) for modname, module in modules_copy.items(): if modname == 'aaaaa': print(modname, module) print(self.previous_modules) if modname not in self.previous_modules: modpath = getattr(module, '__file__', None) if modpath is None: # *module* is a C module that is statically linked into the # interpreter. There is no way to know its path, so we # choose to ignore it. continue if not self.is_module_ignored(modname, modpath): log.append(modname) del sys.modules[modname] if verbose and log: print("\x1b[4;33m%s\x1b[24m%s\x1b[0m" % ("UMD has deleted", ": " + ", ".join(log))) __umd__ = None _get_globals_callback = None def _set_globals_function(get_globals): global _get_globals_callback _get_globals_callback = get_globals def _get_globals(): """Return current Python interpreter globals namespace""" if _get_globals_callback is not None: return _get_globals_callback() else: try: from __main__ import __dict__ as namespace except ImportError: try: # The import fails on IronPython import __main__ namespace = __main__.__dict__ except: namespace shell = namespace.get('__ipythonshell__') if shell is not None and hasattr(shell, 'user_ns'): # IPython 0.12+ kernel return shell.user_ns else: # Python interpreter return namespace return namespace def runfile(filename, args=None, wdir=None, namespace=None): """ Run filename args: command line arguments (string) wdir: working directory """ try: if hasattr(filename, 'decode'): filename = filename.decode('utf-8') except (UnicodeError, TypeError): pass global __umd__ if os.environ.get("PYDEV_UMD_ENABLED", "").lower() == "true": if __umd__ is None: namelist = os.environ.get("PYDEV_UMD_NAMELIST", None) if namelist is not None: namelist = namelist.split(',') __umd__ = UserModuleDeleter(namelist=namelist) else: verbose = os.environ.get("PYDEV_UMD_VERBOSE", "").lower() == "true" __umd__.run(verbose=verbose) if args is not None and not isinstance(args, (bytes, str)): raise TypeError("expected a character buffer object") if namespace is None: namespace = _get_globals() if '__file__' in namespace: old_file = namespace['__file__'] else: old_file = None namespace['__file__'] = filename sys.argv = [filename] if args is not None: for arg in args.split(): sys.argv.append(arg) if wdir is not None: try: if hasattr(wdir, 'decode'): wdir = wdir.decode('utf-8') except (UnicodeError, TypeError): pass os.chdir(wdir) execfile(filename, namespace) sys.argv = [''] if old_file is None: del namespace['__file__'] else: namespace['__file__'] = old_file
6,279
Python
33.696132
97
0.607262
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_import_hook.py
import sys import traceback from types import ModuleType from _pydevd_bundle.pydevd_constants import DebugInfoHolder import builtins class ImportHookManager(ModuleType): def __init__(self, name, system_import): ModuleType.__init__(self, name) self._system_import = system_import self._modules_to_patch = {} def add_module_name(self, module_name, activate_function): self._modules_to_patch[module_name] = activate_function def do_import(self, name, *args, **kwargs): module = self._system_import(name, *args, **kwargs) try: activate_func = self._modules_to_patch.pop(name, None) if activate_func: activate_func() # call activate function except: if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 2: traceback.print_exc() # Restore normal system importer to reduce performance impact # of calling this method every time an import statement is invoked if not self._modules_to_patch: builtins.__import__ = self._system_import return module import_hook_manager = ImportHookManager(__name__ + '.import_hook', builtins.__import__) builtins.__import__ = import_hook_manager.do_import sys.modules[import_hook_manager.__name__] = import_hook_manager
1,322
Python
31.268292
87
0.652799
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_localhost.py
from _pydev_bundle._pydev_saved_modules import socket import sys IS_JYTHON = sys.platform.find('java') != -1 _cache = None def get_localhost(): ''' Should return 127.0.0.1 in ipv4 and ::1 in ipv6 localhost is not used because on windows vista/windows 7, there can be issues where the resolving doesn't work properly and takes a lot of time (had this issue on the pyunit server). Using the IP directly solves the problem. ''' # TODO: Needs better investigation! global _cache if _cache is None: try: for addr_info in socket.getaddrinfo("localhost", 80, 0, 0, socket.SOL_TCP): config = addr_info[4] if config[0] == '127.0.0.1': _cache = '127.0.0.1' return _cache except: # Ok, some versions of Python don't have getaddrinfo or SOL_TCP... Just consider it 127.0.0.1 in this case. _cache = '127.0.0.1' else: _cache = 'localhost' return _cache def get_socket_names(n_sockets, close=False): socket_names = [] sockets = [] for _ in range(n_sockets): if IS_JYTHON: # Although the option which would be pure java *should* work for Jython, the socket being returned is still 0 # (i.e.: it doesn't give the local port bound, only the original port, which was 0). from java.net import ServerSocket sock = ServerSocket(0) socket_name = get_localhost(), sock.getLocalPort() else: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((get_localhost(), 0)) socket_name = sock.getsockname() sockets.append(sock) socket_names.append(socket_name) if close: for s in sockets: s.close() return socket_names def get_socket_name(close=False): return get_socket_names(1, close)[0] if __name__ == '__main__': print(get_socket_name())
2,070
Python
29.455882
121
0.591304
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_is_thread_alive.py
from _pydev_bundle._pydev_saved_modules import threading # Hack for https://www.brainwy.com/tracker/PyDev/363 (i.e.: calling is_alive() can throw AssertionError under some # circumstances). # It is required to debug threads started by start_new_thread in Python 3.4 _temp = threading.Thread() if hasattr(_temp, '_is_stopped'): # Python 3.x has this def is_thread_alive(t): return not t._is_stopped elif hasattr(_temp, '_Thread__stopped'): # Python 2.x has this def is_thread_alive(t): return not t._Thread__stopped else: # Jython wraps a native java thread and thus only obeys the public API. def is_thread_alive(t): return t.is_alive() del _temp
696
Python
28.041665
114
0.688218
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_tipper_common.py
import inspect import re def do_find(f, mod): import linecache if inspect.ismodule(mod): return f, 0, 0 lines = linecache.getlines(f) if inspect.isclass(mod): name = mod.__name__ pat = re.compile(r'^\s*class\s*' + name + r'\b') for i in range(len(lines)): if pat.match(lines[i]): return f, i, 0 return f, 0, 0 if inspect.ismethod(mod): mod = mod.im_func if inspect.isfunction(mod): try: mod = mod.func_code except AttributeError: mod = mod.__code__ # python 3k if inspect.istraceback(mod): mod = mod.tb_frame if inspect.isframe(mod): mod = mod.f_code if inspect.iscode(mod): if not hasattr(mod, 'co_filename'): return None, 0, 0 if not hasattr(mod, 'co_firstlineno'): return mod.co_filename, 0, 0 lnum = mod.co_firstlineno pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)') while lnum > 0: if pat.match(lines[lnum]): break lnum -= 1 return f, lnum, 0 raise RuntimeError('Do not know about: ' + f + ' ' + str(mod))
1,227
Python
22.169811
72
0.509372
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_saved_modules.py
import sys import os def find_in_pythonpath(module_name): # Check all the occurrences where we could match the given module/package in the PYTHONPATH. # # This is a simplistic approach, but probably covers most of the cases we're interested in # (i.e.: this may fail in more elaborate cases of import customization or .zip imports, but # this should be rare in general). found_at = [] parts = module_name.split('.') # split because we need to convert mod.name to mod/name for path in sys.path: target = os.path.join(path, *parts) target_py = target + '.py' if os.path.isdir(target): found_at.append(target) if os.path.exists(target_py): found_at.append(target_py) return found_at class DebuggerInitializationError(Exception): pass class VerifyShadowedImport(object): def __init__(self, import_name): self.import_name = import_name def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if exc_type is not None: if exc_type == DebuggerInitializationError: return False # It's already an error we generated. # We couldn't even import it... found_at = find_in_pythonpath(self.import_name) if len(found_at) <= 1: # It wasn't found anywhere or there was just 1 occurrence. # Let's just return to show the original error. return False # We found more than 1 occurrence of the same module in the PYTHONPATH # (the user module and the standard library module). # Let's notify the user as it seems that the module was shadowed. msg = self._generate_shadowed_import_message(found_at) raise DebuggerInitializationError(msg) def _generate_shadowed_import_message(self, found_at): msg = '''It was not possible to initialize the debugger due to a module name conflict. i.e.: the module "%(import_name)s" could not be imported because it is shadowed by: %(found_at)s Please rename this file/folder so that the original module from the standard library can be imported.''' % { 'import_name': self.import_name, 'found_at': found_at[0]} return msg def check(self, module, expected_attributes): msg = '' for expected_attribute in expected_attributes: try: getattr(module, expected_attribute) except: msg = self._generate_shadowed_import_message([module.__file__]) break if msg: raise DebuggerInitializationError(msg) with VerifyShadowedImport('threading') as verify_shadowed: import threading; verify_shadowed.check(threading, ['Thread', 'settrace', 'setprofile', 'Lock', 'RLock', 'current_thread']) with VerifyShadowedImport('time') as verify_shadowed: import time; verify_shadowed.check(time, ['sleep', 'time', 'mktime']) with VerifyShadowedImport('socket') as verify_shadowed: import socket; verify_shadowed.check(socket, ['socket', 'gethostname', 'getaddrinfo']) with VerifyShadowedImport('select') as verify_shadowed: import select; verify_shadowed.check(select, ['select']) with VerifyShadowedImport('code') as verify_shadowed: import code as _code; verify_shadowed.check(_code, ['compile_command', 'InteractiveInterpreter']) with VerifyShadowedImport('_thread') as verify_shadowed: import _thread as thread; verify_shadowed.check(thread, ['start_new_thread', 'start_new', 'allocate_lock']) with VerifyShadowedImport('queue') as verify_shadowed: import queue as _queue; verify_shadowed.check(_queue, ['Queue', 'LifoQueue', 'Empty', 'Full', 'deque']) with VerifyShadowedImport('xmlrpclib') as verify_shadowed: import xmlrpc.client as xmlrpclib; verify_shadowed.check(xmlrpclib, ['ServerProxy', 'Marshaller', 'Server']) with VerifyShadowedImport('xmlrpc.server') as verify_shadowed: import xmlrpc.server as xmlrpcserver; verify_shadowed.check(xmlrpcserver, ['SimpleXMLRPCServer']) with VerifyShadowedImport('http.server') as verify_shadowed: import http.server as BaseHTTPServer; verify_shadowed.check(BaseHTTPServer, ['BaseHTTPRequestHandler']) # If set, this is a version of the threading.enumerate that doesn't have the patching to remove the pydevd threads. # Note: as it can't be set during execution, don't import the name (import the module and access it through its name). pydevd_saved_threading_enumerate = None
4,573
Python
40.207207
130
0.674393
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_monkey_qt.py
from __future__ import nested_scopes from _pydev_bundle._pydev_saved_modules import threading import os from _pydev_bundle import pydev_log def set_trace_in_qt(): from _pydevd_bundle.pydevd_comm import get_global_debugger py_db = get_global_debugger() if py_db is not None: threading.current_thread() # Create the dummy thread for qt. py_db.enable_tracing() _patched_qt = False def patch_qt(qt_support_mode): ''' This method patches qt (PySide2, PySide, PyQt4, PyQt5) so that we have hooks to set the tracing for QThread. ''' if not qt_support_mode: return if qt_support_mode is True or qt_support_mode == 'True': # do not break backward compatibility qt_support_mode = 'auto' if qt_support_mode == 'auto': qt_support_mode = os.getenv('PYDEVD_PYQT_MODE', 'auto') # Avoid patching more than once global _patched_qt if _patched_qt: return pydev_log.debug('Qt support mode: %s', qt_support_mode) _patched_qt = True if qt_support_mode == 'auto': patch_qt_on_import = None try: import PySide2 # @UnresolvedImport @UnusedImport qt_support_mode = 'pyside2' except: try: import Pyside # @UnresolvedImport @UnusedImport qt_support_mode = 'pyside' except: try: import PyQt5 # @UnresolvedImport @UnusedImport qt_support_mode = 'pyqt5' except: try: import PyQt4 # @UnresolvedImport @UnusedImport qt_support_mode = 'pyqt4' except: return if qt_support_mode == 'pyside2': try: import PySide2.QtCore # @UnresolvedImport _internal_patch_qt(PySide2.QtCore, qt_support_mode) except: return elif qt_support_mode == 'pyside': try: import PySide.QtCore # @UnresolvedImport _internal_patch_qt(PySide.QtCore, qt_support_mode) except: return elif qt_support_mode == 'pyqt5': try: import PyQt5.QtCore # @UnresolvedImport _internal_patch_qt(PyQt5.QtCore) except: return elif qt_support_mode == 'pyqt4': # Ok, we have an issue here: # PyDev-452: Selecting PyQT API version using sip.setapi fails in debug mode # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html # Mostly, if the user uses a different API version (i.e.: v2 instead of v1), # that has to be done before importing PyQt4 modules (PySide/PyQt5 don't have this issue # as they only implements v2). patch_qt_on_import = 'PyQt4' def get_qt_core_module(): import PyQt4.QtCore # @UnresolvedImport return PyQt4.QtCore _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module) else: raise ValueError('Unexpected qt support mode: %s' % (qt_support_mode,)) def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module): # I don't like this approach very much as we have to patch __import__, but I like even less # asking the user to configure something in the client side... # So, our approach is to patch PyQt4 right before the user tries to import it (at which # point he should've set the sip api version properly already anyways). pydev_log.debug('Setting up Qt post-import monkeypatch.') dotted = patch_qt_on_import + '.' original_import = __import__ from _pydev_bundle._pydev_sys_patch import patch_sys_module, patch_reload, cancel_patches_in_sys_module patch_sys_module() patch_reload() def patched_import(name, *args, **kwargs): if patch_qt_on_import == name or name.startswith(dotted): builtins.__import__ = original_import cancel_patches_in_sys_module() _internal_patch_qt(get_qt_core_module()) # Patch it only when the user would import the qt module return original_import(name, *args, **kwargs) import builtins # Py3 builtins.__import__ = patched_import def _internal_patch_qt(QtCore, qt_support_mode='auto'): pydev_log.debug('Patching Qt: %s', QtCore) _original_thread_init = QtCore.QThread.__init__ _original_runnable_init = QtCore.QRunnable.__init__ _original_QThread = QtCore.QThread class FuncWrapper: def __init__(self, original): self._original = original def __call__(self, *args, **kwargs): set_trace_in_qt() return self._original(*args, **kwargs) class StartedSignalWrapper(QtCore.QObject): # Wrapper for the QThread.started signal try: _signal = QtCore.Signal() # @UndefinedVariable except: _signal = QtCore.pyqtSignal() # @UndefinedVariable def __init__(self, thread, original_started): QtCore.QObject.__init__(self) self.thread = thread self.original_started = original_started if qt_support_mode in ('pyside', 'pyside2'): self._signal = original_started else: self._signal.connect(self._on_call) self.original_started.connect(self._signal) def connect(self, func, *args, **kwargs): if qt_support_mode in ('pyside', 'pyside2'): return self._signal.connect(FuncWrapper(func), *args, **kwargs) else: return self._signal.connect(func, *args, **kwargs) def disconnect(self, *args, **kwargs): return self._signal.disconnect(*args, **kwargs) def emit(self, *args, **kwargs): return self._signal.emit(*args, **kwargs) def _on_call(self, *args, **kwargs): set_trace_in_qt() class ThreadWrapper(QtCore.QThread): # Wrapper for QThread def __init__(self, *args, **kwargs): _original_thread_init(self, *args, **kwargs) # In PyQt5 the program hangs when we try to call original run method of QThread class. # So we need to distinguish instances of QThread class and instances of QThread inheritors. if self.__class__.run == _original_QThread.run: self.run = self._exec_run else: self._original_run = self.run self.run = self._new_run self._original_started = self.started self.started = StartedSignalWrapper(self, self.started) def _exec_run(self): set_trace_in_qt() self.exec_() return None def _new_run(self): set_trace_in_qt() return self._original_run() class RunnableWrapper(QtCore.QRunnable): # Wrapper for QRunnable def __init__(self, *args, **kwargs): _original_runnable_init(self, *args, **kwargs) self._original_run = self.run self.run = self._new_run def _new_run(self): set_trace_in_qt() return self._original_run() QtCore.QThread = ThreadWrapper QtCore.QRunnable = RunnableWrapper
7,306
Python
32.672811
112
0.588968
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_log.py
from _pydevd_bundle.pydevd_constants import DebugInfoHolder, SHOW_COMPILE_CYTHON_COMMAND_LINE, NULL, LOG_TIME from contextlib import contextmanager import traceback import os import sys class _LoggingGlobals(object): _warn_once_map = {} _debug_stream_filename = None _debug_stream = sys.stderr _debug_stream_initialized = False def initialize_debug_stream(reinitialize=False): ''' :param bool reinitialize: Reinitialize is used to update the debug stream after a fork (thus, if it wasn't initialized, we don't need to do anything). ''' if reinitialize: if not _LoggingGlobals._debug_stream_initialized: return else: if _LoggingGlobals._debug_stream_initialized: return _LoggingGlobals._debug_stream_initialized = True # Note: we cannot initialize with sys.stderr because when forking we may end up logging things in 'os' calls. _LoggingGlobals._debug_stream = NULL _LoggingGlobals._debug_stream_filename = None if not DebugInfoHolder.PYDEVD_DEBUG_FILE: _LoggingGlobals._debug_stream = sys.stderr else: # Add pid to the filename. try: dirname = os.path.dirname(DebugInfoHolder.PYDEVD_DEBUG_FILE) basename = os.path.basename(DebugInfoHolder.PYDEVD_DEBUG_FILE) try: os.makedirs(dirname) except: pass # Ignore error if it already exists. name, ext = os.path.splitext(basename) debug_file = os.path.join(dirname, name + '.' + str(os.getpid()) + ext) _LoggingGlobals._debug_stream = open(debug_file, 'w') _LoggingGlobals._debug_stream_filename = debug_file except: _LoggingGlobals._debug_stream = sys.stderr # Don't fail when trying to setup logging, just show the exception. traceback.print_exc() def list_log_files(pydevd_debug_file): log_files = [] dirname = os.path.dirname(pydevd_debug_file) basename = os.path.basename(pydevd_debug_file) if os.path.isdir(dirname): name, ext = os.path.splitext(basename) for f in os.listdir(dirname): if f.startswith(name) and f.endswith(ext): log_files.append(os.path.join(dirname, f)) return log_files @contextmanager def log_context(trace_level, stream): ''' To be used to temporarily change the logging settings. ''' original_trace_level = DebugInfoHolder.DEBUG_TRACE_LEVEL original_debug_stream = _LoggingGlobals._debug_stream original_pydevd_debug_file = DebugInfoHolder.PYDEVD_DEBUG_FILE original_debug_stream_filename = _LoggingGlobals._debug_stream_filename original_initialized = _LoggingGlobals._debug_stream_initialized DebugInfoHolder.DEBUG_TRACE_LEVEL = trace_level _LoggingGlobals._debug_stream = stream _LoggingGlobals._debug_stream_initialized = True try: yield finally: DebugInfoHolder.DEBUG_TRACE_LEVEL = original_trace_level _LoggingGlobals._debug_stream = original_debug_stream DebugInfoHolder.PYDEVD_DEBUG_FILE = original_pydevd_debug_file _LoggingGlobals._debug_stream_filename = original_debug_stream_filename _LoggingGlobals._debug_stream_initialized = original_initialized import time _last_log_time = time.time() def _pydevd_log(level, msg, *args): ''' Levels are: 0 most serious warnings/errors (always printed) 1 warnings/significant events 2 informational trace 3 verbose mode ''' if level <= DebugInfoHolder.DEBUG_TRACE_LEVEL: # yes, we can have errors printing if the console of the program has been finished (and we're still trying to print something) try: try: if args: msg = msg % args except: msg = '%s - %s' % (msg, args) if LOG_TIME: global _last_log_time new_log_time = time.time() time_diff = new_log_time - _last_log_time _last_log_time = new_log_time msg = '%.2fs - %s\n' % (time_diff, msg,) else: msg = '%s\n' % (msg,) try: try: initialize_debug_stream() # Do it as late as possible _LoggingGlobals._debug_stream.write(msg) except TypeError: if isinstance(msg, bytes): # Depending on the StringIO flavor, it may only accept unicode. msg = msg.decode('utf-8', 'replace') _LoggingGlobals._debug_stream.write(msg) except UnicodeEncodeError: # When writing to the stream it's possible that the string can't be represented # in the encoding expected (in this case, convert it to the stream encoding # or ascii if we can't find one suitable using a suitable replace). encoding = getattr(_LoggingGlobals._debug_stream, 'encoding', 'ascii') msg = msg.encode(encoding, 'backslashreplace') msg = msg.decode(encoding) _LoggingGlobals._debug_stream.write(msg) _LoggingGlobals._debug_stream.flush() except: pass return True def _pydevd_log_exception(msg='', *args): if msg or args: _pydevd_log(0, msg, *args) try: initialize_debug_stream() # Do it as late as possible traceback.print_exc(file=_LoggingGlobals._debug_stream) _LoggingGlobals._debug_stream.flush() except: raise def verbose(msg, *args): if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3: _pydevd_log(3, msg, *args) def debug(msg, *args): if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 2: _pydevd_log(2, msg, *args) def info(msg, *args): if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1: _pydevd_log(1, msg, *args) warn = info def critical(msg, *args): _pydevd_log(0, msg, *args) def exception(msg='', *args): try: _pydevd_log_exception(msg, *args) except: pass # Should never fail (even at interpreter shutdown). error = exception def error_once(msg, *args): try: if args: message = msg % args else: message = str(msg) except: message = '%s - %s' % (msg, args) if message not in _LoggingGlobals._warn_once_map: _LoggingGlobals._warn_once_map[message] = True critical(message) def exception_once(msg, *args): try: if args: message = msg % args else: message = str(msg) except: message = '%s - %s' % (msg, args) if message not in _LoggingGlobals._warn_once_map: _LoggingGlobals._warn_once_map[message] = True exception(message) def debug_once(msg, *args): if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3: error_once(msg, *args) def show_compile_cython_command_line(): if SHOW_COMPILE_CYTHON_COMMAND_LINE: dirname = os.path.dirname(os.path.dirname(__file__)) error_once("warning: Debugger speedups using cython not found. Run '\"%s\" \"%s\" build_ext --inplace' to build.", sys.executable, os.path.join(dirname, 'setup_pydevd_cython.py'))
7,359
Python
31.139738
134
0.608507
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_versioncheck.py
import sys def versionok_for_gui(): ''' Return True if running Python is suitable for GUI Event Integration and deeper IPython integration ''' # We require Python 2.6+ ... if sys.hexversion < 0x02060000: return False # Or Python 3.2+ if sys.hexversion >= 0x03000000 and sys.hexversion < 0x03020000: return False # Not supported under Jython nor IronPython if sys.platform.startswith("java") or sys.platform.startswith('cli'): return False return True
510
Python
29.058822
110
0.678431
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_completer.py
from collections import namedtuple from string import ascii_letters, digits from _pydevd_bundle import pydevd_xml import pydevconsole import builtins as __builtin__ # Py3 try: import java.lang # @UnusedImport from _pydev_bundle import _pydev_jy_imports_tipper _pydev_imports_tipper = _pydev_jy_imports_tipper except ImportError: IS_JYTHON = False from _pydev_bundle import _pydev_imports_tipper dir2 = _pydev_imports_tipper.generate_imports_tip_for_module #======================================================================================================================= # _StartsWithFilter #======================================================================================================================= class _StartsWithFilter: ''' Used because we can't create a lambda that'll use an outer scope in jython 2.1 ''' def __init__(self, start_with): self.start_with = start_with.lower() def __call__(self, name): return name.lower().startswith(self.start_with) #======================================================================================================================= # Completer # # This class was gotten from IPython.completer (dir2 was replaced with the completer already in pydev) #======================================================================================================================= class Completer: def __init__(self, namespace=None, global_namespace=None): """Create a new completer for the command line. Completer([namespace,global_namespace]) -> completer instance. If unspecified, the default namespace where completions are performed is __main__ (technically, __main__.__dict__). Namespaces should be given as dictionaries. An optional second namespace can be given. This allows the completer to handle cases where both the local and global scopes need to be distinguished. Completer instances should be used as the completion mechanism of readline via the set_completer() call: readline.set_completer(Completer(my_namespace).complete) """ # Don't bind to namespace quite yet, but flag whether the user wants a # specific namespace or to use __main__.__dict__. This will allow us # to bind to __main__.__dict__ at completion time, not now. if namespace is None: self.use_main_ns = 1 else: self.use_main_ns = 0 self.namespace = namespace # The global namespace, if given, can be bound directly if global_namespace is None: self.global_namespace = {} else: self.global_namespace = global_namespace def complete(self, text): """Return the next possible completion for 'text'. This is called successively with state == 0, 1, 2, ... until it returns None. The completion should begin with 'text'. """ if self.use_main_ns: # In pydev this option should never be used raise RuntimeError('Namespace must be provided!') self.namespace = __main__.__dict__ # @UndefinedVariable if "." in text: return self.attr_matches(text) else: return self.global_matches(text) def global_matches(self, text): """Compute matches when text is a simple name. Return a list of all keywords, built-in functions and names currently defined in self.namespace or self.global_namespace that match. """ def get_item(obj, attr): return obj[attr] a = {} for dict_with_comps in [__builtin__.__dict__, self.namespace, self.global_namespace]: # @UndefinedVariable a.update(dict_with_comps) filter = _StartsWithFilter(text) return dir2(a, a.keys(), get_item, filter) def attr_matches(self, text): """Compute matches when text contains a dot. Assuming the text is of the form NAME.NAME....[NAME], and is evaluatable in self.namespace or self.global_namespace, it will be evaluated and its attributes (as revealed by dir()) are used as possible completions. (For class instances, class members are are also considered.) WARNING: this can still invoke arbitrary C code, if an object with a __getattr__ hook is evaluated. """ import re # Another option, seems to work great. Catches things like ''.<tab> m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text) # @UndefinedVariable if not m: return [] expr, attr = m.group(1, 3) try: obj = eval(expr, self.namespace) except: try: obj = eval(expr, self.global_namespace) except: return [] filter = _StartsWithFilter(attr) words = dir2(obj, filter=filter) return words def generate_completions(frame, act_tok): ''' :return list(tuple(method_name, docstring, parameters, completion_type)) method_name: str docstring: str parameters: str -- i.e.: "(a, b)" completion_type is an int See: _pydev_bundle._pydev_imports_tipper for TYPE_ constants ''' if frame is None: return [] # Not using frame.f_globals because of https://sourceforge.net/tracker2/?func=detail&aid=2541355&group_id=85796&atid=577329 # (Names not resolved in generator expression in method) # See message: http://mail.python.org/pipermail/python-list/2009-January/526522.html updated_globals = {} updated_globals.update(frame.f_globals) updated_globals.update(frame.f_locals) # locals later because it has precedence over the actual globals if pydevconsole.IPYTHON: completions = pydevconsole.get_completions(act_tok, act_tok, updated_globals, frame.f_locals) else: completer = Completer(updated_globals, None) # list(tuple(name, descr, parameters, type)) completions = completer.complete(act_tok) return completions def generate_completions_as_xml(frame, act_tok): completions = generate_completions(frame, act_tok) return completions_to_xml(completions) def completions_to_xml(completions): valid_xml = pydevd_xml.make_valid_xml_value quote = pydevd_xml.quote msg = ["<xml>"] for comp in completions: msg.append('<comp p0="') msg.append(valid_xml(quote(comp[0], '/>_= \t'))) msg.append('" p1="') msg.append(valid_xml(quote(comp[1], '/>_= \t'))) msg.append('" p2="') msg.append(valid_xml(quote(comp[2], '/>_= \t'))) msg.append('" p3="') msg.append(valid_xml(quote(comp[3], '/>_= \t'))) msg.append('"/>') msg.append("</xml>") return ''.join(msg) identifier_start = ascii_letters + '_' identifier_part = ascii_letters + '_' + digits identifier_start = set(identifier_start) identifier_part = set(identifier_part) def isidentifier(s): return s.isidentifier() TokenAndQualifier = namedtuple('TokenAndQualifier', 'token, qualifier') def extract_token_and_qualifier(text, line=0, column=0): ''' Extracts the token a qualifier from the text given the line/colum (see test_extract_token_and_qualifier for examples). :param unicode text: :param int line: 0-based :param int column: 0-based ''' # Note: not using the tokenize module because text should be unicode and # line/column refer to the unicode text (otherwise we'd have to know # those ranges after converted to bytes). if line < 0: line = 0 if column < 0: column = 0 if isinstance(text, bytes): text = text.decode('utf-8') lines = text.splitlines() try: text = lines[line] except IndexError: return TokenAndQualifier(u'', u'') if column >= len(text): column = len(text) text = text[:column] token = u'' qualifier = u'' temp_token = [] for i in range(column - 1, -1, -1): c = text[i] if c in identifier_part or isidentifier(c) or c == u'.': temp_token.append(c) else: break temp_token = u''.join(reversed(temp_token)) if u'.' in temp_token: temp_token = temp_token.split(u'.') token = u'.'.join(temp_token[:-1]) qualifier = temp_token[-1] else: qualifier = temp_token return TokenAndQualifier(token, qualifier)
8,544
Python
30.884328
127
0.587196
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_filesystem_encoding.py
import sys def __getfilesystemencoding(): ''' Note: there's a copy of this method in interpreterInfo.py ''' try: ret = sys.getfilesystemencoding() if not ret: raise RuntimeError('Unable to get encoding.') return ret except: try: #Handle Jython from java.lang import System # @UnresolvedImport env = System.getProperty("os.name").lower() if env.find('win') != -1: return 'ISO-8859-1' #mbcs does not work on Jython, so, use a (hopefully) suitable replacement return 'utf-8' except: pass #Only available from 2.3 onwards. if sys.platform == 'win32': return 'mbcs' return 'utf-8' def getfilesystemencoding(): try: ret = __getfilesystemencoding() #Check if the encoding is actually there to be used! if hasattr('', 'encode'): ''.encode(ret) if hasattr('', 'decode'): ''.decode(ret) return ret except: return 'utf-8'
1,095
Python
25.095237
110
0.536073
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_imports_tipper.py
import inspect import os.path import sys from _pydev_bundle._pydev_tipper_common import do_find from _pydevd_bundle.pydevd_utils import hasattr_checked, dir_checked from inspect import getfullargspec def getargspec(*args, **kwargs): arg_spec = getfullargspec(*args, **kwargs) return arg_spec.args, arg_spec.varargs, arg_spec.varkw, arg_spec.defaults, arg_spec.kwonlyargs or [], arg_spec.kwonlydefaults or {} # completion types. TYPE_IMPORT = '0' TYPE_CLASS = '1' TYPE_FUNCTION = '2' TYPE_ATTR = '3' TYPE_BUILTIN = '4' TYPE_PARAM = '5' def _imp(name, log=None): try: return __import__(name) except: if '.' in name: sub = name[0:name.rfind('.')] if log is not None: log.add_content('Unable to import', name, 'trying with', sub) log.add_exception() return _imp(sub, log) else: s = 'Unable to import module: %s - sys.path: %s' % (str(name), sys.path) if log is not None: log.add_content(s) log.add_exception() raise ImportError(s) IS_IPY = False if sys.platform == 'cli': IS_IPY = True _old_imp = _imp def _imp(name, log=None): # We must add a reference in clr for .Net import clr # @UnresolvedImport initial_name = name while '.' in name: try: clr.AddReference(name) break # If it worked, that's OK. except: name = name[0:name.rfind('.')] else: try: clr.AddReference(name) except: pass # That's OK (not dot net module). return _old_imp(initial_name, log) def get_file(mod): f = None try: f = inspect.getsourcefile(mod) or inspect.getfile(mod) except: try: f = getattr(mod, '__file__', None) except: f = None if f and f.lower(f[-4:]) in ['.pyc', '.pyo']: filename = f[:-4] + '.py' if os.path.exists(filename): f = filename return f def Find(name, log=None): f = None mod = _imp(name, log) parent = mod foundAs = '' if inspect.ismodule(mod): f = get_file(mod) components = name.split('.') old_comp = None for comp in components[1:]: try: # this happens in the following case: # we have mx.DateTime.mxDateTime.mxDateTime.pyd # but after importing it, mx.DateTime.mxDateTime shadows access to mxDateTime.pyd mod = getattr(mod, comp) except AttributeError: if old_comp != comp: raise if inspect.ismodule(mod): f = get_file(mod) else: if len(foundAs) > 0: foundAs = foundAs + '.' foundAs = foundAs + comp old_comp = comp return f, mod, parent, foundAs def search_definition(data): '''@return file, line, col ''' data = data.replace('\n', '') if data.endswith('.'): data = data.rstrip('.') f, mod, parent, foundAs = Find(data) try: return do_find(f, mod), foundAs except: return do_find(f, parent), foundAs def generate_tip(data, log=None): data = data.replace('\n', '') if data.endswith('.'): data = data.rstrip('.') f, mod, parent, foundAs = Find(data, log) # print_ >> open('temp.txt', 'w'), f tips = generate_imports_tip_for_module(mod) return f, tips def check_char(c): if c == '-' or c == '.': return '_' return c _SENTINEL = object() def generate_imports_tip_for_module(obj_to_complete, dir_comps=None, getattr=getattr, filter=lambda name:True): ''' @param obj_to_complete: the object from where we should get the completions @param dir_comps: if passed, we should not 'dir' the object and should just iterate those passed as kwonly_arg parameter @param getattr: the way to get kwonly_arg given object from the obj_to_complete (used for the completer) @param filter: kwonly_arg callable that receives the name and decides if it should be appended or not to the results @return: list of tuples, so that each tuple represents kwonly_arg completion with: name, doc, args, type (from the TYPE_* constants) ''' ret = [] if dir_comps is None: dir_comps = dir_checked(obj_to_complete) if hasattr_checked(obj_to_complete, '__dict__'): dir_comps.append('__dict__') if hasattr_checked(obj_to_complete, '__class__'): dir_comps.append('__class__') get_complete_info = True if len(dir_comps) > 1000: # ok, we don't want to let our users wait forever... # no complete info for you... get_complete_info = False dontGetDocsOn = (float, int, str, tuple, list, dict) dontGetattrOn = (dict, list, set, tuple) for d in dir_comps: if d is None: continue if not filter(d): continue args = '' try: try: if isinstance(obj_to_complete, dontGetattrOn): raise Exception('Since python 3.9, e.g. "dict[str]" will return' " a dict that's only supposed to take strings. " 'Interestingly, e.g. dict["val"] is also valid ' 'and presumably represents a dict that only takes ' 'keys that are "val". This breaks our check for ' 'class attributes.') obj = getattr(obj_to_complete.__class__, d) except: obj = getattr(obj_to_complete, d) except: # just ignore and get it without additional info ret.append((d, '', args, TYPE_BUILTIN)) else: if get_complete_info: try: retType = TYPE_BUILTIN # check if we have to get docs getDoc = True for class_ in dontGetDocsOn: if isinstance(obj, class_): getDoc = False break doc = '' if getDoc: # no need to get this info... too many constants are defined and # makes things much slower (passing all that through sockets takes quite some time) try: doc = inspect.getdoc(obj) if doc is None: doc = '' except: # may happen on jython when checking java classes (so, just ignore it) doc = '' if inspect.ismethod(obj) or inspect.isbuiltin(obj) or inspect.isfunction(obj) or inspect.isroutine(obj): try: args, vargs, kwargs, defaults, kwonly_args, kwonly_defaults = getargspec(obj) args = args[:] for kwonly_arg in kwonly_args: default = kwonly_defaults.get(kwonly_arg, _SENTINEL) if default is not _SENTINEL: args.append('%s=%s' % (kwonly_arg, default)) else: args.append(str(kwonly_arg)) args = '(%s)' % (', '.join(args)) except TypeError: # ok, let's see if we can get the arguments from the doc args, doc = signature_from_docstring(doc, getattr(obj, '__name__', None)) retType = TYPE_FUNCTION elif inspect.isclass(obj): retType = TYPE_CLASS elif inspect.ismodule(obj): retType = TYPE_IMPORT else: retType = TYPE_ATTR # add token and doc to return - assure only strings. ret.append((d, doc, args, retType)) except: # just ignore and get it without aditional info ret.append((d, '', args, TYPE_BUILTIN)) else: # get_complete_info == False if inspect.ismethod(obj) or inspect.isbuiltin(obj) or inspect.isfunction(obj) or inspect.isroutine(obj): retType = TYPE_FUNCTION elif inspect.isclass(obj): retType = TYPE_CLASS elif inspect.ismodule(obj): retType = TYPE_IMPORT else: retType = TYPE_ATTR # ok, no complete info, let's try to do this as fast and clean as possible # so, no docs for this kind of information, only the signatures ret.append((d, '', str(args), retType)) return ret def signature_from_docstring(doc, obj_name): args = '()' try: found = False if len(doc) > 0: if IS_IPY: # Handle case where we have the situation below # sort(self, object cmp, object key) # sort(self, object cmp, object key, bool reverse) # sort(self) # sort(self, object cmp) # Or: sort(self: list, cmp: object, key: object) # sort(self: list, cmp: object, key: object, reverse: bool) # sort(self: list) # sort(self: list, cmp: object) if obj_name: name = obj_name + '(' # Fix issue where it was appearing sort(aa)sort(bb)sort(cc) in the same line. lines = doc.splitlines() if len(lines) == 1: c = doc.count(name) if c > 1: doc = ('\n' + name).join(doc.split(name)) major = '' for line in doc.splitlines(): if line.startswith(name) and line.endswith(')'): if len(line) > len(major): major = line if major: args = major[major.index('('):] found = True if not found: i = doc.find('->') if i < 0: i = doc.find('--') if i < 0: i = doc.find('\n') if i < 0: i = doc.find('\r') if i > 0: s = doc[0:i] s = s.strip() # let's see if we have a docstring in the first line if s[-1] == ')': start = s.find('(') if start >= 0: end = s.find('[') if end <= 0: end = s.find(')') if end <= 0: end = len(s) args = s[start:end] if not args[-1] == ')': args = args + ')' # now, get rid of unwanted chars l = len(args) - 1 r = [] for i in range(len(args)): if i == 0 or i == l: r.append(args[i]) else: r.append(check_char(args[i])) args = ''.join(r) if IS_IPY: if args.startswith('(self:'): i = args.find(',') if i >= 0: args = '(self' + args[i:] else: args = '(self)' i = args.find(')') if i > 0: args = args[:i + 1] except: pass return args, doc
12,350
Python
32.024064
135
0.453279
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_imports.py
from _pydev_bundle._pydev_saved_modules import xmlrpclib from _pydev_bundle._pydev_saved_modules import xmlrpcserver SimpleXMLRPCServer = xmlrpcserver.SimpleXMLRPCServer from _pydev_bundle._pydev_execfile import execfile from _pydev_bundle._pydev_saved_modules import _queue from _pydevd_bundle.pydevd_exec2 import Exec from urllib.parse import quote, quote_plus, unquote_plus # @UnresolvedImport
404
Python
27.928569
77
0.814356
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_log.py
import traceback import sys from io import StringIO class Log: def __init__(self): self._contents = [] def add_content(self, *content): self._contents.append(' '.join(content)) def add_exception(self): s = StringIO() exc_info = sys.exc_info() traceback.print_exception(exc_info[0], exc_info[1], exc_info[2], limit=None, file=s) self._contents.append(s.getvalue()) def get_contents(self): return '\n'.join(self._contents) def clear_log(self): del self._contents[:]
555
Python
21.239999
92
0.598198
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_calltip_util.py
''' License: Apache 2.0 Author: Yuli Fitterman ''' import types from _pydevd_bundle.pydevd_constants import IS_JYTHON try: import inspect except: import traceback; traceback.print_exc() # Ok, no inspect available (search will not work) from _pydev_bundle._pydev_imports_tipper import signature_from_docstring def is_bound_method(obj): if isinstance(obj, types.MethodType): return getattr(obj, '__self__', getattr(obj, 'im_self', None)) is not None else: return False def get_class_name(instance): return getattr(getattr(instance, "__class__", None), "__name__", None) def get_bound_class_name(obj): my_self = getattr(obj, '__self__', getattr(obj, 'im_self', None)) if my_self is None: return None return get_class_name(my_self) def get_description(obj): try: ob_call = obj.__call__ except: ob_call = None if isinstance(obj, type) or type(obj).__name__ == 'classobj': fob = getattr(obj, '__init__', lambda: None) if not isinstance(fob, (types.FunctionType, types.MethodType)): fob = obj elif is_bound_method(ob_call): fob = ob_call else: fob = obj argspec = "" fn_name = None fn_class = None if isinstance(fob, (types.FunctionType, types.MethodType)): spec_info = inspect.getfullargspec(fob) argspec = inspect.formatargspec(*spec_info) fn_name = getattr(fob, '__name__', None) if isinstance(obj, type) or type(obj).__name__ == 'classobj': fn_name = "__init__" fn_class = getattr(obj, "__name__", "UnknownClass") elif is_bound_method(obj) or is_bound_method(ob_call): fn_class = get_bound_class_name(obj) or "UnknownClass" else: fn_name = getattr(fob, '__name__', None) fn_self = getattr(fob, '__self__', None) if fn_self is not None and not isinstance(fn_self, types.ModuleType): fn_class = get_class_name(fn_self) doc_string = get_docstring(ob_call) if is_bound_method(ob_call) else get_docstring(obj) return create_method_stub(fn_name, fn_class, argspec, doc_string) def create_method_stub(fn_name, fn_class, argspec, doc_string): if fn_name and argspec: doc_string = "" if doc_string is None else doc_string fn_stub = create_function_stub(fn_name, argspec, doc_string, indent=1 if fn_class else 0) if fn_class: expr = fn_class if fn_name == '__init__' else fn_class + '().' + fn_name return create_class_stub(fn_class, fn_stub) + "\n" + expr else: expr = fn_name return fn_stub + "\n" + expr elif doc_string: if fn_name: restored_signature, _ = signature_from_docstring(doc_string, fn_name) if restored_signature: return create_method_stub(fn_name, fn_class, restored_signature, doc_string) return create_function_stub('unknown', '(*args, **kwargs)', doc_string) + '\nunknown' else: return '' def get_docstring(obj): if obj is not None: try: if IS_JYTHON: # Jython doc = obj.__doc__ if doc is not None: return doc from _pydev_bundle import _pydev_jy_imports_tipper is_method, infos = _pydev_jy_imports_tipper.ismethod(obj) ret = '' if is_method: for info in infos: ret += info.get_as_doc() return ret else: doc = inspect.getdoc(obj) if doc is not None: return doc except: pass else: return '' try: # if no attempt succeeded, try to return repr()... return repr(obj) except: try: # otherwise the class return str(obj.__class__) except: # if all fails, go to an empty string return '' def create_class_stub(class_name, contents): return "class %s(object):\n%s" % (class_name, contents) def create_function_stub(fn_name, fn_argspec, fn_docstring, indent=0): def shift_right(string, prefix): return ''.join(prefix + line for line in string.splitlines(True)) fn_docstring = shift_right(inspect.cleandoc(fn_docstring), " " * (indent + 1)) ret = ''' def %s%s: """%s""" pass ''' % (fn_name, fn_argspec, fn_docstring) ret = ret[1:] # remove first /n ret = ret.replace('\t', " ") if indent: prefix = " " * indent ret = shift_right(ret, prefix) return ret
4,687
Python
29.051282
97
0.56326
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_console_utils.py
import os import sys import traceback from _pydev_bundle.pydev_imports import xmlrpclib, _queue, Exec from _pydev_bundle._pydev_calltip_util import get_description from _pydevd_bundle import pydevd_vars from _pydevd_bundle import pydevd_xml from _pydevd_bundle.pydevd_constants import (IS_JYTHON, NEXT_VALUE_SEPARATOR, get_global_debugger, silence_warnings_decorator) from contextlib import contextmanager from _pydev_bundle import pydev_log from _pydevd_bundle.pydevd_utils import interrupt_main_thread from io import StringIO # ======================================================================================================================= # BaseStdIn # ======================================================================================================================= class BaseStdIn: def __init__(self, original_stdin=sys.stdin, *args, **kwargs): try: self.encoding = sys.stdin.encoding except: # Not sure if it's available in all Python versions... pass self.original_stdin = original_stdin try: self.errors = sys.stdin.errors # Who knew? sys streams have an errors attribute! except: # Not sure if it's available in all Python versions... pass def readline(self, *args, **kwargs): # sys.stderr.write('Cannot readline out of the console evaluation\n') -- don't show anything # This could happen if the user had done input('enter number).<-- upon entering this, that message would appear, # which is not something we want. return '\n' def write(self, *args, **kwargs): pass # not available StdIn (but it can be expected to be in the stream interface) def flush(self, *args, **kwargs): pass # not available StdIn (but it can be expected to be in the stream interface) def read(self, *args, **kwargs): # in the interactive interpreter, a read and a readline are the same. return self.readline() def close(self, *args, **kwargs): pass # expected in StdIn def __iter__(self): # BaseStdIn would not be considered as Iterable in Python 3 without explicit `__iter__` implementation return self.original_stdin.__iter__() def __getattr__(self, item): # it's called if the attribute wasn't found if hasattr(self.original_stdin, item): return getattr(self.original_stdin, item) raise AttributeError("%s has no attribute %s" % (self.original_stdin, item)) # ======================================================================================================================= # StdIn # ======================================================================================================================= class StdIn(BaseStdIn): ''' Object to be added to stdin (to emulate it as non-blocking while the next line arrives) ''' def __init__(self, interpreter, host, client_port, original_stdin=sys.stdin): BaseStdIn.__init__(self, original_stdin) self.interpreter = interpreter self.client_port = client_port self.host = host def readline(self, *args, **kwargs): # Ok, callback into the client to get the new input try: server = xmlrpclib.Server('http://%s:%s' % (self.host, self.client_port)) requested_input = server.RequestInput() if not requested_input: return '\n' # Yes, a readline must return something (otherwise we can get an EOFError on the input() call). else: # readline should end with '\n' (not doing so makes IPython 5 remove the last *valid* character). requested_input += '\n' return requested_input except KeyboardInterrupt: raise # Let KeyboardInterrupt go through -- #PyDev-816: Interrupting infinite loop in the Interactive Console except: return '\n' def close(self, *args, **kwargs): pass # expected in StdIn #======================================================================================================================= # DebugConsoleStdIn #======================================================================================================================= class DebugConsoleStdIn(BaseStdIn): ''' Object to be added to stdin (to emulate it as non-blocking while the next line arrives) ''' def __init__(self, py_db, original_stdin): ''' :param py_db: If None, get_global_debugger() is used. ''' BaseStdIn.__init__(self, original_stdin) self._py_db = py_db self._in_notification = 0 def __send_input_requested_message(self, is_started): try: py_db = self._py_db if py_db is None: py_db = get_global_debugger() if py_db is None: return cmd = py_db.cmd_factory.make_input_requested_message(is_started) py_db.writer.add_command(cmd) except Exception: pydev_log.exception() @contextmanager def notify_input_requested(self): self._in_notification += 1 if self._in_notification == 1: self.__send_input_requested_message(True) try: yield finally: self._in_notification -= 1 if self._in_notification == 0: self.__send_input_requested_message(False) def readline(self, *args, **kwargs): with self.notify_input_requested(): return self.original_stdin.readline(*args, **kwargs) def read(self, *args, **kwargs): with self.notify_input_requested(): return self.original_stdin.read(*args, **kwargs) class CodeFragment: def __init__(self, text, is_single_line=True): self.text = text self.is_single_line = is_single_line def append(self, code_fragment): self.text = self.text + "\n" + code_fragment.text if not code_fragment.is_single_line: self.is_single_line = False # ======================================================================================================================= # BaseInterpreterInterface # ======================================================================================================================= class BaseInterpreterInterface: def __init__(self, mainThread, connect_status_queue=None): self.mainThread = mainThread self.interruptable = False self.exec_queue = _queue.Queue(0) self.buffer = None self.banner_shown = False self.connect_status_queue = connect_status_queue self.mpl_modules_for_patching = {} self.init_mpl_modules_for_patching() def build_banner(self): return 'print({0})\n'.format(repr(self.get_greeting_msg())) def get_greeting_msg(self): return 'PyDev console: starting.\n' def init_mpl_modules_for_patching(self): from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot self.mpl_modules_for_patching = { "matplotlib": lambda: activate_matplotlib(self.enableGui), "matplotlib.pyplot": activate_pyplot, "pylab": activate_pylab } def need_more_for_code(self, source): # PyDev-502: PyDev 3.9 F2 doesn't support backslash continuations # Strangely even the IPython console is_complete said it was complete # even with a continuation char at the end. if source.endswith('\\'): return True if hasattr(self.interpreter, 'is_complete'): return not self.interpreter.is_complete(source) try: # At this point, it should always be single. # If we don't do this, things as: # # for i in range(10): print(i) # # (in a single line) don't work. # Note that it won't give an error and code will be None (so, it'll # use execMultipleLines in the next call in this case). symbol = 'single' code = self.interpreter.compile(source, '<input>', symbol) except (OverflowError, SyntaxError, ValueError): # Case 1 return False if code is None: # Case 2 return True # Case 3 return False def need_more(self, code_fragment): if self.buffer is None: self.buffer = code_fragment else: self.buffer.append(code_fragment) return self.need_more_for_code(self.buffer.text) def create_std_in(self, debugger=None, original_std_in=None): if debugger is None: return StdIn(self, self.host, self.client_port, original_stdin=original_std_in) else: return DebugConsoleStdIn(py_db=debugger, original_stdin=original_std_in) def add_exec(self, code_fragment, debugger=None): # In case sys.excepthook called, use original excepthook #PyDev-877: Debug console freezes with Python 3.5+ # (showtraceback does it on python 3.5 onwards) sys.excepthook = sys.__excepthook__ try: original_in = sys.stdin try: help = None if 'pydoc' in sys.modules: pydoc = sys.modules['pydoc'] # Don't import it if it still is not there. if hasattr(pydoc, 'help'): # You never know how will the API be changed, so, let's code defensively here help = pydoc.help if not hasattr(help, 'input'): help = None except: # Just ignore any error here pass more = False try: sys.stdin = self.create_std_in(debugger, original_in) try: if help is not None: # This will enable the help() function to work. try: try: help.input = sys.stdin except AttributeError: help._input = sys.stdin except: help = None if not self._input_error_printed: self._input_error_printed = True sys.stderr.write('\nError when trying to update pydoc.help.input\n') sys.stderr.write('(help() may not work -- please report this as a bug in the pydev bugtracker).\n\n') traceback.print_exc() try: self.start_exec() if hasattr(self, 'debugger'): self.debugger.enable_tracing() more = self.do_add_exec(code_fragment) if hasattr(self, 'debugger'): self.debugger.disable_tracing() self.finish_exec(more) finally: if help is not None: try: try: help.input = original_in except AttributeError: help._input = original_in except: pass finally: sys.stdin = original_in except SystemExit: raise except: traceback.print_exc() finally: sys.__excepthook__ = sys.excepthook return more def do_add_exec(self, codeFragment): ''' Subclasses should override. @return: more (True if more input is needed to complete the statement and False if the statement is complete). ''' raise NotImplementedError() def get_namespace(self): ''' Subclasses should override. @return: dict with namespace. ''' raise NotImplementedError() def __resolve_reference__(self, text): """ :type text: str """ obj = None if '.' not in text: try: obj = self.get_namespace()[text] except KeyError: pass if obj is None: try: obj = self.get_namespace()['__builtins__'][text] except: pass if obj is None: try: obj = getattr(self.get_namespace()['__builtins__'], text, None) except: pass else: try: last_dot = text.rindex('.') parent_context = text[0:last_dot] res = pydevd_vars.eval_in_context(parent_context, self.get_namespace(), self.get_namespace()) obj = getattr(res, text[last_dot + 1:]) except: pass return obj def getDescription(self, text): try: obj = self.__resolve_reference__(text) if obj is None: return '' return get_description(obj) except: return '' def do_exec_code(self, code, is_single_line): try: code_fragment = CodeFragment(code, is_single_line) more = self.need_more(code_fragment) if not more: code_fragment = self.buffer self.buffer = None self.exec_queue.put(code_fragment) return more except: traceback.print_exc() return False def execLine(self, line): return self.do_exec_code(line, True) def execMultipleLines(self, lines): if IS_JYTHON: more = False for line in lines.split('\n'): more = self.do_exec_code(line, True) return more else: return self.do_exec_code(lines, False) def interrupt(self): self.buffer = None # Also clear the buffer when it's interrupted. try: if self.interruptable: # Fix for #PyDev-500: Console interrupt can't interrupt on sleep interrupt_main_thread(self.mainThread) self.finish_exec(False) return True except: traceback.print_exc() return False def close(self): sys.exit(0) def start_exec(self): self.interruptable = True def get_server(self): if getattr(self, 'host', None) is not None: return xmlrpclib.Server('http://%s:%s' % (self.host, self.client_port)) else: return None server = property(get_server) def ShowConsole(self): server = self.get_server() if server is not None: server.ShowConsole() def finish_exec(self, more): self.interruptable = False server = self.get_server() if server is not None: return server.NotifyFinished(more) else: return True def getFrame(self): xml = StringIO() hidden_ns = self.get_ipython_hidden_vars_dict() xml.write("<xml>") xml.write(pydevd_xml.frame_vars_to_xml(self.get_namespace(), hidden_ns)) xml.write("</xml>") return xml.getvalue() @silence_warnings_decorator def getVariable(self, attributes): xml = StringIO() xml.write("<xml>") val_dict = pydevd_vars.resolve_compound_var_object_fields(self.get_namespace(), attributes) if val_dict is None: val_dict = {} for k, val in val_dict.items(): val = val_dict[k] evaluate_full_value = pydevd_xml.should_evaluate_full_value(val) xml.write(pydevd_vars.var_to_xml(val, k, evaluate_full_value=evaluate_full_value)) xml.write("</xml>") return xml.getvalue() def getArray(self, attr, roffset, coffset, rows, cols, format): name = attr.split("\t")[-1] array = pydevd_vars.eval_in_context(name, self.get_namespace(), self.get_namespace()) return pydevd_vars.table_like_struct_to_xml(array, name, roffset, coffset, rows, cols, format) def evaluate(self, expression): xml = StringIO() xml.write("<xml>") result = pydevd_vars.eval_in_context(expression, self.get_namespace(), self.get_namespace()) xml.write(pydevd_vars.var_to_xml(result, expression)) xml.write("</xml>") return xml.getvalue() @silence_warnings_decorator def loadFullValue(self, seq, scope_attrs): """ Evaluate full value for async Console variables in a separate thread and send results to IDE side :param seq: id of command :param scope_attrs: a sequence of variables with their attributes separated by NEXT_VALUE_SEPARATOR (i.e.: obj\tattr1\tattr2NEXT_VALUE_SEPARATORobj2\attr1\tattr2) :return: """ frame_variables = self.get_namespace() var_objects = [] vars = scope_attrs.split(NEXT_VALUE_SEPARATOR) for var_attrs in vars: if '\t' in var_attrs: name, attrs = var_attrs.split('\t', 1) else: name = var_attrs attrs = None if name in frame_variables: var_object = pydevd_vars.resolve_var_object(frame_variables[name], attrs) var_objects.append((var_object, name)) else: var_object = pydevd_vars.eval_in_context(name, frame_variables, frame_variables) var_objects.append((var_object, name)) from _pydevd_bundle.pydevd_comm import GetValueAsyncThreadConsole py_db = getattr(self, 'debugger', None) if py_db is None: py_db = get_global_debugger() if py_db is None: from pydevd import PyDB py_db = PyDB() t = GetValueAsyncThreadConsole(py_db, self.get_server(), seq, var_objects) t.start() def changeVariable(self, attr, value): def do_change_variable(): Exec('%s=%s' % (attr, value), self.get_namespace(), self.get_namespace()) # Important: it has to be really enabled in the main thread, so, schedule # it to run in the main thread. self.exec_queue.put(do_change_variable) def connectToDebugger(self, debuggerPort, debugger_options=None): ''' Used to show console with variables connection. Mainly, monkey-patches things in the debugger structure so that the debugger protocol works. ''' if debugger_options is None: debugger_options = {} env_key = "PYDEVD_EXTRA_ENVS" if env_key in debugger_options: for (env_name, value) in debugger_options[env_key].items(): existing_value = os.environ.get(env_name, None) if existing_value: os.environ[env_name] = "%s%c%s" % (existing_value, os.path.pathsep, value) else: os.environ[env_name] = value if env_name == "PYTHONPATH": sys.path.append(value) del debugger_options[env_key] def do_connect_to_debugger(): try: # Try to import the packages needed to attach the debugger import pydevd from _pydev_bundle._pydev_saved_modules import threading except: # This happens on Jython embedded in host eclipse traceback.print_exc() sys.stderr.write('pydevd is not available, cannot connect\n') from _pydevd_bundle.pydevd_constants import set_thread_id from _pydev_bundle import pydev_localhost set_thread_id(threading.current_thread(), "console_main") VIRTUAL_FRAME_ID = "1" # matches PyStackFrameConsole.java VIRTUAL_CONSOLE_ID = "console_main" # matches PyThreadConsole.java f = FakeFrame() f.f_back = None f.f_globals = {} # As globals=locals here, let's simply let it empty (and save a bit of network traffic). f.f_locals = self.get_namespace() self.debugger = pydevd.PyDB() self.debugger.add_fake_frame(thread_id=VIRTUAL_CONSOLE_ID, frame_id=VIRTUAL_FRAME_ID, frame=f) try: pydevd.apply_debugger_options(debugger_options) self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort) self.debugger.prepare_to_run() self.debugger.disable_tracing() except: traceback.print_exc() sys.stderr.write('Failed to connect to target debugger.\n') # Register to process commands when idle self.debugrunning = False try: import pydevconsole pydevconsole.set_debug_hook(self.debugger.process_internal_commands) except: traceback.print_exc() sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n') # Important: it has to be really enabled in the main thread, so, schedule # it to run in the main thread. self.exec_queue.put(do_connect_to_debugger) return ('connect complete',) def handshake(self): if self.connect_status_queue is not None: self.connect_status_queue.put(True) return "PyCharm" def get_connect_status_queue(self): return self.connect_status_queue def hello(self, input_str): # Don't care what the input string is return ("Hello eclipse",) def enableGui(self, guiname): ''' Enable the GUI specified in guiname (see inputhook for list). As with IPython, enabling multiple GUIs isn't an error, but only the last one's main loop runs and it may not work ''' def do_enable_gui(): from _pydev_bundle.pydev_versioncheck import versionok_for_gui if versionok_for_gui(): try: from pydev_ipython.inputhook import enable_gui enable_gui(guiname) except: sys.stderr.write("Failed to enable GUI event loop integration for '%s'\n" % guiname) traceback.print_exc() elif guiname not in ['none', '', None]: # Only print a warning if the guiname was going to do something sys.stderr.write("PyDev console: Python version does not support GUI event loop integration for '%s'\n" % guiname) # Return value does not matter, so return back what was sent return guiname # Important: it has to be really enabled in the main thread, so, schedule # it to run in the main thread. self.exec_queue.put(do_enable_gui) def get_ipython_hidden_vars_dict(self): return None # ======================================================================================================================= # FakeFrame # ======================================================================================================================= class FakeFrame: ''' Used to show console with variables connection. A class to be used as a mock of a frame. '''
23,769
Python
36.140625
133
0.531869
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_sys_patch.py
import sys def patch_sys_module(): def patched_exc_info(fun): def pydev_debugger_exc_info(): type, value, traceback = fun() if type == ImportError: # we should not show frame added by plugin_import call if traceback and hasattr(traceback, "tb_next"): return type, value, traceback.tb_next return type, value, traceback return pydev_debugger_exc_info system_exc_info = sys.exc_info sys.exc_info = patched_exc_info(system_exc_info) if not hasattr(sys, "system_exc_info"): sys.system_exc_info = system_exc_info def patched_reload(orig_reload): def pydev_debugger_reload(module): orig_reload(module) if module.__name__ == "sys": # if sys module was reloaded we should patch it again patch_sys_module() return pydev_debugger_reload def patch_reload(): import builtins # Py3 if hasattr(builtins, "reload"): sys.builtin_orig_reload = builtins.reload builtins.reload = patched_reload(sys.builtin_orig_reload) # @UndefinedVariable try: import imp sys.imp_orig_reload = imp.reload imp.reload = patched_reload(sys.imp_orig_reload) # @UndefinedVariable except: pass else: try: import importlib sys.importlib_orig_reload = importlib.reload # @UndefinedVariable importlib.reload = patched_reload(sys.importlib_orig_reload) # @UndefinedVariable except: pass del builtins def cancel_patches_in_sys_module(): sys.exc_info = sys.system_exc_info # @UndefinedVariable import builtins # Py3 if hasattr(sys, "builtin_orig_reload"): builtins.reload = sys.builtin_orig_reload if hasattr(sys, "imp_orig_reload"): import imp imp.reload = sys.imp_orig_reload if hasattr(sys, "importlib_orig_reload"): import importlib importlib.reload = sys.importlib_orig_reload del builtins
2,076
Python
27.067567
94
0.611753
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_jy_imports_tipper.py
import traceback from io import StringIO from java.lang import StringBuffer # @UnresolvedImport from java.lang import String # @UnresolvedImport import java.lang # @UnresolvedImport import sys from _pydev_bundle._pydev_tipper_common import do_find from org.python.core import PyReflectedFunction # @UnresolvedImport from org.python import core # @UnresolvedImport from org.python.core import PyClass # @UnresolvedImport # completion types. TYPE_IMPORT = '0' TYPE_CLASS = '1' TYPE_FUNCTION = '2' TYPE_ATTR = '3' TYPE_BUILTIN = '4' TYPE_PARAM = '5' def _imp(name): try: return __import__(name) except: if '.' in name: sub = name[0:name.rfind('.')] return _imp(sub) else: s = 'Unable to import module: %s - sys.path: %s' % (str(name), sys.path) raise RuntimeError(s) import java.util _java_rt_file = getattr(java.util, '__file__', None) def Find(name): f = None if name.startswith('__builtin__'): if name == '__builtin__.str': name = 'org.python.core.PyString' elif name == '__builtin__.dict': name = 'org.python.core.PyDictionary' mod = _imp(name) parent = mod foundAs = '' try: f = getattr(mod, '__file__', None) except: f = None components = name.split('.') old_comp = None for comp in components[1:]: try: # this happens in the following case: # we have mx.DateTime.mxDateTime.mxDateTime.pyd # but after importing it, mx.DateTime.mxDateTime does shadows access to mxDateTime.pyd mod = getattr(mod, comp) except AttributeError: if old_comp != comp: raise if hasattr(mod, '__file__'): f = mod.__file__ else: if len(foundAs) > 0: foundAs = foundAs + '.' foundAs = foundAs + comp old_comp = comp if f is None and name.startswith('java.lang'): # Hack: java.lang.__file__ is None on Jython 2.7 (whereas it pointed to rt.jar on Jython 2.5). f = _java_rt_file if f is not None: if f.endswith('.pyc'): f = f[:-1] elif f.endswith('$py.class'): f = f[:-len('$py.class')] + '.py' return f, mod, parent, foundAs def format_param_class_name(paramClassName): if paramClassName.startswith('<type \'') and paramClassName.endswith('\'>'): paramClassName = paramClassName[len('<type \''):-2] if paramClassName.startswith('['): if paramClassName == '[C': paramClassName = 'char[]' elif paramClassName == '[B': paramClassName = 'byte[]' elif paramClassName == '[I': paramClassName = 'int[]' elif paramClassName.startswith('[L') and paramClassName.endswith(';'): paramClassName = paramClassName[2:-1] paramClassName += '[]' return paramClassName def generate_tip(data, log=None): data = data.replace('\n', '') if data.endswith('.'): data = data.rstrip('.') f, mod, parent, foundAs = Find(data) tips = generate_imports_tip_for_module(mod) return f, tips #======================================================================================================================= # Info #======================================================================================================================= class Info: def __init__(self, name, **kwargs): self.name = name self.doc = kwargs.get('doc', None) self.args = kwargs.get('args', ()) # tuple of strings self.varargs = kwargs.get('varargs', None) # string self.kwargs = kwargs.get('kwargs', None) # string self.ret = kwargs.get('ret', None) # string def basic_as_str(self): '''@returns this class information as a string (just basic format) ''' args = self.args s = 'function:%s args=%s, varargs=%s, kwargs=%s, docs:%s' % \ (self.name, args, self.varargs, self.kwargs, self.doc) return s def get_as_doc(self): s = str(self.name) if self.doc: s += '\n@doc %s\n' % str(self.doc) if self.args: s += '\n@params ' for arg in self.args: s += str(format_param_class_name(arg)) s += ' ' if self.varargs: s += '\n@varargs ' s += str(self.varargs) if self.kwargs: s += '\n@kwargs ' s += str(self.kwargs) if self.ret: s += '\n@return ' s += str(format_param_class_name(str(self.ret))) return str(s) def isclass(cls): return isinstance(cls, core.PyClass) or type(cls) == java.lang.Class def ismethod(func): '''this function should return the information gathered on a function @param func: this is the function we want to get info on @return a tuple where: 0 = indicates whether the parameter passed is a method or not 1 = a list of classes 'Info', with the info gathered from the function this is a list because when we have methods from java with the same name and different signatures, we actually have many methods, each with its own set of arguments ''' try: if isinstance(func, core.PyFunction): # ok, this is from python, created by jython # print_ ' PyFunction' def getargs(func_code): """Get information about the arguments accepted by a code object. Three things are returned: (args, varargs, varkw), where 'args' is a list of argument names (possibly containing nested lists), and 'varargs' and 'varkw' are the names of the * and ** arguments or None.""" nargs = func_code.co_argcount names = func_code.co_varnames args = list(names[:nargs]) step = 0 if not hasattr(func_code, 'CO_VARARGS'): from org.python.core import CodeFlag # @UnresolvedImport co_varargs_flag = CodeFlag.CO_VARARGS.flag co_varkeywords_flag = CodeFlag.CO_VARKEYWORDS.flag else: co_varargs_flag = func_code.CO_VARARGS co_varkeywords_flag = func_code.CO_VARKEYWORDS varargs = None if func_code.co_flags & co_varargs_flag: varargs = func_code.co_varnames[nargs] nargs = nargs + 1 varkw = None if func_code.co_flags & co_varkeywords_flag: varkw = func_code.co_varnames[nargs] return args, varargs, varkw args = getargs(func.func_code) return 1, [Info(func.func_name, args=args[0], varargs=args[1], kwargs=args[2], doc=func.func_doc)] if isinstance(func, core.PyMethod): # this is something from java itself, and jython just wrapped it... # things to play in func: # ['__call__', '__class__', '__cmp__', '__delattr__', '__dir__', '__doc__', '__findattr__', '__name__', '_doget', 'im_class', # 'im_func', 'im_self', 'toString'] # print_ ' PyMethod' # that's the PyReflectedFunction... keep going to get it func = func.im_func if isinstance(func, PyReflectedFunction): # this is something from java itself, and jython just wrapped it... # print_ ' PyReflectedFunction' infos = [] for i in range(len(func.argslist)): # things to play in func.argslist[i]: # 'PyArgsCall', 'PyArgsKeywordsCall', 'REPLACE', 'StandardCall', 'args', 'compare', 'compareTo', 'data', 'declaringClass' # 'flags', 'isStatic', 'matches', 'precedence'] # print_ ' ', func.argslist[i].data.__class__ # func.argslist[i].data.__class__ == java.lang.reflect.Method if func.argslist[i]: met = func.argslist[i].data name = met.getName() try: ret = met.getReturnType() except AttributeError: ret = '' parameterTypes = met.getParameterTypes() args = [] for j in range(len(parameterTypes)): paramTypesClass = parameterTypes[j] try: try: paramClassName = paramTypesClass.getName() except: paramClassName = paramTypesClass.getName(paramTypesClass) except AttributeError: try: paramClassName = repr(paramTypesClass) # should be something like <type 'object'> paramClassName = paramClassName.split('\'')[1] except: paramClassName = repr(paramTypesClass) # just in case something else happens... it will at least be visible # if the parameter equals [C, it means it it a char array, so, let's change it a = format_param_class_name(paramClassName) # a = a.replace('[]','Array') # a = a.replace('Object', 'obj') # a = a.replace('String', 's') # a = a.replace('Integer', 'i') # a = a.replace('Char', 'c') # a = a.replace('Double', 'd') args.append(a) # so we don't leave invalid code info = Info(name, args=args, ret=ret) # print_ info.basic_as_str() infos.append(info) return 1, infos except Exception: s = StringIO() traceback.print_exc(file=s) return 1, [Info(str('ERROR'), doc=s.getvalue())] return 0, None def ismodule(mod): # java modules... do we have other way to know that? if not hasattr(mod, 'getClass') and not hasattr(mod, '__class__') \ and hasattr(mod, '__name__'): return 1 return isinstance(mod, core.PyModule) def dir_obj(obj): ret = [] found = java.util.HashMap() original = obj if hasattr(obj, '__class__'): if obj.__class__ == java.lang.Class: # get info about superclasses classes = [] classes.append(obj) try: c = obj.getSuperclass() except TypeError: # may happen on jython when getting the java.lang.Class class c = obj.getSuperclass(obj) while c != None: classes.append(c) c = c.getSuperclass() # get info about interfaces interfs = [] for obj in classes: try: interfs.extend(obj.getInterfaces()) except TypeError: interfs.extend(obj.getInterfaces(obj)) classes.extend(interfs) # now is the time when we actually get info on the declared methods and fields for obj in classes: try: declaredMethods = obj.getDeclaredMethods() except TypeError: declaredMethods = obj.getDeclaredMethods(obj) try: declaredFields = obj.getDeclaredFields() except TypeError: declaredFields = obj.getDeclaredFields(obj) for i in range(len(declaredMethods)): name = declaredMethods[i].getName() ret.append(name) found.put(name, 1) for i in range(len(declaredFields)): name = declaredFields[i].getName() ret.append(name) found.put(name, 1) elif isclass(obj.__class__): d = dir(obj.__class__) for name in d: ret.append(name) found.put(name, 1) # this simple dir does not always get all the info, that's why we have the part before # (e.g.: if we do a dir on String, some methods that are from other interfaces such as # charAt don't appear) d = dir(original) for name in d: if found.get(name) != 1: ret.append(name) return ret def format_arg(arg): '''formats an argument to be shown ''' s = str(arg) dot = s.rfind('.') if dot >= 0: s = s[dot + 1:] s = s.replace(';', '') s = s.replace('[]', 'Array') if len(s) > 0: c = s[0].lower() s = c + s[1:] return s def search_definition(data): '''@return file, line, col ''' data = data.replace('\n', '') if data.endswith('.'): data = data.rstrip('.') f, mod, parent, foundAs = Find(data) try: return do_find(f, mod), foundAs except: return do_find(f, parent), foundAs def generate_imports_tip_for_module(obj_to_complete, dir_comps=None, getattr=getattr, filter=lambda name:True): ''' @param obj_to_complete: the object from where we should get the completions @param dir_comps: if passed, we should not 'dir' the object and should just iterate those passed as a parameter @param getattr: the way to get a given object from the obj_to_complete (used for the completer) @param filter: a callable that receives the name and decides if it should be appended or not to the results @return: list of tuples, so that each tuple represents a completion with: name, doc, args, type (from the TYPE_* constants) ''' ret = [] if dir_comps is None: dir_comps = dir_obj(obj_to_complete) for d in dir_comps: if d is None: continue if not filter(d): continue args = '' doc = '' retType = TYPE_BUILTIN try: obj = getattr(obj_to_complete, d) except (AttributeError, java.lang.NoClassDefFoundError): # jython has a bug in its custom classloader that prevents some things from working correctly, so, let's see if # we can fix that... (maybe fixing it in jython itself would be a better idea, as this is clearly a bug) # for that we need a custom classloader... we have references from it in the below places: # # http://mindprod.com/jgloss/classloader.html # http://www.javaworld.com/javaworld/jw-03-2000/jw-03-classload-p2.html # http://freshmeat.net/articles/view/1643/ # # note: this only happens when we add things to the sys.path at runtime, if they are added to the classpath # before the run, everything goes fine. # # The code below ilustrates what I mean... # # import sys # sys.path.insert(1, r"C:\bin\eclipse310\plugins\org.junit_3.8.1\junit.jar" ) # # import junit.framework # print_ dir(junit.framework) #shows the TestCase class here # # import junit.framework.TestCase # # raises the error: # Traceback (innermost last): # File "<console>", line 1, in ? # ImportError: No module named TestCase # # whereas if we had added the jar to the classpath before, everything would be fine by now... ret.append((d, '', '', retType)) # that's ok, private things cannot be gotten... continue else: isMet = ismethod(obj) if isMet[0] and isMet[1]: info = isMet[1][0] try: args, vargs, kwargs = info.args, info.varargs, info.kwargs doc = info.get_as_doc() r = '' for a in (args): if len(r) > 0: r += ', ' r += format_arg(a) args = '(%s)' % (r) except TypeError: traceback.print_exc() args = '()' retType = TYPE_FUNCTION elif isclass(obj): retType = TYPE_CLASS elif ismodule(obj): retType = TYPE_IMPORT # add token and doc to return - assure only strings. ret.append((d, doc, args, retType)) return ret if __name__ == "__main__": sys.path.append(r'D:\dev_programs\eclipse_3\310\eclipse\plugins\org.junit_3.8.1\junit.jar') sys.stdout.write('%s\n' % Find('junit.framework.TestCase'))
17,063
Python
33.612576
140
0.515033
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_execfile.py
# We must redefine it in Py3k if it's not already there def execfile(file, glob=None, loc=None): if glob is None: import sys glob = sys._getframe().f_back.f_globals if loc is None: loc = glob import tokenize with tokenize.open(file) as stream: contents = stream.read() # execute the script (note: it's important to compile first to have the filename set in debug mode) exec(compile(contents + "\n", file, 'exec'), glob, loc)
483
Python
31.266665
103
0.643892
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_monkey.py
# License: EPL import os import re import sys from _pydev_bundle._pydev_saved_modules import threading from _pydevd_bundle.pydevd_constants import get_global_debugger, IS_WINDOWS, IS_JYTHON, get_current_thread_id, \ sorted_dict_repr from _pydev_bundle import pydev_log from contextlib import contextmanager from _pydevd_bundle import pydevd_constants from _pydevd_bundle.pydevd_defaults import PydevdCustomization import ast try: from pathlib import Path except ImportError: Path = None #=============================================================================== # Things that are dependent on having the pydevd debugger #=============================================================================== pydev_src_dir = os.path.dirname(os.path.dirname(__file__)) _arg_patch = threading.local() @contextmanager def skip_subprocess_arg_patch(): _arg_patch.apply_arg_patching = False try: yield finally: _arg_patch.apply_arg_patching = True def _get_apply_arg_patching(): return getattr(_arg_patch, 'apply_arg_patching', True) def _get_setup_updated_with_protocol_and_ppid(setup, is_exec=False): if setup is None: setup = {} setup = setup.copy() # Discard anything related to the protocol (we'll set the the protocol based on the one # currently set). setup.pop(pydevd_constants.ARGUMENT_HTTP_JSON_PROTOCOL, None) setup.pop(pydevd_constants.ARGUMENT_JSON_PROTOCOL, None) setup.pop(pydevd_constants.ARGUMENT_QUOTED_LINE_PROTOCOL, None) if not is_exec: # i.e.: The ppid for the subprocess is the current pid. # If it's an exec, keep it what it was. setup[pydevd_constants.ARGUMENT_PPID] = os.getpid() protocol = pydevd_constants.get_protocol() if protocol == pydevd_constants.HTTP_JSON_PROTOCOL: setup[pydevd_constants.ARGUMENT_HTTP_JSON_PROTOCOL] = True elif protocol == pydevd_constants.JSON_PROTOCOL: setup[pydevd_constants.ARGUMENT_JSON_PROTOCOL] = True elif protocol == pydevd_constants.QUOTED_LINE_PROTOCOL: setup[pydevd_constants.ARGUMENT_QUOTED_LINE_PROTOCOL] = True elif protocol == pydevd_constants.HTTP_PROTOCOL: setup[pydevd_constants.ARGUMENT_HTTP_PROTOCOL] = True else: pydev_log.debug('Unexpected protocol: %s', protocol) return setup class _LastFutureImportFinder(ast.NodeVisitor): def __init__(self): self.last_future_import_found = None def visit_ImportFrom(self, node): if node.module == '__future__': self.last_future_import_found = node def _get_offset_from_line_col(code, line, col): offset = 0 for i, line_contents in enumerate(code.splitlines(True)): if i == line: offset += col return offset else: offset += len(line_contents) return -1 def _separate_future_imports(code): ''' :param code: The code from where we want to get the __future__ imports (note that it's possible that there's no such entry). :return tuple(str, str): The return is a tuple(future_import, code). If the future import is not available a return such as ('', code) is given, otherwise, the future import will end with a ';' (so that it can be put right before the pydevd attach code). ''' try: node = ast.parse(code, '<string>', 'exec') visitor = _LastFutureImportFinder() visitor.visit(node) if visitor.last_future_import_found is None: return '', code node = visitor.last_future_import_found offset = -1 if hasattr(node, 'end_lineno') and hasattr(node, 'end_col_offset'): # Python 3.8 onwards has these (so, use when possible). line, col = node.end_lineno, node.end_col_offset offset = _get_offset_from_line_col(code, line - 1, col) # ast lines are 1-based, make it 0-based. else: # end line/col not available, let's just find the offset and then search # for the alias from there. line, col = node.lineno, node.col_offset offset = _get_offset_from_line_col(code, line - 1, col) # ast lines are 1-based, make it 0-based. if offset >= 0 and node.names: from_future_import_name = node.names[-1].name i = code.find(from_future_import_name, offset) if i < 0: offset = -1 else: offset = i + len(from_future_import_name) if offset >= 0: for i in range(offset, len(code)): if code[i] in (' ', '\t', ';', ')', '\n'): offset += 1 else: break future_import = code[:offset] code_remainder = code[offset:] # Now, put '\n' lines back into the code remainder (we had to search for # `\n)`, but in case we just got the `\n`, it should be at the remainder, # not at the future import. while future_import.endswith('\n'): future_import = future_import[:-1] code_remainder = '\n' + code_remainder if not future_import.endswith(';'): future_import += ';' return future_import, code_remainder # This shouldn't happen... pydev_log.info('Unable to find line %s in code:\n%r', line, code) return '', code except: pydev_log.exception('Error getting from __future__ imports from: %r', code) return '', code def _get_python_c_args(host, port, code, args, setup): setup = _get_setup_updated_with_protocol_and_ppid(setup) # i.e.: We want to make the repr sorted so that it works in tests. setup_repr = setup if setup is None else (sorted_dict_repr(setup)) future_imports = '' if '__future__' in code: # If the code has a __future__ import, we need to be able to strip the __future__ # imports from the code and add them to the start of our code snippet. future_imports, code = _separate_future_imports(code) return ("%simport sys; sys.path.insert(0, r'%s'); import pydevd; pydevd.PydevdCustomization.DEFAULT_PROTOCOL=%r; " "pydevd.settrace(host=%r, port=%s, suspend=False, trace_only_current_thread=False, patch_multiprocessing=True, access_token=%r, client_access_token=%r, __setup_holder__=%s); " "%s" ) % ( future_imports, pydev_src_dir, pydevd_constants.get_protocol(), host, port, setup.get('access-token'), setup.get('client-access-token'), setup_repr, code) def _get_host_port(): import pydevd host, port = pydevd.dispatch() return host, port def _is_managed_arg(arg): pydevd_py = _get_str_type_compatible(arg, 'pydevd.py') if arg.endswith(pydevd_py): return True return False def _on_forked_process(setup_tracing=True): pydevd_constants.after_fork() pydev_log.initialize_debug_stream(reinitialize=True) if setup_tracing: pydev_log.debug('pydevd on forked process: %s', os.getpid()) import pydevd pydevd.threadingCurrentThread().__pydevd_main_thread = True pydevd.settrace_forked(setup_tracing=setup_tracing) def _on_set_trace_for_new_thread(global_debugger): if global_debugger is not None: global_debugger.enable_tracing() def _get_str_type_compatible(s, args): ''' This method converts `args` to byte/unicode based on the `s' type. ''' if isinstance(args, (list, tuple)): ret = [] for arg in args: if type(s) == type(arg): ret.append(arg) else: if isinstance(s, bytes): ret.append(arg.encode('utf-8')) else: ret.append(arg.decode('utf-8')) return ret else: if type(s) == type(args): return args else: if isinstance(s, bytes): return args.encode('utf-8') else: return args.decode('utf-8') #=============================================================================== # Things related to monkey-patching #=============================================================================== def is_python(path): single_quote, double_quote = _get_str_type_compatible(path, ["'", '"']) if path.endswith(single_quote) or path.endswith(double_quote): path = path[1:len(path) - 1] filename = os.path.basename(path).lower() for name in _get_str_type_compatible(filename, ['python', 'jython', 'pypy']): if filename.find(name) != -1: return True return False class InvalidTypeInArgsException(Exception): pass def remove_quotes_from_args(args): if sys.platform == "win32": new_args = [] for x in args: if Path is not None and isinstance(x, Path): x = str(x) else: if not isinstance(x, (bytes, str)): raise InvalidTypeInArgsException(str(type(x))) double_quote, two_double_quotes = _get_str_type_compatible(x, ['"', '""']) if x != two_double_quotes: if len(x) > 1 and x.startswith(double_quote) and x.endswith(double_quote): x = x[1:-1] new_args.append(x) return new_args else: new_args = [] for x in args: if Path is not None and isinstance(x, Path): x = x.as_posix() else: if not isinstance(x, (bytes, str)): raise InvalidTypeInArgsException(str(type(x))) new_args.append(x) return new_args def quote_arg_win32(arg): fix_type = lambda x: _get_str_type_compatible(arg, x) # See if we need to quote at all - empty strings need quoting, as do strings # with whitespace or quotes in them. Backslashes do not need quoting. if arg and not set(arg).intersection(fix_type(' "\t\n\v')): return arg # Per https://docs.microsoft.com/en-us/windows/desktop/api/shellapi/nf-shellapi-commandlinetoargvw, # the standard way to interpret arguments in double quotes is as follows: # # 2N backslashes followed by a quotation mark produce N backslashes followed by # begin/end quote. This does not become part of the parsed argument, but toggles # the "in quotes" mode. # # 2N+1 backslashes followed by a quotation mark again produce N backslashes followed # by a quotation mark literal ("). This does not toggle the "in quotes" mode. # # N backslashes not followed by a quotation mark simply produce N backslashes. # # This code needs to do the reverse transformation, thus: # # N backslashes followed by " produce 2N+1 backslashes followed by " # # N backslashes at the end (i.e. where the closing " goes) produce 2N backslashes. # # N backslashes in any other position remain as is. arg = re.sub(fix_type(r'(\\*)\"'), fix_type(r'\1\1\\"'), arg) arg = re.sub(fix_type(r'(\\*)$'), fix_type(r'\1\1'), arg) return fix_type('"') + arg + fix_type('"') def quote_args(args): if sys.platform == "win32": return list(map(quote_arg_win32, args)) else: return args def patch_args(args, is_exec=False): ''' :param list args: Arguments to patch. :param bool is_exec: If it's an exec, the current process will be replaced (this means we have to keep the same ppid). ''' try: pydev_log.debug("Patching args: %s", args) original_args = args try: unquoted_args = remove_quotes_from_args(args) except InvalidTypeInArgsException as e: pydev_log.info('Unable to monkey-patch subprocess arguments because a type found in the args is invalid: %s', e) return original_args # Internally we should reference original_args (if we want to return them) or unquoted_args # to add to the list which will be then quoted in the end. del args from pydevd import SetupHolder if not unquoted_args: return original_args if not is_python(unquoted_args[0]): pydev_log.debug("Process is not python, returning.") return original_args # Note: we create a copy as string to help with analyzing the arguments, but # the final list should have items from the unquoted_args as they were initially. args_as_str = _get_str_type_compatible('', unquoted_args) params_with_value_in_separate_arg = ( '--check-hash-based-pycs', '--jit' # pypy option ) # All short switches may be combined together. The ones below require a value and the # value itself may be embedded in the arg. # # i.e.: Python accepts things as: # # python -OQold -qmtest # # Which is the same as: # # python -O -Q old -q -m test # # or even: # # python -OQold "-vcimport sys;print(sys)" # # Which is the same as: # # python -O -Q old -v -c "import sys;print(sys)" params_with_combinable_arg = set(('W', 'X', 'Q', 'c', 'm')) module_name = None before_module_flag = '' module_name_i_start = -1 module_name_i_end = -1 code = None code_i = -1 code_i_end = -1 code_flag = '' filename = None filename_i = -1 ignore_next = True # start ignoring the first (the first entry is the python executable) for i, arg_as_str in enumerate(args_as_str): if ignore_next: ignore_next = False continue if arg_as_str.startswith('-'): if arg_as_str == '-': # Contents will be read from the stdin. This is not currently handled. pydev_log.debug('Unable to fix arguments to attach debugger on subprocess when reading from stdin ("python ... -").') return original_args if arg_as_str.startswith(params_with_value_in_separate_arg): if arg_as_str in params_with_value_in_separate_arg: ignore_next = True continue break_out = False for j, c in enumerate(arg_as_str): # i.e.: Python supports -X faulthandler as well as -Xfaulthandler # (in one case we have to ignore the next and in the other we don't # have to ignore it). if c in params_with_combinable_arg: remainder = arg_as_str[j + 1:] if not remainder: ignore_next = True if c == 'm': # i.e.: Something as # python -qm test # python -m test # python -qmtest before_module_flag = arg_as_str[:j] # before_module_flag would then be "-q" if before_module_flag == '-': before_module_flag = '' module_name_i_start = i if not remainder: module_name = unquoted_args[i + 1] module_name_i_end = i + 1 else: # i.e.: python -qmtest should provide 'test' as the module_name module_name = unquoted_args[i][j + 1:] module_name_i_end = module_name_i_start break_out = True break elif c == 'c': # i.e.: Something as # python -qc "import sys" # python -c "import sys" # python "-qcimport sys" code_flag = arg_as_str[:j + 1] # code_flag would then be "-qc" if not remainder: # arg_as_str is something as "-qc", "import sys" code = unquoted_args[i + 1] code_i_end = i + 2 else: # if arg_as_str is something as "-qcimport sys" code = remainder # code would be "import sys" code_i_end = i + 1 code_i = i break_out = True break else: break if break_out: break else: # It doesn't start with '-' and we didn't ignore this entry: # this means that this is the file to be executed. filename = unquoted_args[i] # Note that the filename is not validated here. # There are cases where even a .exe is valid (xonsh.exe): # https://github.com/microsoft/debugpy/issues/945 # So, we should support whatever runpy.run_path # supports in this case. filename_i = i if _is_managed_arg(filename): # no need to add pydevd twice pydev_log.debug('Skipped monkey-patching as pydevd.py is in args already.') return original_args break else: # We didn't find the filename (something is unexpected). pydev_log.debug('Unable to fix arguments to attach debugger on subprocess (filename not found).') return original_args if code_i != -1: host, port = _get_host_port() if port is not None: new_args = [] new_args.extend(unquoted_args[:code_i]) new_args.append(code_flag) new_args.append(_get_python_c_args(host, port, code, unquoted_args, SetupHolder.setup)) new_args.extend(unquoted_args[code_i_end:]) return quote_args(new_args) first_non_vm_index = max(filename_i, module_name_i_start) if first_non_vm_index == -1: pydev_log.debug('Unable to fix arguments to attach debugger on subprocess (could not resolve filename nor module name).') return original_args # Original args should be something as: # ['X:\\pysrc\\pydevd.py', '--multiprocess', '--print-in-debugger-startup', # '--vm_type', 'python', '--client', '127.0.0.1', '--port', '56352', '--file', 'x:\\snippet1.py'] from _pydevd_bundle.pydevd_command_line_handling import setup_to_argv new_args = [] new_args.extend(unquoted_args[:first_non_vm_index]) if before_module_flag: new_args.append(before_module_flag) add_module_at = len(new_args) + 1 new_args.extend(setup_to_argv( _get_setup_updated_with_protocol_and_ppid(SetupHolder.setup, is_exec=is_exec), skip_names=set(('module', 'cmd-line')) )) new_args.append('--file') if module_name is not None: assert module_name_i_start != -1 assert module_name_i_end != -1 # Always after 'pydevd' (i.e.: pydevd "--module" --multiprocess ...) new_args.insert(add_module_at, '--module') new_args.append(module_name) new_args.extend(unquoted_args[module_name_i_end + 1:]) elif filename is not None: assert filename_i != -1 new_args.append(filename) new_args.extend(unquoted_args[filename_i + 1:]) else: raise AssertionError('Internal error (unexpected condition)') return quote_args(new_args) except: pydev_log.exception('Error patching args (debugger not attached to subprocess).') return original_args def str_to_args_windows(args): # See https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments. # # Implemetation ported from DebugPlugin.parseArgumentsWindows: # https://github.com/eclipse/eclipse.platform.debug/blob/master/org.eclipse.debug.core/core/org/eclipse/debug/core/DebugPlugin.java result = [] DEFAULT = 0 ARG = 1 IN_DOUBLE_QUOTE = 2 state = DEFAULT backslashes = 0 buf = '' args_len = len(args) for i in range(args_len): ch = args[i] if (ch == '\\'): backslashes += 1 continue elif (backslashes != 0): if ch == '"': while backslashes >= 2: backslashes -= 2 buf += '\\' if (backslashes == 1): if (state == DEFAULT): state = ARG buf += '"' backslashes = 0 continue # else fall through to switch else: # false alarm, treat passed backslashes literally... if (state == DEFAULT): state = ARG while backslashes > 0: backslashes -= 1 buf += '\\' # fall through to switch if ch in (' ', '\t'): if (state == DEFAULT): # skip continue elif (state == ARG): state = DEFAULT result.append(buf) buf = '' continue if state in (DEFAULT, ARG): if ch == '"': state = IN_DOUBLE_QUOTE else: state = ARG buf += ch elif state == IN_DOUBLE_QUOTE: if ch == '"': if (i + 1 < args_len and args[i + 1] == '"'): # Undocumented feature in Windows: # Two consecutive double quotes inside a double-quoted argument are interpreted as # a single double quote. buf += '"' i += 1 else: state = ARG else: buf += ch else: raise RuntimeError('Illegal condition') if len(buf) > 0 or state != DEFAULT: result.append(buf) return result def patch_arg_str_win(arg_str): args = str_to_args_windows(arg_str) # Fix https://youtrack.jetbrains.com/issue/PY-9767 (args may be empty) if not args or not is_python(args[0]): return arg_str arg_str = ' '.join(patch_args(args)) pydev_log.debug("New args: %s", arg_str) return arg_str def monkey_patch_module(module, funcname, create_func): if hasattr(module, funcname): original_name = 'original_' + funcname if not hasattr(module, original_name): setattr(module, original_name, getattr(module, funcname)) setattr(module, funcname, create_func(original_name)) def monkey_patch_os(funcname, create_func): monkey_patch_module(os, funcname, create_func) def warn_multiproc(): pass # TODO: Provide logging as messages to the IDE. # pydev_log.error_once( # "pydev debugger: New process is launching (breakpoints won't work in the new process).\n" # "pydev debugger: To debug that process please enable 'Attach to subprocess automatically while debugging?' option in the debugger settings.\n") # def create_warn_multiproc(original_name): def new_warn_multiproc(*args, **kwargs): import os warn_multiproc() return getattr(os, original_name)(*args, **kwargs) return new_warn_multiproc def create_execl(original_name): def new_execl(path, *args): """ os.execl(path, arg0, arg1, ...) os.execle(path, arg0, arg1, ..., env) os.execlp(file, arg0, arg1, ...) os.execlpe(file, arg0, arg1, ..., env) """ if _get_apply_arg_patching(): args = patch_args(args, is_exec=True) send_process_created_message() send_process_about_to_be_replaced() return getattr(os, original_name)(path, *args) return new_execl def create_execv(original_name): def new_execv(path, args): """ os.execv(path, args) os.execvp(file, args) """ if _get_apply_arg_patching(): args = patch_args(args, is_exec=True) send_process_created_message() send_process_about_to_be_replaced() return getattr(os, original_name)(path, args) return new_execv def create_execve(original_name): """ os.execve(path, args, env) os.execvpe(file, args, env) """ def new_execve(path, args, env): if _get_apply_arg_patching(): args = patch_args(args, is_exec=True) send_process_created_message() send_process_about_to_be_replaced() return getattr(os, original_name)(path, args, env) return new_execve def create_spawnl(original_name): def new_spawnl(mode, path, *args): """ os.spawnl(mode, path, arg0, arg1, ...) os.spawnlp(mode, file, arg0, arg1, ...) """ if _get_apply_arg_patching(): args = patch_args(args) send_process_created_message() return getattr(os, original_name)(mode, path, *args) return new_spawnl def create_spawnv(original_name): def new_spawnv(mode, path, args): """ os.spawnv(mode, path, args) os.spawnvp(mode, file, args) """ if _get_apply_arg_patching(): args = patch_args(args) send_process_created_message() return getattr(os, original_name)(mode, path, args) return new_spawnv def create_spawnve(original_name): """ os.spawnve(mode, path, args, env) os.spawnvpe(mode, file, args, env) """ def new_spawnve(mode, path, args, env): if _get_apply_arg_patching(): args = patch_args(args) send_process_created_message() return getattr(os, original_name)(mode, path, args, env) return new_spawnve def create_posix_spawn(original_name): """ os.posix_spawn(executable, args, env, **kwargs) """ def new_posix_spawn(executable, args, env, **kwargs): if _get_apply_arg_patching(): args = patch_args(args) send_process_created_message() return getattr(os, original_name)(executable, args, env, **kwargs) return new_posix_spawn def create_fork_exec(original_name): """ _posixsubprocess.fork_exec(args, executable_list, close_fds, ... (13 more)) """ def new_fork_exec(args, *other_args): import _posixsubprocess # @UnresolvedImport if _get_apply_arg_patching(): args = patch_args(args) send_process_created_message() return getattr(_posixsubprocess, original_name)(args, *other_args) return new_fork_exec def create_warn_fork_exec(original_name): """ _posixsubprocess.fork_exec(args, executable_list, close_fds, ... (13 more)) """ def new_warn_fork_exec(*args): try: import _posixsubprocess warn_multiproc() return getattr(_posixsubprocess, original_name)(*args) except: pass return new_warn_fork_exec def create_CreateProcess(original_name): """ CreateProcess(*args, **kwargs) """ def new_CreateProcess(app_name, cmd_line, *args): try: import _subprocess except ImportError: import _winapi as _subprocess if _get_apply_arg_patching(): cmd_line = patch_arg_str_win(cmd_line) send_process_created_message() return getattr(_subprocess, original_name)(app_name, cmd_line, *args) return new_CreateProcess def create_CreateProcessWarnMultiproc(original_name): """ CreateProcess(*args, **kwargs) """ def new_CreateProcess(*args): try: import _subprocess except ImportError: import _winapi as _subprocess warn_multiproc() return getattr(_subprocess, original_name)(*args) return new_CreateProcess def create_fork(original_name): def new_fork(): # A simple fork will result in a new python process is_new_python_process = True frame = sys._getframe() apply_arg_patch = _get_apply_arg_patching() is_subprocess_fork = False while frame is not None: if frame.f_code.co_name == '_execute_child' and 'subprocess' in frame.f_code.co_filename: is_subprocess_fork = True # If we're actually in subprocess.Popen creating a child, it may # result in something which is not a Python process, (so, we # don't want to connect with it in the forked version). executable = frame.f_locals.get('executable') if executable is not None: is_new_python_process = False if is_python(executable): is_new_python_process = True break frame = frame.f_back frame = None # Just make sure we don't hold on to it. protocol = pydevd_constants.get_protocol() child_process = getattr(os, original_name)() # fork if not child_process: if is_new_python_process: PydevdCustomization.DEFAULT_PROTOCOL = protocol _on_forked_process(setup_tracing=apply_arg_patch and not is_subprocess_fork) else: if is_new_python_process: send_process_created_message() return child_process return new_fork def send_process_created_message(): py_db = get_global_debugger() if py_db is not None: py_db.send_process_created_message() def send_process_about_to_be_replaced(): py_db = get_global_debugger() if py_db is not None: py_db.send_process_about_to_be_replaced() def patch_new_process_functions(): # os.execl(path, arg0, arg1, ...) # os.execle(path, arg0, arg1, ..., env) # os.execlp(file, arg0, arg1, ...) # os.execlpe(file, arg0, arg1, ..., env) # os.execv(path, args) # os.execve(path, args, env) # os.execvp(file, args) # os.execvpe(file, args, env) monkey_patch_os('execl', create_execl) monkey_patch_os('execle', create_execl) monkey_patch_os('execlp', create_execl) monkey_patch_os('execlpe', create_execl) monkey_patch_os('execv', create_execv) monkey_patch_os('execve', create_execve) monkey_patch_os('execvp', create_execv) monkey_patch_os('execvpe', create_execve) # os.spawnl(mode, path, ...) # os.spawnle(mode, path, ..., env) # os.spawnlp(mode, file, ...) # os.spawnlpe(mode, file, ..., env) # os.spawnv(mode, path, args) # os.spawnve(mode, path, args, env) # os.spawnvp(mode, file, args) # os.spawnvpe(mode, file, args, env) monkey_patch_os('spawnl', create_spawnl) monkey_patch_os('spawnle', create_spawnl) monkey_patch_os('spawnlp', create_spawnl) monkey_patch_os('spawnlpe', create_spawnl) monkey_patch_os('spawnv', create_spawnv) monkey_patch_os('spawnve', create_spawnve) monkey_patch_os('spawnvp', create_spawnv) monkey_patch_os('spawnvpe', create_spawnve) monkey_patch_os('posix_spawn', create_posix_spawn) if not IS_JYTHON: if not IS_WINDOWS: monkey_patch_os('fork', create_fork) try: import _posixsubprocess monkey_patch_module(_posixsubprocess, 'fork_exec', create_fork_exec) except ImportError: pass else: # Windows try: import _subprocess except ImportError: import _winapi as _subprocess monkey_patch_module(_subprocess, 'CreateProcess', create_CreateProcess) def patch_new_process_functions_with_warning(): monkey_patch_os('execl', create_warn_multiproc) monkey_patch_os('execle', create_warn_multiproc) monkey_patch_os('execlp', create_warn_multiproc) monkey_patch_os('execlpe', create_warn_multiproc) monkey_patch_os('execv', create_warn_multiproc) monkey_patch_os('execve', create_warn_multiproc) monkey_patch_os('execvp', create_warn_multiproc) monkey_patch_os('execvpe', create_warn_multiproc) monkey_patch_os('spawnl', create_warn_multiproc) monkey_patch_os('spawnle', create_warn_multiproc) monkey_patch_os('spawnlp', create_warn_multiproc) monkey_patch_os('spawnlpe', create_warn_multiproc) monkey_patch_os('spawnv', create_warn_multiproc) monkey_patch_os('spawnve', create_warn_multiproc) monkey_patch_os('spawnvp', create_warn_multiproc) monkey_patch_os('spawnvpe', create_warn_multiproc) monkey_patch_os('posix_spawn', create_warn_multiproc) if not IS_JYTHON: if not IS_WINDOWS: monkey_patch_os('fork', create_warn_multiproc) try: import _posixsubprocess monkey_patch_module(_posixsubprocess, 'fork_exec', create_warn_fork_exec) except ImportError: pass else: # Windows try: import _subprocess except ImportError: import _winapi as _subprocess monkey_patch_module(_subprocess, 'CreateProcess', create_CreateProcessWarnMultiproc) class _NewThreadStartupWithTrace: def __init__(self, original_func, args, kwargs): self.original_func = original_func self.args = args self.kwargs = kwargs def __call__(self): # We monkey-patch the thread creation so that this function is called in the new thread. At this point # we notify of its creation and start tracing it. py_db = get_global_debugger() thread_id = None if py_db is not None: # Note: if this is a thread from threading.py, we're too early in the boostrap process (because we mocked # the start_new_thread internal machinery and thread._bootstrap has not finished), so, the code below needs # to make sure that we use the current thread bound to the original function and not use # threading.current_thread() unless we're sure it's a dummy thread. t = getattr(self.original_func, '__self__', getattr(self.original_func, 'im_self', None)) if not isinstance(t, threading.Thread): # This is not a threading.Thread but a Dummy thread (so, get it as a dummy thread using # currentThread). t = threading.current_thread() if not getattr(t, 'is_pydev_daemon_thread', False): thread_id = get_current_thread_id(t) py_db.notify_thread_created(thread_id, t) _on_set_trace_for_new_thread(py_db) if getattr(py_db, 'thread_analyser', None) is not None: try: from _pydevd_bundle.pydevd_concurrency_analyser.pydevd_concurrency_logger import log_new_thread log_new_thread(py_db, t) except: sys.stderr.write("Failed to detect new thread for visualization") try: ret = self.original_func(*self.args, **self.kwargs) finally: if thread_id is not None: if py_db is not None: # At thread shutdown we only have pydevd-related code running (which shouldn't # be tracked). py_db.disable_tracing() py_db.notify_thread_not_alive(thread_id) return ret class _NewThreadStartupWithoutTrace: def __init__(self, original_func, args, kwargs): self.original_func = original_func self.args = args self.kwargs = kwargs def __call__(self): return self.original_func(*self.args, **self.kwargs) _UseNewThreadStartup = _NewThreadStartupWithTrace def _get_threading_modules_to_patch(): threading_modules_to_patch = [] try: import thread as _thread except: import _thread threading_modules_to_patch.append(_thread) threading_modules_to_patch.append(threading) return threading_modules_to_patch threading_modules_to_patch = _get_threading_modules_to_patch() def patch_thread_module(thread_module): if getattr(thread_module, '_original_start_new_thread', None) is None: if thread_module is threading: if not hasattr(thread_module, '_start_new_thread'): return # Jython doesn't have it. _original_start_new_thread = thread_module._original_start_new_thread = thread_module._start_new_thread else: _original_start_new_thread = thread_module._original_start_new_thread = thread_module.start_new_thread else: _original_start_new_thread = thread_module._original_start_new_thread class ClassWithPydevStartNewThread: def pydev_start_new_thread(self, function, args=(), kwargs={}): ''' We need to replace the original thread_module.start_new_thread with this function so that threads started through it and not through the threading module are properly traced. ''' return _original_start_new_thread(_UseNewThreadStartup(function, args, kwargs), ()) # This is a hack for the situation where the thread_module.start_new_thread is declared inside a class, such as the one below # class F(object): # start_new_thread = thread_module.start_new_thread # # def start_it(self): # self.start_new_thread(self.function, args, kwargs) # So, if it's an already bound method, calling self.start_new_thread won't really receive a different 'self' -- it # does work in the default case because in builtins self isn't passed either. pydev_start_new_thread = ClassWithPydevStartNewThread().pydev_start_new_thread try: # We need to replace the original thread_module.start_new_thread with this function so that threads started through # it and not through the threading module are properly traced. if thread_module is threading: thread_module._start_new_thread = pydev_start_new_thread else: thread_module.start_new_thread = pydev_start_new_thread thread_module.start_new = pydev_start_new_thread except: pass def patch_thread_modules(): for t in threading_modules_to_patch: patch_thread_module(t) def undo_patch_thread_modules(): for t in threading_modules_to_patch: try: t.start_new_thread = t._original_start_new_thread except: pass try: t.start_new = t._original_start_new_thread except: pass try: t._start_new_thread = t._original_start_new_thread except: pass def disable_trace_thread_modules(): ''' Can be used to temporarily stop tracing threads created with thread.start_new_thread. ''' global _UseNewThreadStartup _UseNewThreadStartup = _NewThreadStartupWithoutTrace def enable_trace_thread_modules(): ''' Can be used to start tracing threads created with thread.start_new_thread again. ''' global _UseNewThreadStartup _UseNewThreadStartup = _NewThreadStartupWithTrace def get_original_start_new_thread(threading_module): try: return threading_module._original_start_new_thread except: return threading_module.start_new_thread
40,358
Python
33.14467
187
0.567199
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_ipython_console.py
import sys from _pydev_bundle.pydev_console_utils import BaseInterpreterInterface import traceback # Uncomment to force PyDev standard shell. # raise ImportError() from _pydev_bundle.pydev_ipython_console_011 import get_pydev_frontend #======================================================================================================================= # InterpreterInterface #======================================================================================================================= class InterpreterInterface(BaseInterpreterInterface): ''' The methods in this class should be registered in the xml-rpc server. ''' def __init__(self, host, client_port, main_thread, show_banner=True, connect_status_queue=None): BaseInterpreterInterface.__init__(self, main_thread, connect_status_queue) self.client_port = client_port self.host = host self.interpreter = get_pydev_frontend(host, client_port) self._input_error_printed = False self.notification_succeeded = False self.notification_tries = 0 self.notification_max_tries = 3 self.show_banner = show_banner self.notify_about_magic() def get_greeting_msg(self): if self.show_banner: self.interpreter.show_banner() return self.interpreter.get_greeting_msg() def do_add_exec(self, code_fragment): self.notify_about_magic() if code_fragment.text.rstrip().endswith('??'): print('IPython-->') try: res = bool(self.interpreter.add_exec(code_fragment.text)) finally: if code_fragment.text.rstrip().endswith('??'): print('<--IPython') return res def get_namespace(self): return self.interpreter.get_namespace() def getCompletions(self, text, act_tok): return self.interpreter.getCompletions(text, act_tok) def close(self): sys.exit(0) def notify_about_magic(self): if not self.notification_succeeded: self.notification_tries += 1 if self.notification_tries > self.notification_max_tries: return completions = self.getCompletions("%", "%") magic_commands = [x[0] for x in completions] server = self.get_server() if server is not None: try: server.NotifyAboutMagic(magic_commands, self.interpreter.is_automagic()) self.notification_succeeded = True except: self.notification_succeeded = False def get_ipython_hidden_vars_dict(self): try: if hasattr(self.interpreter, 'ipython') and hasattr(self.interpreter.ipython, 'user_ns_hidden'): user_ns_hidden = self.interpreter.ipython.user_ns_hidden if isinstance(user_ns_hidden, dict): # Since IPython 2 dict `user_ns_hidden` contains hidden variables and values user_hidden_dict = user_ns_hidden.copy() else: # In IPython 1.x `user_ns_hidden` used to be a set with names of hidden variables user_hidden_dict = dict([(key, val) for key, val in self.interpreter.ipython.user_ns.items() if key in user_ns_hidden]) # while `_`, `__` and `___` were not initialized, they are not presented in `user_ns_hidden` user_hidden_dict.setdefault('_', '') user_hidden_dict.setdefault('__', '') user_hidden_dict.setdefault('___', '') return user_hidden_dict except: # Getting IPython variables shouldn't break loading frame variables traceback.print_exc()
3,821
Python
38
120
0.558754
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/_pydev_getopt.py
#======================================================================================================================= # getopt code copied since gnu_getopt is not available on jython 2.1 #======================================================================================================================= class GetoptError(Exception): opt = '' msg = '' def __init__(self, msg, opt=''): self.msg = msg self.opt = opt Exception.__init__(self, msg, opt) def __str__(self): return self.msg def gnu_getopt(args, shortopts, longopts=[]): """getopt(args, options[, long_options]) -> opts, args This function works like getopt(), except that GNU style scanning mode is used by default. This means that option and non-option arguments may be intermixed. The getopt() function stops processing options as soon as a non-option argument is encountered. If the first character of the option string is `+', or if the environment variable POSIXLY_CORRECT is set, then option processing stops as soon as a non-option argument is encountered. """ opts = [] prog_args = [] if type('') == type(longopts): longopts = [longopts] else: longopts = list(longopts) # Allow options after non-option arguments? all_options_first = False if shortopts.startswith('+'): shortopts = shortopts[1:] all_options_first = True while args: if args[0] == '--': prog_args += args[1:] break if args[0][:2] == '--': opts, args = do_longs(opts, args[0][2:], longopts, args[1:]) elif args[0][:1] == '-': opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:]) else: if all_options_first: prog_args += args break else: prog_args.append(args[0]) args = args[1:] return opts, prog_args def do_longs(opts, opt, longopts, args): try: i = opt.index('=') except ValueError: optarg = None else: opt, optarg = opt[:i], opt[i + 1:] has_arg, opt = long_has_args(opt, longopts) if has_arg: if optarg is None: if not args: raise GetoptError('option --%s requires argument' % opt, opt) optarg, args = args[0], args[1:] elif optarg: raise GetoptError('option --%s must not have an argument' % opt, opt) opts.append(('--' + opt, optarg or '')) return opts, args # Return: # has_arg? # full option name def long_has_args(opt, longopts): possibilities = [o for o in longopts if o.startswith(opt)] if not possibilities: raise GetoptError('option --%s not recognized' % opt, opt) # Is there an exact match? if opt in possibilities: return False, opt elif opt + '=' in possibilities: return True, opt # No exact match, so better be unique. if len(possibilities) > 1: # XXX since possibilities contains all valid continuations, might be # nice to work them into the error msg raise GetoptError('option --%s not a unique prefix' % opt, opt) assert len(possibilities) == 1 unique_match = possibilities[0] has_arg = unique_match.endswith('=') if has_arg: unique_match = unique_match[:-1] return has_arg, unique_match def do_shorts(opts, optstring, shortopts, args): while optstring != '': opt, optstring = optstring[0], optstring[1:] if short_has_arg(opt, shortopts): if optstring == '': if not args: raise GetoptError('option -%s requires argument' % opt, opt) optstring, args = args[0], args[1:] optarg, optstring = optstring, '' else: optarg = '' opts.append(('-' + opt, optarg)) return opts, args def short_has_arg(opt, shortopts): for i in range(len(shortopts)): if opt == shortopts[i] != ':': return shortopts.startswith(':', i + 1) raise GetoptError('option -%s not recognized' % opt, opt) #======================================================================================================================= # End getopt code #=======================================================================================================================
4,458
Python
33.038168
120
0.506729
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/pydev_ipython_console_011.py
# TODO that would make IPython integration better # - show output other times then when enter was pressed # - support proper exit to allow IPython to cleanup (e.g. temp files created with %edit) # - support Ctrl-D (Ctrl-Z on Windows) # - use IPython (numbered) prompts in PyDev # - better integration of IPython and PyDev completions # - some of the semantics on handling the code completion are not correct: # eg: Start a line with % and then type c should give %cd as a completion by it doesn't # however type %c and request completions and %cd is given as an option # eg: Completing a magic when user typed it without the leading % causes the % to be inserted # to the left of what should be the first colon. """Interface to TerminalInteractiveShell for PyDev Interactive Console frontend for IPython 0.11 to 1.0+. """ from __future__ import print_function import os import sys import codeop import traceback from IPython.core.error import UsageError from IPython.core.completer import IPCompleter from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC from IPython.core.usage import default_banner_parts from IPython.utils.strdispatch import StrDispatch import IPython.core.release as IPythonRelease from IPython.terminal.interactiveshell import TerminalInteractiveShell try: from traitlets import CBool, Unicode except ImportError: from IPython.utils.traitlets import CBool, Unicode from IPython.core import release from _pydev_bundle.pydev_imports import xmlrpclib default_pydev_banner_parts = default_banner_parts default_pydev_banner = ''.join(default_pydev_banner_parts) def show_in_pager(self, strng, *args, **kwargs): """ Run a string through pager """ # On PyDev we just output the string, there are scroll bars in the console # to handle "paging". This is the same behaviour as when TERM==dump (see # page.py) # for compatibility with mime-bundle form: if isinstance(strng, dict): strng = strng.get('text/plain', strng) print(strng) def create_editor_hook(pydev_host, pydev_client_port): def call_editor(filename, line=0, wait=True): """ Open an editor in PyDev """ if line is None: line = 0 # Make sure to send an absolution path because unlike most editor hooks # we don't launch a process. This is more like what happens in the zmqshell filename = os.path.abspath(filename) # import sys # sys.__stderr__.write('Calling editor at: %s:%s\n' % (pydev_host, pydev_client_port)) # Tell PyDev to open the editor server = xmlrpclib.Server('http://%s:%s' % (pydev_host, pydev_client_port)) server.IPythonEditor(filename, str(line)) if wait: input("Press Enter when done editing:") return call_editor class PyDevIPCompleter(IPCompleter): def __init__(self, *args, **kwargs): """ Create a Completer that reuses the advanced completion support of PyDev in addition to the completion support provided by IPython """ IPCompleter.__init__(self, *args, **kwargs) # Use PyDev for python matches, see getCompletions below if self.python_matches in self.matchers: # `self.python_matches` matches attributes or global python names self.matchers.remove(self.python_matches) class PyDevIPCompleter6(IPCompleter): def __init__(self, *args, **kwargs): """ Create a Completer that reuses the advanced completion support of PyDev in addition to the completion support provided by IPython """ IPCompleter.__init__(self, *args, **kwargs) @property def matchers(self): """All active matcher routines for completion""" # To remove python_matches we now have to override it as it's now a property in the superclass. return [ self.file_matches, self.magic_matches, self.python_func_kw_matches, self.dict_key_matches, ] @matchers.setter def matchers(self, value): # To stop the init in IPCompleter raising an AttributeError we now have to specify a setter as it's now a property in the superclass. return class PyDevTerminalInteractiveShell(TerminalInteractiveShell): banner1 = Unicode(default_pydev_banner, config=True, help="""The part of the banner to be printed before the profile""" ) # TODO term_title: (can PyDev's title be changed???, see terminal.py for where to inject code, in particular set_term_title as used by %cd) # for now, just disable term_title term_title = CBool(False) # Note in version 0.11 there is no guard in the IPython code about displaying a # warning, so with 0.11 you get: # WARNING: Readline services not available or not loaded. # WARNING: The auto-indent feature requires the readline library # Disable readline, readline type code is all handled by PyDev (on Java side) readline_use = CBool(False) # autoindent has no meaning in PyDev (PyDev always handles that on the Java side), # and attempting to enable it will print a warning in the absence of readline. autoindent = CBool(False) # Force console to not give warning about color scheme choice and default to NoColor. # TODO It would be nice to enable colors in PyDev but: # - The PyDev Console (Eclipse Console) does not support the full range of colors, so the # effect isn't as nice anyway at the command line # - If done, the color scheme should default to LightBG, but actually be dependent on # any settings the user has (such as if a dark theme is in use, then Linux is probably # a better theme). colors_force = CBool(True) colors = Unicode("NoColor") # Since IPython 5 the terminal interface is not compatible with Emacs `inferior-shell` and # the `simple_prompt` flag is needed simple_prompt = CBool(True) # In the PyDev Console, GUI control is done via hookable XML-RPC server @staticmethod def enable_gui(gui=None, app=None): """Switch amongst GUI input hooks by name. """ # Deferred import from pydev_ipython.inputhook import enable_gui as real_enable_gui try: return real_enable_gui(gui, app) except ValueError as e: raise UsageError("%s" % e) #------------------------------------------------------------------------- # Things related to hooks #------------------------------------------------------------------------- def init_history(self): # Disable history so that we don't have an additional thread for that # (and we don't use the history anyways). self.config.HistoryManager.enabled = False super(PyDevTerminalInteractiveShell, self).init_history() def init_hooks(self): super(PyDevTerminalInteractiveShell, self).init_hooks() self.set_hook('show_in_pager', show_in_pager) #------------------------------------------------------------------------- # Things related to exceptions #------------------------------------------------------------------------- def showtraceback(self, exc_tuple=None, *args, **kwargs): # IPython does a lot of clever stuff with Exceptions. However mostly # it is related to IPython running in a terminal instead of an IDE. # (e.g. it prints out snippets of code around the stack trace) # PyDev does a lot of clever stuff too, so leave exception handling # with default print_exc that PyDev can parse and do its clever stuff # with (e.g. it puts links back to the original source code) try: if exc_tuple is None: etype, value, tb = sys.exc_info() else: etype, value, tb = exc_tuple except ValueError: return if tb is not None: traceback.print_exception(etype, value, tb) #------------------------------------------------------------------------- # Things related to text completion #------------------------------------------------------------------------- # The way to construct an IPCompleter changed in most versions, # so we have a custom, per version implementation of the construction def _new_completer_100(self): completer = PyDevIPCompleter(shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, alias_table=self.alias_manager.alias_table, use_readline=self.has_readline, parent=self, ) return completer def _new_completer_234(self): # correct for IPython versions 2.x, 3.x, 4.x completer = PyDevIPCompleter(shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, use_readline=self.has_readline, parent=self, ) return completer def _new_completer_500(self): completer = PyDevIPCompleter(shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, use_readline=False, parent=self ) return completer def _new_completer_600(self): completer = PyDevIPCompleter6(shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, use_readline=False, parent=self ) return completer def add_completer_hooks(self): from IPython.core.completerlib import module_completer, magic_run_completer, cd_completer try: from IPython.core.completerlib import reset_completer except ImportError: # reset_completer was added for rel-0.13 reset_completer = None self.configurables.append(self.Completer) # Add custom completers to the basic ones built into IPCompleter sdisp = self.strdispatchers.get('complete_command', StrDispatch()) self.strdispatchers['complete_command'] = sdisp self.Completer.custom_completers = sdisp self.set_hook('complete_command', module_completer, str_key='import') self.set_hook('complete_command', module_completer, str_key='from') self.set_hook('complete_command', magic_run_completer, str_key='%run') self.set_hook('complete_command', cd_completer, str_key='%cd') if reset_completer: self.set_hook('complete_command', reset_completer, str_key='%reset') def init_completer(self): """Initialize the completion machinery. This creates a completer that provides the completions that are IPython specific. We use this to supplement PyDev's core code completions. """ # PyDev uses its own completer and custom hooks so that it uses # most completions from PyDev's core completer which provides # extra information. # See getCompletions for where the two sets of results are merged if IPythonRelease._version_major >= 6: self.Completer = self._new_completer_600() elif IPythonRelease._version_major >= 5: self.Completer = self._new_completer_500() elif IPythonRelease._version_major >= 2: self.Completer = self._new_completer_234() elif IPythonRelease._version_major >= 1: self.Completer = self._new_completer_100() if hasattr(self.Completer, 'use_jedi'): self.Completer.use_jedi = False self.add_completer_hooks() if IPythonRelease._version_major <= 3: # Only configure readline if we truly are using readline. IPython can # do tab-completion over the network, in GUIs, etc, where readline # itself may be absent if self.has_readline: self.set_readline_completer() #------------------------------------------------------------------------- # Things related to aliases #------------------------------------------------------------------------- def init_alias(self): # InteractiveShell defines alias's we want, but TerminalInteractiveShell defines # ones we don't. So don't use super and instead go right to InteractiveShell InteractiveShell.init_alias(self) #------------------------------------------------------------------------- # Things related to exiting #------------------------------------------------------------------------- def ask_exit(self): """ Ask the shell to exit. Can be overiden and used as a callback. """ # TODO PyDev's console does not have support from the Python side to exit # the console. If user forces the exit (with sys.exit()) then the console # simply reports errors. e.g.: # >>> import sys # >>> sys.exit() # Failed to create input stream: Connection refused # >>> # Console already exited with value: 0 while waiting for an answer. # Error stream: # Output stream: # >>> # # Alternatively if you use the non-IPython shell this is what happens # >>> exit() # <type 'exceptions.SystemExit'>:None # >>> # <type 'exceptions.SystemExit'>:None # >>> # super(PyDevTerminalInteractiveShell, self).ask_exit() print('To exit the PyDev Console, terminate the console within IDE.') #------------------------------------------------------------------------- # Things related to magics #------------------------------------------------------------------------- def init_magics(self): super(PyDevTerminalInteractiveShell, self).init_magics() # TODO Any additional magics for PyDev? InteractiveShellABC.register(PyDevTerminalInteractiveShell) # @UndefinedVariable #======================================================================================================================= # _PyDevFrontEnd #======================================================================================================================= class _PyDevFrontEnd: version = release.__version__ def __init__(self): # Create and initialize our IPython instance. if hasattr(PyDevTerminalInteractiveShell, '_instance') and PyDevTerminalInteractiveShell._instance is not None: self.ipython = PyDevTerminalInteractiveShell._instance else: self.ipython = PyDevTerminalInteractiveShell.instance() self._curr_exec_line = 0 self._curr_exec_lines = [] def show_banner(self): self.ipython.show_banner() def update(self, globals, locals): ns = self.ipython.user_ns for key, value in list(ns.items()): if key not in locals: locals[key] = value self.ipython.user_global_ns.clear() self.ipython.user_global_ns.update(globals) self.ipython.user_ns = locals if hasattr(self.ipython, 'history_manager') and hasattr(self.ipython.history_manager, 'save_thread'): self.ipython.history_manager.save_thread.pydev_do_not_trace = True # don't trace ipython history saving thread def complete(self, string): try: if string: return self.ipython.complete(None, line=string, cursor_pos=string.__len__()) else: return self.ipython.complete(string, string, 0) except: # Silence completer exceptions pass def is_complete(self, string): # Based on IPython 0.10.1 if string in ('', '\n'): # Prefiltering, eg through ipython0, may return an empty # string although some operations have been accomplished. We # thus want to consider an empty string as a complete # statement. return True else: try: # Add line returns here, to make sure that the statement is # complete (except if '\' was used). # This should probably be done in a different place (like # maybe 'prefilter_input' method? For now, this works. clean_string = string.rstrip('\n') if not clean_string.endswith('\\'): clean_string += '\n\n' is_complete = codeop.compile_command( clean_string, "<string>", "exec" ) except Exception: # XXX: Hack: return True so that the # code gets executed and the error captured. is_complete = True return is_complete def getCompletions(self, text, act_tok): # Get completions from IPython and from PyDev and merge the results # IPython only gives context free list of completions, while PyDev # gives detailed information about completions. try: TYPE_IPYTHON = '11' TYPE_IPYTHON_MAGIC = '12' _line, ipython_completions = self.complete(text) from _pydev_bundle._pydev_completer import Completer completer = Completer(self.get_namespace(), None) ret = completer.complete(act_tok) append = ret.append ip = self.ipython pydev_completions = set([f[0] for f in ret]) for ipython_completion in ipython_completions: # PyCharm was not expecting completions with '%'... # Could be fixed in the backend, but it's probably better # fixing it at PyCharm. # if ipython_completion.startswith('%'): # ipython_completion = ipython_completion[1:] if ipython_completion not in pydev_completions: pydev_completions.add(ipython_completion) inf = ip.object_inspect(ipython_completion) if inf['type_name'] == 'Magic function': pydev_type = TYPE_IPYTHON_MAGIC else: pydev_type = TYPE_IPYTHON pydev_doc = inf['docstring'] if pydev_doc is None: pydev_doc = '' append((ipython_completion, pydev_doc, '', pydev_type)) return ret except: import traceback;traceback.print_exc() return [] def get_namespace(self): return self.ipython.user_ns def clear_buffer(self): del self._curr_exec_lines[:] def add_exec(self, line): if self._curr_exec_lines: self._curr_exec_lines.append(line) buf = '\n'.join(self._curr_exec_lines) if self.is_complete(buf): self._curr_exec_line += 1 self.ipython.run_cell(buf) del self._curr_exec_lines[:] return False # execute complete (no more) return True # needs more else: if not self.is_complete(line): # Did not execute self._curr_exec_lines.append(line) return True # needs more else: self._curr_exec_line += 1 self.ipython.run_cell(line, store_history=True) # hist = self.ipython.history_manager.output_hist_reprs # rep = hist.get(self._curr_exec_line, None) # if rep is not None: # print(rep) return False # execute complete (no more) def is_automagic(self): return self.ipython.automagic def get_greeting_msg(self): return 'PyDev console: using IPython %s\n' % self.version class _PyDevFrontEndContainer: _instance = None _last_host_port = None def get_pydev_frontend(pydev_host, pydev_client_port): if _PyDevFrontEndContainer._instance is None: _PyDevFrontEndContainer._instance = _PyDevFrontEnd() if _PyDevFrontEndContainer._last_host_port != (pydev_host, pydev_client_port): _PyDevFrontEndContainer._last_host_port = pydev_host, pydev_client_port # Back channel to PyDev to open editors (in the future other # info may go back this way. This is the same channel that is # used to get stdin, see StdIn in pydev_console_utils) _PyDevFrontEndContainer._instance.ipython.hooks['editor'] = create_editor_hook(pydev_host, pydev_client_port) # Note: setting the callback directly because setting it with set_hook would actually create a chain instead # of ovewriting at each new call). # _PyDevFrontEndContainer._instance.ipython.set_hook('editor', create_editor_hook(pydev_host, pydev_client_port)) return _PyDevFrontEndContainer._instance
21,354
Python
40.305609
143
0.581249
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydev_bundle/fsnotify/__init__.py
''' Sample usage to track changes in a thread. import threading import time watcher = fsnotify.Watcher() watcher.accepted_file_extensions = {'.py', '.pyw'} # Configure target values to compute throttling. # Note: internal sleep times will be updated based on # profiling the actual application runtime to match # those values. watcher.target_time_for_single_scan = 2. watcher.target_time_for_notification = 4. watcher.set_tracked_paths([target_dir]) def start_watching(): # Called from thread for change_enum, change_path in watcher.iter_changes(): if change_enum == fsnotify.Change.added: print('Added: ', change_path) elif change_enum == fsnotify.Change.modified: print('Modified: ', change_path) elif change_enum == fsnotify.Change.deleted: print('Deleted: ', change_path) t = threading.Thread(target=start_watching) t.daemon = True t.start() try: ... finally: watcher.dispose() Note: changes are only reported for files (added/modified/deleted), not directories. ''' import threading import sys from os.path import basename from _pydev_bundle import pydev_log from os import scandir try: from enum import IntEnum except: class IntEnum(object): pass import time __author__ = 'Fabio Zadrozny' __email__ = '[email protected]' __version__ = '0.1.5' # Version here and in setup.py class Change(IntEnum): added = 1 modified = 2 deleted = 3 class _SingleVisitInfo(object): def __init__(self): self.count = 0 self.visited_dirs = set() self.file_to_mtime = {} self.last_sleep_time = time.time() class _PathWatcher(object): ''' Helper to watch a single path. ''' def __init__(self, root_path, accept_directory, accept_file, single_visit_info, max_recursion_level, sleep_time=.0): ''' :type root_path: str :type accept_directory: Callback[str, bool] :type accept_file: Callback[str, bool] :type max_recursion_level: int :type sleep_time: float ''' self.accept_directory = accept_directory self.accept_file = accept_file self._max_recursion_level = max_recursion_level self._root_path = root_path # Initial sleep value for throttling, it'll be auto-updated based on the # Watcher.target_time_for_single_scan. self.sleep_time = sleep_time self.sleep_at_elapsed = 1. / 30. # When created, do the initial snapshot right away! old_file_to_mtime = {} self._check(single_visit_info, lambda _change: None, old_file_to_mtime) def __eq__(self, o): if isinstance(o, _PathWatcher): return self._root_path == o._root_path return False def __ne__(self, o): return not self == o def __hash__(self): return hash(self._root_path) def _check_dir(self, dir_path, single_visit_info, append_change, old_file_to_mtime, level): # This is the actual poll loop if dir_path in single_visit_info.visited_dirs or level > self._max_recursion_level: return single_visit_info.visited_dirs.add(dir_path) try: if isinstance(dir_path, bytes): try: dir_path = dir_path.decode(sys.getfilesystemencoding()) except UnicodeDecodeError: try: dir_path = dir_path.decode('utf-8') except UnicodeDecodeError: return # Ignore if we can't deal with the path. new_files = single_visit_info.file_to_mtime for entry in scandir(dir_path): single_visit_info.count += 1 # Throttle if needed inside the loop # to avoid consuming too much CPU. if single_visit_info.count % 300 == 0: if self.sleep_time > 0: t = time.time() diff = t - single_visit_info.last_sleep_time if diff > self.sleep_at_elapsed: time.sleep(self.sleep_time) single_visit_info.last_sleep_time = time.time() if entry.is_dir(): if self.accept_directory(entry.path): self._check_dir(entry.path, single_visit_info, append_change, old_file_to_mtime, level + 1) elif self.accept_file(entry.path): stat = entry.stat() mtime = (stat.st_mtime_ns, stat.st_size) path = entry.path new_files[path] = mtime old_mtime = old_file_to_mtime.pop(path, None) if not old_mtime: append_change((Change.added, path)) elif old_mtime != mtime: append_change((Change.modified, path)) except OSError: pass # Directory was removed in the meanwhile. def _check(self, single_visit_info, append_change, old_file_to_mtime): self._check_dir(self._root_path, single_visit_info, append_change, old_file_to_mtime, 0) class Watcher(object): # By default (if accept_directory is not specified), these will be the # ignored directories. ignored_dirs = {u'.git', u'__pycache__', u'.idea', u'node_modules', u'.metadata'} # By default (if accept_file is not specified), these will be the # accepted files. accepted_file_extensions = () # Set to the target value for doing full scan of all files (adds a sleep inside the poll loop # which processes files to reach the target time). # Lower values will consume more CPU # Set to 0.0 to have no sleeps (which will result in a higher cpu load). target_time_for_single_scan = 2.0 # Set the target value from the start of one scan to the start of another scan (adds a # sleep after a full poll is done to reach the target time). # Lower values will consume more CPU. # Set to 0.0 to have a new scan start right away without any sleeps. target_time_for_notification = 4.0 # Set to True to print the time for a single poll through all the paths. print_poll_time = False # This is the maximum recursion level. max_recursion_level = 10 def __init__(self, accept_directory=None, accept_file=None): ''' :param Callable[str, bool] accept_directory: Callable that returns whether a directory should be watched. Note: if passed it'll override the `ignored_dirs` :param Callable[str, bool] accept_file: Callable that returns whether a file should be watched. Note: if passed it'll override the `accepted_file_extensions`. ''' self._path_watchers = set() self._disposed = threading.Event() if accept_directory is None: accept_directory = lambda dir_path: basename(dir_path) not in self.ignored_dirs if accept_file is None: accept_file = lambda path_name: \ not self.accepted_file_extensions or path_name.endswith(self.accepted_file_extensions) self.accept_file = accept_file self.accept_directory = accept_directory self._single_visit_info = _SingleVisitInfo() @property def accept_directory(self): return self._accept_directory @accept_directory.setter def accept_directory(self, accept_directory): self._accept_directory = accept_directory for path_watcher in self._path_watchers: path_watcher.accept_directory = accept_directory @property def accept_file(self): return self._accept_file @accept_file.setter def accept_file(self, accept_file): self._accept_file = accept_file for path_watcher in self._path_watchers: path_watcher.accept_file = accept_file def dispose(self): self._disposed.set() @property def path_watchers(self): return tuple(self._path_watchers) def set_tracked_paths(self, paths): """ Note: always resets all path trackers to track the passed paths. """ if not isinstance(paths, (list, tuple, set)): paths = (paths,) # Sort by the path len so that the bigger paths come first (so, # if there's any nesting we want the nested paths to be visited # before the parent paths so that the max_recursion_level is correct). paths = sorted(set(paths), key=lambda path:-len(path)) path_watchers = set() self._single_visit_info = _SingleVisitInfo() initial_time = time.time() for path in paths: sleep_time = 0. # When collecting the first time, sleep_time should be 0! path_watcher = _PathWatcher( path, self.accept_directory, self.accept_file, self._single_visit_info, max_recursion_level=self.max_recursion_level, sleep_time=sleep_time, ) path_watchers.add(path_watcher) actual_time = (time.time() - initial_time) pydev_log.debug('Tracking the following paths for changes: %s', paths) pydev_log.debug('Time to track: %.2fs', actual_time) pydev_log.debug('Folders found: %s', len(self._single_visit_info.visited_dirs)) pydev_log.debug('Files found: %s', len(self._single_visit_info.file_to_mtime)) self._path_watchers = path_watchers def iter_changes(self): ''' Continuously provides changes (until dispose() is called). Changes provided are tuples with the Change enum and filesystem path. :rtype: Iterable[Tuple[Change, str]] ''' while not self._disposed.is_set(): initial_time = time.time() old_visit_info = self._single_visit_info old_file_to_mtime = old_visit_info.file_to_mtime changes = [] append_change = changes.append self._single_visit_info = single_visit_info = _SingleVisitInfo() for path_watcher in self._path_watchers: path_watcher._check(single_visit_info, append_change, old_file_to_mtime) # Note that we pop entries while visiting, so, what remained is what's deleted. for entry in old_file_to_mtime: append_change((Change.deleted, entry)) for change in changes: yield change actual_time = (time.time() - initial_time) if self.print_poll_time: print('--- Total poll time: %.3fs' % actual_time) if actual_time > 0: if self.target_time_for_single_scan <= 0.0: for path_watcher in self._path_watchers: path_watcher.sleep_time = 0.0 else: perc = self.target_time_for_single_scan / actual_time # Prevent from changing the values too much (go slowly into the right # direction). # (to prevent from cases where the user puts the machine on sleep and # values become too skewed). if perc > 2.: perc = 2. elif perc < 0.5: perc = 0.5 for path_watcher in self._path_watchers: if path_watcher.sleep_time <= 0.0: path_watcher.sleep_time = 0.001 new_sleep_time = path_watcher.sleep_time * perc # Prevent from changing the values too much (go slowly into the right # direction). # (to prevent from cases where the user puts the machine on sleep and # values become too skewed). diff_sleep_time = new_sleep_time - path_watcher.sleep_time path_watcher.sleep_time += (diff_sleep_time / (3.0 * len(self._path_watchers))) if actual_time > 0: self._disposed.wait(actual_time) if path_watcher.sleep_time < 0.001: path_watcher.sleep_time = 0.001 # print('new sleep time: %s' % path_watcher.sleep_time) diff = self.target_time_for_notification - actual_time if diff > 0.: self._disposed.wait(diff)
12,704
Python
34.88983
120
0.574465
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_eval_cython_wrapper.py
try: try: from _pydevd_frame_eval_ext import pydevd_frame_evaluator as mod except ImportError: from _pydevd_frame_eval import pydevd_frame_evaluator as mod except ImportError: try: import sys try: is_64bits = sys.maxsize > 2 ** 32 except: # In Jython this call fails, but this is Ok, we don't support Jython for speedups anyways. raise ImportError plat = '32' if is_64bits: plat = '64' # We also accept things as: # # _pydevd_frame_eval.pydevd_frame_evaluator_win32_27_32 # _pydevd_frame_eval.pydevd_frame_evaluator_win32_34_64 # # to have multiple pre-compiled pyds distributed along the IDE # (generated by build_tools/build_binaries_windows.py). mod_name = 'pydevd_frame_evaluator_%s_%s%s_%s' % (sys.platform, sys.version_info[0], sys.version_info[1], plat) check_name = '_pydevd_frame_eval.%s' % (mod_name,) mod = __import__(check_name) mod = getattr(mod, mod_name) except ImportError: raise frame_eval_func = mod.frame_eval_func stop_frame_eval = mod.stop_frame_eval dummy_trace_dispatch = mod.dummy_trace_dispatch get_thread_info_py = mod.get_thread_info_py clear_thread_local_info = mod.clear_thread_local_info
1,343
Python
29.545454
119
0.621742
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_tracing.py
import sys from _pydev_bundle import pydev_log from _pydev_bundle._pydev_saved_modules import threading from _pydevd_bundle.pydevd_comm import get_global_debugger from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info class DummyTracingHolder: dummy_trace_func = None def set_trace_func(self, trace_func): self.dummy_trace_func = trace_func dummy_tracing_holder = DummyTracingHolder() def update_globals_dict(globals_dict): new_globals = {'_pydev_stop_at_break': _pydev_stop_at_break} globals_dict.update(new_globals) def _get_line_for_frame(frame): # it's absolutely necessary to reset tracing function for frame in order to get the real line number tracing_func = frame.f_trace frame.f_trace = None line = frame.f_lineno frame.f_trace = tracing_func return line def _pydev_stop_at_break(line): frame = sys._getframe(1) # print('pydevd SET TRACING at ', line, 'curr line', frame.f_lineno) t = threading.current_thread() try: additional_info = t.additional_info except: additional_info = set_additional_thread_info(t) if additional_info.is_tracing: return additional_info.is_tracing += 1 try: py_db = get_global_debugger() if py_db is None: return pydev_log.debug("Setting f_trace due to frame eval mode in file: %s on line %s", frame.f_code.co_filename, line) additional_info.trace_suspend_type = 'frame_eval' pydevd_frame_eval_cython_wrapper = sys.modules['_pydevd_frame_eval.pydevd_frame_eval_cython_wrapper'] thread_info = pydevd_frame_eval_cython_wrapper.get_thread_info_py() if thread_info.thread_trace_func is not None: frame.f_trace = thread_info.thread_trace_func else: frame.f_trace = py_db.get_thread_local_trace_func() finally: additional_info.is_tracing -= 1 def _pydev_needs_stop_at_break(line): ''' We separate the functionality into 2 functions so that we can generate a bytecode which generates a spurious line change so that we can do: if _pydev_needs_stop_at_break(): # Set line to line -1 _pydev_stop_at_break() # then, proceed to go to the current line # (which will then trigger a line event). ''' t = threading.current_thread() try: additional_info = t.additional_info except: additional_info = set_additional_thread_info(t) if additional_info.is_tracing: return False additional_info.is_tracing += 1 try: frame = sys._getframe(1) # print('pydev needs stop at break?', line, 'curr line', frame.f_lineno, 'curr trace', frame.f_trace) if frame.f_trace is not None: # i.e.: this frame is already being traced, thus, we don't need to use programmatic breakpoints. return False py_db = get_global_debugger() if py_db is None: return False try: abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] except: abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame) canonical_normalized_filename = abs_path_real_path_and_base[1] try: python_breakpoint = py_db.breakpoints[canonical_normalized_filename][line] except: # print("Couldn't find breakpoint in the file %s on line %s" % (frame.f_code.co_filename, line)) # Could be KeyError if line is not there or TypeError if breakpoints_for_file is None. # Note: using catch-all exception for performance reasons (if the user adds a breakpoint # and then removes it after hitting it once, this method added for the programmatic # breakpoint will keep on being called and one of those exceptions will always be raised # here). return False if python_breakpoint: # print('YES') return True finally: additional_info.is_tracing -= 1 return False
4,219
Python
33.308943
120
0.650391
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/release_mem.h
#include "Python.h" void release_co_extra(void *obj) { Py_XDECREF(obj); }
79
C
12.333331
34
0.64557
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_modify_bytecode.py
from collections import namedtuple import dis from functools import partial import itertools import os.path import sys from _pydevd_frame_eval.vendored import bytecode from _pydevd_frame_eval.vendored.bytecode.instr import Instr, Label from _pydev_bundle import pydev_log from _pydevd_frame_eval.pydevd_frame_tracing import _pydev_stop_at_break, _pydev_needs_stop_at_break DEBUG = False class DebugHelper(object): def __init__(self): self._debug_dir = os.path.join(os.path.dirname(__file__), 'debug_info') try: os.makedirs(self._debug_dir) except: pass self._next = partial(next, itertools.count(0)) def _get_filename(self, op_number=None, prefix=''): if op_number is None: op_number = self._next() name = '%03d_before.txt' % op_number else: name = '%03d_change.txt' % op_number filename = os.path.join(self._debug_dir, prefix + name) return filename, op_number def write_bytecode(self, b, op_number=None, prefix=''): filename, op_number = self._get_filename(op_number, prefix) with open(filename, 'w') as stream: bytecode.dump_bytecode(b, stream=stream, lineno=True) return op_number def write_dis(self, code_to_modify, op_number=None, prefix=''): filename, op_number = self._get_filename(op_number, prefix) with open(filename, 'w') as stream: stream.write('-------- ') stream.write('-------- ') stream.write('id(code_to_modify): %s' % id(code_to_modify)) stream.write('\n\n') dis.dis(code_to_modify, file=stream) return op_number _CodeLineInfo = namedtuple('_CodeLineInfo', 'line_to_offset, first_line, last_line') # Note: this method has a version in cython too (that one is usually used, this is just for tests). def _get_code_line_info(code_obj): line_to_offset = {} first_line = None last_line = None for offset, line in dis.findlinestarts(code_obj): line_to_offset[line] = offset if line_to_offset: first_line = min(line_to_offset) last_line = max(line_to_offset) return _CodeLineInfo(line_to_offset, first_line, last_line) if DEBUG: debug_helper = DebugHelper() def get_instructions_to_add( stop_at_line, _pydev_stop_at_break=_pydev_stop_at_break, _pydev_needs_stop_at_break=_pydev_needs_stop_at_break ): ''' This is the bytecode for something as: if _pydev_needs_stop_at_break(): _pydev_stop_at_break() but with some special handling for lines. ''' # Good reference to how things work regarding line numbers and jumps: # https://github.com/python/cpython/blob/3.6/Objects/lnotab_notes.txt # Usually use a stop line -1, but if that'd be 0, using line +1 is ok too. spurious_line = stop_at_line - 1 if spurious_line <= 0: spurious_line = stop_at_line + 1 label = Label() return [ # -- if _pydev_needs_stop_at_break(): Instr("LOAD_CONST", _pydev_needs_stop_at_break, lineno=stop_at_line), Instr("LOAD_CONST", stop_at_line, lineno=stop_at_line), Instr("CALL_FUNCTION", 1, lineno=stop_at_line), Instr("POP_JUMP_IF_FALSE", label, lineno=stop_at_line), # -- _pydev_stop_at_break() # # Note that this has line numbers -1 so that when the NOP just below # is executed we have a spurious line event. Instr("LOAD_CONST", _pydev_stop_at_break, lineno=spurious_line), Instr("LOAD_CONST", stop_at_line, lineno=spurious_line), Instr("CALL_FUNCTION", 1, lineno=spurious_line), Instr("POP_TOP", lineno=spurious_line), # Reason for the NOP: Python will give us a 'line' trace event whenever we forward jump to # the first instruction of a line, so, in the case where we haven't added a programmatic # breakpoint (either because we didn't hit a breakpoint anymore or because it was already # tracing), we don't want the spurious line event due to the line change, so, we make a jump # to the instruction right after the NOP so that the spurious line event is NOT generated in # this case (otherwise we'd have a line event even if the line didn't change). Instr("NOP", lineno=stop_at_line), label, ] class _Node(object): def __init__(self, data): self.prev = None self.next = None self.data = data def append(self, data): node = _Node(data) curr_next = self.next node.next = self.next node.prev = self self.next = node if curr_next is not None: curr_next.prev = node return node def prepend(self, data): node = _Node(data) curr_prev = self.prev node.prev = self.prev node.next = self self.prev = node if curr_prev is not None: curr_prev.next = node return node class _HelperBytecodeList(object): ''' A helper double-linked list to make the manipulation a bit easier (so that we don't need to keep track of indices that change) and performant (because adding multiple items to the middle of a regular list isn't ideal). ''' def __init__(self, lst=None): self._head = None self._tail = None if lst: node = self for item in lst: node = node.append(item) def append(self, data): if self._tail is None: node = _Node(data) self._head = self._tail = node return node else: node = self._tail = self.tail.append(data) return node @property def head(self): node = self._head # Manipulating the node directly may make it unsynchronized. while node.prev: self._head = node = node.prev return node @property def tail(self): node = self._tail # Manipulating the node directly may make it unsynchronized. while node.next: self._tail = node = node.next return node def __iter__(self): node = self.head while node: yield node.data node = node.next _PREDICT_TABLE = { 'LIST_APPEND': ('JUMP_ABSOLUTE',), 'SET_ADD': ('JUMP_ABSOLUTE',), 'GET_ANEXT': ('LOAD_CONST',), 'GET_AWAITABLE': ('LOAD_CONST',), 'DICT_MERGE': ('CALL_FUNCTION_EX',), 'MAP_ADD': ('JUMP_ABSOLUTE',), 'COMPARE_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',), 'IS_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',), 'CONTAINS_OP': ('POP_JUMP_IF_FALSE', 'POP_JUMP_IF_TRUE',), # Note: there are some others with PREDICT on ceval, but they have more logic # and it needs more experimentation to know how it behaves in the static generated # code (and it's only an issue for us if there's actually a line change between # those, so, we don't have to really handle all the cases, only the one where # the line number actually changes from one instruction to the predicted one). } # 3.10 optimizations include copying code branches multiple times (for instance # if the body of a finally has a single assign statement it can copy the assign to the case # where an exception happens and doesn't happen for optimization purposes) and as such # we need to add the programmatic breakpoint multiple times. TRACK_MULTIPLE_BRANCHES = sys.version_info[:2] >= (3, 10) # When tracking multiple branches, we try to fix the bytecodes which would be PREDICTED in the # Python eval loop so that we don't have spurious line events that wouldn't usually be issued # in the tracing as they're ignored due to the eval prediction (even though they're in the bytecode). FIX_PREDICT = sys.version_info[:2] >= (3, 10) def insert_pydevd_breaks( code_to_modify, breakpoint_lines, code_line_info=None, _pydev_stop_at_break=_pydev_stop_at_break, _pydev_needs_stop_at_break=_pydev_needs_stop_at_break, ): """ Inserts pydevd programmatic breaks into the code (at the given lines). :param breakpoint_lines: set with the lines where we should add breakpoints. :return: tuple(boolean flag whether insertion was successful, modified code). """ if code_line_info is None: code_line_info = _get_code_line_info(code_to_modify) if not code_line_info.line_to_offset: return False, code_to_modify # Create a copy (and make sure we're dealing with a set). breakpoint_lines = set(breakpoint_lines) # Note that we can even generate breakpoints on the first line of code # now, since we generate a spurious line event -- it may be a bit pointless # as we'll stop in the first line and we don't currently stop the tracing after the # user resumes, but in the future, if we do that, this would be a nice # improvement. # if code_to_modify.co_firstlineno in breakpoint_lines: # return False, code_to_modify for line in breakpoint_lines: if line <= 0: # The first line is line 1, so, a break at line 0 is not valid. pydev_log.info('Trying to add breakpoint in invalid line: %s', line) return False, code_to_modify try: b = bytecode.Bytecode.from_code(code_to_modify) if DEBUG: op_number_bytecode = debug_helper.write_bytecode(b, prefix='bytecode.') helper_list = _HelperBytecodeList(b) modified_breakpoint_lines = breakpoint_lines.copy() curr_node = helper_list.head added_breaks_in_lines = set() last_lineno = None while curr_node is not None: instruction = curr_node.data instruction_lineno = getattr(instruction, 'lineno', None) curr_name = getattr(instruction, 'name', None) if FIX_PREDICT: predict_targets = _PREDICT_TABLE.get(curr_name) if predict_targets: # Odd case: the next instruction may have a line number but it doesn't really # appear in the tracing due to the PREDICT() in ceval, so, fix the bytecode so # that it does things the way that ceval actually interprets it. # See: https://mail.python.org/archives/list/[email protected]/thread/CP2PTFCMTK57KM3M3DLJNWGO66R5RVPB/ next_instruction = curr_node.next.data next_name = getattr(next_instruction, 'name', None) if next_name in predict_targets: next_instruction_lineno = getattr(next_instruction, 'lineno', None) if next_instruction_lineno: next_instruction.lineno = None if instruction_lineno is not None: if TRACK_MULTIPLE_BRANCHES: if last_lineno is None: last_lineno = instruction_lineno else: if last_lineno == instruction_lineno: # If the previous is a label, someone may jump into it, so, we need to add # the break even if it's in the same line. if curr_node.prev.data.__class__ != Label: # Skip adding this as the line is still the same. curr_node = curr_node.next continue last_lineno = instruction_lineno else: if instruction_lineno in added_breaks_in_lines: curr_node = curr_node.next continue if instruction_lineno in modified_breakpoint_lines: added_breaks_in_lines.add(instruction_lineno) if curr_node.prev is not None and curr_node.prev.data.__class__ == Label \ and curr_name == 'POP_TOP': # If we have a SETUP_FINALLY where the target is a POP_TOP, we can't change # the target to be the breakpoint instruction (this can crash the interpreter). for new_instruction in get_instructions_to_add( instruction_lineno, _pydev_stop_at_break=_pydev_stop_at_break, _pydev_needs_stop_at_break=_pydev_needs_stop_at_break, ): curr_node = curr_node.append(new_instruction) else: for new_instruction in get_instructions_to_add( instruction_lineno, _pydev_stop_at_break=_pydev_stop_at_break, _pydev_needs_stop_at_break=_pydev_needs_stop_at_break, ): curr_node.prepend(new_instruction) curr_node = curr_node.next b[:] = helper_list if DEBUG: debug_helper.write_bytecode(b, op_number_bytecode, prefix='bytecode.') new_code = b.to_code() except: pydev_log.exception('Error inserting pydevd breaks.') return False, code_to_modify if DEBUG: op_number = debug_helper.write_dis(code_to_modify) debug_helper.write_dis(new_code, op_number) return True, new_code
13,545
Python
36.010929
127
0.591953
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.c
/* Generated by Cython 0.29.32 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ "_pydevd_frame_eval/release_mem.h" ], "include_dirs": [ "_pydevd_frame_eval" ], "name": "_pydevd_frame_eval.pydevd_frame_evaluator", "sources": [ "_pydevd_frame_eval/pydevd_frame_evaluator.pyx" ] }, "module_name": "_pydevd_frame_eval.pydevd_frame_evaluator" } END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #if PY_VERSION_HEX >= 0x03090000 #include "internal/pycore_gc.h" #include "internal/pycore_interp.h" #endif #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_32" #define CYTHON_HEX_VERSION 0x001D20F0 #define CYTHON_FUTURE_DIVISION 0 #include <stddef.h> #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) #endif #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif #elif defined(PY_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #ifndef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 1 #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_NOGIL 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #elif !defined(CYTHON_FAST_THREAD_STATE) #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #if PY_VERSION_HEX >= 0x030B00A4 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" #endif #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include <stdint.h> #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if PY_VERSION_HEX >= 0x030B00A1 static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; const char *fn_cstr=NULL; const char *name_cstr=NULL; PyCodeObject* co=NULL; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); if (!(kwds=PyDict_New())) goto end; if (!(argcount=PyLong_FromLong(a))) goto end; if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; if (!(posonlyargcount=PyLong_FromLong(0))) goto end; if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; if (!(nlocals=PyLong_FromLong(l))) goto end; if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; if (!(stacksize=PyLong_FromLong(s))) goto end; if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; if (!(flags=PyLong_FromLong(f))) goto end; if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; Py_XDECREF((PyObject*)co); co = (PyCodeObject*)call_result; call_result = NULL; if (0) { cleanup_code_too: Py_XDECREF((PyObject*)co); co = NULL; } end: Py_XDECREF(kwds); Py_XDECREF(argcount); Py_XDECREF(posonlyargcount); Py_XDECREF(kwonlyargcount); Py_XDECREF(nlocals); Py_XDECREF(stacksize); Py_XDECREF(replace); Py_XDECREF(call_result); Py_XDECREF(empty); if (type) { PyErr_Restore(type, value, traceback); } return co; } #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #else #define __Pyx_PyUnicode_READY(op) (0) #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) #if !defined(_USE_MATH_DEFINES) #define _USE_MATH_DEFINES #endif #endif #include <math.h> #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE___pydevd_frame_eval__pydevd_frame_evaluator #define __PYX_HAVE_API___pydevd_frame_eval__pydevd_frame_evaluator /* Early includes */ #include "frameobject.h" #include "release_mem.h" #include "code.h" #include "pystate.h" #if PY_VERSION_HEX >= 0x03080000 #include "internal/pycore_pystate.h" #endif #include "ceval.h" #if PY_VERSION_HEX >= 0x03090000 PyObject * noop(PyFrameObject *frame, int exc) { return NULL; } #define CALL_EvalFrameDefault_38(a, b) noop(a, b) #define CALL_EvalFrameDefault_39(a, b, c) _PyEval_EvalFrameDefault(a, b, c) #else PyObject * noop(PyThreadState* tstate, PyFrameObject *frame, int exc) { return NULL; } #define CALL_EvalFrameDefault_39(a, b, c) noop(a, b, c) #define CALL_EvalFrameDefault_38(a, b) _PyEval_EvalFrameDefault(a, b) #endif #ifdef _OPENMP #include <omp.h> #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include <cstdlib> #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "_pydevd_frame_eval/pydevd_frame_evaluator.pyx", "stringsource", "_pydevd_bundle/pydevd_cython.pxd", }; /*--- Type declarations ---*/ struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; /* "_pydevd_bundle/pydevd_cython.pxd":1 * cdef class PyDBAdditionalThreadInfo: # <<<<<<<<<<<<<< * cdef public int pydev_state * cdef public object pydev_step_stop # Actually, it's a frame or None */ struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo { PyObject_HEAD int pydev_state; PyObject *pydev_step_stop; int pydev_original_step_cmd; int pydev_step_cmd; int pydev_notify_kill; PyObject *pydev_smart_step_stop; int pydev_django_resolve_frame; PyObject *pydev_call_from_jinja2; PyObject *pydev_call_inside_jinja2; int is_tracing; PyObject *conditional_breakpoint_exception; PyObject *pydev_message; int suspend_type; int pydev_next_line; PyObject *pydev_func_name; int suspended_at_unhandled; PyObject *trace_suspend_type; PyObject *top_level_thread_tracer_no_back_frames; PyObject *top_level_thread_tracer_unhandled; PyObject *thread_tracer; PyObject *step_in_initial_location; int pydev_smart_parent_offset; int pydev_smart_child_offset; PyObject *pydev_smart_step_into_variants; PyObject *target_id_to_smart_step_into_variant; int pydev_use_scoped_step_frame; }; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":24 * * * cdef class ThreadInfo: # <<<<<<<<<<<<<< * * cdef public PyDBAdditionalThreadInfo additional_info */ struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo { PyObject_HEAD struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_vtab; struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *additional_info; int is_pydevd_thread; int inside_frame_eval; int fully_initialized; PyObject *thread_trace_func; int _can_create_dummy_thread; int force_stay_in_untraced_mode; }; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":125 * * * cdef class FuncCodeInfo: # <<<<<<<<<<<<<< * * cdef public str co_filename */ struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo { PyObject_HEAD PyObject *co_filename; PyObject *co_name; PyObject *canonical_normalized_filename; int always_skip_code; int breakpoint_found; PyObject *new_code; int breakpoints_mtime; }; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":316 * * * cdef class _CodeLineInfo: # <<<<<<<<<<<<<< * * cdef public dict line_to_offset */ struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo { PyObject_HEAD PyObject *line_to_offset; int first_line; int last_line; }; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":361 * * * cdef class _CacheValue(object): # <<<<<<<<<<<<<< * * cdef public object code_obj_py */ struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue { PyObject_HEAD struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_vtab; PyObject *code_obj_py; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *code_line_info; PyObject *breakpoints_hit_at_lines; PyObject *code_lines_as_set; }; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":24 * * * cdef class ThreadInfo: # <<<<<<<<<<<<<< * * cdef public PyDBAdditionalThreadInfo additional_info */ struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo { PyObject *(*initialize)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *, PyFrameObject *); PyObject *(*initialize_if_possible)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *); }; static struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":361 * * * cdef class _CacheValue(object): # <<<<<<<<<<<<<< * * cdef public object code_obj_py */ struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue { PyObject *(*compute_force_stay_in_untraced_mode)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *, PyObject *, int __pyx_skip_dispatch); }; static struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif #if CYTHON_FAST_PYCALL static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif // CYTHON_FAST_PYCALL #endif /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyIntBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) #endif /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* IncludeStringH.proto */ #include <string.h> /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StrEquals.proto */ #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* PyObjectLookupSpecial.proto */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return __Pyx_PyObject_GetAttrStr(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #else #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* None.proto */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* PyDictContains.proto */ static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { int result = PyDict_Contains(dict, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* GCCDiagnostics.proto */ #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define __Pyx_HAS_GCC_DIAGNOSTIC #endif /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyFrameObject *__pyx_v_frame_obj); /* proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize_if_possible(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_compute_force_stay_in_untraced_mode(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_breakpoints, int __pyx_skip_dispatch); /* proto*/ /* Module declarations from 'cpython.mem' */ /* Module declarations from '_pydevd_bundle.pydevd_cython' */ static PyTypeObject *__pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo = 0; /* Module declarations from '_pydevd_frame_eval.pydevd_frame_evaluator' */ static PyTypeObject *__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo = 0; static PyTypeObject *__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo = 0; static PyTypeObject *__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo = 0; static PyTypeObject *__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue = 0; static int __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index; static int __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator_IS_PY_39_OWNARDS; static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_thread_info(PyFrameObject *); /*proto*/ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_func_code_info(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *, PyFrameObject *, PyCodeObject *); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_generate_code_with_breakpoints(PyObject *, PyObject *); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_38(PyFrameObject *, int); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_39(PyThreadState *, PyFrameObject *, int); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_ThreadInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *, PyObject *); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_FuncCodeInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *, PyObject *); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CodeLineInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *, PyObject *); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CacheValue__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *, PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "_pydevd_frame_eval.pydevd_frame_evaluator" extern int __pyx_module_is_main__pydevd_frame_eval__pydevd_frame_evaluator; int __pyx_module_is_main__pydevd_frame_eval__pydevd_frame_evaluator = 0; /* Implementation of '_pydevd_frame_eval.pydevd_frame_evaluator' */ static PyObject *__pyx_builtin_AttributeError; static PyObject *__pyx_builtin_min; static PyObject *__pyx_builtin_max; static const char __pyx_k_[] = "/"; static const char __pyx_k__2[] = "\\"; static const char __pyx_k__3[] = "."; static const char __pyx_k__5[] = ""; static const char __pyx_k_arg[] = "arg"; static const char __pyx_k_dis[] = "dis"; static const char __pyx_k_get[] = "get"; static const char __pyx_k_max[] = "max"; static const char __pyx_k_min[] = "min"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_obj[] = "obj"; static const char __pyx_k_run[] = "run"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_call[] = "__call__"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_exec[] = "_exec"; static const char __pyx_k_exit[] = "__exit__"; static const char __pyx_k_line[] = "line"; static const char __pyx_k_main[] = "main"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_cache[] = "_cache"; static const char __pyx_k_enter[] = "__enter__"; static const char __pyx_k_event[] = "event"; static const char __pyx_k_frame[] = "frame"; static const char __pyx_k_local[] = "local"; static const char __pyx_k_mtime[] = "mtime"; static const char __pyx_k_rfind[] = "rfind"; static const char __pyx_k_state[] = "state"; static const char __pyx_k_active[] = "_active"; static const char __pyx_k_call_2[] = "call"; static const char __pyx_k_f_back[] = "f_back"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_main_2[] = "__main__"; static const char __pyx_k_offset[] = "offset"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_plugin[] = "plugin"; static const char __pyx_k_pydevd[] = "pydevd"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_thread[] = "thread"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_f_trace[] = "f_trace"; static const char __pyx_k_SetTrace[] = "SetTrace"; static const char __pyx_k_can_skip[] = "can_skip"; static const char __pyx_k_code_obj[] = "code_obj"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_bootstrap[] = "__bootstrap"; static const char __pyx_k_decref_py[] = "decref_py"; static const char __pyx_k_get_ident[] = "_get_ident"; static const char __pyx_k_last_line[] = "last_line"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_threading[] = "threading"; static const char __pyx_k_CacheValue[] = "_CacheValue"; static const char __pyx_k_ThreadInfo[] = "ThreadInfo"; static const char __pyx_k_first_line[] = "first_line"; static const char __pyx_k_global_dbg[] = "global_dbg"; static const char __pyx_k_issuperset[] = "issuperset"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_DebugHelper[] = "DebugHelper"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_bootstrap_2[] = "_bootstrap"; static const char __pyx_k_breakpoints[] = "breakpoints"; static const char __pyx_k_code_obj_py[] = "code_obj_py"; static const char __pyx_k_get_ident_2[] = "get_ident"; static const char __pyx_k_thread_info[] = "thread_info"; static const char __pyx_k_CodeLineInfo[] = "_CodeLineInfo"; static const char __pyx_k_FuncCodeInfo[] = "FuncCodeInfo"; static const char __pyx_k_intersection[] = "intersection"; static const char __pyx_k_pydev_monkey[] = "pydev_monkey"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_version_info[] = "version_info"; static const char __pyx_k_get_file_type[] = "get_file_type"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_thread_active[] = "_thread_active"; static const char __pyx_k_AttributeError[] = "AttributeError"; static const char __pyx_k_code_line_info[] = "code_line_info"; static const char __pyx_k_current_thread[] = "current_thread"; static const char __pyx_k_findlinestarts[] = "findlinestarts"; static const char __pyx_k_line_to_offset[] = "line_to_offset"; static const char __pyx_k_pydevd_tracing[] = "pydevd_tracing"; static const char __pyx_k_set_trace_func[] = "set_trace_func"; static const char __pyx_k_trace_dispatch[] = "trace_dispatch"; static const char __pyx_k_additional_info[] = "additional_info"; static const char __pyx_k_bootstrap_inner[] = "__bootstrap_inner"; static const char __pyx_k_frame_eval_func[] = "frame_eval_func"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_stop_frame_eval[] = "stop_frame_eval"; static const char __pyx_k_bootstrap_inner_2[] = "_bootstrap_inner"; static const char __pyx_k_pydevd_file_utils[] = "pydevd_file_utils"; static const char __pyx_k_signature_factory[] = "signature_factory"; static const char __pyx_k_thread_local_info[] = "_thread_local_info"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_get_code_line_info[] = "_get_code_line_info"; static const char __pyx_k_get_thread_info_py[] = "get_thread_info_py"; static const char __pyx_k_show_return_values[] = "show_return_values"; static const char __pyx_k_get_cache_file_type[] = "get_cache_file_type"; static const char __pyx_k_update_globals_dict[] = "update_globals_dict"; static const char __pyx_k_GlobalDebuggerHolder[] = "GlobalDebuggerHolder"; static const char __pyx_k_dummy_trace_dispatch[] = "dummy_trace_dispatch"; static const char __pyx_k_dummy_tracing_holder[] = "dummy_tracing_holder"; static const char __pyx_k_insert_pydevd_breaks[] = "insert_pydevd_breaks"; static const char __pyx_k_get_func_code_info_py[] = "get_func_code_info_py"; static const char __pyx_k_has_plugin_line_breaks[] = "has_plugin_line_breaks"; static const char __pyx_k_is_pydev_daemon_thread[] = "is_pydev_daemon_thread"; static const char __pyx_k_clear_thread_local_info[] = "clear_thread_local_info"; static const char __pyx_k_pyx_unpickle_ThreadInfo[] = "__pyx_unpickle_ThreadInfo"; static const char __pyx_k_breakpoints_hit_at_lines[] = "breakpoints_hit_at_lines"; static const char __pyx_k_pyx_unpickle__CacheValue[] = "__pyx_unpickle__CacheValue"; static const char __pyx_k_pyx_unpickle_FuncCodeInfo[] = "__pyx_unpickle_FuncCodeInfo"; static const char __pyx_k_break_on_caught_exceptions[] = "break_on_caught_exceptions"; static const char __pyx_k_pyx_unpickle__CodeLineInfo[] = "__pyx_unpickle__CodeLineInfo"; static const char __pyx_k_get_cached_code_obj_info_py[] = "get_cached_code_obj_info_py"; static const char __pyx_k_has_plugin_exception_breaks[] = "has_plugin_exception_breaks"; static const char __pyx_k_NORM_PATHS_AND_BASE_CONTAINER[] = "NORM_PATHS_AND_BASE_CONTAINER"; static const char __pyx_k_pydevd_bundle_pydevd_constants[] = "_pydevd_bundle.pydevd_constants"; static const char __pyx_k_pydevd_frame_eval_pydevd_frame[] = "_pydevd_frame_eval.pydevd_frame_tracing"; static const char __pyx_k_If_a_code_object_is_cached_that[] = "If a code object is cached, that same code object must be reused."; static const char __pyx_k_get_abs_path_real_path_and_base[] = "get_abs_path_real_path_and_base_from_frame"; static const char __pyx_k_pydev_bundle__pydev_saved_modul[] = "_pydev_bundle._pydev_saved_modules"; static const char __pyx_k_pydevd_bundle_pydevd_additional[] = "_pydevd_bundle.pydevd_additional_thread_info"; static const char __pyx_k_pydevd_bundle_pydevd_trace_disp[] = "_pydevd_bundle.pydevd_trace_dispatch"; static const char __pyx_k_pydevd_frame_eval_pydevd_modify[] = "_pydevd_frame_eval.pydevd_modify_bytecode"; static const char __pyx_k_set_additional_thread_info_lock[] = "_set_additional_thread_info_lock"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))"; static const char __pyx_k_break_on_user_uncaught_exception[] = "break_on_user_uncaught_exceptions"; static const char __pyx_k_compute_force_stay_in_untraced_m[] = "compute_force_stay_in_untraced_mode"; static const char __pyx_k_fix_top_level_trace_and_get_trac[] = "fix_top_level_trace_and_get_trace_func"; static const char __pyx_k_function_breakpoint_name_to_brea[] = "function_breakpoint_name_to_breakpoint"; static const char __pyx_k_generate_code_with_breakpoints_p[] = "generate_code_with_breakpoints_py"; static const char __pyx_k_pydevd_frame_eval_pydevd_frame_2[] = "_pydevd_frame_eval/pydevd_frame_evaluator.pyx"; static const char __pyx_k_pydevd_frame_eval_pydevd_frame_3[] = "_pydevd_frame_eval.pydevd_frame_evaluator"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_2[] = "Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_3[] = "Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))"; static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_4[] = "Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))"; static PyObject *__pyx_kp_s_; static PyObject *__pyx_n_s_AttributeError; static PyObject *__pyx_n_s_CacheValue; static PyObject *__pyx_n_s_CodeLineInfo; static PyObject *__pyx_n_s_DebugHelper; static PyObject *__pyx_n_s_FuncCodeInfo; static PyObject *__pyx_n_s_GlobalDebuggerHolder; static PyObject *__pyx_kp_s_If_a_code_object_is_cached_that; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3; static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4; static PyObject *__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_n_s_SetTrace; static PyObject *__pyx_n_s_ThreadInfo; static PyObject *__pyx_kp_s__2; static PyObject *__pyx_kp_s__3; static PyObject *__pyx_kp_s__5; static PyObject *__pyx_n_s_active; static PyObject *__pyx_n_s_additional_info; static PyObject *__pyx_n_s_arg; static PyObject *__pyx_n_s_bootstrap; static PyObject *__pyx_n_s_bootstrap_2; static PyObject *__pyx_n_s_bootstrap_inner; static PyObject *__pyx_n_s_bootstrap_inner_2; static PyObject *__pyx_n_s_break_on_caught_exceptions; static PyObject *__pyx_n_s_break_on_user_uncaught_exception; static PyObject *__pyx_n_s_breakpoints; static PyObject *__pyx_n_s_breakpoints_hit_at_lines; static PyObject *__pyx_n_s_cache; static PyObject *__pyx_n_s_call; static PyObject *__pyx_n_s_call_2; static PyObject *__pyx_n_s_can_skip; static PyObject *__pyx_n_s_clear_thread_local_info; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_code_line_info; static PyObject *__pyx_n_s_code_obj; static PyObject *__pyx_n_s_code_obj_py; static PyObject *__pyx_n_s_compute_force_stay_in_untraced_m; static PyObject *__pyx_n_s_current_thread; static PyObject *__pyx_n_s_decref_py; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_dis; static PyObject *__pyx_n_s_dummy_trace_dispatch; static PyObject *__pyx_n_s_dummy_tracing_holder; static PyObject *__pyx_n_s_enter; static PyObject *__pyx_n_s_event; static PyObject *__pyx_n_s_exec; static PyObject *__pyx_n_s_exit; static PyObject *__pyx_n_s_f_back; static PyObject *__pyx_n_s_f_trace; static PyObject *__pyx_n_s_findlinestarts; static PyObject *__pyx_n_s_first_line; static PyObject *__pyx_n_s_fix_top_level_trace_and_get_trac; static PyObject *__pyx_n_s_frame; static PyObject *__pyx_n_s_frame_eval_func; static PyObject *__pyx_n_s_function_breakpoint_name_to_brea; static PyObject *__pyx_n_s_generate_code_with_breakpoints_p; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_get_abs_path_real_path_and_base; static PyObject *__pyx_n_s_get_cache_file_type; static PyObject *__pyx_n_s_get_cached_code_obj_info_py; static PyObject *__pyx_n_s_get_code_line_info; static PyObject *__pyx_n_s_get_file_type; static PyObject *__pyx_n_s_get_func_code_info_py; static PyObject *__pyx_n_s_get_ident; static PyObject *__pyx_n_s_get_ident_2; static PyObject *__pyx_n_s_get_thread_info_py; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_global_dbg; static PyObject *__pyx_n_s_has_plugin_exception_breaks; static PyObject *__pyx_n_s_has_plugin_line_breaks; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_insert_pydevd_breaks; static PyObject *__pyx_n_s_intersection; static PyObject *__pyx_n_s_is_pydev_daemon_thread; static PyObject *__pyx_n_s_issuperset; static PyObject *__pyx_n_s_last_line; static PyObject *__pyx_n_s_line; static PyObject *__pyx_n_s_line_to_offset; static PyObject *__pyx_n_s_local; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_main_2; static PyObject *__pyx_n_s_max; static PyObject *__pyx_n_s_min; static PyObject *__pyx_n_s_mtime; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_new; static PyObject *__pyx_n_s_obj; static PyObject *__pyx_n_s_offset; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_plugin; static PyObject *__pyx_n_s_pydev_bundle__pydev_saved_modul; static PyObject *__pyx_n_s_pydev_monkey; static PyObject *__pyx_n_s_pydevd; static PyObject *__pyx_n_s_pydevd_bundle_pydevd_additional; static PyObject *__pyx_n_s_pydevd_bundle_pydevd_constants; static PyObject *__pyx_n_s_pydevd_bundle_pydevd_trace_disp; static PyObject *__pyx_n_s_pydevd_file_utils; static PyObject *__pyx_n_s_pydevd_frame_eval_pydevd_frame; static PyObject *__pyx_kp_s_pydevd_frame_eval_pydevd_frame_2; static PyObject *__pyx_n_s_pydevd_frame_eval_pydevd_frame_3; static PyObject *__pyx_n_s_pydevd_frame_eval_pydevd_modify; static PyObject *__pyx_n_s_pydevd_tracing; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_FuncCodeInfo; static PyObject *__pyx_n_s_pyx_unpickle_ThreadInfo; static PyObject *__pyx_n_s_pyx_unpickle__CacheValue; static PyObject *__pyx_n_s_pyx_unpickle__CodeLineInfo; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_rfind; static PyObject *__pyx_n_s_run; static PyObject *__pyx_n_s_set_additional_thread_info_lock; static PyObject *__pyx_n_s_set_trace_func; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_show_return_values; static PyObject *__pyx_n_s_signature_factory; static PyObject *__pyx_n_s_state; static PyObject *__pyx_n_s_stop_frame_eval; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_thread; static PyObject *__pyx_n_s_thread_active; static PyObject *__pyx_n_s_thread_info; static PyObject *__pyx_n_s_thread_local_info; static PyObject *__pyx_n_s_threading; static PyObject *__pyx_n_s_trace_dispatch; static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_update_globals_dict; static PyObject *__pyx_n_s_version_info; static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_clear_thread_local_info(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo___reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_2__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_2__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_4__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_2dummy_trace_dispatch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_frame, PyObject *__pyx_v_event, PyObject *__pyx_v_arg); /* proto */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_4get_thread_info_py(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_6decref_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_obj); /* proto */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_8get_func_code_info_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_thread_info, PyObject *__pyx_v_frame, PyObject *__pyx_v_code_obj); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_line_to_offset, int __pyx_v_first_line, int __pyx_v_last_line); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_2__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_4__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10_get_code_line_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12get_cached_code_obj_info_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_code_obj_py, struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_code_line_info, PyObject *__pyx_v_breakpoints_hit_at_lines); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_2compute_force_stay_in_untraced_mode(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_breakpoints); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_4__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_6__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_14generate_code_with_breakpoints_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py, PyObject *__pyx_v_breakpoints); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_16frame_eval_func(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_18stop_frame_eval(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_20__pyx_unpickle_ThreadInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_22__pyx_unpickle_FuncCodeInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_24__pyx_unpickle__CodeLineInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_26__pyx_unpickle__CacheValue(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; static PyObject *__pyx_int_3; static PyObject *__pyx_int_9; static PyObject *__pyx_int_2520179; static PyObject *__pyx_int_11485321; static PyObject *__pyx_int_64258489; static PyObject *__pyx_int_66829570; static PyObject *__pyx_int_72405718; static PyObject *__pyx_int_95010005; static PyObject *__pyx_int_156687530; static PyObject *__pyx_int_180628038; static PyObject *__pyx_int_188670045; static PyObject *__pyx_int_193022138; static PyObject *__pyx_int_240343912; static PyObject *__pyx_int_249558979; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_slice__24; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__36; static PyObject *__pyx_codeobj__10; static PyObject *__pyx_codeobj__12; static PyObject *__pyx_codeobj__13; static PyObject *__pyx_codeobj__15; static PyObject *__pyx_codeobj__17; static PyObject *__pyx_codeobj__19; static PyObject *__pyx_codeobj__21; static PyObject *__pyx_codeobj__23; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__31; static PyObject *__pyx_codeobj__33; static PyObject *__pyx_codeobj__35; static PyObject *__pyx_codeobj__37; /* Late includes */ /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":19 * _thread_active = threading._active * * def clear_thread_local_info(): # <<<<<<<<<<<<<< * global _thread_local_info * _thread_local_info = threading.local() */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_1clear_thread_local_info(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_1clear_thread_local_info = {"clear_thread_local_info", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_1clear_thread_local_info, METH_NOARGS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_1clear_thread_local_info(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("clear_thread_local_info (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_clear_thread_local_info(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_clear_thread_local_info(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_thread_local_info", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":21 * def clear_thread_local_info(): * global _thread_local_info * _thread_local_info = threading.local() # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_local); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_thread_local_info, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":19 * _thread_active = threading._active * * def clear_thread_local_info(): # <<<<<<<<<<<<<< * global _thread_local_info * _thread_local_info = threading.local() */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.clear_thread_local_info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":39 * cdef public bint force_stay_in_untraced_mode * * cdef initialize(self, PyFrameObject * frame_obj): # <<<<<<<<<<<<<< * # Places that create a ThreadInfo should verify that * # a current Python frame is being executed! */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyFrameObject *__pyx_v_frame_obj) { PyObject *__pyx_v_basename = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_j = NULL; PyObject *__pyx_v_co_name = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyFrameObject *__pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("initialize", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":42 * # Places that create a ThreadInfo should verify that * # a current Python frame is being executed! * assert frame_obj != NULL # <<<<<<<<<<<<<< * * self.additional_info = None */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_frame_obj != NULL) != 0))) { PyErr_SetNone(PyExc_AssertionError); __PYX_ERR(0, 42, __pyx_L1_error) } } #endif /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":44 * assert frame_obj != NULL * * self.additional_info = None # <<<<<<<<<<<<<< * self.is_pydevd_thread = False * self.inside_frame_eval = 0 */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->additional_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->additional_info)); __pyx_v_self->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)Py_None); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":45 * * self.additional_info = None * self.is_pydevd_thread = False # <<<<<<<<<<<<<< * self.inside_frame_eval = 0 * self.fully_initialized = False */ __pyx_v_self->is_pydevd_thread = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":46 * self.additional_info = None * self.is_pydevd_thread = False * self.inside_frame_eval = 0 # <<<<<<<<<<<<<< * self.fully_initialized = False * self.thread_trace_func = None */ __pyx_v_self->inside_frame_eval = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":47 * self.is_pydevd_thread = False * self.inside_frame_eval = 0 * self.fully_initialized = False # <<<<<<<<<<<<<< * self.thread_trace_func = None * */ __pyx_v_self->fully_initialized = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":48 * self.inside_frame_eval = 0 * self.fully_initialized = False * self.thread_trace_func = None # <<<<<<<<<<<<<< * * # Get the root (if it's not a Thread initialized from the threading */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->thread_trace_func); __Pyx_DECREF(__pyx_v_self->thread_trace_func); __pyx_v_self->thread_trace_func = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":54 * # otherwise, we have to wait for the threading module itself to * # create the Thread entry). * while frame_obj.f_back != NULL: # <<<<<<<<<<<<<< * frame_obj = frame_obj.f_back * */ while (1) { __pyx_t_1 = ((__pyx_v_frame_obj->f_back != NULL) != 0); if (!__pyx_t_1) break; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":55 * # create the Thread entry). * while frame_obj.f_back != NULL: * frame_obj = frame_obj.f_back # <<<<<<<<<<<<<< * * basename = <str> frame_obj.f_code.co_filename */ __pyx_t_2 = __pyx_v_frame_obj->f_back; __pyx_v_frame_obj = __pyx_t_2; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":57 * frame_obj = frame_obj.f_back * * basename = <str> frame_obj.f_code.co_filename # <<<<<<<<<<<<<< * i = basename.rfind('/') * j = basename.rfind('\\') */ __pyx_t_3 = ((PyObject *)__pyx_v_frame_obj->f_code->co_filename); __Pyx_INCREF(__pyx_t_3); __pyx_v_basename = __pyx_t_3; __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":58 * * basename = <str> frame_obj.f_code.co_filename * i = basename.rfind('/') # <<<<<<<<<<<<<< * j = basename.rfind('\\') * if j > i: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_basename, __pyx_n_s_rfind); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_s_) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s_); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_i = __pyx_t_3; __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":59 * basename = <str> frame_obj.f_code.co_filename * i = basename.rfind('/') * j = basename.rfind('\\') # <<<<<<<<<<<<<< * if j > i: * i = j */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_basename, __pyx_n_s_rfind); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_s__2) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s__2); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_j = __pyx_t_3; __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":60 * i = basename.rfind('/') * j = basename.rfind('\\') * if j > i: # <<<<<<<<<<<<<< * i = j * if i >= 0: */ __pyx_t_3 = PyObject_RichCompare(__pyx_v_j, __pyx_v_i, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 60, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":61 * j = basename.rfind('\\') * if j > i: * i = j # <<<<<<<<<<<<<< * if i >= 0: * basename = basename[i + 1:] */ __Pyx_INCREF(__pyx_v_j); __Pyx_DECREF_SET(__pyx_v_i, __pyx_v_j); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":60 * i = basename.rfind('/') * j = basename.rfind('\\') * if j > i: # <<<<<<<<<<<<<< * i = j * if i >= 0: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":62 * if j > i: * i = j * if i >= 0: # <<<<<<<<<<<<<< * basename = basename[i + 1:] * # remove ext */ __pyx_t_3 = PyObject_RichCompare(__pyx_v_i, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 62, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":63 * i = j * if i >= 0: * basename = basename[i + 1:] # <<<<<<<<<<<<<< * # remove ext * i = basename.rfind('.') */ __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_basename, 0, 0, &__pyx_t_3, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_basename, __pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":62 * if j > i: * i = j * if i >= 0: # <<<<<<<<<<<<<< * basename = basename[i + 1:] * # remove ext */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":65 * basename = basename[i + 1:] * # remove ext * i = basename.rfind('.') # <<<<<<<<<<<<<< * if i >= 0: * basename = basename[:i] */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_basename, __pyx_n_s_rfind); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_kp_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_s__3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_i, __pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":66 * # remove ext * i = basename.rfind('.') * if i >= 0: # <<<<<<<<<<<<<< * basename = basename[:i] * */ __pyx_t_4 = PyObject_RichCompare(__pyx_v_i, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 66, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 66, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":67 * i = basename.rfind('.') * if i >= 0: * basename = basename[:i] # <<<<<<<<<<<<<< * * co_name = <str> frame_obj.f_code.co_name */ __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_basename, 0, 0, NULL, &__pyx_v_i, NULL, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_basename, __pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":66 * # remove ext * i = basename.rfind('.') * if i >= 0: # <<<<<<<<<<<<<< * basename = basename[:i] * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":69 * basename = basename[:i] * * co_name = <str> frame_obj.f_code.co_name # <<<<<<<<<<<<<< * * # In these cases we cannot create a dummy thread (an actual */ __pyx_t_4 = ((PyObject *)__pyx_v_frame_obj->f_code->co_name); __Pyx_INCREF(__pyx_t_4); __pyx_v_co_name = __pyx_t_4; __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":73 * # In these cases we cannot create a dummy thread (an actual * # thread will be created later or tracing will already be set). * if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydev_monkey' and co_name == '__call__': */ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_v_basename, __pyx_n_s_threading, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 73, __pyx_L1_error) if (__pyx_t_6) { } else { __pyx_t_1 = __pyx_t_6; goto __pyx_L9_bool_binop_done; } __Pyx_INCREF(__pyx_v_co_name); __pyx_t_4 = __pyx_v_co_name; __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_bootstrap, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 73, __pyx_L1_error) if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L11_bool_binop_done; } __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_bootstrap_2, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 73, __pyx_L1_error) if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L11_bool_binop_done; } __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_bootstrap_inner, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 73, __pyx_L1_error) if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L11_bool_binop_done; } __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_bootstrap_inner_2, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 73, __pyx_L1_error) __pyx_t_6 = __pyx_t_7; __pyx_L11_bool_binop_done:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = (__pyx_t_6 != 0); __pyx_t_1 = __pyx_t_7; __pyx_L9_bool_binop_done:; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":74 * # thread will be created later or tracing will already be set). * if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): * self._can_create_dummy_thread = False # <<<<<<<<<<<<<< * elif basename == 'pydev_monkey' and co_name == '__call__': * self._can_create_dummy_thread = False */ __pyx_v_self->_can_create_dummy_thread = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":73 * # In these cases we cannot create a dummy thread (an actual * # thread will be created later or tracing will already be set). * if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydev_monkey' and co_name == '__call__': */ goto __pyx_L8; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":75 * if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): * self._can_create_dummy_thread = False * elif basename == 'pydev_monkey' and co_name == '__call__': # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): */ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_basename, __pyx_n_s_pydev_monkey, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 75, __pyx_L1_error) if (__pyx_t_7) { } else { __pyx_t_1 = __pyx_t_7; goto __pyx_L15_bool_binop_done; } __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_co_name, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 75, __pyx_L1_error) __pyx_t_1 = __pyx_t_7; __pyx_L15_bool_binop_done:; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":76 * self._can_create_dummy_thread = False * elif basename == 'pydev_monkey' and co_name == '__call__': * self._can_create_dummy_thread = False # <<<<<<<<<<<<<< * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): * self._can_create_dummy_thread = False */ __pyx_v_self->_can_create_dummy_thread = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":75 * if basename == 'threading' and co_name in ('__bootstrap', '_bootstrap', '__bootstrap_inner', '_bootstrap_inner'): * self._can_create_dummy_thread = False * elif basename == 'pydev_monkey' and co_name == '__call__': # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): */ goto __pyx_L8; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":77 * elif basename == 'pydev_monkey' and co_name == '__call__': * self._can_create_dummy_thread = False * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydevd_tracing': */ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_basename, __pyx_n_s_pydevd, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) if (__pyx_t_7) { } else { __pyx_t_1 = __pyx_t_7; goto __pyx_L17_bool_binop_done; } __Pyx_INCREF(__pyx_v_co_name); __pyx_t_4 = __pyx_v_co_name; __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_run, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) if (!__pyx_t_6) { } else { __pyx_t_7 = __pyx_t_6; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_main, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) if (!__pyx_t_6) { } else { __pyx_t_7 = __pyx_t_6; goto __pyx_L19_bool_binop_done; } __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_exec, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) __pyx_t_7 = __pyx_t_6; __pyx_L19_bool_binop_done:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = (__pyx_t_7 != 0); __pyx_t_1 = __pyx_t_6; __pyx_L17_bool_binop_done:; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":78 * self._can_create_dummy_thread = False * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): * self._can_create_dummy_thread = False # <<<<<<<<<<<<<< * elif basename == 'pydevd_tracing': * self._can_create_dummy_thread = False */ __pyx_v_self->_can_create_dummy_thread = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":77 * elif basename == 'pydev_monkey' and co_name == '__call__': * self._can_create_dummy_thread = False * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * elif basename == 'pydevd_tracing': */ goto __pyx_L8; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":79 * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): * self._can_create_dummy_thread = False * elif basename == 'pydevd_tracing': # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * else: */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_basename, __pyx_n_s_pydevd_tracing, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 79, __pyx_L1_error) if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":80 * self._can_create_dummy_thread = False * elif basename == 'pydevd_tracing': * self._can_create_dummy_thread = False # <<<<<<<<<<<<<< * else: * self._can_create_dummy_thread = True */ __pyx_v_self->_can_create_dummy_thread = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":79 * elif basename == 'pydevd' and co_name in ('run', 'main', '_exec'): * self._can_create_dummy_thread = False * elif basename == 'pydevd_tracing': # <<<<<<<<<<<<<< * self._can_create_dummy_thread = False * else: */ goto __pyx_L8; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":82 * self._can_create_dummy_thread = False * else: * self._can_create_dummy_thread = True # <<<<<<<<<<<<<< * * # print('Can create dummy thread for thread started in: %s %s' % (basename, co_name)) */ /*else*/ { __pyx_v_self->_can_create_dummy_thread = 1; } __pyx_L8:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":39 * cdef public bint force_stay_in_untraced_mode * * cdef initialize(self, PyFrameObject * frame_obj): # <<<<<<<<<<<<<< * # Places that create a ThreadInfo should verify that * # a current Python frame is being executed! */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.initialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_basename); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_j); __Pyx_XDECREF(__pyx_v_co_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":86 * # print('Can create dummy thread for thread started in: %s %s' % (basename, co_name)) * * cdef initialize_if_possible(self): # <<<<<<<<<<<<<< * # Don't call threading.currentThread because if we're too early in the process * # we may create a dummy thread. */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize_if_possible(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_v_thread_ident = NULL; PyObject *__pyx_v_t = NULL; PyObject *__pyx_v_additional_info = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("initialize_if_possible", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":89 * # Don't call threading.currentThread because if we're too early in the process * # we may create a dummy thread. * self.inside_frame_eval += 1 # <<<<<<<<<<<<<< * * try: */ __pyx_v_self->inside_frame_eval = (__pyx_v_self->inside_frame_eval + 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":91 * self.inside_frame_eval += 1 * * try: # <<<<<<<<<<<<<< * thread_ident = _get_ident() * t = _thread_active.get(thread_ident) */ /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":92 * * try: * thread_ident = _get_ident() # <<<<<<<<<<<<<< * t = _thread_active.get(thread_ident) * if t is None: */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_get_ident); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_thread_ident = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":93 * try: * thread_ident = _get_ident() * t = _thread_active.get(thread_ident) # <<<<<<<<<<<<<< * if t is None: * if self._can_create_dummy_thread: */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_thread_active); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 93, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_thread_ident) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_thread_ident); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_t = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":94 * thread_ident = _get_ident() * t = _thread_active.get(thread_ident) * if t is None: # <<<<<<<<<<<<<< * if self._can_create_dummy_thread: * # Initialize the dummy thread and set the tracing (both are needed to */ __pyx_t_4 = (__pyx_v_t == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":95 * t = _thread_active.get(thread_ident) * if t is None: * if self._can_create_dummy_thread: # <<<<<<<<<<<<<< * # Initialize the dummy thread and set the tracing (both are needed to * # actually stop on breakpoints). */ __pyx_t_5 = (__pyx_v_self->_can_create_dummy_thread != 0); if (__pyx_t_5) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":98 * # Initialize the dummy thread and set the tracing (both are needed to * # actually stop on breakpoints). * t = threading.current_thread() # <<<<<<<<<<<<<< * SetTrace(dummy_trace_dispatch) * else: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_current_thread); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_t, __pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":99 * # actually stop on breakpoints). * t = threading.current_thread() * SetTrace(dummy_trace_dispatch) # <<<<<<<<<<<<<< * else: * return # Cannot initialize until thread becomes active. */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SetTrace); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_dummy_trace_dispatch); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":95 * t = _thread_active.get(thread_ident) * if t is None: * if self._can_create_dummy_thread: # <<<<<<<<<<<<<< * # Initialize the dummy thread and set the tracing (both are needed to * # actually stop on breakpoints). */ goto __pyx_L7; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":101 * SetTrace(dummy_trace_dispatch) * else: * return # Cannot initialize until thread becomes active. # <<<<<<<<<<<<<< * * if getattr(t, 'is_pydev_daemon_thread', False): */ /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L3_return; } __pyx_L7:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":94 * thread_ident = _get_ident() * t = _thread_active.get(thread_ident) * if t is None: # <<<<<<<<<<<<<< * if self._can_create_dummy_thread: * # Initialize the dummy thread and set the tracing (both are needed to */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":103 * return # Cannot initialize until thread becomes active. * * if getattr(t, 'is_pydev_daemon_thread', False): # <<<<<<<<<<<<<< * self.is_pydevd_thread = True * self.fully_initialized = True */ __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_t, __pyx_n_s_is_pydev_daemon_thread, Py_False); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 103, __pyx_L4_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_5) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":104 * * if getattr(t, 'is_pydev_daemon_thread', False): * self.is_pydevd_thread = True # <<<<<<<<<<<<<< * self.fully_initialized = True * else: */ __pyx_v_self->is_pydevd_thread = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":105 * if getattr(t, 'is_pydev_daemon_thread', False): * self.is_pydevd_thread = True * self.fully_initialized = True # <<<<<<<<<<<<<< * else: * try: */ __pyx_v_self->fully_initialized = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":103 * return # Cannot initialize until thread becomes active. * * if getattr(t, 'is_pydev_daemon_thread', False): # <<<<<<<<<<<<<< * self.is_pydevd_thread = True * self.fully_initialized = True */ goto __pyx_L8; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":107 * self.fully_initialized = True * else: * try: # <<<<<<<<<<<<<< * additional_info = t.additional_info * if additional_info is None: */ /*else*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":108 * else: * try: * additional_info = t.additional_info # <<<<<<<<<<<<<< * if additional_info is None: * raise AttributeError() */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_additional_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L9_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_additional_info = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":109 * try: * additional_info = t.additional_info * if additional_info is None: # <<<<<<<<<<<<<< * raise AttributeError() * except: */ __pyx_t_5 = (__pyx_v_additional_info == Py_None); __pyx_t_4 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_4)) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":110 * additional_info = t.additional_info * if additional_info is None: * raise AttributeError() # <<<<<<<<<<<<<< * except: * with _set_additional_thread_info_lock: */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_AttributeError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L9_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 110, __pyx_L9_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":109 * try: * additional_info = t.additional_info * if additional_info is None: # <<<<<<<<<<<<<< * raise AttributeError() * except: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":107 * self.fully_initialized = True * else: * try: # <<<<<<<<<<<<<< * additional_info = t.additional_info * if additional_info is None: */ } __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L14_try_end; __pyx_L9_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":111 * if additional_info is None: * raise AttributeError() * except: # <<<<<<<<<<<<<< * with _set_additional_thread_info_lock: * # If it's not there, set it within a lock to avoid any racing */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.initialize_if_possible", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 111, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_3); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":112 * raise AttributeError() * except: * with _set_additional_thread_info_lock: # <<<<<<<<<<<<<< * # If it's not there, set it within a lock to avoid any racing * # conditions. */ /*with:*/ { __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_set_additional_thread_info_lock); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 112, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = __Pyx_PyObject_LookupSpecial(__pyx_t_6, __pyx_n_s_exit); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 112, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_12 = __Pyx_PyObject_LookupSpecial(__pyx_t_6, __pyx_n_s_enter); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 112, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } __pyx_t_11 = (__pyx_t_13) ? __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_13) : __Pyx_PyObject_CallNoArg(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 112, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /*try:*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":115 * # If it's not there, set it within a lock to avoid any racing * # conditions. * additional_info = getattr(thread, 'additional_info', None) # <<<<<<<<<<<<<< * if additional_info is None: * additional_info = PyDBAdditionalThreadInfo() */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_thread); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 115, __pyx_L24_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __Pyx_GetAttr3(__pyx_t_6, __pyx_n_s_additional_info, Py_None); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 115, __pyx_L24_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_additional_info, __pyx_t_11); __pyx_t_11 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":116 * # conditions. * additional_info = getattr(thread, 'additional_info', None) * if additional_info is None: # <<<<<<<<<<<<<< * additional_info = PyDBAdditionalThreadInfo() * t.additional_info = additional_info */ __pyx_t_4 = (__pyx_v_additional_info == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":117 * additional_info = getattr(thread, 'additional_info', None) * if additional_info is None: * additional_info = PyDBAdditionalThreadInfo() # <<<<<<<<<<<<<< * t.additional_info = additional_info * self.additional_info = additional_info */ __pyx_t_11 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 117, __pyx_L24_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF_SET(__pyx_v_additional_info, __pyx_t_11); __pyx_t_11 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":116 * # conditions. * additional_info = getattr(thread, 'additional_info', None) * if additional_info is None: # <<<<<<<<<<<<<< * additional_info = PyDBAdditionalThreadInfo() * t.additional_info = additional_info */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":118 * if additional_info is None: * additional_info = PyDBAdditionalThreadInfo() * t.additional_info = additional_info # <<<<<<<<<<<<<< * self.additional_info = additional_info * self.fully_initialized = True */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_additional_info, __pyx_v_additional_info) < 0) __PYX_ERR(0, 118, __pyx_L24_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":112 * raise AttributeError() * except: * with _set_additional_thread_info_lock: # <<<<<<<<<<<<<< * # If it's not there, set it within a lock to avoid any racing * # conditions. */ } __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L31_try_end; __pyx_L24_error:; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.initialize_if_possible", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_6, &__pyx_t_12) < 0) __PYX_ERR(0, 112, __pyx_L26_except_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_11, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L26_except_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 112, __pyx_L26_except_error) __Pyx_GOTREF(__pyx_t_17); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_5 < 0) __PYX_ERR(0, 112, __pyx_L26_except_error) __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestoreWithState(__pyx_t_11, __pyx_t_6, __pyx_t_12); __pyx_t_11 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; __PYX_ERR(0, 112, __pyx_L26_except_error) } __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L25_exception_handled; } __pyx_L26_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L11_except_error; __pyx_L25_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_L31_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_10) { __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_tuple__4, NULL); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 112, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; } goto __pyx_L23; } __pyx_L23:; } goto __pyx_L36; __pyx_L18_error:; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L11_except_error; __pyx_L36:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_exception_handled; } __pyx_L11_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":107 * self.fully_initialized = True * else: * try: # <<<<<<<<<<<<<< * additional_info = t.additional_info * if additional_info is None: */ __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); goto __pyx_L4_error; __pyx_L10_exception_handled:; __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); __pyx_L14_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":119 * additional_info = PyDBAdditionalThreadInfo() * t.additional_info = additional_info * self.additional_info = additional_info # <<<<<<<<<<<<<< * self.fully_initialized = True * finally: */ if (unlikely(!__pyx_v_additional_info)) { __Pyx_RaiseUnboundLocalError("additional_info"); __PYX_ERR(0, 119, __pyx_L4_error) } if (!(likely(((__pyx_v_additional_info) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_additional_info, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) __PYX_ERR(0, 119, __pyx_L4_error) __pyx_t_3 = __pyx_v_additional_info; __Pyx_INCREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_self->additional_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->additional_info)); __pyx_v_self->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_3); __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":120 * t.additional_info = additional_info * self.additional_info = additional_info * self.fully_initialized = True # <<<<<<<<<<<<<< * finally: * self.inside_frame_eval -= 1 */ __pyx_v_self->fully_initialized = 1; } __pyx_L8:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":122 * self.fully_initialized = True * finally: * self.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * * */ /*finally:*/ { /*normal exit:*/{ __pyx_v_self->inside_frame_eval = (__pyx_v_self->inside_frame_eval - 1); goto __pyx_L5; } __pyx_L4_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_10 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_16, &__pyx_t_15); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __pyx_v_self->inside_frame_eval = (__pyx_v_self->inside_frame_eval - 1); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_16, __pyx_t_15); } __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_9, __pyx_t_8, __pyx_t_7); __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_10 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L1_error; } __pyx_L3_return: { __pyx_t_15 = __pyx_r; __pyx_r = 0; __pyx_v_self->inside_frame_eval = (__pyx_v_self->inside_frame_eval - 1); __pyx_r = __pyx_t_15; __pyx_t_15 = 0; goto __pyx_L0; } __pyx_L5:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":86 * # print('Can create dummy thread for thread started in: %s %s' % (basename, co_name)) * * cdef initialize_if_possible(self): # <<<<<<<<<<<<<< * # Don't call threading.currentThread because if we're too early in the process * # we may create a dummy thread. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.initialize_if_possible", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_thread_ident); __Pyx_XDECREF(__pyx_v_t); __Pyx_XDECREF(__pyx_v_additional_info); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":26 * cdef class ThreadInfo: * * cdef public PyDBAdditionalThreadInfo additional_info # <<<<<<<<<<<<<< * cdef public bint is_pydevd_thread * cdef public int inside_frame_eval */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self->additional_info)); __pyx_r = ((PyObject *)__pyx_v_self->additional_info); goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) __PYX_ERR(0, 26, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->additional_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->additional_info)); __pyx_v_self->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.additional_info.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->additional_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->additional_info)); __pyx_v_self->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":27 * * cdef public PyDBAdditionalThreadInfo additional_info * cdef public bint is_pydevd_thread # <<<<<<<<<<<<<< * cdef public int inside_frame_eval * cdef public bint fully_initialized */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->is_pydevd_thread); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.is_pydevd_thread.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L1_error) __pyx_v_self->is_pydevd_thread = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.is_pydevd_thread.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":28 * cdef public PyDBAdditionalThreadInfo additional_info * cdef public bint is_pydevd_thread * cdef public int inside_frame_eval # <<<<<<<<<<<<<< * cdef public bint fully_initialized * cdef public object thread_trace_func */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->inside_frame_eval); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.inside_frame_eval.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L1_error) __pyx_v_self->inside_frame_eval = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.inside_frame_eval.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":29 * cdef public bint is_pydevd_thread * cdef public int inside_frame_eval * cdef public bint fully_initialized # <<<<<<<<<<<<<< * cdef public object thread_trace_func * cdef bint _can_create_dummy_thread */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->fully_initialized); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.fully_initialized.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 29, __pyx_L1_error) __pyx_v_self->fully_initialized = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.fully_initialized.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":30 * cdef public int inside_frame_eval * cdef public bint fully_initialized * cdef public object thread_trace_func # <<<<<<<<<<<<<< * cdef bint _can_create_dummy_thread * */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->thread_trace_func); __pyx_r = __pyx_v_self->thread_trace_func; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->thread_trace_func); __Pyx_DECREF(__pyx_v_self->thread_trace_func); __pyx_v_self->thread_trace_func = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->thread_trace_func); __Pyx_DECREF(__pyx_v_self->thread_trace_func); __pyx_v_self->thread_trace_func = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":37 * # If True the debugger should not go into trace mode even if the new * # code for a function is None and there are breakpoints. * cdef public bint force_stay_in_untraced_mode # <<<<<<<<<<<<<< * * cdef initialize(self, PyFrameObject * frame_obj): */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->force_stay_in_untraced_mode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.force_stay_in_untraced_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 37, __pyx_L1_error) __pyx_v_self->force_stay_in_untraced_mode = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.force_stay_in_untraced_mode.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo___reduce_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo___reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self._can_create_dummy_thread, self.additional_info, self.force_stay_in_untraced_mode, self.fully_initialized, self.inside_frame_eval, self.is_pydevd_thread, self.thread_trace_func) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_can_create_dummy_thread); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->force_stay_in_untraced_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_self->fully_initialized); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_self->inside_frame_eval); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->is_pydevd_thread); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyTuple_New(7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_v_self->additional_info)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self->additional_info)); PyTuple_SET_ITEM(__pyx_t_6, 1, ((PyObject *)__pyx_v_self->additional_info)); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 4, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 5, __pyx_t_5); __Pyx_INCREF(__pyx_v_self->thread_trace_func); __Pyx_GIVEREF(__pyx_v_self->thread_trace_func); PyTuple_SET_ITEM(__pyx_t_6, 6, __pyx_v_self->thread_trace_func); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_v_state = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self._can_create_dummy_thread, self.additional_info, self.force_stay_in_untraced_mode, self.fully_initialized, self.inside_frame_eval, self.is_pydevd_thread, self.thread_trace_func) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_6 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_v__dict = __pyx_t_6; __pyx_t_6 = 0; /* "(tree fragment)":7 * state = (self._can_create_dummy_thread, self.additional_info, self.force_stay_in_untraced_mode, self.fully_initialized, self.inside_frame_eval, self.is_pydevd_thread, self.thread_trace_func) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_7 = (__pyx_v__dict != Py_None); __pyx_t_8 = (__pyx_t_7 != 0); if (__pyx_t_8) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v__dict); __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_5)); __pyx_t_5 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.additional_info is not None or self.thread_trace_func is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self._can_create_dummy_thread, self.additional_info, self.force_stay_in_untraced_mode, self.fully_initialized, self.inside_frame_eval, self.is_pydevd_thread, self.thread_trace_func) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.additional_info is not None or self.thread_trace_func is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, None), state */ /*else*/ { __pyx_t_7 = (((PyObject *)__pyx_v_self->additional_info) != Py_None); __pyx_t_9 = (__pyx_t_7 != 0); if (!__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L4_bool_binop_done; } __pyx_t_9 = (__pyx_v_self->thread_trace_func != Py_None); __pyx_t_7 = (__pyx_t_9 != 0); __pyx_t_8 = __pyx_t_7; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_8; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.additional_info is not None or self.thread_trace_func is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, None), state * else: */ __pyx_t_8 = (__pyx_v_use_setstate != 0); if (__pyx_t_8) { /* "(tree fragment)":13 * use_setstate = self.additional_info is not None or self.thread_trace_func is not None * if use_setstate: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_ThreadInfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_6, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_11485321); __Pyx_GIVEREF(__pyx_int_11485321); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_11485321); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_6, 2, Py_None); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.additional_info is not None or self.thread_trace_func is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, None), state * else: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_ThreadInfo__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_ThreadInfo); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_6, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_11485321); __Pyx_GIVEREF(__pyx_int_11485321); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_11485321); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_ThreadInfo__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_2__setstate_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_2__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_ThreadInfo__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_ThreadInfo__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_ThreadInfo, (type(self), 0x0af4089, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_ThreadInfo__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":139 * cdef public int breakpoints_mtime * * def __init__(self): # <<<<<<<<<<<<<< * self.co_filename = '' * self.canonical_normalized_filename = '' */ /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo___init__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":140 * * def __init__(self): * self.co_filename = '' # <<<<<<<<<<<<<< * self.canonical_normalized_filename = '' * self.always_skip_code = False */ __Pyx_INCREF(__pyx_kp_s__5); __Pyx_GIVEREF(__pyx_kp_s__5); __Pyx_GOTREF(__pyx_v_self->co_filename); __Pyx_DECREF(__pyx_v_self->co_filename); __pyx_v_self->co_filename = __pyx_kp_s__5; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":141 * def __init__(self): * self.co_filename = '' * self.canonical_normalized_filename = '' # <<<<<<<<<<<<<< * self.always_skip_code = False * */ __Pyx_INCREF(__pyx_kp_s__5); __Pyx_GIVEREF(__pyx_kp_s__5); __Pyx_GOTREF(__pyx_v_self->canonical_normalized_filename); __Pyx_DECREF(__pyx_v_self->canonical_normalized_filename); __pyx_v_self->canonical_normalized_filename = __pyx_kp_s__5; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":142 * self.co_filename = '' * self.canonical_normalized_filename = '' * self.always_skip_code = False # <<<<<<<<<<<<<< * * # If breakpoints are found but new_code is None, */ __pyx_v_self->always_skip_code = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":147 * # this means we weren't able to actually add the code * # where needed, so, fallback to tracing. * self.breakpoint_found = False # <<<<<<<<<<<<<< * self.new_code = None * self.breakpoints_mtime = -1 */ __pyx_v_self->breakpoint_found = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":148 * # where needed, so, fallback to tracing. * self.breakpoint_found = False * self.new_code = None # <<<<<<<<<<<<<< * self.breakpoints_mtime = -1 * */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->new_code); __Pyx_DECREF(__pyx_v_self->new_code); __pyx_v_self->new_code = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":149 * self.breakpoint_found = False * self.new_code = None * self.breakpoints_mtime = -1 # <<<<<<<<<<<<<< * * */ __pyx_v_self->breakpoints_mtime = -1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":139 * cdef public int breakpoints_mtime * * def __init__(self): # <<<<<<<<<<<<<< * self.co_filename = '' * self.canonical_normalized_filename = '' */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":127 * cdef class FuncCodeInfo: * * cdef public str co_filename # <<<<<<<<<<<<<< * cdef public str co_name * cdef public str canonical_normalized_filename */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->co_filename); __pyx_r = __pyx_v_self->co_filename; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PyString_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 127, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->co_filename); __Pyx_DECREF(__pyx_v_self->co_filename); __pyx_v_self->co_filename = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.co_filename.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->co_filename); __Pyx_DECREF(__pyx_v_self->co_filename); __pyx_v_self->co_filename = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":128 * * cdef public str co_filename * cdef public str co_name # <<<<<<<<<<<<<< * cdef public str canonical_normalized_filename * cdef bint always_skip_code */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->co_name); __pyx_r = __pyx_v_self->co_name; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PyString_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 128, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->co_name); __Pyx_DECREF(__pyx_v_self->co_name); __pyx_v_self->co_name = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.co_name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->co_name); __Pyx_DECREF(__pyx_v_self->co_name); __pyx_v_self->co_name = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":129 * cdef public str co_filename * cdef public str co_name * cdef public str canonical_normalized_filename # <<<<<<<<<<<<<< * cdef bint always_skip_code * cdef public bint breakpoint_found */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->canonical_normalized_filename); __pyx_r = __pyx_v_self->canonical_normalized_filename; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PyString_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 129, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->canonical_normalized_filename); __Pyx_DECREF(__pyx_v_self->canonical_normalized_filename); __pyx_v_self->canonical_normalized_filename = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.canonical_normalized_filename.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->canonical_normalized_filename); __Pyx_DECREF(__pyx_v_self->canonical_normalized_filename); __pyx_v_self->canonical_normalized_filename = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":131 * cdef public str canonical_normalized_filename * cdef bint always_skip_code * cdef public bint breakpoint_found # <<<<<<<<<<<<<< * cdef public object new_code * */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->breakpoint_found); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.breakpoint_found.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error) __pyx_v_self->breakpoint_found = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.breakpoint_found.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":132 * cdef bint always_skip_code * cdef public bint breakpoint_found * cdef public object new_code # <<<<<<<<<<<<<< * * # When breakpoints_mtime != PyDb.mtime the validity of breakpoints have */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->new_code); __pyx_r = __pyx_v_self->new_code; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->new_code); __Pyx_DECREF(__pyx_v_self->new_code); __pyx_v_self->new_code = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->new_code); __Pyx_DECREF(__pyx_v_self->new_code); __pyx_v_self->new_code = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":137 * # to be re-evaluated (if invalid a new FuncCodeInfo must be created and * # tracing can't be disabled for the related frames). * cdef public int breakpoints_mtime # <<<<<<<<<<<<<< * * def __init__(self): */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->breakpoints_mtime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.breakpoints_mtime.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 137, __pyx_L1_error) __pyx_v_self->breakpoints_mtime = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.breakpoints_mtime.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_2__reduce_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_2__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.always_skip_code, self.breakpoint_found, self.breakpoints_mtime, self.canonical_normalized_filename, self.co_filename, self.co_name, self.new_code) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->always_skip_code); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->breakpoint_found); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->breakpoints_mtime); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); __Pyx_INCREF(__pyx_v_self->canonical_normalized_filename); __Pyx_GIVEREF(__pyx_v_self->canonical_normalized_filename); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_self->canonical_normalized_filename); __Pyx_INCREF(__pyx_v_self->co_filename); __Pyx_GIVEREF(__pyx_v_self->co_filename); PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_v_self->co_filename); __Pyx_INCREF(__pyx_v_self->co_name); __Pyx_GIVEREF(__pyx_v_self->co_name); PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_v_self->co_name); __Pyx_INCREF(__pyx_v_self->new_code); __Pyx_GIVEREF(__pyx_v_self->new_code); PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_v_self->new_code); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_v_state = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.always_skip_code, self.breakpoint_found, self.breakpoints_mtime, self.canonical_normalized_filename, self.co_filename, self.co_name, self.new_code) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v__dict = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":7 * state = (self.always_skip_code, self.breakpoint_found, self.breakpoints_mtime, self.canonical_normalized_filename, self.co_filename, self.co_name, self.new_code) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_5 = (__pyx_v__dict != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict); __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.canonical_normalized_filename is not None or self.co_filename is not None or self.co_name is not None or self.new_code is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.always_skip_code, self.breakpoint_found, self.breakpoints_mtime, self.canonical_normalized_filename, self.co_filename, self.co_name, self.new_code) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.canonical_normalized_filename is not None or self.co_filename is not None or self.co_name is not None or self.new_code is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, None), state */ /*else*/ { __pyx_t_5 = (__pyx_v_self->canonical_normalized_filename != ((PyObject*)Py_None)); __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L4_bool_binop_done; } __pyx_t_7 = (__pyx_v_self->co_filename != ((PyObject*)Py_None)); __pyx_t_5 = (__pyx_t_7 != 0); if (!__pyx_t_5) { } else { __pyx_t_6 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (__pyx_v_self->co_name != ((PyObject*)Py_None)); __pyx_t_7 = (__pyx_t_5 != 0); if (!__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L4_bool_binop_done; } __pyx_t_7 = (__pyx_v_self->new_code != Py_None); __pyx_t_5 = (__pyx_t_7 != 0); __pyx_t_6 = __pyx_t_5; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_6; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.canonical_normalized_filename is not None or self.co_filename is not None or self.co_name is not None or self.new_code is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, None), state * else: */ __pyx_t_6 = (__pyx_v_use_setstate != 0); if (__pyx_t_6) { /* "(tree fragment)":13 * use_setstate = self.canonical_normalized_filename is not None or self.co_filename is not None or self.co_name is not None or self.new_code is not None * if use_setstate: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_FuncCodeInfo); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_188670045); __Pyx_GIVEREF(__pyx_int_188670045); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_188670045); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.canonical_normalized_filename is not None or self.co_filename is not None or self.co_name is not None or self.new_code is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, None), state * else: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_FuncCodeInfo__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle_FuncCodeInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_188670045); __Pyx_GIVEREF(__pyx_int_188670045); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_188670045); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_FuncCodeInfo__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_4__setstate_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_4__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_FuncCodeInfo__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_FuncCodeInfo__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_FuncCodeInfo, (type(self), 0xb3ee05d, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_FuncCodeInfo__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":152 * * * def dummy_trace_dispatch(frame, str event, arg): # <<<<<<<<<<<<<< * if event == 'call': * if frame.f_trace is not None: */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_3dummy_trace_dispatch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_3dummy_trace_dispatch = {"dummy_trace_dispatch", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_3dummy_trace_dispatch, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_3dummy_trace_dispatch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_frame = 0; PyObject *__pyx_v_event = 0; PyObject *__pyx_v_arg = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dummy_trace_dispatch (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,&__pyx_n_s_event,&__pyx_n_s_arg,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("dummy_trace_dispatch", 1, 3, 3, 1); __PYX_ERR(0, 152, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("dummy_trace_dispatch", 1, 3, 3, 2); __PYX_ERR(0, 152, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dummy_trace_dispatch") < 0)) __PYX_ERR(0, 152, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_frame = values[0]; __pyx_v_event = ((PyObject*)values[1]); __pyx_v_arg = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("dummy_trace_dispatch", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 152, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.dummy_trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), (&PyString_Type), 1, "event", 1))) __PYX_ERR(0, 152, __pyx_L1_error) __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_2dummy_trace_dispatch(__pyx_self, __pyx_v_frame, __pyx_v_event, __pyx_v_arg); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_2dummy_trace_dispatch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_frame, PyObject *__pyx_v_event, PyObject *__pyx_v_arg) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("dummy_trace_dispatch", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":153 * * def dummy_trace_dispatch(frame, str event, arg): * if event == 'call': # <<<<<<<<<<<<<< * if frame.f_trace is not None: * return frame.f_trace(frame, event, arg) */ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_call_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":154 * def dummy_trace_dispatch(frame, str event, arg): * if event == 'call': * if frame.f_trace is not None: # <<<<<<<<<<<<<< * return frame.f_trace(frame, event, arg) * return None */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = (__pyx_t_3 != Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":155 * if event == 'call': * if frame.f_trace is not None: * return frame.f_trace(frame, event, arg) # <<<<<<<<<<<<<< * return None * */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_frame, __pyx_v_event, __pyx_v_arg}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_v_frame, __pyx_v_event, __pyx_v_arg}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_frame); __Pyx_INCREF(__pyx_v_event); __Pyx_GIVEREF(__pyx_v_event); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_event); __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_v_arg); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":154 * def dummy_trace_dispatch(frame, str event, arg): * if event == 'call': * if frame.f_trace is not None: # <<<<<<<<<<<<<< * return frame.f_trace(frame, event, arg) * return None */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":153 * * def dummy_trace_dispatch(frame, str event, arg): * if event == 'call': # <<<<<<<<<<<<<< * if frame.f_trace is not None: * return frame.f_trace(frame, event, arg) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":156 * if frame.f_trace is not None: * return frame.f_trace(frame, event, arg) * return None # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":152 * * * def dummy_trace_dispatch(frame, str event, arg): # <<<<<<<<<<<<<< * if event == 'call': * if frame.f_trace is not None: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.dummy_trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":159 * * * def get_thread_info_py() -> ThreadInfo: # <<<<<<<<<<<<<< * return get_thread_info(PyEval_GetFrame()) * */ /* Python wrapper */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_5get_thread_info_py(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_5get_thread_info_py = {"get_thread_info_py", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_5get_thread_info_py, METH_NOARGS, 0}; static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_5get_thread_info_py(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_thread_info_py (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_4get_thread_info_py(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_4get_thread_info_py(CYTHON_UNUSED PyObject *__pyx_self) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_thread_info_py", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":160 * * def get_thread_info_py() -> ThreadInfo: * return get_thread_info(PyEval_GetFrame()) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_1 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_thread_info(PyEval_GetFrame())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":159 * * * def get_thread_info_py() -> ThreadInfo: # <<<<<<<<<<<<<< * return get_thread_info(PyEval_GetFrame()) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_thread_info_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":163 * * * cdef ThreadInfo get_thread_info(PyFrameObject * frame_obj): # <<<<<<<<<<<<<< * ''' * Provides thread-related info. */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_thread_info(PyFrameObject *__pyx_v_frame_obj) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_thread_info = 0; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_thread_info", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":170 * ''' * cdef ThreadInfo thread_info * try: # <<<<<<<<<<<<<< * # Note: changing to a `dict[thread.ident] = thread_info` had almost no * # effect in the performance. */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":173 * # Note: changing to a `dict[thread.ident] = thread_info` had almost no * # effect in the performance. * thread_info = _thread_local_info.thread_info # <<<<<<<<<<<<<< * except: * if frame_obj == NULL: */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 173, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_thread_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 173, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo))))) __PYX_ERR(0, 173, __pyx_L3_error) __pyx_v_thread_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_5); __pyx_t_5 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":170 * ''' * cdef ThreadInfo thread_info * try: # <<<<<<<<<<<<<< * # Note: changing to a `dict[thread.ident] = thread_info` had almost no * # effect in the performance. */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":174 * # effect in the performance. * thread_info = _thread_local_info.thread_info * except: # <<<<<<<<<<<<<< * if frame_obj == NULL: * return None */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_thread_info", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(0, 174, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":175 * thread_info = _thread_local_info.thread_info * except: * if frame_obj == NULL: # <<<<<<<<<<<<<< * return None * thread_info = ThreadInfo() */ __pyx_t_7 = ((__pyx_v_frame_obj == NULL) != 0); if (__pyx_t_7) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":176 * except: * if frame_obj == NULL: * return None # <<<<<<<<<<<<<< * thread_info = ThreadInfo() * thread_info.initialize(frame_obj) */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_r = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)Py_None); __Pyx_INCREF(Py_None); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L6_except_return; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":175 * thread_info = _thread_local_info.thread_info * except: * if frame_obj == NULL: # <<<<<<<<<<<<<< * return None * thread_info = ThreadInfo() */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":177 * if frame_obj == NULL: * return None * thread_info = ThreadInfo() # <<<<<<<<<<<<<< * thread_info.initialize(frame_obj) * thread_info.inside_frame_eval += 1 */ __pyx_t_8 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 177, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_thread_info, ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_8)); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":178 * return None * thread_info = ThreadInfo() * thread_info.initialize(frame_obj) # <<<<<<<<<<<<<< * thread_info.inside_frame_eval += 1 * try: */ __pyx_t_8 = ((struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_thread_info->__pyx_vtab)->initialize(__pyx_v_thread_info, __pyx_v_frame_obj); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 178, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":179 * thread_info = ThreadInfo() * thread_info.initialize(frame_obj) * thread_info.inside_frame_eval += 1 # <<<<<<<<<<<<<< * try: * _thread_local_info.thread_info = thread_info */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval + 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":180 * thread_info.initialize(frame_obj) * thread_info.inside_frame_eval += 1 * try: # <<<<<<<<<<<<<< * _thread_local_info.thread_info = thread_info * */ /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":181 * thread_info.inside_frame_eval += 1 * try: * _thread_local_info.thread_info = thread_info # <<<<<<<<<<<<<< * * # Note: _code_extra_index is not actually thread-related, */ __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_8); if (__Pyx_PyObject_SetAttrStr(__pyx_t_8, __pyx_n_s_thread_info, ((PyObject *)__pyx_v_thread_info)) < 0) __PYX_ERR(0, 181, __pyx_L15_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":186 * # but this is a good point to initialize it. * global _code_extra_index * if _code_extra_index == -1: # <<<<<<<<<<<<<< * _code_extra_index = <int> _PyEval_RequestCodeExtraIndex(release_co_extra) * */ __pyx_t_7 = ((__pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index == -1L) != 0); if (__pyx_t_7) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":187 * global _code_extra_index * if _code_extra_index == -1: * _code_extra_index = <int> _PyEval_RequestCodeExtraIndex(release_co_extra) # <<<<<<<<<<<<<< * * thread_info.initialize_if_possible() */ __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index = ((int)_PyEval_RequestCodeExtraIndex(release_co_extra)); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":186 * # but this is a good point to initialize it. * global _code_extra_index * if _code_extra_index == -1: # <<<<<<<<<<<<<< * _code_extra_index = <int> _PyEval_RequestCodeExtraIndex(release_co_extra) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":189 * _code_extra_index = <int> _PyEval_RequestCodeExtraIndex(release_co_extra) * * thread_info.initialize_if_possible() # <<<<<<<<<<<<<< * finally: * thread_info.inside_frame_eval -= 1 */ __pyx_t_8 = ((struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_thread_info->__pyx_vtab)->initialize_if_possible(__pyx_v_thread_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 189, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":191 * thread_info.initialize_if_possible() * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * * return thread_info */ /*finally:*/ { /*normal exit:*/{ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); goto __pyx_L16; } __pyx_L15_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_9 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L5_except_error; } __pyx_L16:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } __pyx_L5_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":170 * ''' * cdef ThreadInfo thread_info * try: # <<<<<<<<<<<<<< * # Note: changing to a `dict[thread.ident] = thread_info` had almost no * # effect in the performance. */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L8_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":193 * thread_info.inside_frame_eval -= 1 * * return thread_info # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_thread_info)); __pyx_r = __pyx_v_thread_info; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":163 * * * cdef ThreadInfo get_thread_info(PyFrameObject * frame_obj): # <<<<<<<<<<<<<< * ''' * Provides thread-related info. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_thread_info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_thread_info); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":196 * * * def decref_py(obj): # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_7decref_py(PyObject *__pyx_self, PyObject *__pyx_v_obj); /*proto*/ static char __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_6decref_py[] = "\n Helper to be called from Python.\n "; static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_7decref_py = {"decref_py", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_7decref_py, METH_O, __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_6decref_py}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_7decref_py(PyObject *__pyx_self, PyObject *__pyx_v_obj) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("decref_py (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_6decref_py(__pyx_self, ((PyObject *)__pyx_v_obj)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_6decref_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_obj) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("decref_py", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":200 * Helper to be called from Python. * ''' * Py_DECREF(obj) # <<<<<<<<<<<<<< * * */ Py_DECREF(__pyx_v_obj); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":196 * * * def decref_py(obj): # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":203 * * * def get_func_code_info_py(thread_info, frame, code_obj) -> FuncCodeInfo: # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ /* Python wrapper */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_9get_func_code_info_py(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_8get_func_code_info_py[] = "\n Helper to be called from Python.\n "; static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_9get_func_code_info_py = {"get_func_code_info_py", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_9get_func_code_info_py, METH_VARARGS|METH_KEYWORDS, __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_8get_func_code_info_py}; static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_9get_func_code_info_py(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_thread_info = 0; PyObject *__pyx_v_frame = 0; PyObject *__pyx_v_code_obj = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_func_code_info_py (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_thread_info,&__pyx_n_s_frame,&__pyx_n_s_code_obj,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_thread_info)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("get_func_code_info_py", 1, 3, 3, 1); __PYX_ERR(0, 203, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_code_obj)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("get_func_code_info_py", 1, 3, 3, 2); __PYX_ERR(0, 203, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_func_code_info_py") < 0)) __PYX_ERR(0, 203, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_thread_info = values[0]; __pyx_v_frame = values[1]; __pyx_v_code_obj = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_func_code_info_py", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 203, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_func_code_info_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_8get_func_code_info_py(__pyx_self, __pyx_v_thread_info, __pyx_v_frame, __pyx_v_code_obj); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_8get_func_code_info_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_thread_info, PyObject *__pyx_v_frame, PyObject *__pyx_v_code_obj) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_func_code_info_py", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":207 * Helper to be called from Python. * ''' * return get_func_code_info(<ThreadInfo> thread_info, <PyFrameObject *> frame, <PyCodeObject *> code_obj) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_1 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_func_code_info(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_thread_info), ((PyFrameObject *)__pyx_v_frame), ((PyCodeObject *)__pyx_v_code_obj))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":203 * * * def get_func_code_info_py(thread_info, frame, code_obj) -> FuncCodeInfo: # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_func_code_info_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":212 * cdef int _code_extra_index = -1 * * cdef FuncCodeInfo get_func_code_info(ThreadInfo thread_info, PyFrameObject * frame_obj, PyCodeObject * code_obj): # <<<<<<<<<<<<<< * ''' * Provides code-object related info. */ static struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_func_code_info(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_thread_info, PyFrameObject *__pyx_v_frame_obj, PyCodeObject *__pyx_v_code_obj) { PyObject *__pyx_v_main_debugger = 0; PyObject *__pyx_v_extra; PyObject *__pyx_v_extra_obj; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_func_code_info_obj = NULL; PyObject *__pyx_v_co_filename = 0; PyObject *__pyx_v_co_name = 0; PyObject *__pyx_v_cache_file_type = 0; PyObject *__pyx_v_cache_file_type_key = 0; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_func_code_info = NULL; PyObject *__pyx_v_abs_path_real_path_and_base = NULL; PyObject *__pyx_v_file_type = NULL; PyObject *__pyx_v_breakpoints = 0; PyObject *__pyx_v_function_breakpoint = 0; PyObject *__pyx_v_code_obj_py = 0; PyObject *__pyx_v_cached_code_obj_info = 0; PyObject *__pyx_v_breakpoint_found = NULL; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; PyObject *(*__pyx_t_14)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_func_code_info", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":228 * # print('get_func_code_info', f_code.co_name, f_code.co_filename) * * cdef object main_debugger = GlobalDebuggerHolder.global_dbg # <<<<<<<<<<<<<< * thread_info.force_stay_in_untraced_mode = False # This is an output value of the function. * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_global_dbg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_main_debugger = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":229 * * cdef object main_debugger = GlobalDebuggerHolder.global_dbg * thread_info.force_stay_in_untraced_mode = False # This is an output value of the function. # <<<<<<<<<<<<<< * * cdef PyObject * extra */ __pyx_v_thread_info->force_stay_in_untraced_mode = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":232 * * cdef PyObject * extra * _PyCode_GetExtra(<PyObject *> code_obj, _code_extra_index, & extra) # <<<<<<<<<<<<<< * if extra is not NULL: * extra_obj = <PyObject *> extra */ (void)(_PyCode_GetExtra(((PyObject *)__pyx_v_code_obj), __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index, (&__pyx_v_extra))); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":233 * cdef PyObject * extra * _PyCode_GetExtra(<PyObject *> code_obj, _code_extra_index, & extra) * if extra is not NULL: # <<<<<<<<<<<<<< * extra_obj = <PyObject *> extra * if extra_obj is not NULL: */ __pyx_t_3 = ((__pyx_v_extra != NULL) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":234 * _PyCode_GetExtra(<PyObject *> code_obj, _code_extra_index, & extra) * if extra is not NULL: * extra_obj = <PyObject *> extra # <<<<<<<<<<<<<< * if extra_obj is not NULL: * func_code_info_obj = <FuncCodeInfo> extra_obj */ __pyx_v_extra_obj = ((PyObject *)__pyx_v_extra); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":235 * if extra is not NULL: * extra_obj = <PyObject *> extra * if extra_obj is not NULL: # <<<<<<<<<<<<<< * func_code_info_obj = <FuncCodeInfo> extra_obj * if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: */ __pyx_t_3 = ((__pyx_v_extra_obj != NULL) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":236 * extra_obj = <PyObject *> extra * if extra_obj is not NULL: * func_code_info_obj = <FuncCodeInfo> extra_obj # <<<<<<<<<<<<<< * if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: * # if DEBUG: */ __pyx_t_2 = ((PyObject *)__pyx_v_extra_obj); __Pyx_INCREF(__pyx_t_2); __pyx_v_func_code_info_obj = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":237 * if extra_obj is not NULL: * func_code_info_obj = <FuncCodeInfo> extra_obj * if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_func_code_info: matched mtime', f_code.co_name, f_code.co_filename) */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_func_code_info_obj->breakpoints_mtime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_mtime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":241 * # print('get_func_code_info: matched mtime', f_code.co_name, f_code.co_filename) * * return func_code_info_obj # <<<<<<<<<<<<<< * * cdef str co_filename = <str> code_obj.co_filename */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_func_code_info_obj)); __pyx_r = __pyx_v_func_code_info_obj; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":237 * if extra_obj is not NULL: * func_code_info_obj = <FuncCodeInfo> extra_obj * if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_func_code_info: matched mtime', f_code.co_name, f_code.co_filename) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":235 * if extra is not NULL: * extra_obj = <PyObject *> extra * if extra_obj is not NULL: # <<<<<<<<<<<<<< * func_code_info_obj = <FuncCodeInfo> extra_obj * if func_code_info_obj.breakpoints_mtime == main_debugger.mtime: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":233 * cdef PyObject * extra * _PyCode_GetExtra(<PyObject *> code_obj, _code_extra_index, & extra) * if extra is not NULL: # <<<<<<<<<<<<<< * extra_obj = <PyObject *> extra * if extra_obj is not NULL: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":243 * return func_code_info_obj * * cdef str co_filename = <str> code_obj.co_filename # <<<<<<<<<<<<<< * cdef str co_name = <str> code_obj.co_name * cdef dict cache_file_type */ __pyx_t_4 = ((PyObject *)__pyx_v_code_obj->co_filename); __Pyx_INCREF(__pyx_t_4); __pyx_v_co_filename = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":244 * * cdef str co_filename = <str> code_obj.co_filename * cdef str co_name = <str> code_obj.co_name # <<<<<<<<<<<<<< * cdef dict cache_file_type * cdef tuple cache_file_type_key */ __pyx_t_4 = ((PyObject *)__pyx_v_code_obj->co_name); __Pyx_INCREF(__pyx_t_4); __pyx_v_co_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":248 * cdef tuple cache_file_type_key * * func_code_info = FuncCodeInfo() # <<<<<<<<<<<<<< * func_code_info.breakpoints_mtime = main_debugger.mtime * */ __pyx_t_4 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_func_code_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":249 * * func_code_info = FuncCodeInfo() * func_code_info.breakpoints_mtime = main_debugger.mtime # <<<<<<<<<<<<<< * * func_code_info.co_filename = co_filename */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_mtime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 249, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_func_code_info->breakpoints_mtime = __pyx_t_5; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":251 * func_code_info.breakpoints_mtime = main_debugger.mtime * * func_code_info.co_filename = co_filename # <<<<<<<<<<<<<< * func_code_info.co_name = co_name * */ __Pyx_INCREF(__pyx_v_co_filename); __Pyx_GIVEREF(__pyx_v_co_filename); __Pyx_GOTREF(__pyx_v_func_code_info->co_filename); __Pyx_DECREF(__pyx_v_func_code_info->co_filename); __pyx_v_func_code_info->co_filename = __pyx_v_co_filename; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":252 * * func_code_info.co_filename = co_filename * func_code_info.co_name = co_name # <<<<<<<<<<<<<< * * if not func_code_info.always_skip_code: */ __Pyx_INCREF(__pyx_v_co_name); __Pyx_GIVEREF(__pyx_v_co_name); __Pyx_GOTREF(__pyx_v_func_code_info->co_name); __Pyx_DECREF(__pyx_v_func_code_info->co_name); __pyx_v_func_code_info->co_name = __pyx_v_co_name; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":254 * func_code_info.co_name = co_name * * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * try: * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] */ __pyx_t_3 = ((!(__pyx_v_func_code_info->always_skip_code != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":255 * * if not func_code_info.always_skip_code: * try: # <<<<<<<<<<<<<< * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] * except: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":256 * if not func_code_info.always_skip_code: * try: * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] # <<<<<<<<<<<<<< * except: * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(<object>frame_obj) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 256, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_4, __pyx_v_co_filename); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_abs_path_real_path_and_base = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":255 * * if not func_code_info.always_skip_code: * try: # <<<<<<<<<<<<<< * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] * except: */ } __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":257 * try: * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] * except: # <<<<<<<<<<<<<< * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(<object>frame_obj) * */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_func_code_info", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_2) < 0) __PYX_ERR(0, 257, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_2); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":258 * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] * except: * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(<object>frame_obj) # <<<<<<<<<<<<<< * * func_code_info.canonical_normalized_filename = abs_path_real_path_and_base[1] */ __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 258, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10); if (likely(__pyx_t_11)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_10, function); } } __pyx_t_9 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_10, __pyx_t_11, ((PyObject *)__pyx_v_frame_obj)) : __Pyx_PyObject_CallOneArg(__pyx_t_10, ((PyObject *)__pyx_v_frame_obj)); __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 258, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_abs_path_real_path_and_base, __pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L8_exception_handled; } __pyx_L9_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":255 * * if not func_code_info.always_skip_code: * try: # <<<<<<<<<<<<<< * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] * except: */ __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); goto __pyx_L1_error; __pyx_L8_exception_handled:; __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); __pyx_L12_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":260 * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(<object>frame_obj) * * func_code_info.canonical_normalized_filename = abs_path_real_path_and_base[1] # <<<<<<<<<<<<<< * * cache_file_type = main_debugger.get_cache_file_type() */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_func_code_info->canonical_normalized_filename); __Pyx_DECREF(__pyx_v_func_code_info->canonical_normalized_filename); __pyx_v_func_code_info->canonical_normalized_filename = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":262 * func_code_info.canonical_normalized_filename = abs_path_real_path_and_base[1] * * cache_file_type = main_debugger.get_cache_file_type() # <<<<<<<<<<<<<< * # Note: this cache key must be the same from PyDB.get_file_type() -- see it for comments * # on the cache. */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_get_cache_file_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 262, __pyx_L1_error) __pyx_v_cache_file_type = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":265 * # Note: this cache key must be the same from PyDB.get_file_type() -- see it for comments * # on the cache. * cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], <object>frame_obj.f_code) # <<<<<<<<<<<<<< * try: * file_type = cache_file_type[cache_file_type_key] # Make it faster */ __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_frame_obj->f_code->co_firstlineno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_abs_path_real_path_and_base, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_v_frame_obj->f_code)); __Pyx_GIVEREF(((PyObject *)__pyx_v_frame_obj->f_code)); PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_frame_obj->f_code)); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_v_cache_file_type_key = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":266 * # on the cache. * cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], <object>frame_obj.f_code) * try: # <<<<<<<<<<<<<< * file_type = cache_file_type[cache_file_type_key] # Make it faster * except: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_6); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":267 * cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], <object>frame_obj.f_code) * try: * file_type = cache_file_type[cache_file_type_key] # Make it faster # <<<<<<<<<<<<<< * except: * file_type = main_debugger.get_file_type(<object>frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd */ if (unlikely(__pyx_v_cache_file_type == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 267, __pyx_L15_error) } __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_cache_file_type, __pyx_v_cache_file_type_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 267, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_file_type = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":266 * # on the cache. * cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], <object>frame_obj.f_code) * try: # <<<<<<<<<<<<<< * file_type = cache_file_type[cache_file_type_key] # Make it faster * except: */ } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L20_try_end; __pyx_L15_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":268 * try: * file_type = cache_file_type[cache_file_type_key] # Make it faster * except: # <<<<<<<<<<<<<< * file_type = main_debugger.get_file_type(<object>frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd * */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_func_code_info", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_2) < 0) __PYX_ERR(0, 268, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_2); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":269 * file_type = cache_file_type[cache_file_type_key] # Make it faster * except: * file_type = main_debugger.get_file_type(<object>frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd # <<<<<<<<<<<<<< * * if file_type is not None: */ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_get_file_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 269, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) { __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10); if (likely(__pyx_t_11)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_10, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_11, ((PyObject *)__pyx_v_frame_obj), __pyx_v_abs_path_real_path_and_base}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 269, __pyx_L17_except_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_11, ((PyObject *)__pyx_v_frame_obj), __pyx_v_abs_path_real_path_and_base}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 269, __pyx_L17_except_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_9); } else #endif { __pyx_t_12 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 269, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_frame_obj)); __Pyx_GIVEREF(((PyObject *)__pyx_v_frame_obj)); PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_5, ((PyObject *)__pyx_v_frame_obj)); __Pyx_INCREF(__pyx_v_abs_path_real_path_and_base); __Pyx_GIVEREF(__pyx_v_abs_path_real_path_and_base); PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_5, __pyx_v_abs_path_real_path_and_base); __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 269, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF_SET(__pyx_v_file_type, __pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L16_exception_handled; } __pyx_L17_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":266 * # on the cache. * cache_file_type_key = (frame_obj.f_code.co_firstlineno, abs_path_real_path_and_base[0], <object>frame_obj.f_code) * try: # <<<<<<<<<<<<<< * file_type = cache_file_type[cache_file_type_key] # Make it faster * except: */ __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6); goto __pyx_L1_error; __pyx_L16_exception_handled:; __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_7, __pyx_t_6); __pyx_L20_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":271 * file_type = main_debugger.get_file_type(<object>frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd * * if file_type is not None: # <<<<<<<<<<<<<< * func_code_info.always_skip_code = True * */ __pyx_t_3 = (__pyx_v_file_type != Py_None); __pyx_t_13 = (__pyx_t_3 != 0); if (__pyx_t_13) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":272 * * if file_type is not None: * func_code_info.always_skip_code = True # <<<<<<<<<<<<<< * * if not func_code_info.always_skip_code: */ __pyx_v_func_code_info->always_skip_code = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":271 * file_type = main_debugger.get_file_type(<object>frame_obj, abs_path_real_path_and_base) # we don't want to debug anything related to pydevd * * if file_type is not None: # <<<<<<<<<<<<<< * func_code_info.always_skip_code = True * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":254 * func_code_info.co_name = co_name * * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * try: * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[co_filename] */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":274 * func_code_info.always_skip_code = True * * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * if main_debugger is not None: * */ __pyx_t_13 = ((!(__pyx_v_func_code_info->always_skip_code != 0)) != 0); if (__pyx_t_13) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":275 * * if not func_code_info.always_skip_code: * if main_debugger is not None: # <<<<<<<<<<<<<< * * breakpoints: dict = main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename) */ __pyx_t_13 = (__pyx_v_main_debugger != Py_None); __pyx_t_3 = (__pyx_t_13 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":277 * if main_debugger is not None: * * breakpoints: dict = main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename) # <<<<<<<<<<<<<< * function_breakpoint: object = main_debugger.function_breakpoint_name_to_breakpoint.get(func_code_info.co_name) * # print('\n---') */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_breakpoints); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_func_code_info->canonical_normalized_filename) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_func_code_info->canonical_normalized_filename); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 277, __pyx_L1_error) __pyx_v_breakpoints = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":278 * * breakpoints: dict = main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename) * function_breakpoint: object = main_debugger.function_breakpoint_name_to_breakpoint.get(func_code_info.co_name) # <<<<<<<<<<<<<< * # print('\n---') * # print(main_debugger.breakpoints) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_function_breakpoint_name_to_brea); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_v_func_code_info->co_name) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_func_code_info->co_name); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_function_breakpoint = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":283 * # print(func_code_info.canonical_normalized_filename) * # print(main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename)) * code_obj_py: object = <object> code_obj # <<<<<<<<<<<<<< * cached_code_obj_info: object = _cache.get(code_obj_py) * if cached_code_obj_info: */ __pyx_t_2 = ((PyObject *)__pyx_v_code_obj); __Pyx_INCREF(__pyx_t_2); __pyx_v_code_obj_py = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":284 * # print(main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename)) * code_obj_py: object = <object> code_obj * cached_code_obj_info: object = _cache.get(code_obj_py) # <<<<<<<<<<<<<< * if cached_code_obj_info: * # The cache is for new code objects, so, in this case it's already */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_cache); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_code_obj_py) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_code_obj_py); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_cached_code_obj_info = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":285 * code_obj_py: object = <object> code_obj * cached_code_obj_info: object = _cache.get(code_obj_py) * if cached_code_obj_info: # <<<<<<<<<<<<<< * # The cache is for new code objects, so, in this case it's already * # using the new code and we can't change it as this is a generator! */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_cached_code_obj_info); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 285, __pyx_L1_error) if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":291 * # we may not want to go into tracing mode (as would usually happen * # when the new_code is None). * func_code_info.new_code = None # <<<<<<<<<<<<<< * breakpoint_found, thread_info.force_stay_in_untraced_mode = \ * cached_code_obj_info.compute_force_stay_in_untraced_mode(breakpoints) */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_func_code_info->new_code); __Pyx_DECREF(__pyx_v_func_code_info->new_code); __pyx_v_func_code_info->new_code = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":293 * func_code_info.new_code = None * breakpoint_found, thread_info.force_stay_in_untraced_mode = \ * cached_code_obj_info.compute_force_stay_in_untraced_mode(breakpoints) # <<<<<<<<<<<<<< * func_code_info.breakpoint_found = breakpoint_found * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cached_code_obj_info, __pyx_n_s_compute_force_stay_in_untraced_m); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_breakpoints) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_breakpoints); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 292, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_1 = PyList_GET_ITEM(sequence, 0); __pyx_t_4 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_14 = Py_TYPE(__pyx_t_9)->tp_iternext; index = 0; __pyx_t_1 = __pyx_t_14(__pyx_t_9); if (unlikely(!__pyx_t_1)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); index = 1; __pyx_t_4 = __pyx_t_14(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_9), 2) < 0) __PYX_ERR(0, 292, __pyx_L1_error) __pyx_t_14 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L28_unpacking_done; __pyx_L27_unpacking_failed:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_14 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 292, __pyx_L1_error) __pyx_L28_unpacking_done:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":292 * # when the new_code is None). * func_code_info.new_code = None * breakpoint_found, thread_info.force_stay_in_untraced_mode = \ # <<<<<<<<<<<<<< * cached_code_obj_info.compute_force_stay_in_untraced_mode(breakpoints) * func_code_info.breakpoint_found = breakpoint_found */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_breakpoint_found = __pyx_t_1; __pyx_t_1 = 0; __pyx_v_thread_info->force_stay_in_untraced_mode = __pyx_t_3; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":294 * breakpoint_found, thread_info.force_stay_in_untraced_mode = \ * cached_code_obj_info.compute_force_stay_in_untraced_mode(breakpoints) * func_code_info.breakpoint_found = breakpoint_found # <<<<<<<<<<<<<< * * elif function_breakpoint: */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoint_found); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error) __pyx_v_func_code_info->breakpoint_found = __pyx_t_3; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":285 * code_obj_py: object = <object> code_obj * cached_code_obj_info: object = _cache.get(code_obj_py) * if cached_code_obj_info: # <<<<<<<<<<<<<< * # The cache is for new code objects, so, in this case it's already * # using the new code and we can't change it as this is a generator! */ goto __pyx_L26; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":296 * func_code_info.breakpoint_found = breakpoint_found * * elif function_breakpoint: # <<<<<<<<<<<<<< * # Go directly into tracing mode * func_code_info.breakpoint_found = True */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_function_breakpoint); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 296, __pyx_L1_error) if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":298 * elif function_breakpoint: * # Go directly into tracing mode * func_code_info.breakpoint_found = True # <<<<<<<<<<<<<< * func_code_info.new_code = None * */ __pyx_v_func_code_info->breakpoint_found = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":299 * # Go directly into tracing mode * func_code_info.breakpoint_found = True * func_code_info.new_code = None # <<<<<<<<<<<<<< * * elif breakpoints: */ __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_func_code_info->new_code); __Pyx_DECREF(__pyx_v_func_code_info->new_code); __pyx_v_func_code_info->new_code = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":296 * func_code_info.breakpoint_found = breakpoint_found * * elif function_breakpoint: # <<<<<<<<<<<<<< * # Go directly into tracing mode * func_code_info.breakpoint_found = True */ goto __pyx_L26; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":301 * func_code_info.new_code = None * * elif breakpoints: # <<<<<<<<<<<<<< * # if DEBUG: * # print('found breakpoints', code_obj_py.co_name, breakpoints) */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoints); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":307 * # Note: new_code can be None if unable to generate. * # It should automatically put the new code object in the cache. * breakpoint_found, func_code_info.new_code = generate_code_with_breakpoints(code_obj_py, breakpoints) # <<<<<<<<<<<<<< * func_code_info.breakpoint_found = breakpoint_found * */ __pyx_t_2 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_generate_code_with_breakpoints(__pyx_v_code_obj_py, __pyx_v_breakpoints); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 307, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_4 = PyList_GET_ITEM(sequence, 0); __pyx_t_1 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); #else __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_14 = Py_TYPE(__pyx_t_9)->tp_iternext; index = 0; __pyx_t_4 = __pyx_t_14(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L29_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); index = 1; __pyx_t_1 = __pyx_t_14(__pyx_t_9); if (unlikely(!__pyx_t_1)) goto __pyx_L29_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_9), 2) < 0) __PYX_ERR(0, 307, __pyx_L1_error) __pyx_t_14 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L30_unpacking_done; __pyx_L29_unpacking_failed:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_14 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 307, __pyx_L1_error) __pyx_L30_unpacking_done:; } __pyx_v_breakpoint_found = __pyx_t_4; __pyx_t_4 = 0; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_func_code_info->new_code); __Pyx_DECREF(__pyx_v_func_code_info->new_code); __pyx_v_func_code_info->new_code = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":308 * # It should automatically put the new code object in the cache. * breakpoint_found, func_code_info.new_code = generate_code_with_breakpoints(code_obj_py, breakpoints) * func_code_info.breakpoint_found = breakpoint_found # <<<<<<<<<<<<<< * * Py_INCREF(func_code_info) */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoint_found); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 308, __pyx_L1_error) __pyx_v_func_code_info->breakpoint_found = __pyx_t_3; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":301 * func_code_info.new_code = None * * elif breakpoints: # <<<<<<<<<<<<<< * # if DEBUG: * # print('found breakpoints', code_obj_py.co_name, breakpoints) */ } __pyx_L26:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":275 * * if not func_code_info.always_skip_code: * if main_debugger is not None: # <<<<<<<<<<<<<< * * breakpoints: dict = main_debugger.breakpoints.get(func_code_info.canonical_normalized_filename) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":274 * func_code_info.always_skip_code = True * * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * if main_debugger is not None: * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":310 * func_code_info.breakpoint_found = breakpoint_found * * Py_INCREF(func_code_info) # <<<<<<<<<<<<<< * _PyCode_SetExtra(<PyObject *> code_obj, _code_extra_index, <PyObject *> func_code_info) * */ Py_INCREF(((PyObject *)__pyx_v_func_code_info)); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":311 * * Py_INCREF(func_code_info) * _PyCode_SetExtra(<PyObject *> code_obj, _code_extra_index, <PyObject *> func_code_info) # <<<<<<<<<<<<<< * * return func_code_info */ (void)(_PyCode_SetExtra(((PyObject *)__pyx_v_code_obj), __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index, ((PyObject *)__pyx_v_func_code_info))); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":313 * _PyCode_SetExtra(<PyObject *> code_obj, _code_extra_index, <PyObject *> func_code_info) * * return func_code_info # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_func_code_info)); __pyx_r = __pyx_v_func_code_info; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":212 * cdef int _code_extra_index = -1 * * cdef FuncCodeInfo get_func_code_info(ThreadInfo thread_info, PyFrameObject * frame_obj, PyCodeObject * code_obj): # <<<<<<<<<<<<<< * ''' * Provides code-object related info. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_func_code_info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_main_debugger); __Pyx_XDECREF((PyObject *)__pyx_v_func_code_info_obj); __Pyx_XDECREF(__pyx_v_co_filename); __Pyx_XDECREF(__pyx_v_co_name); __Pyx_XDECREF(__pyx_v_cache_file_type); __Pyx_XDECREF(__pyx_v_cache_file_type_key); __Pyx_XDECREF((PyObject *)__pyx_v_func_code_info); __Pyx_XDECREF(__pyx_v_abs_path_real_path_and_base); __Pyx_XDECREF(__pyx_v_file_type); __Pyx_XDECREF(__pyx_v_breakpoints); __Pyx_XDECREF(__pyx_v_function_breakpoint); __Pyx_XDECREF(__pyx_v_code_obj_py); __Pyx_XDECREF(__pyx_v_cached_code_obj_info); __Pyx_XDECREF(__pyx_v_breakpoint_found); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":322 * cdef public int last_line * * def __init__(self, dict line_to_offset, int first_line, int last_line): # <<<<<<<<<<<<<< * self.line_to_offset = line_to_offset * self.first_line = first_line */ /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_line_to_offset = 0; int __pyx_v_first_line; int __pyx_v_last_line; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_line_to_offset,&__pyx_n_s_first_line,&__pyx_n_s_last_line,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_line_to_offset)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_first_line)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_last_line)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 322, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 322, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_line_to_offset = ((PyObject*)values[0]); __pyx_v_first_line = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_first_line == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) __pyx_v_last_line = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_last_line == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 322, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_line_to_offset), (&PyDict_Type), 1, "line_to_offset", 1))) __PYX_ERR(0, 322, __pyx_L1_error) __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo___init__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self), __pyx_v_line_to_offset, __pyx_v_first_line, __pyx_v_last_line); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_line_to_offset, int __pyx_v_first_line, int __pyx_v_last_line) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":323 * * def __init__(self, dict line_to_offset, int first_line, int last_line): * self.line_to_offset = line_to_offset # <<<<<<<<<<<<<< * self.first_line = first_line * self.last_line = last_line */ __Pyx_INCREF(__pyx_v_line_to_offset); __Pyx_GIVEREF(__pyx_v_line_to_offset); __Pyx_GOTREF(__pyx_v_self->line_to_offset); __Pyx_DECREF(__pyx_v_self->line_to_offset); __pyx_v_self->line_to_offset = __pyx_v_line_to_offset; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":324 * def __init__(self, dict line_to_offset, int first_line, int last_line): * self.line_to_offset = line_to_offset * self.first_line = first_line # <<<<<<<<<<<<<< * self.last_line = last_line * */ __pyx_v_self->first_line = __pyx_v_first_line; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":325 * self.line_to_offset = line_to_offset * self.first_line = first_line * self.last_line = last_line # <<<<<<<<<<<<<< * * */ __pyx_v_self->last_line = __pyx_v_last_line; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":322 * cdef public int last_line * * def __init__(self, dict line_to_offset, int first_line, int last_line): # <<<<<<<<<<<<<< * self.line_to_offset = line_to_offset * self.first_line = first_line */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":318 * cdef class _CodeLineInfo: * * cdef public dict line_to_offset # <<<<<<<<<<<<<< * cdef public int first_line * cdef public int last_line */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->line_to_offset); __pyx_r = __pyx_v_self->line_to_offset; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PyDict_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 318, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->line_to_offset); __Pyx_DECREF(__pyx_v_self->line_to_offset); __pyx_v_self->line_to_offset = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.line_to_offset.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->line_to_offset); __Pyx_DECREF(__pyx_v_self->line_to_offset); __pyx_v_self->line_to_offset = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":319 * * cdef public dict line_to_offset * cdef public int first_line # <<<<<<<<<<<<<< * cdef public int last_line * */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->first_line); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.first_line.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 319, __pyx_L1_error) __pyx_v_self->first_line = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.first_line.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":320 * cdef public dict line_to_offset * cdef public int first_line * cdef public int last_line # <<<<<<<<<<<<<< * * def __init__(self, dict line_to_offset, int first_line, int last_line): */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->last_line); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.last_line.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 320, __pyx_L1_error) __pyx_v_self->last_line = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.last_line.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_2__reduce_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_2__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.first_line, self.last_line, self.line_to_offset) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->first_line); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->last_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __Pyx_INCREF(__pyx_v_self->line_to_offset); __Pyx_GIVEREF(__pyx_v_self->line_to_offset); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_self->line_to_offset); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_v_state = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.first_line, self.last_line, self.line_to_offset) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_3 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v__dict = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":7 * state = (self.first_line, self.last_line, self.line_to_offset) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_4 = (__pyx_v__dict != Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict); __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.line_to_offset is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.first_line, self.last_line, self.line_to_offset) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.line_to_offset is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, None), state */ /*else*/ { __pyx_t_5 = (__pyx_v_self->line_to_offset != ((PyObject*)Py_None)); __pyx_v_use_setstate = __pyx_t_5; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.line_to_offset is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, None), state * else: */ __pyx_t_5 = (__pyx_v_use_setstate != 0); if (__pyx_t_5) { /* "(tree fragment)":13 * use_setstate = self.line_to_offset is not None * if use_setstate: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle__CodeLineInfo); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_66829570); __Pyx_GIVEREF(__pyx_int_66829570); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_66829570); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.line_to_offset is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, None), state * else: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__CodeLineInfo__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyx_unpickle__CodeLineInfo); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_66829570); __Pyx_GIVEREF(__pyx_int_66829570); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_66829570); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__CodeLineInfo__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_4__setstate_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_4__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__CodeLineInfo__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CodeLineInfo__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle__CodeLineInfo, (type(self), 0x3fbbd02, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__CodeLineInfo__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":329 * * # Note: this method has a version in pure-python too. * def _get_code_line_info(code_obj): # <<<<<<<<<<<<<< * line_to_offset: dict = {} * first_line: int = None */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_get_code_line_info(PyObject *__pyx_self, PyObject *__pyx_v_code_obj); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_get_code_line_info = {"_get_code_line_info", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_get_code_line_info, METH_O, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_get_code_line_info(PyObject *__pyx_self, PyObject *__pyx_v_code_obj) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_code_line_info (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10_get_code_line_info(__pyx_self, ((PyObject *)__pyx_v_code_obj)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_10_get_code_line_info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj) { PyObject *__pyx_v_line_to_offset = 0; PyObject *__pyx_v_first_line = 0; PyObject *__pyx_v_last_line = 0; int __pyx_v_offset; int __pyx_v_line; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *(*__pyx_t_5)(PyObject *); PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); int __pyx_t_9; int __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_code_line_info", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":330 * # Note: this method has a version in pure-python too. * def _get_code_line_info(code_obj): * line_to_offset: dict = {} # <<<<<<<<<<<<<< * first_line: int = None * last_line: int = None */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_line_to_offset = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":331 * def _get_code_line_info(code_obj): * line_to_offset: dict = {} * first_line: int = None # <<<<<<<<<<<<<< * last_line: int = None * */ __Pyx_INCREF(Py_None); __pyx_v_first_line = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":332 * line_to_offset: dict = {} * first_line: int = None * last_line: int = None # <<<<<<<<<<<<<< * * cdef int offset */ __Pyx_INCREF(Py_None); __pyx_v_last_line = Py_None; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":337 * cdef int line * * for offset, line in dis.findlinestarts(code_obj): # <<<<<<<<<<<<<< * line_to_offset[line] = offset * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_dis); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_findlinestarts); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_code_obj) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_code_obj); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 337, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_5)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_5(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(0, 337, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 337, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_2 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_2 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 337, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; __pyx_L5_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 337, __pyx_L1_error) __pyx_L6_unpacking_done:; } __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_offset = __pyx_t_9; __pyx_v_line = __pyx_t_10; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":338 * * for offset, line in dis.findlinestarts(code_obj): * line_to_offset[line] = offset # <<<<<<<<<<<<<< * * if line_to_offset: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_offset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (unlikely(PyDict_SetItem(__pyx_v_line_to_offset, __pyx_t_6, __pyx_t_1) < 0)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":337 * cdef int line * * for offset, line in dis.findlinestarts(code_obj): # <<<<<<<<<<<<<< * line_to_offset[line] = offset * */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":340 * line_to_offset[line] = offset * * if line_to_offset: # <<<<<<<<<<<<<< * first_line = min(line_to_offset) * last_line = max(line_to_offset) */ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_line_to_offset); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 340, __pyx_L1_error) if (__pyx_t_11) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":341 * * if line_to_offset: * first_line = min(line_to_offset) # <<<<<<<<<<<<<< * last_line = max(line_to_offset) * return _CodeLineInfo(line_to_offset, first_line, last_line) */ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_min, __pyx_v_line_to_offset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_first_line, __pyx_t_3); __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":342 * if line_to_offset: * first_line = min(line_to_offset) * last_line = max(line_to_offset) # <<<<<<<<<<<<<< * return _CodeLineInfo(line_to_offset, first_line, last_line) * */ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_max, __pyx_v_line_to_offset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_last_line, __pyx_t_3); __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":340 * line_to_offset[line] = offset * * if line_to_offset: # <<<<<<<<<<<<<< * first_line = min(line_to_offset) * last_line = max(line_to_offset) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":343 * first_line = min(line_to_offset) * last_line = max(line_to_offset) * return _CodeLineInfo(line_to_offset, first_line, last_line) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_line_to_offset); __Pyx_GIVEREF(__pyx_v_line_to_offset); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_line_to_offset); __Pyx_INCREF(__pyx_v_first_line); __Pyx_GIVEREF(__pyx_v_first_line); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_first_line); __Pyx_INCREF(__pyx_v_last_line); __Pyx_GIVEREF(__pyx_v_last_line); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_last_line); __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":329 * * # Note: this method has a version in pure-python too. * def _get_code_line_info(code_obj): # <<<<<<<<<<<<<< * line_to_offset: dict = {} * first_line: int = None */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._get_code_line_info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_line_to_offset); __Pyx_XDECREF(__pyx_v_first_line); __Pyx_XDECREF(__pyx_v_last_line); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":353 * _cache: dict = {} * * def get_cached_code_obj_info_py(code_obj_py): # <<<<<<<<<<<<<< * ''' * :return _CacheValue: */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13get_cached_code_obj_info_py(PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py); /*proto*/ static char __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_12get_cached_code_obj_info_py[] = "\n :return _CacheValue:\n :note: on cython use _cache.get(code_obj_py) directly.\n "; static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_13get_cached_code_obj_info_py = {"get_cached_code_obj_info_py", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13get_cached_code_obj_info_py, METH_O, __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_12get_cached_code_obj_info_py}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13get_cached_code_obj_info_py(PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_cached_code_obj_info_py (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12get_cached_code_obj_info_py(__pyx_self, ((PyObject *)__pyx_v_code_obj_py)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_12get_cached_code_obj_info_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_cached_code_obj_info_py", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":358 * :note: on cython use _cache.get(code_obj_py) directly. * ''' * return _cache.get(code_obj_py) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_code_obj_py) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_code_obj_py); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":353 * _cache: dict = {} * * def get_cached_code_obj_info_py(code_obj_py): # <<<<<<<<<<<<<< * ''' * :return _CacheValue: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_cached_code_obj_info_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":368 * cdef public set code_lines_as_set * * def __init__(self, object code_obj_py, _CodeLineInfo code_line_info, set breakpoints_hit_at_lines): # <<<<<<<<<<<<<< * ''' * :param code_obj_py: */ /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__[] = "\n :param code_obj_py:\n :param _CodeLineInfo code_line_info:\n :param set[int] breakpoints_hit_at_lines:\n "; #if CYTHON_UPDATE_DESCRIPTOR_DOC struct wrapperbase __pyx_wrapperbase_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__; #endif static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_code_obj_py = 0; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_code_line_info = 0; PyObject *__pyx_v_breakpoints_hit_at_lines = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_code_obj_py,&__pyx_n_s_code_line_info,&__pyx_n_s_breakpoints_hit_at_lines,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_code_obj_py)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_code_line_info)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 368, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_breakpoints_hit_at_lines)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 368, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 368, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_code_obj_py = values[0]; __pyx_v_code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)values[1]); __pyx_v_breakpoints_hit_at_lines = ((PyObject*)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 368, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_code_line_info), __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, 1, "code_line_info", 0))) __PYX_ERR(0, 368, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_breakpoints_hit_at_lines), (&PySet_Type), 1, "breakpoints_hit_at_lines", 1))) __PYX_ERR(0, 368, __pyx_L1_error) __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), __pyx_v_code_obj_py, __pyx_v_code_line_info, __pyx_v_breakpoints_hit_at_lines); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_code_obj_py, struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v_code_line_info, PyObject *__pyx_v_breakpoints_hit_at_lines) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":374 * :param set[int] breakpoints_hit_at_lines: * ''' * self.code_obj_py = code_obj_py # <<<<<<<<<<<<<< * self.code_line_info = code_line_info * self.breakpoints_hit_at_lines = breakpoints_hit_at_lines */ __Pyx_INCREF(__pyx_v_code_obj_py); __Pyx_GIVEREF(__pyx_v_code_obj_py); __Pyx_GOTREF(__pyx_v_self->code_obj_py); __Pyx_DECREF(__pyx_v_self->code_obj_py); __pyx_v_self->code_obj_py = __pyx_v_code_obj_py; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":375 * ''' * self.code_obj_py = code_obj_py * self.code_line_info = code_line_info # <<<<<<<<<<<<<< * self.breakpoints_hit_at_lines = breakpoints_hit_at_lines * self.code_lines_as_set = set(code_line_info.line_to_offset) */ __Pyx_INCREF(((PyObject *)__pyx_v_code_line_info)); __Pyx_GIVEREF(((PyObject *)__pyx_v_code_line_info)); __Pyx_GOTREF(__pyx_v_self->code_line_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->code_line_info)); __pyx_v_self->code_line_info = __pyx_v_code_line_info; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":376 * self.code_obj_py = code_obj_py * self.code_line_info = code_line_info * self.breakpoints_hit_at_lines = breakpoints_hit_at_lines # <<<<<<<<<<<<<< * self.code_lines_as_set = set(code_line_info.line_to_offset) * */ __Pyx_INCREF(__pyx_v_breakpoints_hit_at_lines); __Pyx_GIVEREF(__pyx_v_breakpoints_hit_at_lines); __Pyx_GOTREF(__pyx_v_self->breakpoints_hit_at_lines); __Pyx_DECREF(__pyx_v_self->breakpoints_hit_at_lines); __pyx_v_self->breakpoints_hit_at_lines = __pyx_v_breakpoints_hit_at_lines; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":377 * self.code_line_info = code_line_info * self.breakpoints_hit_at_lines = breakpoints_hit_at_lines * self.code_lines_as_set = set(code_line_info.line_to_offset) # <<<<<<<<<<<<<< * * cpdef compute_force_stay_in_untraced_mode(self, breakpoints): */ __pyx_t_1 = PySet_New(__pyx_v_code_line_info->line_to_offset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->code_lines_as_set); __Pyx_DECREF(__pyx_v_self->code_lines_as_set); __pyx_v_self->code_lines_as_set = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":368 * cdef public set code_lines_as_set * * def __init__(self, object code_obj_py, _CodeLineInfo code_line_info, set breakpoints_hit_at_lines): # <<<<<<<<<<<<<< * ''' * :param code_obj_py: */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":379 * self.code_lines_as_set = set(code_line_info.line_to_offset) * * cpdef compute_force_stay_in_untraced_mode(self, breakpoints): # <<<<<<<<<<<<<< * ''' * :param breakpoints: */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_3compute_force_stay_in_untraced_mode(PyObject *__pyx_v_self, PyObject *__pyx_v_breakpoints); /*proto*/ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_compute_force_stay_in_untraced_mode(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_breakpoints, int __pyx_skip_dispatch) { int __pyx_v_force_stay_in_untraced_mode; int __pyx_v_breakpoint_found; PyObject *__pyx_v_target_breakpoints = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("compute_force_stay_in_untraced_mode", 0); /* Check if called by wrapper */ if (unlikely(__pyx_skip_dispatch)) ; /* Check if overridden in Python */ else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_compute_force_stay_in_untraced_m); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_3compute_force_stay_in_untraced_mode)) { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_breakpoints) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_breakpoints); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":389 * cdef set target_breakpoints * * force_stay_in_untraced_mode = False # <<<<<<<<<<<<<< * * target_breakpoints = self.code_lines_as_set.intersection(breakpoints) */ __pyx_v_force_stay_in_untraced_mode = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":391 * force_stay_in_untraced_mode = False * * target_breakpoints = self.code_lines_as_set.intersection(breakpoints) # <<<<<<<<<<<<<< * breakpoint_found = bool(target_breakpoints) * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->code_lines_as_set, __pyx_n_s_intersection); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_breakpoints) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_breakpoints); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 391, __pyx_L1_error) __pyx_v_target_breakpoints = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":392 * * target_breakpoints = self.code_lines_as_set.intersection(breakpoints) * breakpoint_found = bool(target_breakpoints) # <<<<<<<<<<<<<< * * if not breakpoint_found: */ __pyx_t_5 = (__pyx_v_target_breakpoints != Py_None)&&(PySet_GET_SIZE(__pyx_v_target_breakpoints) != 0); __pyx_v_breakpoint_found = (!(!__pyx_t_5)); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":394 * breakpoint_found = bool(target_breakpoints) * * if not breakpoint_found: # <<<<<<<<<<<<<< * force_stay_in_untraced_mode = True * else: */ __pyx_t_5 = ((!(__pyx_v_breakpoint_found != 0)) != 0); if (__pyx_t_5) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":395 * * if not breakpoint_found: * force_stay_in_untraced_mode = True # <<<<<<<<<<<<<< * else: * force_stay_in_untraced_mode = self.breakpoints_hit_at_lines.issuperset(set(breakpoints)) */ __pyx_v_force_stay_in_untraced_mode = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":394 * breakpoint_found = bool(target_breakpoints) * * if not breakpoint_found: # <<<<<<<<<<<<<< * force_stay_in_untraced_mode = True * else: */ goto __pyx_L3; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":397 * force_stay_in_untraced_mode = True * else: * force_stay_in_untraced_mode = self.breakpoints_hit_at_lines.issuperset(set(breakpoints)) # <<<<<<<<<<<<<< * * return breakpoint_found, force_stay_in_untraced_mode */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->breakpoints_hit_at_lines, __pyx_n_s_issuperset); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PySet_New(__pyx_v_breakpoints); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_force_stay_in_untraced_mode = __pyx_t_5; } __pyx_L3:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":399 * force_stay_in_untraced_mode = self.breakpoints_hit_at_lines.issuperset(set(breakpoints)) * * return breakpoint_found, force_stay_in_untraced_mode # <<<<<<<<<<<<<< * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_breakpoint_found); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_force_stay_in_untraced_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":379 * self.code_lines_as_set = set(code_line_info.line_to_offset) * * cpdef compute_force_stay_in_untraced_mode(self, breakpoints): # <<<<<<<<<<<<<< * ''' * :param breakpoints: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.compute_force_stay_in_untraced_mode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_target_breakpoints); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_3compute_force_stay_in_untraced_mode(PyObject *__pyx_v_self, PyObject *__pyx_v_breakpoints); /*proto*/ static char __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_2compute_force_stay_in_untraced_mode[] = "\n :param breakpoints:\n set(breakpoint_lines) or dict(breakpoint_line->breakpoint info)\n :return tuple(breakpoint_found, force_stay_in_untraced_mode)\n "; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_3compute_force_stay_in_untraced_mode(PyObject *__pyx_v_self, PyObject *__pyx_v_breakpoints) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("compute_force_stay_in_untraced_mode (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_2compute_force_stay_in_untraced_mode(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v_breakpoints)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_2compute_force_stay_in_untraced_mode(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_breakpoints) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("compute_force_stay_in_untraced_mode", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_compute_force_stay_in_untraced_mode(__pyx_v_self, __pyx_v_breakpoints, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.compute_force_stay_in_untraced_mode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":363 * cdef class _CacheValue(object): * * cdef public object code_obj_py # <<<<<<<<<<<<<< * cdef public _CodeLineInfo code_line_info * cdef public set breakpoints_hit_at_lines */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->code_obj_py); __pyx_r = __pyx_v_self->code_obj_py; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__", 0); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __Pyx_GOTREF(__pyx_v_self->code_obj_py); __Pyx_DECREF(__pyx_v_self->code_obj_py); __pyx_v_self->code_obj_py = __pyx_v_value; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->code_obj_py); __Pyx_DECREF(__pyx_v_self->code_obj_py); __pyx_v_self->code_obj_py = Py_None; /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":364 * * cdef public object code_obj_py * cdef public _CodeLineInfo code_line_info # <<<<<<<<<<<<<< * cdef public set breakpoints_hit_at_lines * cdef public set code_lines_as_set */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self->code_line_info)); __pyx_r = ((PyObject *)__pyx_v_self->code_line_info); goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo))))) __PYX_ERR(0, 364, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->code_line_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->code_line_info)); __pyx_v_self->code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.code_line_info.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->code_line_info); __Pyx_DECREF(((PyObject *)__pyx_v_self->code_line_info)); __pyx_v_self->code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":365 * cdef public object code_obj_py * cdef public _CodeLineInfo code_line_info * cdef public set breakpoints_hit_at_lines # <<<<<<<<<<<<<< * cdef public set code_lines_as_set * */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->breakpoints_hit_at_lines); __pyx_r = __pyx_v_self->breakpoints_hit_at_lines; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PySet_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 365, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->breakpoints_hit_at_lines); __Pyx_DECREF(__pyx_v_self->breakpoints_hit_at_lines); __pyx_v_self->breakpoints_hit_at_lines = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.breakpoints_hit_at_lines.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->breakpoints_hit_at_lines); __Pyx_DECREF(__pyx_v_self->breakpoints_hit_at_lines); __pyx_v_self->breakpoints_hit_at_lines = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":366 * cdef public _CodeLineInfo code_line_info * cdef public set breakpoints_hit_at_lines * cdef public set code_lines_as_set # <<<<<<<<<<<<<< * * def __init__(self, object code_obj_py, _CodeLineInfo code_line_info, set breakpoints_hit_at_lines): */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set___get__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set___get__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->code_lines_as_set); __pyx_r = __pyx_v_self->code_lines_as_set; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_2__set__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_2__set__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); if (!(likely(PySet_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_v_value)->tp_name), 0))) __PYX_ERR(0, 366, __pyx_L1_error) __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->code_lines_as_set); __Pyx_DECREF(__pyx_v_self->code_lines_as_set); __pyx_v_self->code_lines_as_set = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.code_lines_as_set.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_5__del__(PyObject *__pyx_v_self); /*proto*/ static int __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_5__del__(PyObject *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_4__del__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_4__del__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__del__", 0); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); __Pyx_GOTREF(__pyx_v_self->code_lines_as_set); __Pyx_DECREF(__pyx_v_self->code_lines_as_set); __pyx_v_self->code_lines_as_set = ((PyObject*)Py_None); /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_4__reduce_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_4__reduce_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.breakpoints_hit_at_lines, self.code_line_info, self.code_lines_as_set, self.code_obj_py) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_self->breakpoints_hit_at_lines); __Pyx_GIVEREF(__pyx_v_self->breakpoints_hit_at_lines); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->breakpoints_hit_at_lines); __Pyx_INCREF(((PyObject *)__pyx_v_self->code_line_info)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self->code_line_info)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self->code_line_info)); __Pyx_INCREF(__pyx_v_self->code_lines_as_set); __Pyx_GIVEREF(__pyx_v_self->code_lines_as_set); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->code_lines_as_set); __Pyx_INCREF(__pyx_v_self->code_obj_py); __Pyx_GIVEREF(__pyx_v_self->code_obj_py); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_self->code_obj_py); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.breakpoints_hit_at_lines, self.code_line_info, self.code_lines_as_set, self.code_obj_py) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__dict = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":7 * state = (self.breakpoints_hit_at_lines, self.code_line_info, self.code_lines_as_set, self.code_obj_py) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_2 = (__pyx_v__dict != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.breakpoints_hit_at_lines is not None or self.code_line_info is not None or self.code_lines_as_set is not None or self.code_obj_py is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.breakpoints_hit_at_lines, self.code_line_info, self.code_lines_as_set, self.code_obj_py) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.breakpoints_hit_at_lines is not None or self.code_line_info is not None or self.code_lines_as_set is not None or self.code_obj_py is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, None), state */ /*else*/ { __pyx_t_2 = (__pyx_v_self->breakpoints_hit_at_lines != ((PyObject*)Py_None)); __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (((PyObject *)__pyx_v_self->code_line_info) != Py_None); __pyx_t_2 = (__pyx_t_5 != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = (__pyx_v_self->code_lines_as_set != ((PyObject*)Py_None)); __pyx_t_5 = (__pyx_t_2 != 0); if (!__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = (__pyx_v_self->code_obj_py != Py_None); __pyx_t_2 = (__pyx_t_5 != 0); __pyx_t_3 = __pyx_t_2; __pyx_L4_bool_binop_done:; __pyx_v_use_setstate = __pyx_t_3; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.breakpoints_hit_at_lines is not None or self.code_line_info is not None or self.code_lines_as_set is not None or self.code_obj_py is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, None), state * else: */ __pyx_t_3 = (__pyx_v_use_setstate != 0); if (__pyx_t_3) { /* "(tree fragment)":13 * use_setstate = self.breakpoints_hit_at_lines is not None or self.code_line_info is not None or self.code_lines_as_set is not None or self.code_obj_py is not None * if use_setstate: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle__CacheValue); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_64258489); __Pyx_GIVEREF(__pyx_int_64258489); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_64258489); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_state); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.breakpoints_hit_at_lines is not None or self.code_line_info is not None or self.code_lines_as_set is not None or self.code_obj_py is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, None), state * else: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__CacheValue__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_pyx_unpickle__CacheValue); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_64258489); __Pyx_GIVEREF(__pyx_int_64258489); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_64258489); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__CacheValue__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_6__setstate_cython__(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_6__setstate_cython__(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__CacheValue__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CacheValue__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle__CacheValue, (type(self), 0x3d481b9, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__CacheValue__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":401 * return breakpoint_found, force_stay_in_untraced_mode * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * return generate_code_with_breakpoints(code_obj_py, breakpoints) * */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_15generate_code_with_breakpoints_py(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_15generate_code_with_breakpoints_py = {"generate_code_with_breakpoints_py", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_15generate_code_with_breakpoints_py, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_15generate_code_with_breakpoints_py(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_code_obj_py = 0; PyObject *__pyx_v_breakpoints = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("generate_code_with_breakpoints_py (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_code_obj_py,&__pyx_n_s_breakpoints,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_code_obj_py)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_breakpoints)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("generate_code_with_breakpoints_py", 1, 2, 2, 1); __PYX_ERR(0, 401, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "generate_code_with_breakpoints_py") < 0)) __PYX_ERR(0, 401, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_code_obj_py = values[0]; __pyx_v_breakpoints = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("generate_code_with_breakpoints_py", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 401, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.generate_code_with_breakpoints_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_breakpoints), (&PyDict_Type), 1, "breakpoints", 1))) __PYX_ERR(0, 401, __pyx_L1_error) __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_14generate_code_with_breakpoints_py(__pyx_self, __pyx_v_code_obj_py, __pyx_v_breakpoints); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_14generate_code_with_breakpoints_py(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_code_obj_py, PyObject *__pyx_v_breakpoints) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("generate_code_with_breakpoints_py", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":402 * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): * return generate_code_with_breakpoints(code_obj_py, breakpoints) # <<<<<<<<<<<<<< * * # DEBUG = True */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_generate_code_with_breakpoints(__pyx_v_code_obj_py, __pyx_v_breakpoints); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":401 * return breakpoint_found, force_stay_in_untraced_mode * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * return generate_code_with_breakpoints(code_obj_py, breakpoints) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.generate_code_with_breakpoints_py", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":407 * # debug_helper = DebugHelper() * * cdef generate_code_with_breakpoints(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * ''' * :param breakpoints: */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_generate_code_with_breakpoints(PyObject *__pyx_v_code_obj_py, PyObject *__pyx_v_breakpoints) { int __pyx_v_success; int __pyx_v_breakpoint_line; int __pyx_v_breakpoint_found; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v_cache_value = 0; PyObject *__pyx_v_breakpoints_hit_at_lines = 0; PyObject *__pyx_v_line_to_offset = 0; PyObject *__pyx_v_code_line_info = NULL; PyObject *__pyx_v_new_code = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("generate_code_with_breakpoints", 0); __Pyx_INCREF(__pyx_v_code_obj_py); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":424 * cdef dict line_to_offset * * assert code_obj_py not in _cache, 'If a code object is cached, that same code object must be reused.' # <<<<<<<<<<<<<< * * # if DEBUG: */ #ifndef CYTHON_WITHOUT_ASSERTIONS if (unlikely(!Py_OptimizeFlag)) { __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_cache); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_code_obj_py, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 424, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!(__pyx_t_2 != 0))) { PyErr_SetObject(PyExc_AssertionError, __pyx_kp_s_If_a_code_object_is_cached_that); __PYX_ERR(0, 424, __pyx_L1_error) } } #endif /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":429 * # initial_code_obj_py = code_obj_py * * code_line_info = _get_code_line_info(code_obj_py) # <<<<<<<<<<<<<< * * success = True */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_get_code_line_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_code_obj_py) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_code_obj_py); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_code_line_info = __pyx_t_1; __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":431 * code_line_info = _get_code_line_info(code_obj_py) * * success = True # <<<<<<<<<<<<<< * * breakpoints_hit_at_lines = set() */ __pyx_v_success = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":433 * success = True * * breakpoints_hit_at_lines = set() # <<<<<<<<<<<<<< * line_to_offset = code_line_info.line_to_offset * */ __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_breakpoints_hit_at_lines = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":434 * * breakpoints_hit_at_lines = set() * line_to_offset = code_line_info.line_to_offset # <<<<<<<<<<<<<< * * for breakpoint_line in breakpoints: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_code_line_info, __pyx_n_s_line_to_offset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 434, __pyx_L1_error) __pyx_v_line_to_offset = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":436 * line_to_offset = code_line_info.line_to_offset * * for breakpoint_line in breakpoints: # <<<<<<<<<<<<<< * if breakpoint_line in line_to_offset: * breakpoints_hit_at_lines.add(breakpoint_line) */ __pyx_t_5 = 0; if (unlikely(__pyx_v_breakpoints == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 436, __pyx_L1_error) } __pyx_t_3 = __Pyx_dict_iterator(__pyx_v_breakpoints, 1, ((PyObject *)NULL), (&__pyx_t_6), (&__pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_3; __pyx_t_3 = 0; while (1) { __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_6, &__pyx_t_5, &__pyx_t_3, NULL, NULL, __pyx_t_7); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 436, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_breakpoint_line = __pyx_t_8; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":437 * * for breakpoint_line in breakpoints: * if breakpoint_line in line_to_offset: # <<<<<<<<<<<<<< * breakpoints_hit_at_lines.add(breakpoint_line) * */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_breakpoint_line); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(__pyx_v_line_to_offset == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); __PYX_ERR(0, 437, __pyx_L1_error) } __pyx_t_2 = (__Pyx_PyDict_ContainsTF(__pyx_t_3, __pyx_v_line_to_offset, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_9 = (__pyx_t_2 != 0); if (__pyx_t_9) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":438 * for breakpoint_line in breakpoints: * if breakpoint_line in line_to_offset: * breakpoints_hit_at_lines.add(breakpoint_line) # <<<<<<<<<<<<<< * * if breakpoints_hit_at_lines: */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_breakpoint_line); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = PySet_Add(__pyx_v_breakpoints_hit_at_lines, __pyx_t_3); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(0, 438, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":437 * * for breakpoint_line in breakpoints: * if breakpoint_line in line_to_offset: # <<<<<<<<<<<<<< * breakpoints_hit_at_lines.add(breakpoint_line) * */ } } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":440 * breakpoints_hit_at_lines.add(breakpoint_line) * * if breakpoints_hit_at_lines: # <<<<<<<<<<<<<< * success, new_code = insert_pydevd_breaks( * code_obj_py, */ __pyx_t_9 = (PySet_GET_SIZE(__pyx_v_breakpoints_hit_at_lines) != 0); if (__pyx_t_9) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":441 * * if breakpoints_hit_at_lines: * success, new_code = insert_pydevd_breaks( # <<<<<<<<<<<<<< * code_obj_py, * breakpoints_hit_at_lines, */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_insert_pydevd_breaks); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":444 * code_obj_py, * breakpoints_hit_at_lines, * code_line_info # <<<<<<<<<<<<<< * ) * */ __pyx_t_4 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_code_obj_py, __pyx_v_breakpoints_hit_at_lines, __pyx_v_code_line_info}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_4, __pyx_v_code_obj_py, __pyx_v_breakpoints_hit_at_lines, __pyx_v_code_line_info}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_11 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(__pyx_v_code_obj_py); __Pyx_GIVEREF(__pyx_v_code_obj_py); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_7, __pyx_v_code_obj_py); __Pyx_INCREF(__pyx_v_breakpoints_hit_at_lines); __Pyx_GIVEREF(__pyx_v_breakpoints_hit_at_lines); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_7, __pyx_v_breakpoints_hit_at_lines); __Pyx_INCREF(__pyx_v_code_line_info); __Pyx_GIVEREF(__pyx_v_code_line_info); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_7, __pyx_v_code_line_info); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 441, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_11 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_11 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_11); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_11 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_4)->tp_iternext; index = 0; __pyx_t_3 = __pyx_t_12(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L7_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 1; __pyx_t_11 = __pyx_t_12(__pyx_t_4); if (unlikely(!__pyx_t_11)) goto __pyx_L7_unpacking_failed; __Pyx_GOTREF(__pyx_t_11); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_4), 2) < 0) __PYX_ERR(0, 441, __pyx_L1_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L8_unpacking_done; __pyx_L7_unpacking_failed:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 441, __pyx_L1_error) __pyx_L8_unpacking_done:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":441 * * if breakpoints_hit_at_lines: * success, new_code = insert_pydevd_breaks( # <<<<<<<<<<<<<< * code_obj_py, * breakpoints_hit_at_lines, */ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_success = __pyx_t_9; __pyx_v_new_code = __pyx_t_11; __pyx_t_11 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":447 * ) * * if not success: # <<<<<<<<<<<<<< * code_obj_py = None * else: */ __pyx_t_9 = ((!(__pyx_v_success != 0)) != 0); if (__pyx_t_9) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":448 * * if not success: * code_obj_py = None # <<<<<<<<<<<<<< * else: * code_obj_py = new_code */ __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_code_obj_py, Py_None); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":447 * ) * * if not success: # <<<<<<<<<<<<<< * code_obj_py = None * else: */ goto __pyx_L9; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":450 * code_obj_py = None * else: * code_obj_py = new_code # <<<<<<<<<<<<<< * * breakpoint_found = bool(breakpoints_hit_at_lines) */ /*else*/ { __Pyx_INCREF(__pyx_v_new_code); __Pyx_DECREF_SET(__pyx_v_code_obj_py, __pyx_v_new_code); } __pyx_L9:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":440 * breakpoints_hit_at_lines.add(breakpoint_line) * * if breakpoints_hit_at_lines: # <<<<<<<<<<<<<< * success, new_code = insert_pydevd_breaks( * code_obj_py, */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":452 * code_obj_py = new_code * * breakpoint_found = bool(breakpoints_hit_at_lines) # <<<<<<<<<<<<<< * if breakpoint_found and success: * # if DEBUG: */ __pyx_t_9 = (PySet_GET_SIZE(__pyx_v_breakpoints_hit_at_lines) != 0); __pyx_v_breakpoint_found = (!(!__pyx_t_9)); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":453 * * breakpoint_found = bool(breakpoints_hit_at_lines) * if breakpoint_found and success: # <<<<<<<<<<<<<< * # if DEBUG: * # op_number = debug_helper.write_dis( */ __pyx_t_2 = (__pyx_v_breakpoint_found != 0); if (__pyx_t_2) { } else { __pyx_t_9 = __pyx_t_2; goto __pyx_L11_bool_binop_done; } __pyx_t_2 = (__pyx_v_success != 0); __pyx_t_9 = __pyx_t_2; __pyx_L11_bool_binop_done:; if (__pyx_t_9) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":466 * # ) * * cache_value = _CacheValue(code_obj_py, code_line_info, breakpoints_hit_at_lines) # <<<<<<<<<<<<<< * _cache[code_obj_py] = cache_value * */ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_code_obj_py); __Pyx_GIVEREF(__pyx_v_code_obj_py); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_code_obj_py); __Pyx_INCREF(__pyx_v_code_line_info); __Pyx_GIVEREF(__pyx_v_code_line_info); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_code_line_info); __Pyx_INCREF(__pyx_v_breakpoints_hit_at_lines); __Pyx_GIVEREF(__pyx_v_breakpoints_hit_at_lines); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_breakpoints_hit_at_lines); __pyx_t_11 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue), __pyx_t_1, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_cache_value = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_t_11); __pyx_t_11 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":467 * * cache_value = _CacheValue(code_obj_py, code_line_info, breakpoints_hit_at_lines) * _cache[code_obj_py] = cache_value # <<<<<<<<<<<<<< * * return breakpoint_found, code_obj_py */ __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_cache); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_v_code_obj_py, ((PyObject *)__pyx_v_cache_value)) < 0)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":453 * * breakpoint_found = bool(breakpoints_hit_at_lines) * if breakpoint_found and success: # <<<<<<<<<<<<<< * # if DEBUG: * # op_number = debug_helper.write_dis( */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":469 * _cache[code_obj_py] = cache_value * * return breakpoint_found, code_obj_py # <<<<<<<<<<<<<< * * import sys */ __Pyx_XDECREF(__pyx_r); __pyx_t_11 = __Pyx_PyBool_FromLong(__pyx_v_breakpoint_found); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_11); __Pyx_INCREF(__pyx_v_code_obj_py); __Pyx_GIVEREF(__pyx_v_code_obj_py); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_code_obj_py); __pyx_t_11 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":407 * # debug_helper = DebugHelper() * * cdef generate_code_with_breakpoints(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * ''' * :param breakpoints: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.generate_code_with_breakpoints", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_cache_value); __Pyx_XDECREF(__pyx_v_breakpoints_hit_at_lines); __Pyx_XDECREF(__pyx_v_line_to_offset); __Pyx_XDECREF(__pyx_v_code_line_info); __Pyx_XDECREF(__pyx_v_new_code); __Pyx_XDECREF(__pyx_v_code_obj_py); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":475 * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) * * def frame_eval_func(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_17frame_eval_func(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_17frame_eval_func = {"frame_eval_func", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_17frame_eval_func, METH_NOARGS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_17frame_eval_func(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("frame_eval_func (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_16frame_eval_func(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_16frame_eval_func(CYTHON_UNUSED PyObject *__pyx_self) { PyThreadState *__pyx_v_state; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("frame_eval_func", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":476 * * def frame_eval_func(): * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< * if IS_PY_39_OWNARDS: * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 */ __pyx_v_state = PyThreadState_Get(); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":477 * def frame_eval_func(): * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: # <<<<<<<<<<<<<< * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 * else: */ __pyx_t_1 = (__pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator_IS_PY_39_OWNARDS != 0); if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":478 * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 # <<<<<<<<<<<<<< * else: * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_38 */ __pyx_v_state->interp->eval_frame = ((_PyFrameEvalFunction *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_39); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":477 * def frame_eval_func(): * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: # <<<<<<<<<<<<<< * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 * else: */ goto __pyx_L3; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":480 * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_39 * else: * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_38 # <<<<<<<<<<<<<< * dummy_tracing_holder.set_trace_func(dummy_trace_dispatch) * */ /*else*/ { __pyx_v_state->interp->eval_frame = ((_PyFrameEvalFunction *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_38); } __pyx_L3:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":481 * else: * state.interp.eval_frame = <_PyFrameEvalFunction *> get_bytecode_while_frame_eval_38 * dummy_tracing_holder.set_trace_func(dummy_trace_dispatch) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_dummy_tracing_holder); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_set_trace_func); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_dummy_trace_dispatch); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":475 * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) * * def frame_eval_func(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.frame_eval_func", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":484 * * * def stop_frame_eval(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * state.interp.eval_frame = _PyEval_EvalFrameDefault */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_19stop_frame_eval(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_19stop_frame_eval = {"stop_frame_eval", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_19stop_frame_eval, METH_NOARGS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_19stop_frame_eval(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stop_frame_eval (wrapper)", 0); __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_18stop_frame_eval(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_18stop_frame_eval(CYTHON_UNUSED PyObject *__pyx_self) { PyThreadState *__pyx_v_state; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stop_frame_eval", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":485 * * def stop_frame_eval(): * cdef PyThreadState *state = PyThreadState_Get() # <<<<<<<<<<<<<< * state.interp.eval_frame = _PyEval_EvalFrameDefault * */ __pyx_v_state = PyThreadState_Get(); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":486 * def stop_frame_eval(): * cdef PyThreadState *state = PyThreadState_Get() * state.interp.eval_frame = _PyEval_EvalFrameDefault # <<<<<<<<<<<<<< * * # During the build we'll generate 2 versions of the code below so that we're compatible with */ __pyx_v_state->interp->eval_frame = _PyEval_EvalFrameDefault; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":484 * * * def stop_frame_eval(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * state.interp.eval_frame = _PyEval_EvalFrameDefault */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":494 * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! * cdef PyObject * get_bytecode_while_frame_eval_38(PyFrameObject * frame_obj, int exc): # <<<<<<<<<<<<<< * ''' * This function makes the actual evaluation and changes the bytecode to a version */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_38(PyFrameObject *__pyx_v_frame_obj, int __pyx_v_exc) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_thread_info = 0; CYTHON_UNUSED int __pyx_v_STATE_SUSPEND; int __pyx_v_CMD_STEP_INTO; int __pyx_v_CMD_STEP_OVER; int __pyx_v_CMD_STEP_OVER_MY_CODE; int __pyx_v_CMD_STEP_INTO_MY_CODE; int __pyx_v_CMD_STEP_INTO_COROUTINE; int __pyx_v_CMD_SMART_STEP_INTO; int __pyx_v_can_skip; struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *__pyx_v_additional_info = 0; PyObject *__pyx_v_main_debugger = 0; PyObject *__pyx_v_frame = NULL; PyObject *__pyx_v_trace_func = NULL; PyObject *__pyx_v_apply_to_global = NULL; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_func_code_info = 0; PyObject *__pyx_v_old = NULL; PyObject *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_t_13; char const *__pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_bytecode_while_frame_eval_38", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":499 * where programmatic breakpoints are added. * ''' * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: # <<<<<<<<<<<<<< * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = (__pyx_t_2 == Py_None); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_t_2 == Py_None); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_exc != 0); __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":501 * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * * # co_filename: str = <str>frame_obj.f_code.co_filename */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":499 * where programmatic breakpoints are added. * ''' * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: # <<<<<<<<<<<<<< * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_38(frame_obj, exc) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":508 * * cdef ThreadInfo thread_info * cdef int STATE_SUSPEND = 2 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 */ __pyx_v_STATE_SUSPEND = 2; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":509 * cdef ThreadInfo thread_info * cdef int STATE_SUSPEND = 2 * cdef int CMD_STEP_INTO = 107 # <<<<<<<<<<<<<< * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 */ __pyx_v_CMD_STEP_INTO = 0x6B; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":510 * cdef int STATE_SUSPEND = 2 * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 # <<<<<<<<<<<<<< * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 */ __pyx_v_CMD_STEP_OVER = 0x6C; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":511 * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 */ __pyx_v_CMD_STEP_OVER_MY_CODE = 0x9F; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":512 * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 */ __pyx_v_CMD_STEP_INTO_MY_CODE = 0x90; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":513 * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 # <<<<<<<<<<<<<< * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True */ __pyx_v_CMD_STEP_INTO_COROUTINE = 0xCE; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":514 * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 # <<<<<<<<<<<<<< * cdef bint can_skip = True * try: */ __pyx_v_CMD_SMART_STEP_INTO = 0x80; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":515 * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True # <<<<<<<<<<<<<< * try: * thread_info = _thread_local_info.thread_info */ __pyx_v_can_skip = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":516 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":517 * cdef bint can_skip = True * try: * thread_info = _thread_local_info.thread_info # <<<<<<<<<<<<<< * except: * thread_info = get_thread_info(frame_obj) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 517, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_thread_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 517, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo))))) __PYX_ERR(0, 517, __pyx_L7_error) __pyx_v_thread_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":516 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":518 * try: * thread_info = _thread_local_info.thread_info * except: # <<<<<<<<<<<<<< * thread_info = get_thread_info(frame_obj) * if thread_info is None: */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_bytecode_while_frame_eval_38", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 518, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_9); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":519 * thread_info = _thread_local_info.thread_info * except: * thread_info = get_thread_info(frame_obj) # <<<<<<<<<<<<<< * if thread_info is None: * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_t_10 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_thread_info(__pyx_v_frame_obj)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 519, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_XDECREF_SET(__pyx_v_thread_info, ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_10)); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":520 * except: * thread_info = get_thread_info(frame_obj) * if thread_info is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ __pyx_t_1 = (((PyObject *)__pyx_v_thread_info) == Py_None); __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":521 * thread_info = get_thread_info(frame_obj) * if thread_info is None: * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * * if thread_info.inside_frame_eval: */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L10_except_return; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":520 * except: * thread_info = get_thread_info(frame_obj) * if thread_info is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L8_exception_handled; } __pyx_L9_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":516 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); goto __pyx_L1_error; __pyx_L10_except_return:; __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); goto __pyx_L0; __pyx_L8_exception_handled:; __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); __pyx_L12_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":523 * return CALL_EvalFrameDefault_38(frame_obj, exc) * * if thread_info.inside_frame_eval: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ __pyx_t_3 = (__pyx_v_thread_info->inside_frame_eval != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":524 * * if thread_info.inside_frame_eval: * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * * if not thread_info.fully_initialized: */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":523 * return CALL_EvalFrameDefault_38(frame_obj, exc) * * if thread_info.inside_frame_eval: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":526 * return CALL_EvalFrameDefault_38(frame_obj, exc) * * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: */ __pyx_t_3 = ((!(__pyx_v_thread_info->fully_initialized != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":527 * * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() # <<<<<<<<<<<<<< * if not thread_info.fully_initialized: * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_t_9 = ((struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_thread_info->__pyx_vtab)->initialize_if_possible(__pyx_v_thread_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":528 * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ __pyx_t_3 = ((!(__pyx_v_thread_info->fully_initialized != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":529 * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * * # Can only get additional_info when fully initialized. */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":528 * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":526 * return CALL_EvalFrameDefault_38(frame_obj, exc) * * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":532 * * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info # <<<<<<<<<<<<<< * if thread_info.is_pydevd_thread or additional_info.is_tracing: * # Make sure that we don't trace pydevd threads or inside our own calls. */ __pyx_t_9 = ((PyObject *)__pyx_v_thread_info->additional_info); __Pyx_INCREF(__pyx_t_9); __pyx_v_additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":533 * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info * if thread_info.is_pydevd_thread or additional_info.is_tracing: # <<<<<<<<<<<<<< * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_t_1 = (__pyx_v_thread_info->is_pydevd_thread != 0); if (!__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L20_bool_binop_done; } __pyx_t_1 = (__pyx_v_additional_info->is_tracing != 0); __pyx_t_3 = __pyx_t_1; __pyx_L20_bool_binop_done:; if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":535 * if thread_info.is_pydevd_thread or additional_info.is_tracing: * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * * # frame = <object> frame_obj */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":533 * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info * if thread_info.is_pydevd_thread or additional_info.is_tracing: # <<<<<<<<<<<<<< * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_38(frame_obj, exc) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":542 * # print('get_bytecode_while_frame_eval', frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename) * * thread_info.inside_frame_eval += 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = True * try: */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval + 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":543 * * thread_info.inside_frame_eval += 1 * additional_info.is_tracing = True # <<<<<<<<<<<<<< * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg */ __pyx_v_additional_info->is_tracing = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":544 * thread_info.inside_frame_eval += 1 * additional_info.is_tracing = True * try: # <<<<<<<<<<<<<< * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: */ /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":545 * additional_info.is_tracing = True * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg # <<<<<<<<<<<<<< * if main_debugger is None: * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 545, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_global_dbg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 545, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_main_debugger = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":546 * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * frame = <object> frame_obj */ __pyx_t_3 = (__pyx_v_main_debugger == Py_None); __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":547 * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * frame = <object> frame_obj * */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L22_return; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":546 * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_38(frame_obj, exc) * frame = <object> frame_obj */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":548 * if main_debugger is None: * return CALL_EvalFrameDefault_38(frame_obj, exc) * frame = <object> frame_obj # <<<<<<<<<<<<<< * * if thread_info.thread_trace_func is None: */ __pyx_t_2 = ((PyObject *)__pyx_v_frame_obj); __Pyx_INCREF(__pyx_t_2); __pyx_v_frame = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":550 * frame = <object> frame_obj * * if thread_info.thread_trace_func is None: # <<<<<<<<<<<<<< * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: */ __pyx_t_1 = (__pyx_v_thread_info->thread_trace_func == Py_None); __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":551 * * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) # <<<<<<<<<<<<<< * if apply_to_global: * thread_info.thread_trace_func = trace_func */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_fix_top_level_trace_and_get_trac); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_main_debugger, __pyx_v_frame}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_main_debugger, __pyx_v_frame}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_10 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_v_main_debugger); __Pyx_GIVEREF(__pyx_v_main_debugger); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_11, __pyx_v_main_debugger); __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_11, __pyx_v_frame); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 551, __pyx_L23_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_9 = PyList_GET_ITEM(sequence, 0); __pyx_t_10 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_10); #else __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 551, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_8)->tp_iternext; index = 0; __pyx_t_9 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_9)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_9); index = 1; __pyx_t_10 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_10)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_8), 2) < 0) __PYX_ERR(0, 551, __pyx_L23_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L28_unpacking_done; __pyx_L27_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 551, __pyx_L23_error) __pyx_L28_unpacking_done:; } __pyx_v_trace_func = __pyx_t_9; __pyx_t_9 = 0; __pyx_v_apply_to_global = __pyx_t_10; __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":552 * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: # <<<<<<<<<<<<<< * thread_info.thread_trace_func = trace_func * */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_apply_to_global); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 552, __pyx_L23_error) if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":553 * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: * thread_info.thread_trace_func = trace_func # <<<<<<<<<<<<<< * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ */ __Pyx_INCREF(__pyx_v_trace_func); __Pyx_GIVEREF(__pyx_v_trace_func); __Pyx_GOTREF(__pyx_v_thread_info->thread_trace_func); __Pyx_DECREF(__pyx_v_thread_info->thread_trace_func); __pyx_v_thread_info->thread_trace_func = __pyx_v_trace_func; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":552 * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: # <<<<<<<<<<<<<< * thread_info.thread_trace_func = trace_func * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":550 * frame = <object> frame_obj * * if thread_info.thread_trace_func is None: # <<<<<<<<<<<<<< * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":555 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ __pyx_t_11 = __pyx_v_additional_info->pydev_step_cmd; __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO_MY_CODE) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO_COROUTINE) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_SMART_STEP_INTO) != 0); __pyx_t_1 = __pyx_t_4; __pyx_L33_bool_binop_done:; __pyx_t_4 = (__pyx_t_1 != 0); if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":556 * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ * main_debugger.break_on_caught_exceptions or \ # <<<<<<<<<<<<<< * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_caught_exceptions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 556, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":557 * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ # <<<<<<<<<<<<<< * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_user_uncaught_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 557, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 557, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":558 * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ # <<<<<<<<<<<<<< * main_debugger.signature_factory or \ * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 558, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 558, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":559 * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ # <<<<<<<<<<<<<< * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 559, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 559, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":560 * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: # <<<<<<<<<<<<<< * * # if DEBUG: */ __pyx_t_11 = __pyx_v_additional_info->pydev_step_cmd; __pyx_t_1 = ((__pyx_t_11 == __pyx_v_CMD_STEP_OVER) != 0); if (!__pyx_t_1) { } else { __pyx_t_4 = __pyx_t_1; goto __pyx_L42_bool_binop_done; } __pyx_t_1 = ((__pyx_t_11 == __pyx_v_CMD_STEP_OVER_MY_CODE) != 0); __pyx_t_4 = __pyx_t_1; __pyx_L42_bool_binop_done:; __pyx_t_1 = (__pyx_t_4 != 0); if (__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L31_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 560, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L31_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = (__pyx_t_2 == __pyx_v_additional_info->pydev_step_stop); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_1 != 0); __pyx_t_3 = __pyx_t_4; __pyx_L31_bool_binop_done:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":555 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":564 * # if DEBUG: * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_3 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":565 * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_2 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_2); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_2) < 0) __PYX_ERR(0, 565, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":564 * # if DEBUG: * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L45; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":567 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * else: * func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 567, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = __pyx_t_2; __Pyx_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 567, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L45:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":555 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ goto __pyx_L30; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":569 * frame.f_trace = <object> main_debugger.trace_dispatch * else: * func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) */ /*else*/ { __pyx_t_10 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_func_code_info(__pyx_v_thread_info, __pyx_v_frame_obj, __pyx_v_frame_obj->f_code)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 569, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_v_func_code_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":572 * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: */ __pyx_t_4 = ((!(__pyx_v_func_code_info->always_skip_code != 0)) != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":574 * if not func_code_info.always_skip_code: * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: # <<<<<<<<<<<<<< * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * */ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 574, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 574, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L48_bool_binop_done; } __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 574, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 574, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_4 = __pyx_t_3; __pyx_L48_bool_binop_done:; if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":575 * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) # <<<<<<<<<<<<<< * * if not can_skip: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_plugin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_can_skip); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_main_debugger, ((PyObject *)__pyx_v_frame_obj)}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_10); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_main_debugger, ((PyObject *)__pyx_v_frame_obj)}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_10); } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(__pyx_v_main_debugger); __Pyx_GIVEREF(__pyx_v_main_debugger); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_11, __pyx_v_main_debugger); __Pyx_INCREF(((PyObject *)__pyx_v_frame_obj)); __Pyx_GIVEREF(((PyObject *)__pyx_v_frame_obj)); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_11, ((PyObject *)__pyx_v_frame_obj)); __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 575, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_can_skip = __pyx_t_4; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":577 * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * * if not can_skip: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') */ __pyx_t_4 = ((!(__pyx_v_can_skip != 0)) != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":580 * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_4 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":581 * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_10 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_10); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 581, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":580 * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L51; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":583 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * * if can_skip and func_code_info.breakpoint_found: */ /*else*/ { __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 583, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_9 = __pyx_t_10; __Pyx_INCREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_9) < 0) __PYX_ERR(0, 583, __pyx_L23_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L51:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":577 * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * * if not can_skip: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":574 * if not func_code_info.always_skip_code: * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: # <<<<<<<<<<<<<< * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":585 * frame.f_trace = <object> main_debugger.trace_dispatch * * if can_skip and func_code_info.breakpoint_found: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) */ __pyx_t_4 = (__pyx_v_can_skip != 0); if (__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L53_bool_binop_done; } __pyx_t_4 = (__pyx_v_func_code_info->breakpoint_found != 0); __pyx_t_3 = __pyx_t_4; __pyx_L53_bool_binop_done:; if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":588 * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) * if not thread_info.force_stay_in_untraced_mode: # <<<<<<<<<<<<<< * # If breakpoints are found but new_code is None, * # this means we weren't able to actually add the code */ __pyx_t_3 = ((!(__pyx_v_thread_info->force_stay_in_untraced_mode != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":592 * # this means we weren't able to actually add the code * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: # <<<<<<<<<<<<<< * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func */ __pyx_t_3 = (__pyx_v_func_code_info->new_code == Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":593 * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_4 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":594 * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_9 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_9); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_9) < 0) __PYX_ERR(0, 594, __pyx_L23_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":593 * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L57; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":596 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * else: * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) */ /*else*/ { __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 596, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __pyx_t_9; __Pyx_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 596, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L57:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":592 * # this means we weren't able to actually add the code * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: # <<<<<<<<<<<<<< * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func */ goto __pyx_L56; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":599 * else: * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) * update_globals_dict(<object> frame_obj.f_globals) # <<<<<<<<<<<<<< * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_update_globals_dict); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 599, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); } } __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, ((PyObject *)__pyx_v_frame_obj->f_globals)) : __Pyx_PyObject_CallOneArg(__pyx_t_9, ((PyObject *)__pyx_v_frame_obj->f_globals)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 599, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":600 * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) * update_globals_dict(<object> frame_obj.f_globals) * Py_INCREF(func_code_info.new_code) # <<<<<<<<<<<<<< * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code */ __pyx_t_10 = __pyx_v_func_code_info->new_code; __Pyx_INCREF(__pyx_t_10); Py_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":601 * update_globals_dict(<object> frame_obj.f_globals) * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code # <<<<<<<<<<<<<< * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code * Py_DECREF(old) */ __pyx_t_10 = ((PyObject *)__pyx_v_frame_obj->f_code); __Pyx_INCREF(__pyx_t_10); __pyx_v_old = __pyx_t_10; __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":602 * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code # <<<<<<<<<<<<<< * Py_DECREF(old) * else: */ __pyx_v_frame_obj->f_code = ((PyCodeObject *)__pyx_v_func_code_info->new_code); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":603 * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code * Py_DECREF(old) # <<<<<<<<<<<<<< * else: * # When we're forcing to stay in traced mode we need to */ Py_DECREF(__pyx_v_old); } __pyx_L56:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":588 * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) * if not thread_info.force_stay_in_untraced_mode: # <<<<<<<<<<<<<< * # If breakpoints are found but new_code is None, * # this means we weren't able to actually add the code */ goto __pyx_L55; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":608 * # update the globals dict (because this means that we're reusing * # a previous code which had breakpoints added in a new frame). * update_globals_dict(<object> frame_obj.f_globals) # <<<<<<<<<<<<<< * * finally: */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_update_globals_dict); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 608, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); } } __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, ((PyObject *)__pyx_v_frame_obj->f_globals)) : __Pyx_PyObject_CallOneArg(__pyx_t_9, ((PyObject *)__pyx_v_frame_obj->f_globals)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 608, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L55:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":585 * frame.f_trace = <object> main_debugger.trace_dispatch * * if can_skip and func_code_info.breakpoint_found: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":572 * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: */ } } __pyx_L30:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":611 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ /*finally:*/ { /*normal exit:*/{ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":612 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; goto __pyx_L24; } __pyx_L23_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_11 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":611 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":612 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5); __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; goto __pyx_L1_error; } __pyx_L22_return: { __pyx_t_18 = __pyx_r; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":611 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":612 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_38(frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; __pyx_r = __pyx_t_18; goto __pyx_L0; } __pyx_L24:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":614 * additional_info.is_tracing = False * * return CALL_EvalFrameDefault_38(frame_obj, exc) # <<<<<<<<<<<<<< * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! */ __pyx_r = CALL_EvalFrameDefault_38(__pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":494 * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! * cdef PyObject * get_bytecode_while_frame_eval_38(PyFrameObject * frame_obj, int exc): # <<<<<<<<<<<<<< * ''' * This function makes the actual evaluation and changes the bytecode to a version */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_WriteUnraisable("_pydevd_frame_eval.pydevd_frame_evaluator.get_bytecode_while_frame_eval_38", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_thread_info); __Pyx_XDECREF((PyObject *)__pyx_v_additional_info); __Pyx_XDECREF(__pyx_v_main_debugger); __Pyx_XDECREF(__pyx_v_frame); __Pyx_XDECREF(__pyx_v_trace_func); __Pyx_XDECREF(__pyx_v_apply_to_global); __Pyx_XDECREF((PyObject *)__pyx_v_func_code_info); __Pyx_XDECREF(__pyx_v_old); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":623 * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! * cdef PyObject * get_bytecode_while_frame_eval_39(PyThreadState* tstate, PyFrameObject * frame_obj, int exc): # <<<<<<<<<<<<<< * ''' * This function makes the actual evaluation and changes the bytecode to a version */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_bytecode_while_frame_eval_39(PyThreadState *__pyx_v_tstate, PyFrameObject *__pyx_v_frame_obj, int __pyx_v_exc) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v_thread_info = 0; CYTHON_UNUSED int __pyx_v_STATE_SUSPEND; int __pyx_v_CMD_STEP_INTO; int __pyx_v_CMD_STEP_OVER; int __pyx_v_CMD_STEP_OVER_MY_CODE; int __pyx_v_CMD_STEP_INTO_MY_CODE; int __pyx_v_CMD_STEP_INTO_COROUTINE; int __pyx_v_CMD_SMART_STEP_INTO; int __pyx_v_can_skip; struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *__pyx_v_additional_info = 0; PyObject *__pyx_v_main_debugger = 0; PyObject *__pyx_v_frame = NULL; PyObject *__pyx_v_trace_func = NULL; PyObject *__pyx_v_apply_to_global = NULL; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v_func_code_info = 0; PyObject *__pyx_v_old = NULL; PyObject *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; PyObject *(*__pyx_t_12)(PyObject *); int __pyx_t_13; char const *__pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_bytecode_while_frame_eval_39", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":628 * where programmatic breakpoints are added. * ''' * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: # <<<<<<<<<<<<<< * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = (__pyx_t_2 == Py_None); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_t_2 == Py_None); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = (__pyx_t_4 != 0); if (!__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_exc != 0); __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":630 * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * * # co_filename: str = <str>frame_obj.f_code.co_filename */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":628 * where programmatic breakpoints are added. * ''' * if GlobalDebuggerHolder is None or _thread_local_info is None or exc: # <<<<<<<<<<<<<< * # Sometimes during process shutdown these global variables become None * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":637 * * cdef ThreadInfo thread_info * cdef int STATE_SUSPEND = 2 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 */ __pyx_v_STATE_SUSPEND = 2; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":638 * cdef ThreadInfo thread_info * cdef int STATE_SUSPEND = 2 * cdef int CMD_STEP_INTO = 107 # <<<<<<<<<<<<<< * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 */ __pyx_v_CMD_STEP_INTO = 0x6B; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":639 * cdef int STATE_SUSPEND = 2 * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 # <<<<<<<<<<<<<< * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 */ __pyx_v_CMD_STEP_OVER = 0x6C; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":640 * cdef int CMD_STEP_INTO = 107 * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 */ __pyx_v_CMD_STEP_OVER_MY_CODE = 0x9F; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":641 * cdef int CMD_STEP_OVER = 108 * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 # <<<<<<<<<<<<<< * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 */ __pyx_v_CMD_STEP_INTO_MY_CODE = 0x90; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":642 * cdef int CMD_STEP_OVER_MY_CODE = 159 * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 # <<<<<<<<<<<<<< * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True */ __pyx_v_CMD_STEP_INTO_COROUTINE = 0xCE; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":643 * cdef int CMD_STEP_INTO_MY_CODE = 144 * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 # <<<<<<<<<<<<<< * cdef bint can_skip = True * try: */ __pyx_v_CMD_SMART_STEP_INTO = 0x80; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":644 * cdef int CMD_STEP_INTO_COROUTINE = 206 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True # <<<<<<<<<<<<<< * try: * thread_info = _thread_local_info.thread_info */ __pyx_v_can_skip = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":645 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":646 * cdef bint can_skip = True * try: * thread_info = _thread_local_info.thread_info # <<<<<<<<<<<<<< * except: * thread_info = get_thread_info(frame_obj) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_thread_local_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 646, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_thread_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 646, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo))))) __PYX_ERR(0, 646, __pyx_L7_error) __pyx_v_thread_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":645 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":647 * try: * thread_info = _thread_local_info.thread_info * except: # <<<<<<<<<<<<<< * thread_info = get_thread_info(frame_obj) * if thread_info is None: */ /*except:*/ { __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.get_bytecode_while_frame_eval_39", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(0, 647, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_9); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":648 * thread_info = _thread_local_info.thread_info * except: * thread_info = get_thread_info(frame_obj) # <<<<<<<<<<<<<< * if thread_info is None: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_t_10 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_thread_info(__pyx_v_frame_obj)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 648, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_XDECREF_SET(__pyx_v_thread_info, ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_t_10)); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":649 * except: * thread_info = get_thread_info(frame_obj) * if thread_info is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ __pyx_t_1 = (((PyObject *)__pyx_v_thread_info) == Py_None); __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":650 * thread_info = get_thread_info(frame_obj) * if thread_info is None: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * * if thread_info.inside_frame_eval: */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L10_except_return; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":649 * except: * thread_info = get_thread_info(frame_obj) * if thread_info is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L8_exception_handled; } __pyx_L9_except_error:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":645 * cdef int CMD_SMART_STEP_INTO = 128 * cdef bint can_skip = True * try: # <<<<<<<<<<<<<< * thread_info = _thread_local_info.thread_info * except: */ __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); goto __pyx_L1_error; __pyx_L10_except_return:; __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); goto __pyx_L0; __pyx_L8_exception_handled:; __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); __pyx_L12_try_end:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":652 * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * * if thread_info.inside_frame_eval: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ __pyx_t_3 = (__pyx_v_thread_info->inside_frame_eval != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":653 * * if thread_info.inside_frame_eval: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * * if not thread_info.fully_initialized: */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":652 * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * * if thread_info.inside_frame_eval: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":655 * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: */ __pyx_t_3 = ((!(__pyx_v_thread_info->fully_initialized != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":656 * * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() # <<<<<<<<<<<<<< * if not thread_info.fully_initialized: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_t_9 = ((struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v_thread_info->__pyx_vtab)->initialize_if_possible(__pyx_v_thread_info); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 656, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":657 * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ __pyx_t_3 = ((!(__pyx_v_thread_info->fully_initialized != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":658 * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * * # Can only get additional_info when fully initialized. */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":657 * if not thread_info.fully_initialized: * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":655 * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * * if not thread_info.fully_initialized: # <<<<<<<<<<<<<< * thread_info.initialize_if_possible() * if not thread_info.fully_initialized: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":661 * * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info # <<<<<<<<<<<<<< * if thread_info.is_pydevd_thread or additional_info.is_tracing: * # Make sure that we don't trace pydevd threads or inside our own calls. */ __pyx_t_9 = ((PyObject *)__pyx_v_thread_info->additional_info); __Pyx_INCREF(__pyx_t_9); __pyx_v_additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":662 * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info * if thread_info.is_pydevd_thread or additional_info.is_tracing: # <<<<<<<<<<<<<< * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_t_1 = (__pyx_v_thread_info->is_pydevd_thread != 0); if (!__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L20_bool_binop_done; } __pyx_t_1 = (__pyx_v_additional_info->is_tracing != 0); __pyx_t_3 = __pyx_t_1; __pyx_L20_bool_binop_done:; if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":664 * if thread_info.is_pydevd_thread or additional_info.is_tracing: * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * * # frame = <object> frame_obj */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":662 * # Can only get additional_info when fully initialized. * cdef PyDBAdditionalThreadInfo additional_info = thread_info.additional_info * if thread_info.is_pydevd_thread or additional_info.is_tracing: # <<<<<<<<<<<<<< * # Make sure that we don't trace pydevd threads or inside our own calls. * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":671 * # print('get_bytecode_while_frame_eval', frame.f_lineno, frame.f_code.co_name, frame.f_code.co_filename) * * thread_info.inside_frame_eval += 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = True * try: */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval + 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":672 * * thread_info.inside_frame_eval += 1 * additional_info.is_tracing = True # <<<<<<<<<<<<<< * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg */ __pyx_v_additional_info->is_tracing = 1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":673 * thread_info.inside_frame_eval += 1 * additional_info.is_tracing = True * try: # <<<<<<<<<<<<<< * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: */ /*try:*/ { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":674 * additional_info.is_tracing = True * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg # <<<<<<<<<<<<<< * if main_debugger is None: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 674, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_global_dbg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 674, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_main_debugger = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":675 * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * frame = <object> frame_obj */ __pyx_t_3 = (__pyx_v_main_debugger == Py_None); __pyx_t_1 = (__pyx_t_3 != 0); if (__pyx_t_1) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":676 * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * frame = <object> frame_obj * */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L22_return; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":675 * try: * main_debugger: object = GlobalDebuggerHolder.global_dbg * if main_debugger is None: # <<<<<<<<<<<<<< * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * frame = <object> frame_obj */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":677 * if main_debugger is None: * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) * frame = <object> frame_obj # <<<<<<<<<<<<<< * * if thread_info.thread_trace_func is None: */ __pyx_t_2 = ((PyObject *)__pyx_v_frame_obj); __Pyx_INCREF(__pyx_t_2); __pyx_v_frame = __pyx_t_2; __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":679 * frame = <object> frame_obj * * if thread_info.thread_trace_func is None: # <<<<<<<<<<<<<< * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: */ __pyx_t_1 = (__pyx_v_thread_info->thread_trace_func == Py_None); __pyx_t_3 = (__pyx_t_1 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":680 * * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) # <<<<<<<<<<<<<< * if apply_to_global: * thread_info.thread_trace_func = trace_func */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_fix_top_level_trace_and_get_trac); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_main_debugger, __pyx_v_frame}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_main_debugger, __pyx_v_frame}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { __pyx_t_10 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_v_main_debugger); __Pyx_GIVEREF(__pyx_v_main_debugger); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_11, __pyx_v_main_debugger); __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_11, __pyx_v_frame); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 680, __pyx_L23_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_9 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_9 = PyList_GET_ITEM(sequence, 0); __pyx_t_10 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_10); #else __pyx_t_9 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 680, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_12 = Py_TYPE(__pyx_t_8)->tp_iternext; index = 0; __pyx_t_9 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_9)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_9); index = 1; __pyx_t_10 = __pyx_t_12(__pyx_t_8); if (unlikely(!__pyx_t_10)) goto __pyx_L27_unpacking_failed; __Pyx_GOTREF(__pyx_t_10); if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_8), 2) < 0) __PYX_ERR(0, 680, __pyx_L23_error) __pyx_t_12 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L28_unpacking_done; __pyx_L27_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 680, __pyx_L23_error) __pyx_L28_unpacking_done:; } __pyx_v_trace_func = __pyx_t_9; __pyx_t_9 = 0; __pyx_v_apply_to_global = __pyx_t_10; __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":681 * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: # <<<<<<<<<<<<<< * thread_info.thread_trace_func = trace_func * */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_apply_to_global); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 681, __pyx_L23_error) if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":682 * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: * thread_info.thread_trace_func = trace_func # <<<<<<<<<<<<<< * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ */ __Pyx_INCREF(__pyx_v_trace_func); __Pyx_GIVEREF(__pyx_v_trace_func); __Pyx_GOTREF(__pyx_v_thread_info->thread_trace_func); __Pyx_DECREF(__pyx_v_thread_info->thread_trace_func); __pyx_v_thread_info->thread_trace_func = __pyx_v_trace_func; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":681 * if thread_info.thread_trace_func is None: * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: # <<<<<<<<<<<<<< * thread_info.thread_trace_func = trace_func * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":679 * frame = <object> frame_obj * * if thread_info.thread_trace_func is None: # <<<<<<<<<<<<<< * trace_func, apply_to_global = fix_top_level_trace_and_get_trace_func(main_debugger, frame) * if apply_to_global: */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":684 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ __pyx_t_11 = __pyx_v_additional_info->pydev_step_cmd; __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO_MY_CODE) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_STEP_INTO_COROUTINE) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L33_bool_binop_done; } __pyx_t_4 = ((__pyx_t_11 == __pyx_v_CMD_SMART_STEP_INTO) != 0); __pyx_t_1 = __pyx_t_4; __pyx_L33_bool_binop_done:; __pyx_t_4 = (__pyx_t_1 != 0); if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":685 * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ * main_debugger.break_on_caught_exceptions or \ # <<<<<<<<<<<<<< * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_caught_exceptions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 685, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":686 * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ # <<<<<<<<<<<<<< * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_user_uncaught_exception); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 686, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":687 * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ # <<<<<<<<<<<<<< * main_debugger.signature_factory or \ * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 687, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 687, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":688 * main_debugger.break_on_user_uncaught_exceptions or \ * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ # <<<<<<<<<<<<<< * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 688, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 688, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L31_bool_binop_done; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":689 * main_debugger.has_plugin_exception_breaks or \ * main_debugger.signature_factory or \ * additional_info.pydev_step_cmd in (CMD_STEP_OVER, CMD_STEP_OVER_MY_CODE) and main_debugger.show_return_values and frame.f_back is additional_info.pydev_step_stop: # <<<<<<<<<<<<<< * * # if DEBUG: */ __pyx_t_11 = __pyx_v_additional_info->pydev_step_cmd; __pyx_t_1 = ((__pyx_t_11 == __pyx_v_CMD_STEP_OVER) != 0); if (!__pyx_t_1) { } else { __pyx_t_4 = __pyx_t_1; goto __pyx_L42_bool_binop_done; } __pyx_t_1 = ((__pyx_t_11 == __pyx_v_CMD_STEP_OVER_MY_CODE) != 0); __pyx_t_4 = __pyx_t_1; __pyx_L42_bool_binop_done:; __pyx_t_1 = (__pyx_t_4 != 0); if (__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L31_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 689, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_1) { } else { __pyx_t_3 = __pyx_t_1; goto __pyx_L31_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = (__pyx_t_2 == __pyx_v_additional_info->pydev_step_stop); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_1 != 0); __pyx_t_3 = __pyx_t_4; __pyx_L31_bool_binop_done:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":684 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":693 * # if DEBUG: * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_3 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":694 * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_2 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_2); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_2) < 0) __PYX_ERR(0, 694, __pyx_L23_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":693 * # if DEBUG: * # print('get_bytecode_while_frame_eval enabled trace') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L45; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":696 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * else: * func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) */ /*else*/ { __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 696, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = __pyx_t_2; __Pyx_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 696, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L45:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":684 * thread_info.thread_trace_func = trace_func * * if additional_info.pydev_step_cmd in (CMD_STEP_INTO, CMD_STEP_INTO_MY_CODE, CMD_STEP_INTO_COROUTINE, CMD_SMART_STEP_INTO) or \ # <<<<<<<<<<<<<< * main_debugger.break_on_caught_exceptions or \ * main_debugger.break_on_user_uncaught_exceptions or \ */ goto __pyx_L30; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":698 * frame.f_trace = <object> main_debugger.trace_dispatch * else: * func_code_info: FuncCodeInfo = get_func_code_info(thread_info, frame_obj, frame_obj.f_code) # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) */ /*else*/ { __pyx_t_10 = ((PyObject *)__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_get_func_code_info(__pyx_v_thread_info, __pyx_v_frame_obj, __pyx_v_frame_obj->f_code)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 698, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_v_func_code_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":701 * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: */ __pyx_t_4 = ((!(__pyx_v_func_code_info->always_skip_code != 0)) != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":703 * if not func_code_info.always_skip_code: * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: # <<<<<<<<<<<<<< * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * */ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 703, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 703, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (!__pyx_t_3) { } else { __pyx_t_4 = __pyx_t_3; goto __pyx_L48_bool_binop_done; } __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 703, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 703, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_4 = __pyx_t_3; __pyx_L48_bool_binop_done:; if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":704 * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) # <<<<<<<<<<<<<< * * if not can_skip: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_plugin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_can_skip); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_main_debugger, ((PyObject *)__pyx_v_frame_obj)}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_10); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_main_debugger, ((PyObject *)__pyx_v_frame_obj)}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_10); } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(__pyx_v_main_debugger); __Pyx_GIVEREF(__pyx_v_main_debugger); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_11, __pyx_v_main_debugger); __Pyx_INCREF(((PyObject *)__pyx_v_frame_obj)); __Pyx_GIVEREF(((PyObject *)__pyx_v_frame_obj)); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_11, ((PyObject *)__pyx_v_frame_obj)); __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 704, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_v_can_skip = __pyx_t_4; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":706 * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * * if not can_skip: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') */ __pyx_t_4 = ((!(__pyx_v_can_skip != 0)) != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":709 * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_4 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":710 * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_10 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_10); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 710, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":709 * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L51; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":712 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * * if can_skip and func_code_info.breakpoint_found: */ /*else*/ { __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 712, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_9 = __pyx_t_10; __Pyx_INCREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_9) < 0) __PYX_ERR(0, 712, __pyx_L23_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L51:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":706 * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * * if not can_skip: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval not can_skip') */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":703 * if not func_code_info.always_skip_code: * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: # <<<<<<<<<<<<<< * can_skip = main_debugger.plugin.can_skip(main_debugger, <object> frame_obj) * */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":714 * frame.f_trace = <object> main_debugger.trace_dispatch * * if can_skip and func_code_info.breakpoint_found: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) */ __pyx_t_4 = (__pyx_v_can_skip != 0); if (__pyx_t_4) { } else { __pyx_t_3 = __pyx_t_4; goto __pyx_L53_bool_binop_done; } __pyx_t_4 = (__pyx_v_func_code_info->breakpoint_found != 0); __pyx_t_3 = __pyx_t_4; __pyx_L53_bool_binop_done:; if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":717 * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) * if not thread_info.force_stay_in_untraced_mode: # <<<<<<<<<<<<<< * # If breakpoints are found but new_code is None, * # this means we weren't able to actually add the code */ __pyx_t_3 = ((!(__pyx_v_thread_info->force_stay_in_untraced_mode != 0)) != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":721 * # this means we weren't able to actually add the code * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: # <<<<<<<<<<<<<< * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func */ __pyx_t_3 = (__pyx_v_func_code_info->new_code == Py_None); __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":722 * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ __pyx_t_4 = (__pyx_v_thread_info->thread_trace_func != Py_None); __pyx_t_3 = (__pyx_t_4 != 0); if (__pyx_t_3) { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":723 * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func # <<<<<<<<<<<<<< * else: * frame.f_trace = <object> main_debugger.trace_dispatch */ __pyx_t_9 = __pyx_v_thread_info->thread_trace_func; __Pyx_INCREF(__pyx_t_9); if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_9) < 0) __PYX_ERR(0, 723, __pyx_L23_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":722 * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: * if thread_info.thread_trace_func is not None: # <<<<<<<<<<<<<< * frame.f_trace = thread_info.thread_trace_func * else: */ goto __pyx_L57; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":725 * frame.f_trace = thread_info.thread_trace_func * else: * frame.f_trace = <object> main_debugger.trace_dispatch # <<<<<<<<<<<<<< * else: * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) */ /*else*/ { __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 725, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __pyx_t_9; __Pyx_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_10) < 0) __PYX_ERR(0, 725, __pyx_L23_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L57:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":721 * # this means we weren't able to actually add the code * # where needed, so, fallback to tracing. * if func_code_info.new_code is None: # <<<<<<<<<<<<<< * if thread_info.thread_trace_func is not None: * frame.f_trace = thread_info.thread_trace_func */ goto __pyx_L56; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":728 * else: * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) * update_globals_dict(<object> frame_obj.f_globals) # <<<<<<<<<<<<<< * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_update_globals_dict); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 728, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); } } __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, ((PyObject *)__pyx_v_frame_obj->f_globals)) : __Pyx_PyObject_CallOneArg(__pyx_t_9, ((PyObject *)__pyx_v_frame_obj->f_globals)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 728, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":729 * # print('Using frame eval break for', <object> frame_obj.f_code.co_name) * update_globals_dict(<object> frame_obj.f_globals) * Py_INCREF(func_code_info.new_code) # <<<<<<<<<<<<<< * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code */ __pyx_t_10 = __pyx_v_func_code_info->new_code; __Pyx_INCREF(__pyx_t_10); Py_INCREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":730 * update_globals_dict(<object> frame_obj.f_globals) * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code # <<<<<<<<<<<<<< * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code * Py_DECREF(old) */ __pyx_t_10 = ((PyObject *)__pyx_v_frame_obj->f_code); __Pyx_INCREF(__pyx_t_10); __pyx_v_old = __pyx_t_10; __pyx_t_10 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":731 * Py_INCREF(func_code_info.new_code) * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code # <<<<<<<<<<<<<< * Py_DECREF(old) * else: */ __pyx_v_frame_obj->f_code = ((PyCodeObject *)__pyx_v_func_code_info->new_code); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":732 * old = <object> frame_obj.f_code * frame_obj.f_code = <PyCodeObject *> func_code_info.new_code * Py_DECREF(old) # <<<<<<<<<<<<<< * else: * # When we're forcing to stay in traced mode we need to */ Py_DECREF(__pyx_v_old); } __pyx_L56:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":717 * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) * if not thread_info.force_stay_in_untraced_mode: # <<<<<<<<<<<<<< * # If breakpoints are found but new_code is None, * # this means we weren't able to actually add the code */ goto __pyx_L55; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":737 * # update the globals dict (because this means that we're reusing * # a previous code which had breakpoints added in a new frame). * update_globals_dict(<object> frame_obj.f_globals) # <<<<<<<<<<<<<< * * finally: */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_update_globals_dict); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 737, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_9, function); } } __pyx_t_10 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_8, ((PyObject *)__pyx_v_frame_obj->f_globals)) : __Pyx_PyObject_CallOneArg(__pyx_t_9, ((PyObject *)__pyx_v_frame_obj->f_globals)); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 737, __pyx_L23_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __pyx_L55:; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":714 * frame.f_trace = <object> main_debugger.trace_dispatch * * if can_skip and func_code_info.breakpoint_found: # <<<<<<<<<<<<<< * # if DEBUG: * # print('get_bytecode_while_frame_eval new_code', func_code_info.new_code) */ } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":701 * # if DEBUG: * # print('get_bytecode_while_frame_eval always skip', func_code_info.always_skip_code) * if not func_code_info.always_skip_code: # <<<<<<<<<<<<<< * * if main_debugger.has_plugin_line_breaks or main_debugger.has_plugin_exception_breaks: */ } } __pyx_L30:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":740 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ /*finally:*/ { /*normal exit:*/{ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":741 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; goto __pyx_L24; } __pyx_L23_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_6, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_11 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; { /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":740 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":741 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_6, __pyx_t_5); __pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; goto __pyx_L1_error; } __pyx_L22_return: { __pyx_t_18 = __pyx_r; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":740 * * finally: * thread_info.inside_frame_eval -= 1 # <<<<<<<<<<<<<< * additional_info.is_tracing = False * */ __pyx_v_thread_info->inside_frame_eval = (__pyx_v_thread_info->inside_frame_eval - 1); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":741 * finally: * thread_info.inside_frame_eval -= 1 * additional_info.is_tracing = False # <<<<<<<<<<<<<< * * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) */ __pyx_v_additional_info->is_tracing = 0; __pyx_r = __pyx_t_18; goto __pyx_L0; } __pyx_L24:; } /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":743 * additional_info.is_tracing = False * * return CALL_EvalFrameDefault_39(tstate, frame_obj, exc) # <<<<<<<<<<<<<< * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! */ __pyx_r = CALL_EvalFrameDefault_39(__pyx_v_tstate, __pyx_v_frame_obj, __pyx_v_exc); goto __pyx_L0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":623 * ### WARNING: GENERATED CODE, DO NOT EDIT! * ### WARNING: GENERATED CODE, DO NOT EDIT! * cdef PyObject * get_bytecode_while_frame_eval_39(PyThreadState* tstate, PyFrameObject * frame_obj, int exc): # <<<<<<<<<<<<<< * ''' * This function makes the actual evaluation and changes the bytecode to a version */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_WriteUnraisable("_pydevd_frame_eval.pydevd_frame_evaluator.get_bytecode_while_frame_eval_39", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_thread_info); __Pyx_XDECREF((PyObject *)__pyx_v_additional_info); __Pyx_XDECREF(__pyx_v_main_debugger); __Pyx_XDECREF(__pyx_v_frame); __Pyx_XDECREF(__pyx_v_trace_func); __Pyx_XDECREF(__pyx_v_apply_to_global); __Pyx_XDECREF((PyObject *)__pyx_v_func_code_info); __Pyx_XDECREF(__pyx_v_old); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_ThreadInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_21__pyx_unpickle_ThreadInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_21__pyx_unpickle_ThreadInfo = {"__pyx_unpickle_ThreadInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_21__pyx_unpickle_ThreadInfo, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_21__pyx_unpickle_ThreadInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_ThreadInfo (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ThreadInfo", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ThreadInfo", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_ThreadInfo") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ThreadInfo", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_ThreadInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_20__pyx_unpickle_ThreadInfo(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_20__pyx_unpickle_ThreadInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_ThreadInfo", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x0af4089, 0xe535b68, 0xb8148ba): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__6, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0x0af4089, 0xe535b68, 0xb8148ba): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) * __pyx_result = ThreadInfo.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0x0af4089, 0xe535b68, 0xb8148ba): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = ThreadInfo.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x0af4089, 0xe535b68, 0xb8148ba): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) * __pyx_result = ThreadInfo.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) * __pyx_result = ThreadInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = ThreadInfo.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_ThreadInfo__set_state(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) * __pyx_result = ThreadInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_ThreadInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_ThreadInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_ThreadInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_ThreadInfo__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] # <<<<<<<<<<<<<< * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[7]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->_can_create_dummy_thread = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->additional_info); __Pyx_DECREF(((PyObject *)__pyx_v___pyx_result->additional_info)); __pyx_v___pyx_result->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->force_stay_in_untraced_mode = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->fully_initialized = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->inside_frame_eval = __pyx_t_3; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->is_pydevd_thread = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->thread_trace_func); __Pyx_DECREF(__pyx_v___pyx_result->thread_trace_func); __pyx_v___pyx_result->thread_trace_func = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[7]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 7) != 0); if (__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[7]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[7]) */ } /* "(tree fragment)":11 * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_ThreadInfo__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_FuncCodeInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_23__pyx_unpickle_FuncCodeInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_23__pyx_unpickle_FuncCodeInfo = {"__pyx_unpickle_FuncCodeInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_23__pyx_unpickle_FuncCodeInfo, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_23__pyx_unpickle_FuncCodeInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_FuncCodeInfo (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_FuncCodeInfo", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_FuncCodeInfo", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_FuncCodeInfo") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_FuncCodeInfo", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_FuncCodeInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_22__pyx_unpickle_FuncCodeInfo(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_22__pyx_unpickle_FuncCodeInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_FuncCodeInfo", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb3ee05d, 0x450d2d6, 0x956dcaa): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__7, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0xb3ee05d, 0x450d2d6, 0x956dcaa): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) * __pyx_result = FuncCodeInfo.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0xb3ee05d, 0x450d2d6, 0x956dcaa): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = FuncCodeInfo.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0xb3ee05d, 0x450d2d6, 0x956dcaa): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) * __pyx_result = FuncCodeInfo.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) * __pyx_result = FuncCodeInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = FuncCodeInfo.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_FuncCodeInfo__set_state(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb3ee05d, 0x450d2d6, 0x956dcaa) = (always_skip_code, breakpoint_found, breakpoints_mtime, canonical_normalized_filename, co_filename, co_name, new_code))" % __pyx_checksum) * __pyx_result = FuncCodeInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_FuncCodeInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_FuncCodeInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle_FuncCodeInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_FuncCodeInfo__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] # <<<<<<<<<<<<<< * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[7]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->always_skip_code = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->breakpoint_found = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->breakpoints_mtime = __pyx_t_3; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->canonical_normalized_filename); __Pyx_DECREF(__pyx_v___pyx_result->canonical_normalized_filename); __pyx_v___pyx_result->canonical_normalized_filename = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->co_filename); __Pyx_DECREF(__pyx_v___pyx_result->co_filename); __pyx_v___pyx_result->co_filename = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyString_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->co_name); __Pyx_DECREF(__pyx_v___pyx_result->co_name); __pyx_v___pyx_result->co_name = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->new_code); __Pyx_DECREF(__pyx_v___pyx_result->new_code); __pyx_v___pyx_result->new_code = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[7]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 7) != 0); if (__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_2 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[7]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[7]) */ } /* "(tree fragment)":11 * __pyx_unpickle_FuncCodeInfo__set_state(<FuncCodeInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_FuncCodeInfo__set_state(FuncCodeInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.always_skip_code = __pyx_state[0]; __pyx_result.breakpoint_found = __pyx_state[1]; __pyx_result.breakpoints_mtime = __pyx_state[2]; __pyx_result.canonical_normalized_filename = __pyx_state[3]; __pyx_result.co_filename = __pyx_state[4]; __pyx_result.co_name = __pyx_state[5]; __pyx_result.new_code = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle_FuncCodeInfo__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle__CodeLineInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_25__pyx_unpickle__CodeLineInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_25__pyx_unpickle__CodeLineInfo = {"__pyx_unpickle__CodeLineInfo", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_25__pyx_unpickle__CodeLineInfo, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_25__pyx_unpickle__CodeLineInfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle__CodeLineInfo (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CodeLineInfo", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CodeLineInfo", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle__CodeLineInfo") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CodeLineInfo", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CodeLineInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_24__pyx_unpickle__CodeLineInfo(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_24__pyx_unpickle__CodeLineInfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__CodeLineInfo", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x3fbbd02, 0x5a9bcd5, 0x0267473): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__8, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0x3fbbd02, 0x5a9bcd5, 0x0267473): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) * __pyx_result = _CodeLineInfo.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0x3fbbd02, 0x5a9bcd5, 0x0267473): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = _CodeLineInfo.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x3fbbd02, 0x5a9bcd5, 0x0267473): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) * __pyx_result = _CodeLineInfo.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) * __pyx_result = _CodeLineInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = _CodeLineInfo.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CodeLineInfo__set_state(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3fbbd02, 0x5a9bcd5, 0x0267473) = (first_line, last_line, line_to_offset))" % __pyx_checksum) * __pyx_result = _CodeLineInfo.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle__CodeLineInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CodeLineInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CodeLineInfo__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__CodeLineInfo__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] # <<<<<<<<<<<<<< * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[3]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->first_line = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->last_line = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->line_to_offset); __Pyx_DECREF(__pyx_v___pyx_result->line_to_offset); __pyx_v___pyx_result->line_to_offset = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[3]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 3) != 0); if (__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_3 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "(tree fragment)":14 * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[3]) */ } /* "(tree fragment)":11 * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CodeLineInfo__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle__CacheValue(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_27__pyx_unpickle__CacheValue(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_27__pyx_unpickle__CacheValue = {"__pyx_unpickle__CacheValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_27__pyx_unpickle__CacheValue, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_27__pyx_unpickle__CacheValue(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle__CacheValue (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CacheValue", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CacheValue", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle__CacheValue") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__CacheValue", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CacheValue", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_26__pyx_unpickle__CacheValue(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_18_pydevd_frame_eval_22pydevd_frame_evaluator_26__pyx_unpickle__CacheValue(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__CacheValue", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x3d481b9, 0xac42a46, 0xedff7c3): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__9, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum not in (0x3d481b9, 0xac42a46, 0xedff7c3): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) * __pyx_result = _CacheValue.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, -1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * if __pyx_checksum not in (0x3d481b9, 0xac42a46, 0xedff7c3): * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = _CacheValue.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x3d481b9, 0xac42a46, 0xedff7c3): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) * __pyx_result = _CacheValue.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) * __pyx_result = _CacheValue.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_3 = (__pyx_v___pyx_state != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "(tree fragment)":9 * __pyx_result = _CacheValue.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) __pyx_t_4 = __pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CacheValue__set_state(((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x3d481b9, 0xac42a46, 0xedff7c3) = (breakpoints_hit_at_lines, code_line_info, code_lines_as_set, code_obj_py))" % __pyx_checksum) * __pyx_result = _CacheValue.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle__CacheValue(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CacheValue", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator___pyx_unpickle__CacheValue__set_state(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__CacheValue__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] # <<<<<<<<<<<<<< * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->breakpoints_hit_at_lines); __Pyx_DECREF(__pyx_v___pyx_result->breakpoints_hit_at_lines); __pyx_v___pyx_result->breakpoints_hit_at_lines = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo))))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->code_line_info); __Pyx_DECREF(((PyObject *)__pyx_v___pyx_result->code_line_info)); __pyx_v___pyx_result->code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "set", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->code_lines_as_set); __Pyx_DECREF(__pyx_v___pyx_result->code_lines_as_set); __pyx_v___pyx_result->code_lines_as_set = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->code_obj_py); __Pyx_DECREF(__pyx_v___pyx_result->code_obj_py); __pyx_v___pyx_result->code_obj_py = __pyx_t_1; __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_4 = ((__pyx_t_3 > 4) != 0); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); __pyx_t_2 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { /* "(tree fragment)":14 * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) # <<<<<<<<<<<<<< */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ } /* "(tree fragment)":11 * __pyx_unpickle__CacheValue__set_state(<_CacheValue> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__CacheValue__set_state(_CacheValue __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.breakpoints_hit_at_lines = __pyx_state[0]; __pyx_result.code_line_info = __pyx_state[1]; __pyx_result.code_lines_as_set = __pyx_state[2]; __pyx_result.code_obj_py = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_pydevd_frame_eval.pydevd_frame_evaluator.__pyx_unpickle__CacheValue__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo __pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)o); p->__pyx_vtab = __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; p->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)Py_None); Py_INCREF(Py_None); p->thread_trace_func = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo(PyObject *o) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->additional_info); Py_CLEAR(p->thread_trace_func); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)o; if (p->additional_info) { e = (*v)(((PyObject *)p->additional_info), a); if (e) return e; } if (p->thread_trace_func) { e = (*v)(p->thread_trace_func, a); if (e) return e; } return 0; } static int __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo(PyObject *o) { PyObject* tmp; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *)o; tmp = ((PyObject*)p->additional_info); p->additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->thread_trace_func); p->thread_trace_func = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_additional_info(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_additional_info(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_15additional_info_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_is_pydevd_thread(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_is_pydevd_thread(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_16is_pydevd_thread_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_inside_frame_eval(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_inside_frame_eval(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17inside_frame_eval_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_fully_initialized(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_fully_initialized(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17fully_initialized_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_thread_trace_func(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_thread_trace_func(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_17thread_trace_func_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_force_stay_in_untraced_mode(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_force_stay_in_untraced_mode(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_27force_stay_in_untraced_mode_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_1__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_3__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo[] = { {(char *)"additional_info", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_additional_info, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_additional_info, (char *)0, 0}, {(char *)"is_pydevd_thread", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_is_pydevd_thread, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_is_pydevd_thread, (char *)0, 0}, {(char *)"inside_frame_eval", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_inside_frame_eval, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_inside_frame_eval, (char *)0, 0}, {(char *)"fully_initialized", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_fully_initialized, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_fully_initialized, (char *)0, 0}, {(char *)"thread_trace_func", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_thread_trace_func, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_thread_trace_func, (char *)0, 0}, {(char *)"force_stay_in_untraced_mode", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_force_stay_in_untraced_mode, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_force_stay_in_untraced_mode, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo = { PyVarObject_HEAD_INIT(0, 0) "_pydevd_frame_eval.pydevd_frame_evaluator.ThreadInfo", /*tp_name*/ sizeof(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_traverse*/ __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)o); p->co_filename = ((PyObject*)Py_None); Py_INCREF(Py_None); p->co_name = ((PyObject*)Py_None); Py_INCREF(Py_None); p->canonical_normalized_filename = ((PyObject*)Py_None); Py_INCREF(Py_None); p->new_code = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo(PyObject *o) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->co_filename); Py_CLEAR(p->co_name); Py_CLEAR(p->canonical_normalized_filename); Py_CLEAR(p->new_code); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)o; if (p->new_code) { e = (*v)(p->new_code, a); if (e) return e; } return 0; } static int __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo(PyObject *o) { PyObject* tmp; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo *)o; tmp = ((PyObject*)p->new_code); p->new_code = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_filename(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_filename(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_11co_filename_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_name(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_7co_name_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_canonical_normalized_filename(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_canonical_normalized_filename(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_29canonical_normalized_filename_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoint_found(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoint_found(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_16breakpoint_found_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_new_code(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_new_code(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_8new_code_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoints_mtime(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoints_mtime(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_17breakpoints_mtime_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_3__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_5__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo[] = { {(char *)"co_filename", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_filename, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_filename, (char *)0, 0}, {(char *)"co_name", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_name, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_co_name, (char *)0, 0}, {(char *)"canonical_normalized_filename", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_canonical_normalized_filename, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_canonical_normalized_filename, (char *)0, 0}, {(char *)"breakpoint_found", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoint_found, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoint_found, (char *)0, 0}, {(char *)"new_code", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_new_code, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_new_code, (char *)0, 0}, {(char *)"breakpoints_mtime", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoints_mtime, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_breakpoints_mtime, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo = { PyVarObject_HEAD_INIT(0, 0) "_pydevd_frame_eval.pydevd_frame_evaluator.FuncCodeInfo", /*tp_name*/ sizeof(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_traverse*/ __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_12FuncCodeInfo_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)o); p->line_to_offset = ((PyObject*)Py_None); Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo(PyObject *o) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->line_to_offset); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)o; if (p->line_to_offset) { e = (*v)(p->line_to_offset, a); if (e) return e; } return 0; } static int __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo(PyObject *o) { PyObject* tmp; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)o; tmp = ((PyObject*)p->line_to_offset); p->line_to_offset = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_line_to_offset(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_line_to_offset(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_14line_to_offset_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_first_line(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_first_line(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_10first_line_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_last_line(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_last_line(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_9last_line_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_3__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_5__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo[] = { {(char *)"line_to_offset", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_line_to_offset, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_line_to_offset, (char *)0, 0}, {(char *)"first_line", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_first_line, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_first_line, (char *)0, 0}, {(char *)"last_line", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_last_line, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_last_line, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo = { PyVarObject_HEAD_INIT(0, 0) "_pydevd_frame_eval.pydevd_frame_evaluator._CodeLineInfo", /*tp_name*/ sizeof(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_traverse*/ __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_13_CodeLineInfo_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static struct __pyx_vtabstruct_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue __pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; static PyObject *__pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)o); p->__pyx_vtab = __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; p->code_obj_py = Py_None; Py_INCREF(Py_None); p->code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)Py_None); Py_INCREF(Py_None); p->breakpoints_hit_at_lines = ((PyObject*)Py_None); Py_INCREF(Py_None); p->code_lines_as_set = ((PyObject*)Py_None); Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue(PyObject *o) { struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->code_obj_py); Py_CLEAR(p->code_line_info); Py_CLEAR(p->breakpoints_hit_at_lines); Py_CLEAR(p->code_lines_as_set); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)o; if (p->code_obj_py) { e = (*v)(p->code_obj_py, a); if (e) return e; } if (p->code_line_info) { e = (*v)(((PyObject *)p->code_line_info), a); if (e) return e; } if (p->breakpoints_hit_at_lines) { e = (*v)(p->breakpoints_hit_at_lines, a); if (e) return e; } if (p->code_lines_as_set) { e = (*v)(p->code_lines_as_set, a); if (e) return e; } return 0; } static int __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue(PyObject *o) { PyObject* tmp; struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *p = (struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *)o; tmp = ((PyObject*)p->code_obj_py); p->code_obj_py = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->code_line_info); p->code_line_info = ((struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->breakpoints_hit_at_lines); p->breakpoints_hit_at_lines = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->code_lines_as_set); p->code_lines_as_set = ((PyObject*)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_obj_py(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_obj_py(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_11code_obj_py_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_line_info(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_line_info(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_14code_line_info_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_breakpoints_hit_at_lines(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_breakpoints_hit_at_lines(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_24breakpoints_hit_at_lines_5__del__(o); } } static PyObject *__pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_lines_as_set(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_1__get__(o); } static int __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_lines_as_set(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_3__set__(o, v); } else { return __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_17code_lines_as_set_5__del__(o); } } static PyMethodDef __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue[] = { {"compute_force_stay_in_untraced_mode", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_3compute_force_stay_in_untraced_mode, METH_O, __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_2compute_force_stay_in_untraced_mode}, {"__reduce_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_5__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_7__setstate_cython__, METH_O, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue[] = { {(char *)"code_obj_py", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_obj_py, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_obj_py, (char *)0, 0}, {(char *)"code_line_info", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_line_info, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_line_info, (char *)0, 0}, {(char *)"breakpoints_hit_at_lines", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_breakpoints_hit_at_lines, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_breakpoints_hit_at_lines, (char *)0, 0}, {(char *)"code_lines_as_set", __pyx_getprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_lines_as_set, __pyx_setprop_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_code_lines_as_set, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue = { PyVarObject_HEAD_INIT(0, 0) "_pydevd_frame_eval.pydevd_frame_evaluator._CacheValue", /*tp_name*/ sizeof(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_traverse*/ __pyx_tp_clear_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 0, /*tp_pypy_flags*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_pydevd_frame_evaluator(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_pydevd_frame_evaluator}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "pydevd_frame_evaluator", 0, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0}, {&__pyx_n_s_AttributeError, __pyx_k_AttributeError, sizeof(__pyx_k_AttributeError), 0, 0, 1, 1}, {&__pyx_n_s_CacheValue, __pyx_k_CacheValue, sizeof(__pyx_k_CacheValue), 0, 0, 1, 1}, {&__pyx_n_s_CodeLineInfo, __pyx_k_CodeLineInfo, sizeof(__pyx_k_CodeLineInfo), 0, 0, 1, 1}, {&__pyx_n_s_DebugHelper, __pyx_k_DebugHelper, sizeof(__pyx_k_DebugHelper), 0, 0, 1, 1}, {&__pyx_n_s_FuncCodeInfo, __pyx_k_FuncCodeInfo, sizeof(__pyx_k_FuncCodeInfo), 0, 0, 1, 1}, {&__pyx_n_s_GlobalDebuggerHolder, __pyx_k_GlobalDebuggerHolder, sizeof(__pyx_k_GlobalDebuggerHolder), 0, 0, 1, 1}, {&__pyx_kp_s_If_a_code_object_is_cached_that, __pyx_k_If_a_code_object_is_cached_that, sizeof(__pyx_k_If_a_code_object_is_cached_that), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_k_Incompatible_checksums_0x_x_vs_0_2, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_2), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_k_Incompatible_checksums_0x_x_vs_0_3, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_3), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_k_Incompatible_checksums_0x_x_vs_0_4, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_4), 0, 0, 1, 0}, {&__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER, __pyx_k_NORM_PATHS_AND_BASE_CONTAINER, sizeof(__pyx_k_NORM_PATHS_AND_BASE_CONTAINER), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_SetTrace, __pyx_k_SetTrace, sizeof(__pyx_k_SetTrace), 0, 0, 1, 1}, {&__pyx_n_s_ThreadInfo, __pyx_k_ThreadInfo, sizeof(__pyx_k_ThreadInfo), 0, 0, 1, 1}, {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0}, {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0}, {&__pyx_kp_s__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 0, 1, 0}, {&__pyx_n_s_active, __pyx_k_active, sizeof(__pyx_k_active), 0, 0, 1, 1}, {&__pyx_n_s_additional_info, __pyx_k_additional_info, sizeof(__pyx_k_additional_info), 0, 0, 1, 1}, {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, {&__pyx_n_s_bootstrap, __pyx_k_bootstrap, sizeof(__pyx_k_bootstrap), 0, 0, 1, 1}, {&__pyx_n_s_bootstrap_2, __pyx_k_bootstrap_2, sizeof(__pyx_k_bootstrap_2), 0, 0, 1, 1}, {&__pyx_n_s_bootstrap_inner, __pyx_k_bootstrap_inner, sizeof(__pyx_k_bootstrap_inner), 0, 0, 1, 1}, {&__pyx_n_s_bootstrap_inner_2, __pyx_k_bootstrap_inner_2, sizeof(__pyx_k_bootstrap_inner_2), 0, 0, 1, 1}, {&__pyx_n_s_break_on_caught_exceptions, __pyx_k_break_on_caught_exceptions, sizeof(__pyx_k_break_on_caught_exceptions), 0, 0, 1, 1}, {&__pyx_n_s_break_on_user_uncaught_exception, __pyx_k_break_on_user_uncaught_exception, sizeof(__pyx_k_break_on_user_uncaught_exception), 0, 0, 1, 1}, {&__pyx_n_s_breakpoints, __pyx_k_breakpoints, sizeof(__pyx_k_breakpoints), 0, 0, 1, 1}, {&__pyx_n_s_breakpoints_hit_at_lines, __pyx_k_breakpoints_hit_at_lines, sizeof(__pyx_k_breakpoints_hit_at_lines), 0, 0, 1, 1}, {&__pyx_n_s_cache, __pyx_k_cache, sizeof(__pyx_k_cache), 0, 0, 1, 1}, {&__pyx_n_s_call, __pyx_k_call, sizeof(__pyx_k_call), 0, 0, 1, 1}, {&__pyx_n_s_call_2, __pyx_k_call_2, sizeof(__pyx_k_call_2), 0, 0, 1, 1}, {&__pyx_n_s_can_skip, __pyx_k_can_skip, sizeof(__pyx_k_can_skip), 0, 0, 1, 1}, {&__pyx_n_s_clear_thread_local_info, __pyx_k_clear_thread_local_info, sizeof(__pyx_k_clear_thread_local_info), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_code_line_info, __pyx_k_code_line_info, sizeof(__pyx_k_code_line_info), 0, 0, 1, 1}, {&__pyx_n_s_code_obj, __pyx_k_code_obj, sizeof(__pyx_k_code_obj), 0, 0, 1, 1}, {&__pyx_n_s_code_obj_py, __pyx_k_code_obj_py, sizeof(__pyx_k_code_obj_py), 0, 0, 1, 1}, {&__pyx_n_s_compute_force_stay_in_untraced_m, __pyx_k_compute_force_stay_in_untraced_m, sizeof(__pyx_k_compute_force_stay_in_untraced_m), 0, 0, 1, 1}, {&__pyx_n_s_current_thread, __pyx_k_current_thread, sizeof(__pyx_k_current_thread), 0, 0, 1, 1}, {&__pyx_n_s_decref_py, __pyx_k_decref_py, sizeof(__pyx_k_decref_py), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_dis, __pyx_k_dis, sizeof(__pyx_k_dis), 0, 0, 1, 1}, {&__pyx_n_s_dummy_trace_dispatch, __pyx_k_dummy_trace_dispatch, sizeof(__pyx_k_dummy_trace_dispatch), 0, 0, 1, 1}, {&__pyx_n_s_dummy_tracing_holder, __pyx_k_dummy_tracing_holder, sizeof(__pyx_k_dummy_tracing_holder), 0, 0, 1, 1}, {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, {&__pyx_n_s_event, __pyx_k_event, sizeof(__pyx_k_event), 0, 0, 1, 1}, {&__pyx_n_s_exec, __pyx_k_exec, sizeof(__pyx_k_exec), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_f_back, __pyx_k_f_back, sizeof(__pyx_k_f_back), 0, 0, 1, 1}, {&__pyx_n_s_f_trace, __pyx_k_f_trace, sizeof(__pyx_k_f_trace), 0, 0, 1, 1}, {&__pyx_n_s_findlinestarts, __pyx_k_findlinestarts, sizeof(__pyx_k_findlinestarts), 0, 0, 1, 1}, {&__pyx_n_s_first_line, __pyx_k_first_line, sizeof(__pyx_k_first_line), 0, 0, 1, 1}, {&__pyx_n_s_fix_top_level_trace_and_get_trac, __pyx_k_fix_top_level_trace_and_get_trac, sizeof(__pyx_k_fix_top_level_trace_and_get_trac), 0, 0, 1, 1}, {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, {&__pyx_n_s_frame_eval_func, __pyx_k_frame_eval_func, sizeof(__pyx_k_frame_eval_func), 0, 0, 1, 1}, {&__pyx_n_s_function_breakpoint_name_to_brea, __pyx_k_function_breakpoint_name_to_brea, sizeof(__pyx_k_function_breakpoint_name_to_brea), 0, 0, 1, 1}, {&__pyx_n_s_generate_code_with_breakpoints_p, __pyx_k_generate_code_with_breakpoints_p, sizeof(__pyx_k_generate_code_with_breakpoints_p), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_get_abs_path_real_path_and_base, __pyx_k_get_abs_path_real_path_and_base, sizeof(__pyx_k_get_abs_path_real_path_and_base), 0, 0, 1, 1}, {&__pyx_n_s_get_cache_file_type, __pyx_k_get_cache_file_type, sizeof(__pyx_k_get_cache_file_type), 0, 0, 1, 1}, {&__pyx_n_s_get_cached_code_obj_info_py, __pyx_k_get_cached_code_obj_info_py, sizeof(__pyx_k_get_cached_code_obj_info_py), 0, 0, 1, 1}, {&__pyx_n_s_get_code_line_info, __pyx_k_get_code_line_info, sizeof(__pyx_k_get_code_line_info), 0, 0, 1, 1}, {&__pyx_n_s_get_file_type, __pyx_k_get_file_type, sizeof(__pyx_k_get_file_type), 0, 0, 1, 1}, {&__pyx_n_s_get_func_code_info_py, __pyx_k_get_func_code_info_py, sizeof(__pyx_k_get_func_code_info_py), 0, 0, 1, 1}, {&__pyx_n_s_get_ident, __pyx_k_get_ident, sizeof(__pyx_k_get_ident), 0, 0, 1, 1}, {&__pyx_n_s_get_ident_2, __pyx_k_get_ident_2, sizeof(__pyx_k_get_ident_2), 0, 0, 1, 1}, {&__pyx_n_s_get_thread_info_py, __pyx_k_get_thread_info_py, sizeof(__pyx_k_get_thread_info_py), 0, 0, 1, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_global_dbg, __pyx_k_global_dbg, sizeof(__pyx_k_global_dbg), 0, 0, 1, 1}, {&__pyx_n_s_has_plugin_exception_breaks, __pyx_k_has_plugin_exception_breaks, sizeof(__pyx_k_has_plugin_exception_breaks), 0, 0, 1, 1}, {&__pyx_n_s_has_plugin_line_breaks, __pyx_k_has_plugin_line_breaks, sizeof(__pyx_k_has_plugin_line_breaks), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_insert_pydevd_breaks, __pyx_k_insert_pydevd_breaks, sizeof(__pyx_k_insert_pydevd_breaks), 0, 0, 1, 1}, {&__pyx_n_s_intersection, __pyx_k_intersection, sizeof(__pyx_k_intersection), 0, 0, 1, 1}, {&__pyx_n_s_is_pydev_daemon_thread, __pyx_k_is_pydev_daemon_thread, sizeof(__pyx_k_is_pydev_daemon_thread), 0, 0, 1, 1}, {&__pyx_n_s_issuperset, __pyx_k_issuperset, sizeof(__pyx_k_issuperset), 0, 0, 1, 1}, {&__pyx_n_s_last_line, __pyx_k_last_line, sizeof(__pyx_k_last_line), 0, 0, 1, 1}, {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1}, {&__pyx_n_s_line_to_offset, __pyx_k_line_to_offset, sizeof(__pyx_k_line_to_offset), 0, 0, 1, 1}, {&__pyx_n_s_local, __pyx_k_local, sizeof(__pyx_k_local), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_main_2, __pyx_k_main_2, sizeof(__pyx_k_main_2), 0, 0, 1, 1}, {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, {&__pyx_n_s_mtime, __pyx_k_mtime, sizeof(__pyx_k_mtime), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_offset, __pyx_k_offset, sizeof(__pyx_k_offset), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_plugin, __pyx_k_plugin, sizeof(__pyx_k_plugin), 0, 0, 1, 1}, {&__pyx_n_s_pydev_bundle__pydev_saved_modul, __pyx_k_pydev_bundle__pydev_saved_modul, sizeof(__pyx_k_pydev_bundle__pydev_saved_modul), 0, 0, 1, 1}, {&__pyx_n_s_pydev_monkey, __pyx_k_pydev_monkey, sizeof(__pyx_k_pydev_monkey), 0, 0, 1, 1}, {&__pyx_n_s_pydevd, __pyx_k_pydevd, sizeof(__pyx_k_pydevd), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_bundle_pydevd_additional, __pyx_k_pydevd_bundle_pydevd_additional, sizeof(__pyx_k_pydevd_bundle_pydevd_additional), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_bundle_pydevd_constants, __pyx_k_pydevd_bundle_pydevd_constants, sizeof(__pyx_k_pydevd_bundle_pydevd_constants), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_bundle_pydevd_trace_disp, __pyx_k_pydevd_bundle_pydevd_trace_disp, sizeof(__pyx_k_pydevd_bundle_pydevd_trace_disp), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_file_utils, __pyx_k_pydevd_file_utils, sizeof(__pyx_k_pydevd_file_utils), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_frame_eval_pydevd_frame, __pyx_k_pydevd_frame_eval_pydevd_frame, sizeof(__pyx_k_pydevd_frame_eval_pydevd_frame), 0, 0, 1, 1}, {&__pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_k_pydevd_frame_eval_pydevd_frame_2, sizeof(__pyx_k_pydevd_frame_eval_pydevd_frame_2), 0, 0, 1, 0}, {&__pyx_n_s_pydevd_frame_eval_pydevd_frame_3, __pyx_k_pydevd_frame_eval_pydevd_frame_3, sizeof(__pyx_k_pydevd_frame_eval_pydevd_frame_3), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_frame_eval_pydevd_modify, __pyx_k_pydevd_frame_eval_pydevd_modify, sizeof(__pyx_k_pydevd_frame_eval_pydevd_modify), 0, 0, 1, 1}, {&__pyx_n_s_pydevd_tracing, __pyx_k_pydevd_tracing, sizeof(__pyx_k_pydevd_tracing), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_FuncCodeInfo, __pyx_k_pyx_unpickle_FuncCodeInfo, sizeof(__pyx_k_pyx_unpickle_FuncCodeInfo), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_ThreadInfo, __pyx_k_pyx_unpickle_ThreadInfo, sizeof(__pyx_k_pyx_unpickle_ThreadInfo), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle__CacheValue, __pyx_k_pyx_unpickle__CacheValue, sizeof(__pyx_k_pyx_unpickle__CacheValue), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle__CodeLineInfo, __pyx_k_pyx_unpickle__CodeLineInfo, sizeof(__pyx_k_pyx_unpickle__CodeLineInfo), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_rfind, __pyx_k_rfind, sizeof(__pyx_k_rfind), 0, 0, 1, 1}, {&__pyx_n_s_run, __pyx_k_run, sizeof(__pyx_k_run), 0, 0, 1, 1}, {&__pyx_n_s_set_additional_thread_info_lock, __pyx_k_set_additional_thread_info_lock, sizeof(__pyx_k_set_additional_thread_info_lock), 0, 0, 1, 1}, {&__pyx_n_s_set_trace_func, __pyx_k_set_trace_func, sizeof(__pyx_k_set_trace_func), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_show_return_values, __pyx_k_show_return_values, sizeof(__pyx_k_show_return_values), 0, 0, 1, 1}, {&__pyx_n_s_signature_factory, __pyx_k_signature_factory, sizeof(__pyx_k_signature_factory), 0, 0, 1, 1}, {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, {&__pyx_n_s_stop_frame_eval, __pyx_k_stop_frame_eval, sizeof(__pyx_k_stop_frame_eval), 0, 0, 1, 1}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_thread, __pyx_k_thread, sizeof(__pyx_k_thread), 0, 0, 1, 1}, {&__pyx_n_s_thread_active, __pyx_k_thread_active, sizeof(__pyx_k_thread_active), 0, 0, 1, 1}, {&__pyx_n_s_thread_info, __pyx_k_thread_info, sizeof(__pyx_k_thread_info), 0, 0, 1, 1}, {&__pyx_n_s_thread_local_info, __pyx_k_thread_local_info, sizeof(__pyx_k_thread_local_info), 0, 0, 1, 1}, {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, {&__pyx_n_s_trace_dispatch, __pyx_k_trace_dispatch, sizeof(__pyx_k_trace_dispatch), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_n_s_update_globals_dict, __pyx_k_update_globals_dict, sizeof(__pyx_k_update_globals_dict), 0, 0, 1, 1}, {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 110, __pyx_L1_error) __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_n_s_min); if (!__pyx_builtin_min) __PYX_ERR(0, 341, __pyx_L1_error) __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_n_s_max); if (!__pyx_builtin_max) __PYX_ERR(0, 342, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":112 * raise AttributeError() * except: * with _set_additional_thread_info_lock: # <<<<<<<<<<<<<< * # If it's not there, set it within a lock to avoid any racing * # conditions. */ __pyx_tuple__4 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum not in (0x0af4089, 0xe535b68, 0xb8148ba): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0x0af4089, 0xe535b68, 0xb8148ba) = (_can_create_dummy_thread, additional_info, force_stay_in_untraced_mode, fully_initialized, inside_frame_eval, is_pydevd_thread, thread_trace_func))" % __pyx_checksum) */ __pyx_tuple__6 = PyTuple_Pack(3, __pyx_int_11485321, __pyx_int_240343912, __pyx_int_193022138); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); __pyx_tuple__7 = PyTuple_Pack(3, __pyx_int_188670045, __pyx_int_72405718, __pyx_int_156687530); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_66829570, __pyx_int_95010005, __pyx_int_2520179); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); __pyx_tuple__9 = PyTuple_Pack(3, __pyx_int_64258489, __pyx_int_180628038, __pyx_int_249558979); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":19 * _thread_active = threading._active * * def clear_thread_local_info(): # <<<<<<<<<<<<<< * global _thread_local_info * _thread_local_info = threading.local() */ __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_clear_thread_local_info, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 19, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":152 * * * def dummy_trace_dispatch(frame, str event, arg): # <<<<<<<<<<<<<< * if event == 'call': * if frame.f_trace is not None: */ __pyx_tuple__11 = PyTuple_Pack(3, __pyx_n_s_frame, __pyx_n_s_event, __pyx_n_s_arg); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_dummy_trace_dispatch, 152, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 152, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":159 * * * def get_thread_info_py() -> ThreadInfo: # <<<<<<<<<<<<<< * return get_thread_info(PyEval_GetFrame()) * */ __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_get_thread_info_py, 159, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 159, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":196 * * * def decref_py(obj): # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ __pyx_tuple__14 = PyTuple_Pack(1, __pyx_n_s_obj); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_decref_py, 196, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 196, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":203 * * * def get_func_code_info_py(thread_info, frame, code_obj) -> FuncCodeInfo: # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_s_thread_info, __pyx_n_s_frame, __pyx_n_s_code_obj); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_get_func_code_info_py, 203, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 203, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":329 * * # Note: this method has a version in pure-python too. * def _get_code_line_info(code_obj): # <<<<<<<<<<<<<< * line_to_offset: dict = {} * first_line: int = None */ __pyx_tuple__18 = PyTuple_Pack(6, __pyx_n_s_code_obj, __pyx_n_s_line_to_offset, __pyx_n_s_first_line, __pyx_n_s_last_line, __pyx_n_s_offset, __pyx_n_s_line); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_get_code_line_info, 329, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 329, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":353 * _cache: dict = {} * * def get_cached_code_obj_info_py(code_obj_py): # <<<<<<<<<<<<<< * ''' * :return _CacheValue: */ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_code_obj_py); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_get_cached_code_obj_info_py, 353, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 353, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":401 * return breakpoint_found, force_stay_in_untraced_mode * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * return generate_code_with_breakpoints(code_obj_py, breakpoints) * */ __pyx_tuple__22 = PyTuple_Pack(2, __pyx_n_s_code_obj_py, __pyx_n_s_breakpoints); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_generate_code_with_breakpoints_p, 401, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 401, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":473 * import sys * * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) # <<<<<<<<<<<<<< * * def frame_eval_func(): */ __pyx_slice__24 = PySlice_New(Py_None, __pyx_int_2, Py_None); if (unlikely(!__pyx_slice__24)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__24); __Pyx_GIVEREF(__pyx_slice__24); __pyx_tuple__25 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_9); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":475 * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) * * def frame_eval_func(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: */ __pyx_tuple__26 = PyTuple_Pack(1, __pyx_n_s_state); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_frame_eval_func, 475, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 475, __pyx_L1_error) /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":484 * * * def stop_frame_eval(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * state.interp.eval_frame = _PyEval_EvalFrameDefault */ __pyx_tuple__28 = PyTuple_Pack(1, __pyx_n_s_state); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pydevd_frame_eval_pydevd_frame_2, __pyx_n_s_stop_frame_eval, 484, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 484, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_ThreadInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__30 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_ThreadInfo, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_tuple__32 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_FuncCodeInfo, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_tuple__34 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle__CodeLineInfo, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(1, 1, __pyx_L1_error) __pyx_tuple__36 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle__CacheValue, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2520179 = PyInt_FromLong(2520179L); if (unlikely(!__pyx_int_2520179)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_11485321 = PyInt_FromLong(11485321L); if (unlikely(!__pyx_int_11485321)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_64258489 = PyInt_FromLong(64258489L); if (unlikely(!__pyx_int_64258489)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_66829570 = PyInt_FromLong(66829570L); if (unlikely(!__pyx_int_66829570)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_72405718 = PyInt_FromLong(72405718L); if (unlikely(!__pyx_int_72405718)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_95010005 = PyInt_FromLong(95010005L); if (unlikely(!__pyx_int_95010005)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_156687530 = PyInt_FromLong(156687530L); if (unlikely(!__pyx_int_156687530)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_180628038 = PyInt_FromLong(180628038L); if (unlikely(!__pyx_int_180628038)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_188670045 = PyInt_FromLong(188670045L); if (unlikely(!__pyx_int_188670045)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_193022138 = PyInt_FromLong(193022138L); if (unlikely(!__pyx_int_193022138)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_240343912 = PyInt_FromLong(240343912L); if (unlikely(!__pyx_int_240343912)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_249558979 = PyInt_FromLong(249558979L); if (unlikely(!__pyx_int_249558979)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo = &__pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; __pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.initialize = (PyObject *(*)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *, PyFrameObject *))__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize; __pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.initialize_if_possible = (PyObject *(*)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo *))__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_10ThreadInfo_initialize_if_possible; if (PyType_Ready(&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.tp_dictoffset && __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo.tp_dict, __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ThreadInfo, (PyObject *)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo) < 0) __PYX_ERR(0, 24, __pyx_L1_error) __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo = &__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_ThreadInfo; if (PyType_Ready(&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo) < 0) __PYX_ERR(0, 125, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo.tp_dictoffset && __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FuncCodeInfo, (PyObject *)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo) < 0) __PYX_ERR(0, 125, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo) < 0) __PYX_ERR(0, 125, __pyx_L1_error) __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo = &__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator_FuncCodeInfo; if (PyType_Ready(&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo) < 0) __PYX_ERR(0, 316, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo.tp_dictoffset && __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_CodeLineInfo, (PyObject *)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo) < 0) __PYX_ERR(0, 316, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo) < 0) __PYX_ERR(0, 316, __pyx_L1_error) __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo = &__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CodeLineInfo; __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue = &__pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; __pyx_vtable_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.compute_force_stay_in_untraced_mode = (PyObject *(*)(struct __pyx_obj_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue *, PyObject *, int __pyx_skip_dispatch))__pyx_f_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue_compute_force_stay_in_untraced_mode; if (PyType_Ready(&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue) < 0) __PYX_ERR(0, 361, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.tp_dictoffset && __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.tp_getattro = __Pyx_PyObject_GenericGetAttr; } #if CYTHON_UPDATE_DESCRIPTOR_DOC { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 361, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__.doc = __pyx_doc_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_CacheValue___init__; } } #endif if (__Pyx_SetVtable(__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue.tp_dict, __pyx_vtabptr_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue) < 0) __PYX_ERR(0, 361, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_CacheValue, (PyObject *)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue) < 0) __PYX_ERR(0, 361, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue) < 0) __PYX_ERR(0, 361, __pyx_L1_error) __pyx_ptype_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue = &__pyx_type_18_pydevd_frame_eval_22pydevd_frame_evaluator__CacheValue; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule("_pydevd_bundle.pydevd_cython"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo = __Pyx_ImportType(__pyx_t_1, "_pydevd_bundle.pydevd_cython", "PyDBAdditionalThreadInfo", sizeof(struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo), __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initpydevd_frame_evaluator(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initpydevd_frame_evaluator(void) #else __Pyx_PyMODINIT_FUNC PyInit_pydevd_frame_evaluator(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_pydevd_frame_evaluator(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_pydevd_frame_evaluator(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'pydevd_frame_evaluator' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_pydevd_frame_evaluator(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("pydevd_frame_evaluator", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif if (__pyx_module_is_main__pydevd_frame_eval__pydevd_frame_evaluator) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "_pydevd_frame_eval.pydevd_frame_evaluator")) { if (unlikely(PyDict_SetItemString(modules, "_pydevd_frame_eval.pydevd_frame_evaluator", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":2 * from __future__ import print_function * from _pydev_bundle._pydev_saved_modules import threading, thread # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder * import dis */ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_threading); __Pyx_GIVEREF(__pyx_n_s_threading); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_threading); __Pyx_INCREF(__pyx_n_s_thread); __Pyx_GIVEREF(__pyx_n_s_thread); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_thread); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydev_bundle__pydev_saved_modul, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_thread); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_thread, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":3 * from __future__ import print_function * from _pydev_bundle._pydev_saved_modules import threading, thread * from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder # <<<<<<<<<<<<<< * import dis * import sys */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_GlobalDebuggerHolder); __Pyx_GIVEREF(__pyx_n_s_GlobalDebuggerHolder); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_GlobalDebuggerHolder); __pyx_t_1 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_constants, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_GlobalDebuggerHolder); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_GlobalDebuggerHolder, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":4 * from _pydev_bundle._pydev_saved_modules import threading, thread * from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder * import dis # <<<<<<<<<<<<<< * import sys * from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_dis, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dis, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":5 * from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder * import dis * import sys # <<<<<<<<<<<<<< * from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder * from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":6 * import dis * import sys * from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder # <<<<<<<<<<<<<< * from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER */ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_update_globals_dict); __Pyx_GIVEREF(__pyx_n_s_update_globals_dict); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_update_globals_dict); __Pyx_INCREF(__pyx_n_s_dummy_tracing_holder); __Pyx_GIVEREF(__pyx_n_s_dummy_tracing_holder); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_dummy_tracing_holder); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_frame_eval_pydevd_frame, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_update_globals_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_update_globals_dict, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_dummy_tracing_holder); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dummy_tracing_holder, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":7 * import sys * from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder * from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks # <<<<<<<<<<<<<< * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER * from _pydevd_bundle.pydevd_trace_dispatch import fix_top_level_trace_and_get_trace_func */ __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DebugHelper); __Pyx_GIVEREF(__pyx_n_s_DebugHelper); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DebugHelper); __Pyx_INCREF(__pyx_n_s_insert_pydevd_breaks); __Pyx_GIVEREF(__pyx_n_s_insert_pydevd_breaks); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_insert_pydevd_breaks); __pyx_t_1 = __Pyx_Import(__pyx_n_s_pydevd_frame_eval_pydevd_modify, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_DebugHelper); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DebugHelper, __pyx_t_2) < 0) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_insert_pydevd_breaks); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_insert_pydevd_breaks, __pyx_t_2) < 0) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":8 * from _pydevd_frame_eval.pydevd_frame_tracing import update_globals_dict, dummy_tracing_holder * from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_trace_dispatch import fix_top_level_trace_and_get_trace_func * */ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_get_abs_path_real_path_and_base); __Pyx_GIVEREF(__pyx_n_s_get_abs_path_real_path_and_base); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_abs_path_real_path_and_base); __Pyx_INCREF(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); __Pyx_GIVEREF(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_file_utils, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_abs_path_real_path_and_base, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":9 * from _pydevd_frame_eval.pydevd_modify_bytecode import DebugHelper, insert_pydevd_breaks * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER * from _pydevd_bundle.pydevd_trace_dispatch import fix_top_level_trace_and_get_trace_func # <<<<<<<<<<<<<< * * from _pydevd_bundle.pydevd_additional_thread_info import _set_additional_thread_info_lock */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_fix_top_level_trace_and_get_trac); __Pyx_GIVEREF(__pyx_n_s_fix_top_level_trace_and_get_trac); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_fix_top_level_trace_and_get_trac); __pyx_t_1 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_trace_disp, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_fix_top_level_trace_and_get_trac); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fix_top_level_trace_and_get_trac, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":11 * from _pydevd_bundle.pydevd_trace_dispatch import fix_top_level_trace_and_get_trace_func * * from _pydevd_bundle.pydevd_additional_thread_info import _set_additional_thread_info_lock # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_cython cimport PyDBAdditionalThreadInfo * from pydevd_tracing import SetTrace */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_set_additional_thread_info_lock); __Pyx_GIVEREF(__pyx_n_s_set_additional_thread_info_lock); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_set_additional_thread_info_lock); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_additional, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_set_additional_thread_info_lock); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_set_additional_thread_info_lock, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":13 * from _pydevd_bundle.pydevd_additional_thread_info import _set_additional_thread_info_lock * from _pydevd_bundle.pydevd_cython cimport PyDBAdditionalThreadInfo * from pydevd_tracing import SetTrace # <<<<<<<<<<<<<< * * _get_ident = threading.get_ident # Note this is py3 only, if py2 needed to be supported, _get_ident would be needed. */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_SetTrace); __Pyx_GIVEREF(__pyx_n_s_SetTrace); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_SetTrace); __pyx_t_1 = __Pyx_Import(__pyx_n_s_pydevd_tracing, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_SetTrace); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_SetTrace, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":15 * from pydevd_tracing import SetTrace * * _get_ident = threading.get_ident # Note this is py3 only, if py2 needed to be supported, _get_ident would be needed. # <<<<<<<<<<<<<< * _thread_local_info = threading.local() * _thread_active = threading._active */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_threading); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_get_ident_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_ident, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":16 * * _get_ident = threading.get_ident # Note this is py3 only, if py2 needed to be supported, _get_ident would be needed. * _thread_local_info = threading.local() # <<<<<<<<<<<<<< * _thread_active = threading._active * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_local); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_thread_local_info, __pyx_t_2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":17 * _get_ident = threading.get_ident # Note this is py3 only, if py2 needed to be supported, _get_ident would be needed. * _thread_local_info = threading.local() * _thread_active = threading._active # <<<<<<<<<<<<<< * * def clear_thread_local_info(): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_active); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_thread_active, __pyx_t_1) < 0) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":19 * _thread_active = threading._active * * def clear_thread_local_info(): # <<<<<<<<<<<<<< * global _thread_local_info * _thread_local_info = threading.local() */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_1clear_thread_local_info, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_clear_thread_local_info, __pyx_t_1) < 0) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":152 * * * def dummy_trace_dispatch(frame, str event, arg): # <<<<<<<<<<<<<< * if event == 'call': * if frame.f_trace is not None: */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_3dummy_trace_dispatch, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dummy_trace_dispatch, __pyx_t_1) < 0) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":159 * * * def get_thread_info_py() -> ThreadInfo: # <<<<<<<<<<<<<< * return get_thread_info(PyEval_GetFrame()) * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_5get_thread_info_py, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_thread_info_py, __pyx_t_1) < 0) __PYX_ERR(0, 159, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":196 * * * def decref_py(obj): # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_7decref_py, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_decref_py, __pyx_t_1) < 0) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":203 * * * def get_func_code_info_py(thread_info, frame, code_obj) -> FuncCodeInfo: # <<<<<<<<<<<<<< * ''' * Helper to be called from Python. */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_9get_func_code_info_py, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_func_code_info_py, __pyx_t_1) < 0) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":210 * * * cdef int _code_extra_index = -1 # <<<<<<<<<<<<<< * * cdef FuncCodeInfo get_func_code_info(ThreadInfo thread_info, PyFrameObject * frame_obj, PyCodeObject * code_obj): */ __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator__code_extra_index = -1; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":329 * * # Note: this method has a version in pure-python too. * def _get_code_line_info(code_obj): # <<<<<<<<<<<<<< * line_to_offset: dict = {} * first_line: int = None */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_11_get_code_line_info, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_code_line_info, __pyx_t_1) < 0) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":351 * # handled by the cython side in `FuncCodeInfo get_func_code_info` by providing the * # same code info if the debugger mtime is still the same). * _cache: dict = {} # <<<<<<<<<<<<<< * * def get_cached_code_obj_info_py(code_obj_py): */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_cache, __pyx_t_1) < 0) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":353 * _cache: dict = {} * * def get_cached_code_obj_info_py(code_obj_py): # <<<<<<<<<<<<<< * ''' * :return _CacheValue: */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_13get_cached_code_obj_info_py, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_cached_code_obj_info_py, __pyx_t_1) < 0) __PYX_ERR(0, 353, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":401 * return breakpoint_found, force_stay_in_untraced_mode * * def generate_code_with_breakpoints_py(object code_obj_py, dict breakpoints): # <<<<<<<<<<<<<< * return generate_code_with_breakpoints(code_obj_py, breakpoints) * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_15generate_code_with_breakpoints_py, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate_code_with_breakpoints_p, __pyx_t_1) < 0) __PYX_ERR(0, 401, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":471 * return breakpoint_found, code_obj_py * * import sys # <<<<<<<<<<<<<< * * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":473 * import sys * * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) # <<<<<<<<<<<<<< * * def frame_eval_func(): */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_version_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_2, 0, 2, NULL, NULL, &__pyx_slice__24, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_tuple__25, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_18_pydevd_frame_eval_22pydevd_frame_evaluator_IS_PY_39_OWNARDS = __pyx_t_3; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":475 * cdef bint IS_PY_39_OWNARDS = sys.version_info[:2] >= (3, 9) * * def frame_eval_func(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * if IS_PY_39_OWNARDS: */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_17frame_eval_func, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_frame_eval_func, __pyx_t_2) < 0) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":484 * * * def stop_frame_eval(): # <<<<<<<<<<<<<< * cdef PyThreadState *state = PyThreadState_Get() * state.interp.eval_frame = _PyEval_EvalFrameDefault */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_19stop_frame_eval, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_stop_frame_eval, __pyx_t_2) < 0) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 * def __pyx_unpickle_ThreadInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_21__pyx_unpickle_ThreadInfo, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_ThreadInfo, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":11 * __pyx_unpickle_ThreadInfo__set_state(<ThreadInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_ThreadInfo__set_state(ThreadInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result._can_create_dummy_thread = __pyx_state[0]; __pyx_result.additional_info = __pyx_state[1]; __pyx_result.force_stay_in_untraced_mode = __pyx_state[2]; __pyx_result.fully_initialized = __pyx_state[3]; __pyx_result.inside_frame_eval = __pyx_state[4]; __pyx_result.is_pydevd_thread = __pyx_state[5]; __pyx_result.thread_trace_func = __pyx_state[6] * if len(__pyx_state) > 7 and hasattr(__pyx_result, '__dict__'): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_23__pyx_unpickle_FuncCodeInfo, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_FuncCodeInfo, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 * def __pyx_unpickle__CodeLineInfo(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_25__pyx_unpickle__CodeLineInfo, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle__CodeLineInfo, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":11 * __pyx_unpickle__CodeLineInfo__set_state(<_CodeLineInfo> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__CodeLineInfo__set_state(_CodeLineInfo __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.first_line = __pyx_state[0]; __pyx_result.last_line = __pyx_state[1]; __pyx_result.line_to_offset = __pyx_state[2] * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_18_pydevd_frame_eval_22pydevd_frame_evaluator_27__pyx_unpickle__CacheValue, NULL, __pyx_n_s_pydevd_frame_eval_pydevd_frame_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle__CacheValue, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_frame_eval/pydevd_frame_evaluator.pyx":1 * from __future__ import print_function # <<<<<<<<<<<<<< * from _pydev_bundle._pydev_saved_modules import threading, thread * from _pydevd_bundle.pydevd_constants import GlobalDebuggerHolder */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init _pydevd_frame_eval.pydevd_frame_evaluator", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init _pydevd_frame_eval.pydevd_frame_evaluator"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyIntBinop */ #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { const long b = intval; long x; long a = PyInt_AS_LONG(op1); x = (long)((unsigned long)a + b); if (likely((x^a) >= 0 || (x^b) >= 0)) return PyInt_FromLong(x); return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { const long b = intval; long a, x; #ifdef HAVE_LONG_LONG const PY_LONG_LONG llb = intval; PY_LONG_LONG lla, llx; #endif const digit* digits = ((PyLongObject*)op1)->ob_digit; const Py_ssize_t size = Py_SIZE(op1); if (likely(__Pyx_sst_abs(size) <= 1)) { a = likely(size) ? digits[0] : 0; if (size == -1) a = -a; } else { switch (size) { case -2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 2: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 3: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case -4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; case 4: if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); break; #ifdef HAVE_LONG_LONG } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); goto long_long; #endif } CYTHON_FALLTHROUGH; default: return PyLong_Type.tp_as_number->nb_add(op1, op2); } } x = a + b; return PyLong_FromLong(x); #ifdef HAVE_LONG_LONG long_long: llx = lla + llb; return PyLong_FromLongLong(llx); #endif } #endif if (PyFloat_CheckExact(op1)) { const long b = intval; double a = PyFloat_AS_DOUBLE(op1); double result; PyFPE_START_PROTECT("add", return NULL) result = ((double)a) + (double)b; PyFPE_END_PROTECT(result) return PyFloat_FromDouble(result); } return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); } #endif /* SliceObject */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i<n; i++) { if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1; } #endif for (i=0; i<n; i++) { if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1; } return 0; } static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { PyObject *exc_type = tstate->curexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #endif /* None */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { if (unlikely(PyTuple_Check(key))) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) { PyErr_SetObject(PyExc_KeyError, args); Py_DECREF(args); } } else { PyErr_SetObject(PyExc_KeyError, key); } } return NULL; } Py_INCREF(value); return value; } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_getstate = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; PyObject *getstate = NULL; #if CYTHON_USE_PYTYPE_LOOKUP getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); #else getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); if (!getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (getstate) { #if CYTHON_USE_PYTYPE_LOOKUP object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); #else object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); if (!object_getstate && PyErr_Occurred()) { goto __PYX_BAD; } #endif if (object_getstate != getstate) { goto __PYX_GOOD; } } #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); Py_XDECREF(object_getstate); Py_XDECREF(getstate); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" #if PY_VERSION_HEX >= 0x030b00a6 #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; #if PY_MAJOR_VERSION < 3 PyObject *py_srcfile = NULL; py_srcfile = PyString_FromString(filename); if (!py_srcfile) goto bad; #endif if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); if (!py_funcname) goto bad; funcname = PyUnicode_AsUTF8(py_funcname); if (!funcname) goto bad; #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); if (!py_funcname) goto bad; #endif } #if PY_MAJOR_VERSION < 3 py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline return py_code; bad: Py_XDECREF(py_funcname); #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_srcfile); #endif return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; i<n; i++) { if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1; } #endif for (i=0; i<n; i++) { PyObject *t = PyTuple_GET_ITEM(tuple, i); #if PY_MAJOR_VERSION < 3 if (likely(exc_type == t)) return 1; #endif if (likely(PyExceptionClass_Check(t))) { if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1; } else { } } return 0; } static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { if (likely(err == exc_type)) return 1; if (likely(PyExceptionClass_Check(err))) { if (likely(PyExceptionClass_Check(exc_type))) { return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); } else if (likely(PyTuple_Check(exc_type))) { return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); } else { } } return PyErr_GivenExceptionMatches(err, exc_type); } static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { assert(PyExceptionClass_Check(exc_type1)); assert(PyExceptionClass_Check(exc_type2)); if (likely(err == exc_type1 || err == exc_type2)) return 1; if (likely(PyExceptionClass_Check(err))) { return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); } return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); } #endif /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[5]; int same=1, i, found_dot; const char* rt_from_call = Py_GetVersion(); PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); found_dot = 0; for (i = 0; i < 4; i++) { if (!ctversion[i]) { same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); break; } if (rt_from_call[i] != ctversion[i]) { same = 0; break; } } if (!same) { char rtversion[5] = {'\0'}; char message[200]; for (i=0; i<4; ++i) { if (rt_from_call[i] == '.') { if (found_dot) break; found_dot = 1; } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { break; } rtversion[i] = rt_from_call[i]; } PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); #if PY_MAJOR_VERSION < 3 } else if (likely(PyInt_CheckExact(o))) { return PyInt_AS_LONG(o); #endif } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; ival = PyInt_AsLong(x); Py_DECREF(x); return ival; } } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */
935,795
C
44.435813
391
0.592001
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_eval_main.py
import os from _pydev_bundle import pydev_log from _pydevd_bundle.pydevd_trace_dispatch import USING_CYTHON from _pydevd_bundle.pydevd_constants import USE_CYTHON_FLAG, ENV_FALSE_LOWER_VALUES, \ ENV_TRUE_LOWER_VALUES, IS_PY36_OR_GREATER, IS_PY38_OR_GREATER, SUPPORT_GEVENT, IS_PYTHON_STACKLESS, \ PYDEVD_USE_FRAME_EVAL, PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING frame_eval_func = None stop_frame_eval = None dummy_trace_dispatch = None clear_thread_local_info = None # "NO" means we should not use frame evaluation, 'YES' we should use it (and fail if not there) and unspecified uses if possible. if ( PYDEVD_USE_FRAME_EVAL in ENV_FALSE_LOWER_VALUES or USE_CYTHON_FLAG in ENV_FALSE_LOWER_VALUES or not USING_CYTHON or # Frame eval mode does not work with ipython compatible debugging (this happens because the # way that frame eval works is run untraced and set tracing only for the frames with # breakpoints, but ipython compatible debugging creates separate frames for what's logically # the same frame). PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING ): USING_FRAME_EVAL = False elif SUPPORT_GEVENT or (IS_PYTHON_STACKLESS and not IS_PY38_OR_GREATER): USING_FRAME_EVAL = False # i.e gevent and frame eval mode don't get along very well. # https://github.com/microsoft/debugpy/issues/189 # Same problem with Stackless. # https://github.com/stackless-dev/stackless/issues/240 elif PYDEVD_USE_FRAME_EVAL in ENV_TRUE_LOWER_VALUES: # Fail if unable to use from _pydevd_frame_eval.pydevd_frame_eval_cython_wrapper import frame_eval_func, stop_frame_eval, dummy_trace_dispatch, clear_thread_local_info USING_FRAME_EVAL = True else: USING_FRAME_EVAL = False # Try to use if possible if IS_PY36_OR_GREATER: try: from _pydevd_frame_eval.pydevd_frame_eval_cython_wrapper import frame_eval_func, stop_frame_eval, dummy_trace_dispatch, clear_thread_local_info USING_FRAME_EVAL = True except ImportError: pydev_log.show_compile_cython_command_line()
2,105
Python
41.979591
155
0.717815
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/pydevd_fix_code.py
def _fix_contents(filename, contents): import re contents = re.sub( r"from bytecode", r'from _pydevd_frame_eval.vendored.bytecode', contents, flags=re.MULTILINE ) contents = re.sub( r"import bytecode", r'from _pydevd_frame_eval.vendored import bytecode', contents, flags=re.MULTILINE ) # This test will import the wrong setup (we're not interested in it). contents = re.sub( r"def test_version\(self\):", r'def skip_test_version(self):', contents, flags=re.MULTILINE ) if filename.startswith('test_'): if 'pytestmark' not in contents: pytest_mark = ''' import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') ''' contents = pytest_mark + contents return contents def main(): import os # traverse root directory, and list directories as dirs and files as files for root, dirs, files in os.walk(os.path.dirname(__file__)): path = root.split(os.sep) for filename in files: if filename.endswith('.py') and filename != 'pydevd_fix_code.py': with open(os.path.join(root, filename), 'r') as stream: contents = stream.read() new_contents = _fix_contents(filename, contents) if contents != new_contents: print('fixed ', os.path.join(root, filename)) with open(os.path.join(root, filename), 'w') as stream: stream.write(new_contents) # print(len(path) * '---', filename) if __name__ == '__main__': main()
1,801
Python
35.039999
126
0.612438
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/flags.py
# alias to keep the 'bytecode' variable free import sys from enum import IntFlag from _pydevd_frame_eval.vendored import bytecode as _bytecode class CompilerFlags(IntFlag): """Possible values of the co_flags attribute of Code object. Note: We do not rely on inspect values here as some of them are missing and furthermore would be version dependent. """ OPTIMIZED = 0x00001 # noqa NEWLOCALS = 0x00002 # noqa VARARGS = 0x00004 # noqa VARKEYWORDS = 0x00008 # noqa NESTED = 0x00010 # noqa GENERATOR = 0x00020 # noqa NOFREE = 0x00040 # noqa # New in Python 3.5 # Used for coroutines defined using async def ie native coroutine COROUTINE = 0x00080 # noqa # Used for coroutines defined as a generator and then decorated using # types.coroutine ITERABLE_COROUTINE = 0x00100 # noqa # New in Python 3.6 # Generator defined in an async def function ASYNC_GENERATOR = 0x00200 # noqa # __future__ flags # future flags changed in Python 3.9 if sys.version_info < (3, 9): FUTURE_GENERATOR_STOP = 0x80000 # noqa if sys.version_info > (3, 6): FUTURE_ANNOTATIONS = 0x100000 else: FUTURE_GENERATOR_STOP = 0x800000 # noqa FUTURE_ANNOTATIONS = 0x1000000 def infer_flags(bytecode, is_async=None): """Infer the proper flags for a bytecode based on the instructions. Because the bytecode does not have enough context to guess if a function is asynchronous the algorithm tries to be conservative and will never turn a previously async code into a sync one. Parameters ---------- bytecode : Bytecode | ConcreteBytecode | ControlFlowGraph Bytecode for which to infer the proper flags is_async : bool | None, optional Force the code to be marked as asynchronous if True, prevent it from being marked as asynchronous if False and simply infer the best solution based on the opcode and the existing flag if None. """ flags = CompilerFlags(0) if not isinstance( bytecode, (_bytecode.Bytecode, _bytecode.ConcreteBytecode, _bytecode.ControlFlowGraph), ): msg = ( "Expected a Bytecode, ConcreteBytecode or ControlFlowGraph " "instance not %s" ) raise ValueError(msg % bytecode) instructions = ( bytecode.get_instructions() if isinstance(bytecode, _bytecode.ControlFlowGraph) else bytecode ) instr_names = { i.name for i in instructions if not isinstance(i, (_bytecode.SetLineno, _bytecode.Label)) } # Identify optimized code if not (instr_names & {"STORE_NAME", "LOAD_NAME", "DELETE_NAME"}): flags |= CompilerFlags.OPTIMIZED # Check for free variables if not ( instr_names & { "LOAD_CLOSURE", "LOAD_DEREF", "STORE_DEREF", "DELETE_DEREF", "LOAD_CLASSDEREF", } ): flags |= CompilerFlags.NOFREE # Copy flags for which we cannot infer the right value flags |= bytecode.flags & ( CompilerFlags.NEWLOCALS | CompilerFlags.VARARGS | CompilerFlags.VARKEYWORDS | CompilerFlags.NESTED ) sure_generator = instr_names & {"YIELD_VALUE"} maybe_generator = instr_names & {"YIELD_VALUE", "YIELD_FROM"} sure_async = instr_names & { "GET_AWAITABLE", "GET_AITER", "GET_ANEXT", "BEFORE_ASYNC_WITH", "SETUP_ASYNC_WITH", "END_ASYNC_FOR", } # If performing inference or forcing an async behavior, first inspect # the flags since this is the only way to identify iterable coroutines if is_async in (None, True): if bytecode.flags & CompilerFlags.COROUTINE: if sure_generator: flags |= CompilerFlags.ASYNC_GENERATOR else: flags |= CompilerFlags.COROUTINE elif bytecode.flags & CompilerFlags.ITERABLE_COROUTINE: if sure_async: msg = ( "The ITERABLE_COROUTINE flag is set but bytecode that" "can only be used in async functions have been " "detected. Please unset that flag before performing " "inference." ) raise ValueError(msg) flags |= CompilerFlags.ITERABLE_COROUTINE elif bytecode.flags & CompilerFlags.ASYNC_GENERATOR: if not sure_generator: flags |= CompilerFlags.COROUTINE else: flags |= CompilerFlags.ASYNC_GENERATOR # If the code was not asynchronous before determine if it should now be # asynchronous based on the opcode and the is_async argument. else: if sure_async: # YIELD_FROM is not allowed in async generator if sure_generator: flags |= CompilerFlags.ASYNC_GENERATOR else: flags |= CompilerFlags.COROUTINE elif maybe_generator: if is_async: if sure_generator: flags |= CompilerFlags.ASYNC_GENERATOR else: flags |= CompilerFlags.COROUTINE else: flags |= CompilerFlags.GENERATOR elif is_async: flags |= CompilerFlags.COROUTINE # If the code should not be asynchronous, check first it is possible and # next set the GENERATOR flag if relevant else: if sure_async: raise ValueError( "The is_async argument is False but bytecodes " "that can only be used in async functions have " "been detected." ) if maybe_generator: flags |= CompilerFlags.GENERATOR flags |= bytecode.flags & CompilerFlags.FUTURE_GENERATOR_STOP return flags
6,020
Python
32.082417
85
0.598173
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/peephole_opt.py
""" Peephole optimizer of CPython 3.6 reimplemented in pure Python using the bytecode module. """ import opcode import operator import sys from _pydevd_frame_eval.vendored.bytecode import Instr, Bytecode, ControlFlowGraph, BasicBlock, Compare JUMPS_ON_TRUE = frozenset( ( "POP_JUMP_IF_TRUE", "JUMP_IF_TRUE_OR_POP", ) ) NOT_COMPARE = { Compare.IN: Compare.NOT_IN, Compare.NOT_IN: Compare.IN, Compare.IS: Compare.IS_NOT, Compare.IS_NOT: Compare.IS, } MAX_SIZE = 20 class ExitUnchanged(Exception): """Exception used to skip the peephole optimizer""" pass class PeepholeOptimizer: """Python reimplementation of the peephole optimizer. Copy of the C comment: Perform basic peephole optimizations to components of a code object. The consts object should still be in list form to allow new constants to be appended. To keep the optimizer simple, it bails out (does nothing) for code that has a length over 32,700, and does not calculate extended arguments. That allows us to avoid overflow and sign issues. Likewise, it bails when the lineno table has complex encoding for gaps >= 255. EXTENDED_ARG can appear before MAKE_FUNCTION; in this case both opcodes are skipped. EXTENDED_ARG preceding any other opcode causes the optimizer to bail. Optimizations are restricted to simple transformations occuring within a single basic block. All transformations keep the code size the same or smaller. For those that reduce size, the gaps are initially filled with NOPs. Later those NOPs are removed and the jump addresses retargeted in a single pass. Code offset is adjusted accordingly. """ def __init__(self): # bytecode.ControlFlowGraph instance self.code = None self.const_stack = None self.block_index = None self.block = None # index of the current instruction in self.block instructions self.index = None # whether we are in a LOAD_CONST sequence self.in_consts = False def check_result(self, value): try: size = len(value) except TypeError: return True return size <= MAX_SIZE def replace_load_const(self, nconst, instr, result): # FIXME: remove temporary computed constants? # FIXME: or at least reuse existing constants? self.in_consts = True load_const = Instr("LOAD_CONST", result, lineno=instr.lineno) start = self.index - nconst - 1 self.block[start : self.index] = (load_const,) self.index -= nconst if nconst: del self.const_stack[-nconst:] self.const_stack.append(result) self.in_consts = True def eval_LOAD_CONST(self, instr): self.in_consts = True value = instr.arg self.const_stack.append(value) self.in_consts = True def unaryop(self, op, instr): try: value = self.const_stack[-1] result = op(value) except IndexError: return if not self.check_result(result): return self.replace_load_const(1, instr, result) def eval_UNARY_POSITIVE(self, instr): return self.unaryop(operator.pos, instr) def eval_UNARY_NEGATIVE(self, instr): return self.unaryop(operator.neg, instr) def eval_UNARY_INVERT(self, instr): return self.unaryop(operator.invert, instr) def get_next_instr(self, name): try: next_instr = self.block[self.index] except IndexError: return None if next_instr.name == name: return next_instr return None def eval_UNARY_NOT(self, instr): # Note: UNARY_NOT <const> is not optimized next_instr = self.get_next_instr("POP_JUMP_IF_FALSE") if next_instr is None: return None # Replace UNARY_NOT+POP_JUMP_IF_FALSE with POP_JUMP_IF_TRUE instr.set("POP_JUMP_IF_TRUE", next_instr.arg) del self.block[self.index] def binop(self, op, instr): try: left = self.const_stack[-2] right = self.const_stack[-1] except IndexError: return try: result = op(left, right) except Exception: return if not self.check_result(result): return self.replace_load_const(2, instr, result) def eval_BINARY_ADD(self, instr): return self.binop(operator.add, instr) def eval_BINARY_SUBTRACT(self, instr): return self.binop(operator.sub, instr) def eval_BINARY_MULTIPLY(self, instr): return self.binop(operator.mul, instr) def eval_BINARY_TRUE_DIVIDE(self, instr): return self.binop(operator.truediv, instr) def eval_BINARY_FLOOR_DIVIDE(self, instr): return self.binop(operator.floordiv, instr) def eval_BINARY_MODULO(self, instr): return self.binop(operator.mod, instr) def eval_BINARY_POWER(self, instr): return self.binop(operator.pow, instr) def eval_BINARY_LSHIFT(self, instr): return self.binop(operator.lshift, instr) def eval_BINARY_RSHIFT(self, instr): return self.binop(operator.rshift, instr) def eval_BINARY_AND(self, instr): return self.binop(operator.and_, instr) def eval_BINARY_OR(self, instr): return self.binop(operator.or_, instr) def eval_BINARY_XOR(self, instr): return self.binop(operator.xor, instr) def eval_BINARY_SUBSCR(self, instr): return self.binop(operator.getitem, instr) def replace_container_of_consts(self, instr, container_type): items = self.const_stack[-instr.arg :] value = container_type(items) self.replace_load_const(instr.arg, instr, value) def build_tuple_unpack_seq(self, instr): next_instr = self.get_next_instr("UNPACK_SEQUENCE") if next_instr is None or next_instr.arg != instr.arg: return if instr.arg < 1: return if self.const_stack and instr.arg <= len(self.const_stack): nconst = instr.arg start = self.index - 1 # Rewrite LOAD_CONST instructions in the reverse order load_consts = self.block[start - nconst : start] self.block[start - nconst : start] = reversed(load_consts) # Remove BUILD_TUPLE+UNPACK_SEQUENCE self.block[start : start + 2] = () self.index -= 2 self.const_stack.clear() return if instr.arg == 1: # Replace BUILD_TUPLE 1 + UNPACK_SEQUENCE 1 with NOP del self.block[self.index - 1 : self.index + 1] elif instr.arg == 2: # Replace BUILD_TUPLE 2 + UNPACK_SEQUENCE 2 with ROT_TWO rot2 = Instr("ROT_TWO", lineno=instr.lineno) self.block[self.index - 1 : self.index + 1] = (rot2,) self.index -= 1 self.const_stack.clear() elif instr.arg == 3: # Replace BUILD_TUPLE 3 + UNPACK_SEQUENCE 3 # with ROT_THREE + ROT_TWO rot3 = Instr("ROT_THREE", lineno=instr.lineno) rot2 = Instr("ROT_TWO", lineno=instr.lineno) self.block[self.index - 1 : self.index + 1] = (rot3, rot2) self.index -= 1 self.const_stack.clear() def build_tuple(self, instr, container_type): if instr.arg > len(self.const_stack): return next_instr = self.get_next_instr("COMPARE_OP") if next_instr is None or next_instr.arg not in (Compare.IN, Compare.NOT_IN): return self.replace_container_of_consts(instr, container_type) return True def eval_BUILD_TUPLE(self, instr): if not instr.arg: return if instr.arg <= len(self.const_stack): self.replace_container_of_consts(instr, tuple) else: self.build_tuple_unpack_seq(instr) def eval_BUILD_LIST(self, instr): if not instr.arg: return if not self.build_tuple(instr, tuple): self.build_tuple_unpack_seq(instr) def eval_BUILD_SET(self, instr): if not instr.arg: return self.build_tuple(instr, frozenset) # Note: BUILD_SLICE is not optimized def eval_COMPARE_OP(self, instr): # Note: COMPARE_OP: 2 < 3 is not optimized try: new_arg = NOT_COMPARE[instr.arg] except KeyError: return if self.get_next_instr("UNARY_NOT") is None: return # not (a is b) --> a is not b # not (a in b) --> a not in b # not (a is not b) --> a is b # not (a not in b) --> a in b instr.arg = new_arg self.block[self.index - 1 : self.index + 1] = (instr,) def jump_if_or_pop(self, instr): # Simplify conditional jump to conditional jump where the # result of the first test implies the success of a similar # test or the failure of the opposite test. # # Arises in code like: # "if a and b:" # "if a or b:" # "a and b or c" # "(a and b) and c" # # x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_FALSE_OR_POP z # --> x:JUMP_IF_FALSE_OR_POP z # # x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_TRUE_OR_POP z # --> x:POP_JUMP_IF_FALSE y+3 # where y+3 is the instruction following the second test. target_block = instr.arg try: target_instr = target_block[0] except IndexError: return if not target_instr.is_cond_jump(): self.optimize_jump_to_cond_jump(instr) return if (target_instr.name in JUMPS_ON_TRUE) == (instr.name in JUMPS_ON_TRUE): # The second jump will be taken iff the first is. target2 = target_instr.arg # The current opcode inherits its target's stack behaviour instr.name = target_instr.name instr.arg = target2 self.block[self.index - 1] = instr self.index -= 1 else: # The second jump is not taken if the first is (so jump past it), # and all conditional jumps pop their argument when they're not # taken (so change the first jump to pop its argument when it's # taken). if instr.name in JUMPS_ON_TRUE: name = "POP_JUMP_IF_TRUE" else: name = "POP_JUMP_IF_FALSE" new_label = self.code.split_block(target_block, 1) instr.name = name instr.arg = new_label self.block[self.index - 1] = instr self.index -= 1 def eval_JUMP_IF_FALSE_OR_POP(self, instr): self.jump_if_or_pop(instr) def eval_JUMP_IF_TRUE_OR_POP(self, instr): self.jump_if_or_pop(instr) def eval_NOP(self, instr): # Remove NOP del self.block[self.index - 1] self.index -= 1 def optimize_jump_to_cond_jump(self, instr): # Replace jumps to unconditional jumps jump_label = instr.arg assert isinstance(jump_label, BasicBlock), jump_label try: target_instr = jump_label[0] except IndexError: return if instr.is_uncond_jump() and target_instr.name == "RETURN_VALUE": # Replace JUMP_ABSOLUTE => RETURN_VALUE with RETURN_VALUE self.block[self.index - 1] = target_instr elif target_instr.is_uncond_jump(): # Replace JUMP_FORWARD t1 jumping to JUMP_FORWARD t2 # with JUMP_ABSOLUTE t2 jump_target2 = target_instr.arg name = instr.name if instr.name == "JUMP_FORWARD": name = "JUMP_ABSOLUTE" else: # FIXME: reimplement this check # if jump_target2 < 0: # # No backward relative jumps # return # FIXME: remove this workaround and implement comment code ^^ if instr.opcode in opcode.hasjrel: return instr.name = name instr.arg = jump_target2 self.block[self.index - 1] = instr def optimize_jump(self, instr): if instr.is_uncond_jump() and self.index == len(self.block): # JUMP_ABSOLUTE at the end of a block which points to the # following block: remove the jump, link the current block # to the following block block_index = self.block_index target_block = instr.arg target_block_index = self.code.get_block_index(target_block) if target_block_index == block_index: del self.block[self.index - 1] self.block.next_block = target_block return self.optimize_jump_to_cond_jump(instr) def iterblock(self, block): self.block = block self.index = 0 while self.index < len(block): instr = self.block[self.index] self.index += 1 yield instr def optimize_block(self, block): self.const_stack.clear() self.in_consts = False for instr in self.iterblock(block): if not self.in_consts: self.const_stack.clear() self.in_consts = False meth_name = "eval_%s" % instr.name meth = getattr(self, meth_name, None) if meth is not None: meth(instr) elif instr.has_jump(): self.optimize_jump(instr) # Note: Skipping over LOAD_CONST trueconst; POP_JUMP_IF_FALSE # <target> is not implemented, since it looks like the optimization # is never trigerred in practice. The compiler already optimizes if # and while statements. def remove_dead_blocks(self): # FIXME: remove empty blocks? used_blocks = {id(self.code[0])} for block in self.code: if block.next_block is not None: used_blocks.add(id(block.next_block)) for instr in block: if isinstance(instr, Instr) and isinstance(instr.arg, BasicBlock): used_blocks.add(id(instr.arg)) block_index = 0 while block_index < len(self.code): block = self.code[block_index] if id(block) not in used_blocks: del self.code[block_index] else: block_index += 1 # FIXME: merge following blocks if block1 does not contain any # jump and block1.next_block is block2 def optimize_cfg(self, cfg): self.code = cfg self.const_stack = [] self.remove_dead_blocks() self.block_index = 0 while self.block_index < len(self.code): block = self.code[self.block_index] self.block_index += 1 self.optimize_block(block) def optimize(self, code_obj): bytecode = Bytecode.from_code(code_obj) cfg = ControlFlowGraph.from_bytecode(bytecode) self.optimize_cfg(cfg) bytecode = cfg.to_bytecode() code = bytecode.to_code() return code # Code transformer for the PEP 511 class CodeTransformer: name = "pyopt" def code_transformer(self, code, context): if sys.flags.verbose: print( "Optimize %s:%s: %s" % (code.co_filename, code.co_firstlineno, code.co_name) ) optimizer = PeepholeOptimizer() return optimizer.optimize(code)
15,740
Python
30.993902
103
0.581004
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/instr.py
import enum import dis import opcode as _opcode import sys from marshal import dumps as _dumps from _pydevd_frame_eval.vendored import bytecode as _bytecode @enum.unique class Compare(enum.IntEnum): LT = 0 LE = 1 EQ = 2 NE = 3 GT = 4 GE = 5 IN = 6 NOT_IN = 7 IS = 8 IS_NOT = 9 EXC_MATCH = 10 UNSET = object() def const_key(obj): try: return _dumps(obj) except ValueError: # For other types, we use the object identifier as an unique identifier # to ensure that they are seen as unequal. return (type(obj), id(obj)) def _pushes_back(opname): if opname in ["CALL_FINALLY"]: # CALL_FINALLY pushes the address of the "finally" block instead of a # value, hence we don't treat it as pushing back op return False return ( opname.startswith("UNARY_") or opname.startswith("GET_") # BUILD_XXX_UNPACK have been removed in 3.9 or opname.startswith("BINARY_") or opname.startswith("INPLACE_") or opname.startswith("BUILD_") or opname.startswith("CALL_") ) or opname in ( "LIST_TO_TUPLE", "LIST_EXTEND", "SET_UPDATE", "DICT_UPDATE", "DICT_MERGE", "IS_OP", "CONTAINS_OP", "FORMAT_VALUE", "MAKE_FUNCTION", "IMPORT_NAME", # technically, these three do not push back, but leave the container # object on TOS "SET_ADD", "LIST_APPEND", "MAP_ADD", "LOAD_ATTR", ) def _check_lineno(lineno): if not isinstance(lineno, int): raise TypeError("lineno must be an int") if lineno < 1: raise ValueError("invalid lineno") class SetLineno: __slots__ = ("_lineno",) def __init__(self, lineno): _check_lineno(lineno) self._lineno = lineno @property def lineno(self): return self._lineno def __eq__(self, other): if not isinstance(other, SetLineno): return False return self._lineno == other._lineno class Label: __slots__ = () class _Variable: __slots__ = ("name",) def __init__(self, name): self.name = name def __eq__(self, other): if type(self) != type(other): return False return self.name == other.name def __str__(self): return self.name def __repr__(self): return "<%s %r>" % (self.__class__.__name__, self.name) class CellVar(_Variable): __slots__ = () class FreeVar(_Variable): __slots__ = () def _check_arg_int(name, arg): if not isinstance(arg, int): raise TypeError( "operation %s argument must be an int, " "got %s" % (name, type(arg).__name__) ) if not (0 <= arg <= 2147483647): raise ValueError( "operation %s argument must be in " "the range 0..2,147,483,647" % name ) if sys.version_info < (3, 8): _stack_effects = { # NOTE: the entries are all 2-tuples. Entry[0/False] is non-taken jumps. # Entry[1/True] is for taken jumps. # opcodes not in dis.stack_effect _opcode.opmap["EXTENDED_ARG"]: (0, 0), _opcode.opmap["NOP"]: (0, 0), # Jump taken/not-taken are different: _opcode.opmap["JUMP_IF_TRUE_OR_POP"]: (-1, 0), _opcode.opmap["JUMP_IF_FALSE_OR_POP"]: (-1, 0), _opcode.opmap["FOR_ITER"]: (1, -1), _opcode.opmap["SETUP_WITH"]: (1, 6), _opcode.opmap["SETUP_ASYNC_WITH"]: (0, 5), _opcode.opmap["SETUP_EXCEPT"]: (0, 6), # as of 3.7, below for <=3.6 _opcode.opmap["SETUP_FINALLY"]: (0, 6), # as of 3.7, below for <=3.6 } # More stack effect values that are unique to the version of Python. if sys.version_info < (3, 7): _stack_effects.update( { _opcode.opmap["SETUP_WITH"]: (7, 7), _opcode.opmap["SETUP_EXCEPT"]: (6, 9), _opcode.opmap["SETUP_FINALLY"]: (6, 9), } ) class Instr: """Abstract instruction.""" __slots__ = ("_name", "_opcode", "_arg", "_lineno", "offset") def __init__(self, name, arg=UNSET, *, lineno=None, offset=None): self._set(name, arg, lineno) self.offset = offset def _check_arg(self, name, opcode, arg): if name == "EXTENDED_ARG": raise ValueError( "only concrete instruction can contain EXTENDED_ARG, " "highlevel instruction can represent arbitrary argument without it" ) if opcode >= _opcode.HAVE_ARGUMENT: if arg is UNSET: raise ValueError("operation %s requires an argument" % name) else: if arg is not UNSET: raise ValueError("operation %s has no argument" % name) if self._has_jump(opcode): if not isinstance(arg, (Label, _bytecode.BasicBlock)): raise TypeError( "operation %s argument type must be " "Label or BasicBlock, got %s" % (name, type(arg).__name__) ) elif opcode in _opcode.hasfree: if not isinstance(arg, (CellVar, FreeVar)): raise TypeError( "operation %s argument must be CellVar " "or FreeVar, got %s" % (name, type(arg).__name__) ) elif opcode in _opcode.haslocal or opcode in _opcode.hasname: if not isinstance(arg, str): raise TypeError( "operation %s argument must be a str, " "got %s" % (name, type(arg).__name__) ) elif opcode in _opcode.hasconst: if isinstance(arg, Label): raise ValueError( "label argument cannot be used " "in %s operation" % name ) if isinstance(arg, _bytecode.BasicBlock): raise ValueError( "block argument cannot be used " "in %s operation" % name ) elif opcode in _opcode.hascompare: if not isinstance(arg, Compare): raise TypeError( "operation %s argument type must be " "Compare, got %s" % (name, type(arg).__name__) ) elif opcode >= _opcode.HAVE_ARGUMENT: _check_arg_int(name, arg) def _set(self, name, arg, lineno): if not isinstance(name, str): raise TypeError("operation name must be a str") try: opcode = _opcode.opmap[name] except KeyError: raise ValueError("invalid operation name") # check lineno if lineno is not None: _check_lineno(lineno) self._check_arg(name, opcode, arg) self._name = name self._opcode = opcode self._arg = arg self._lineno = lineno def set(self, name, arg=UNSET): """Modify the instruction in-place. Replace name and arg attributes. Don't modify lineno. """ self._set(name, arg, self._lineno) def require_arg(self): """Does the instruction require an argument?""" return self._opcode >= _opcode.HAVE_ARGUMENT @property def name(self): return self._name @name.setter def name(self, name): self._set(name, self._arg, self._lineno) @property def opcode(self): return self._opcode @opcode.setter def opcode(self, op): if not isinstance(op, int): raise TypeError("operator code must be an int") if 0 <= op <= 255: name = _opcode.opname[op] valid = name != "<%r>" % op else: valid = False if not valid: raise ValueError("invalid operator code") self._set(name, self._arg, self._lineno) @property def arg(self): return self._arg @arg.setter def arg(self, arg): self._set(self._name, arg, self._lineno) @property def lineno(self): return self._lineno @lineno.setter def lineno(self, lineno): self._set(self._name, self._arg, lineno) def stack_effect(self, jump=None): if self._opcode < _opcode.HAVE_ARGUMENT: arg = None elif not isinstance(self._arg, int) or self._opcode in _opcode.hasconst: # Argument is either a non-integer or an integer constant, # not oparg. arg = 0 else: arg = self._arg if sys.version_info < (3, 8): effect = _stack_effects.get(self._opcode, None) if effect is not None: return max(effect) if jump is None else effect[jump] return dis.stack_effect(self._opcode, arg) else: return dis.stack_effect(self._opcode, arg, jump=jump) def pre_and_post_stack_effect(self, jump=None): _effect = self.stack_effect(jump=jump) # To compute pre size and post size to avoid segfault cause by not enough # stack element _opname = _opcode.opname[self._opcode] if _opname.startswith("DUP_TOP"): return _effect * -1, _effect * 2 if _pushes_back(_opname): # if the op pushes value back to the stack, then the stack effect given # by dis.stack_effect actually equals pre + post effect, therefore we need # -1 from the stack effect as a pre condition return _effect - 1, 1 if _opname.startswith("UNPACK_"): # Instr(UNPACK_* , n) pops 1 and pushes n # _effect = n - 1 # hence we return -1, _effect + 1 return -1, _effect + 1 if _opname == "FOR_ITER" and not jump: # Since FOR_ITER needs TOS to be an iterator, which basically means # a prerequisite of 1 on the stack return -1, 2 if _opname == "ROT_N": return (-self._arg, self._arg) return {"ROT_TWO": (-2, 2), "ROT_THREE": (-3, 3), "ROT_FOUR": (-4, 4)}.get( _opname, (_effect, 0) ) def copy(self): return self.__class__(self._name, self._arg, lineno=self._lineno, offset=self.offset) def __repr__(self): if self._arg is not UNSET: return "<%s arg=%r lineno=%s>" % (self._name, self._arg, self._lineno) else: return "<%s lineno=%s>" % (self._name, self._lineno) def _cmp_key(self, labels=None): arg = self._arg if self._opcode in _opcode.hasconst: arg = const_key(arg) elif isinstance(arg, Label) and labels is not None: arg = labels[arg] return (self._lineno, self._name, arg) def __eq__(self, other): if type(self) != type(other): return False return self._cmp_key() == other._cmp_key() @staticmethod def _has_jump(opcode): return opcode in _opcode.hasjrel or opcode in _opcode.hasjabs def has_jump(self): return self._has_jump(self._opcode) def is_cond_jump(self): """Is a conditional jump?""" # Ex: POP_JUMP_IF_TRUE, JUMP_IF_FALSE_OR_POP return "JUMP_IF_" in self._name def is_uncond_jump(self): """Is an unconditional jump?""" return self.name in {"JUMP_FORWARD", "JUMP_ABSOLUTE"} def is_final(self): if self._name in { "RETURN_VALUE", "RAISE_VARARGS", "RERAISE", "BREAK_LOOP", "CONTINUE_LOOP", }: return True if self.is_uncond_jump(): return True return False
11,721
Python
28.526448
93
0.534255
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/concrete.py
import dis import inspect import opcode as _opcode import struct import sys import types # alias to keep the 'bytecode' variable free from _pydevd_frame_eval.vendored import bytecode as _bytecode from _pydevd_frame_eval.vendored.bytecode.instr import ( UNSET, Instr, Label, SetLineno, FreeVar, CellVar, Compare, const_key, _check_arg_int, ) # - jumps use instruction # - lineno use bytes (dis.findlinestarts(code)) # - dis displays bytes OFFSET_AS_INSTRUCTION = sys.version_info >= (3, 10) def _set_docstring(code, consts): if not consts: return first_const = consts[0] if isinstance(first_const, str) or first_const is None: code.docstring = first_const class ConcreteInstr(Instr): """Concrete instruction. arg must be an integer in the range 0..2147483647. It has a read-only size attribute. """ __slots__ = ("_size", "_extended_args", "offset") def __init__(self, name, arg=UNSET, *, lineno=None, extended_args=None, offset=None): # Allow to remember a potentially meaningless EXTENDED_ARG emitted by # Python to properly compute the size and avoid messing up the jump # targets self._extended_args = extended_args self._set(name, arg, lineno) self.offset = offset def _check_arg(self, name, opcode, arg): if opcode >= _opcode.HAVE_ARGUMENT: if arg is UNSET: raise ValueError("operation %s requires an argument" % name) _check_arg_int(name, arg) else: if arg is not UNSET: raise ValueError("operation %s has no argument" % name) def _set(self, name, arg, lineno): super()._set(name, arg, lineno) size = 2 if arg is not UNSET: while arg > 0xFF: size += 2 arg >>= 8 if self._extended_args is not None: size = 2 + 2 * self._extended_args self._size = size @property def size(self): return self._size def _cmp_key(self, labels=None): return (self._lineno, self._name, self._arg) def get_jump_target(self, instr_offset): if self._opcode in _opcode.hasjrel: s = (self._size // 2) if OFFSET_AS_INSTRUCTION else self._size return instr_offset + s + self._arg if self._opcode in _opcode.hasjabs: return self._arg return None def assemble(self): if self._arg is UNSET: return bytes((self._opcode, 0)) arg = self._arg b = [self._opcode, arg & 0xFF] while arg > 0xFF: arg >>= 8 b[:0] = [_opcode.EXTENDED_ARG, arg & 0xFF] if self._extended_args: while len(b) < self._size: b[:0] = [_opcode.EXTENDED_ARG, 0x00] return bytes(b) @classmethod def disassemble(cls, lineno, code, offset): index = 2 * offset if OFFSET_AS_INSTRUCTION else offset op = code[index] if op >= _opcode.HAVE_ARGUMENT: arg = code[index + 1] else: arg = UNSET name = _opcode.opname[op] # fabioz: added offset to ConcreteBytecode # Need to keep an eye on https://github.com/MatthieuDartiailh/bytecode/issues/48 in # case the library decides to add this in some other way. return cls(name, arg, lineno=lineno, offset=index) class ConcreteBytecode(_bytecode._BaseBytecodeList): def __init__(self, instructions=(), *, consts=(), names=(), varnames=()): super().__init__() self.consts = list(consts) self.names = list(names) self.varnames = list(varnames) for instr in instructions: self._check_instr(instr) self.extend(instructions) def __iter__(self): instructions = super().__iter__() for instr in instructions: self._check_instr(instr) yield instr def _check_instr(self, instr): if not isinstance(instr, (ConcreteInstr, SetLineno)): raise ValueError( "ConcreteBytecode must only contain " "ConcreteInstr and SetLineno objects, " "but %s was found" % type(instr).__name__ ) def _copy_attr_from(self, bytecode): super()._copy_attr_from(bytecode) if isinstance(bytecode, ConcreteBytecode): self.consts = bytecode.consts self.names = bytecode.names self.varnames = bytecode.varnames def __repr__(self): return "<ConcreteBytecode instr#=%s>" % len(self) def __eq__(self, other): if type(self) != type(other): return False const_keys1 = list(map(const_key, self.consts)) const_keys2 = list(map(const_key, other.consts)) if const_keys1 != const_keys2: return False if self.names != other.names: return False if self.varnames != other.varnames: return False return super().__eq__(other) @staticmethod def from_code(code, *, extended_arg=False): line_starts = dict(dis.findlinestarts(code)) # find block starts instructions = [] offset = 0 lineno = code.co_firstlineno while offset < (len(code.co_code) // (2 if OFFSET_AS_INSTRUCTION else 1)): lineno_off = (2 * offset) if OFFSET_AS_INSTRUCTION else offset if lineno_off in line_starts: lineno = line_starts[lineno_off] instr = ConcreteInstr.disassemble(lineno, code.co_code, offset) instructions.append(instr) offset += (instr.size // 2) if OFFSET_AS_INSTRUCTION else instr.size bytecode = ConcreteBytecode() # replace jump targets with blocks # HINT : in some cases Python generate useless EXTENDED_ARG opcode # with a value of zero. Such opcodes do not increases the size of the # following opcode the way a normal EXTENDED_ARG does. As a # consequence, they need to be tracked manually as otherwise the # offsets in jump targets can end up being wrong. if not extended_arg: # The list is modified in place bytecode._remove_extended_args(instructions) bytecode.name = code.co_name bytecode.filename = code.co_filename bytecode.flags = code.co_flags bytecode.argcount = code.co_argcount if sys.version_info >= (3, 8): bytecode.posonlyargcount = code.co_posonlyargcount bytecode.kwonlyargcount = code.co_kwonlyargcount bytecode.first_lineno = code.co_firstlineno bytecode.names = list(code.co_names) bytecode.consts = list(code.co_consts) bytecode.varnames = list(code.co_varnames) bytecode.freevars = list(code.co_freevars) bytecode.cellvars = list(code.co_cellvars) _set_docstring(bytecode, code.co_consts) bytecode[:] = instructions return bytecode @staticmethod def _normalize_lineno(instructions, first_lineno): lineno = first_lineno for instr in instructions: # if instr.lineno is not set, it's inherited from the previous # instruction, or from self.first_lineno if instr.lineno is not None: lineno = instr.lineno if isinstance(instr, ConcreteInstr): yield (lineno, instr) def _assemble_code(self): offset = 0 code_str = [] linenos = [] for lineno, instr in self._normalize_lineno(self, self.first_lineno): code_str.append(instr.assemble()) i_size = instr.size linenos.append( ((offset * 2) if OFFSET_AS_INSTRUCTION else offset, i_size, lineno) ) offset += (i_size // 2) if OFFSET_AS_INSTRUCTION else i_size code_str = b"".join(code_str) return (code_str, linenos) @staticmethod def _assemble_lnotab(first_lineno, linenos): lnotab = [] old_offset = 0 old_lineno = first_lineno for offset, _, lineno in linenos: dlineno = lineno - old_lineno if dlineno == 0: continue # FIXME: be kind, force monotonic line numbers? add an option? if dlineno < 0 and sys.version_info < (3, 6): raise ValueError( "negative line number delta is not supported " "on Python < 3.6" ) old_lineno = lineno doff = offset - old_offset old_offset = offset while doff > 255: lnotab.append(b"\xff\x00") doff -= 255 while dlineno < -128: lnotab.append(struct.pack("Bb", doff, -128)) doff = 0 dlineno -= -128 while dlineno > 127: lnotab.append(struct.pack("Bb", doff, 127)) doff = 0 dlineno -= 127 assert 0 <= doff <= 255 assert -128 <= dlineno <= 127 lnotab.append(struct.pack("Bb", doff, dlineno)) return b"".join(lnotab) @staticmethod def _pack_linetable(doff, dlineno, linetable): while dlineno < -127: linetable.append(struct.pack("Bb", 0, -127)) dlineno -= -127 while dlineno > 127: linetable.append(struct.pack("Bb", 0, 127)) dlineno -= 127 if doff > 254: linetable.append(struct.pack("Bb", 254, dlineno)) doff -= 254 while doff > 254: linetable.append(b"\xfe\x00") doff -= 254 linetable.append(struct.pack("Bb", doff, 0)) else: linetable.append(struct.pack("Bb", doff, dlineno)) assert 0 <= doff <= 254 assert -127 <= dlineno <= 127 def _assemble_linestable(self, first_lineno, linenos): if not linenos: return b"" linetable = [] old_offset = 0 iter_in = iter(linenos) offset, i_size, old_lineno = next(iter_in) old_dlineno = old_lineno - first_lineno for offset, i_size, lineno in iter_in: dlineno = lineno - old_lineno if dlineno == 0: continue old_lineno = lineno doff = offset - old_offset old_offset = offset self._pack_linetable(doff, old_dlineno, linetable) old_dlineno = dlineno # Pack the line of the last instruction. doff = offset + i_size - old_offset self._pack_linetable(doff, old_dlineno, linetable) return b"".join(linetable) @staticmethod def _remove_extended_args(instructions): # replace jump targets with blocks # HINT : in some cases Python generate useless EXTENDED_ARG opcode # with a value of zero. Such opcodes do not increases the size of the # following opcode the way a normal EXTENDED_ARG does. As a # consequence, they need to be tracked manually as otherwise the # offsets in jump targets can end up being wrong. nb_extended_args = 0 extended_arg = None index = 0 while index < len(instructions): instr = instructions[index] # Skip SetLineno meta instruction if isinstance(instr, SetLineno): index += 1 continue if instr.name == "EXTENDED_ARG": nb_extended_args += 1 if extended_arg is not None: extended_arg = (extended_arg << 8) + instr.arg else: extended_arg = instr.arg del instructions[index] continue if extended_arg is not None: arg = (extended_arg << 8) + instr.arg extended_arg = None instr = ConcreteInstr( instr.name, arg, lineno=instr.lineno, extended_args=nb_extended_args, offset=instr.offset, ) instructions[index] = instr nb_extended_args = 0 index += 1 if extended_arg is not None: raise ValueError("EXTENDED_ARG at the end of the code") def compute_stacksize(self, *, check_pre_and_post=True): bytecode = self.to_bytecode() cfg = _bytecode.ControlFlowGraph.from_bytecode(bytecode) return cfg.compute_stacksize(check_pre_and_post=check_pre_and_post) def to_code(self, stacksize=None, *, check_pre_and_post=True): code_str, linenos = self._assemble_code() lnotab = ( self._assemble_linestable(self.first_lineno, linenos) if sys.version_info >= (3, 10) else self._assemble_lnotab(self.first_lineno, linenos) ) nlocals = len(self.varnames) if stacksize is None: stacksize = self.compute_stacksize(check_pre_and_post=check_pre_and_post) if sys.version_info < (3, 8): return types.CodeType( self.argcount, self.kwonlyargcount, nlocals, stacksize, int(self.flags), code_str, tuple(self.consts), tuple(self.names), tuple(self.varnames), self.filename, self.name, self.first_lineno, lnotab, tuple(self.freevars), tuple(self.cellvars), ) else: return types.CodeType( self.argcount, self.posonlyargcount, self.kwonlyargcount, nlocals, stacksize, int(self.flags), code_str, tuple(self.consts), tuple(self.names), tuple(self.varnames), self.filename, self.name, self.first_lineno, lnotab, tuple(self.freevars), tuple(self.cellvars), ) def to_bytecode(self): # Copy instruction and remove extended args if any (in-place) c_instructions = self[:] self._remove_extended_args(c_instructions) # find jump targets jump_targets = set() offset = 0 for instr in c_instructions: if isinstance(instr, SetLineno): continue target = instr.get_jump_target(offset) if target is not None: jump_targets.add(target) offset += (instr.size // 2) if OFFSET_AS_INSTRUCTION else instr.size # create labels jumps = [] instructions = [] labels = {} offset = 0 ncells = len(self.cellvars) for lineno, instr in self._normalize_lineno(c_instructions, self.first_lineno): if offset in jump_targets: label = Label() labels[offset] = label instructions.append(label) jump_target = instr.get_jump_target(offset) size = instr.size arg = instr.arg # FIXME: better error reporting if instr.opcode in _opcode.hasconst: arg = self.consts[arg] elif instr.opcode in _opcode.haslocal: arg = self.varnames[arg] elif instr.opcode in _opcode.hasname: arg = self.names[arg] elif instr.opcode in _opcode.hasfree: if arg < ncells: name = self.cellvars[arg] arg = CellVar(name) else: name = self.freevars[arg - ncells] arg = FreeVar(name) elif instr.opcode in _opcode.hascompare: arg = Compare(arg) if jump_target is None: instr = Instr(instr.name, arg, lineno=lineno, offset=instr.offset) else: instr_index = len(instructions) instructions.append(instr) offset += (size // 2) if OFFSET_AS_INSTRUCTION else size if jump_target is not None: jumps.append((instr_index, jump_target)) # replace jump targets with labels for index, jump_target in jumps: instr = instructions[index] # FIXME: better error reporting on missing label label = labels[jump_target] instructions[index] = Instr(instr.name, label, lineno=instr.lineno, offset=instr.offset) bytecode = _bytecode.Bytecode() bytecode._copy_attr_from(self) nargs = bytecode.argcount + bytecode.kwonlyargcount if sys.version_info > (3, 8): nargs += bytecode.posonlyargcount if bytecode.flags & inspect.CO_VARARGS: nargs += 1 if bytecode.flags & inspect.CO_VARKEYWORDS: nargs += 1 bytecode.argnames = self.varnames[:nargs] _set_docstring(bytecode, self.consts) bytecode.extend(instructions) return bytecode class _ConvertBytecodeToConcrete: # Default number of passes of compute_jumps() before giving up. Refer to # assemble_jump_offsets() in compile.c for background. _compute_jumps_passes = 10 def __init__(self, code): assert isinstance(code, _bytecode.Bytecode) self.bytecode = code # temporary variables self.instructions = [] self.jumps = [] self.labels = {} # used to build ConcreteBytecode() object self.consts_indices = {} self.consts_list = [] self.names = [] self.varnames = [] def add_const(self, value): key = const_key(value) if key in self.consts_indices: return self.consts_indices[key] index = len(self.consts_indices) self.consts_indices[key] = index self.consts_list.append(value) return index @staticmethod def add(names, name): try: index = names.index(name) except ValueError: index = len(names) names.append(name) return index def concrete_instructions(self): ncells = len(self.bytecode.cellvars) lineno = self.bytecode.first_lineno for instr in self.bytecode: if isinstance(instr, Label): self.labels[instr] = len(self.instructions) continue if isinstance(instr, SetLineno): lineno = instr.lineno continue if isinstance(instr, ConcreteInstr): instr = instr.copy() else: assert isinstance(instr, Instr) if instr.lineno is not None: lineno = instr.lineno arg = instr.arg is_jump = isinstance(arg, Label) if is_jump: label = arg # fake value, real value is set in compute_jumps() arg = 0 elif instr.opcode in _opcode.hasconst: arg = self.add_const(arg) elif instr.opcode in _opcode.haslocal: arg = self.add(self.varnames, arg) elif instr.opcode in _opcode.hasname: arg = self.add(self.names, arg) elif instr.opcode in _opcode.hasfree: if isinstance(arg, CellVar): arg = self.bytecode.cellvars.index(arg.name) else: assert isinstance(arg, FreeVar) arg = ncells + self.bytecode.freevars.index(arg.name) elif instr.opcode in _opcode.hascompare: if isinstance(arg, Compare): arg = arg.value instr = ConcreteInstr(instr.name, arg, lineno=lineno) if is_jump: self.jumps.append((len(self.instructions), label, instr)) self.instructions.append(instr) def compute_jumps(self): offsets = [] offset = 0 for index, instr in enumerate(self.instructions): offsets.append(offset) offset += instr.size // 2 if OFFSET_AS_INSTRUCTION else instr.size # needed if a label is at the end offsets.append(offset) # fix argument of jump instructions: resolve labels modified = False for index, label, instr in self.jumps: target_index = self.labels[label] target_offset = offsets[target_index] if instr.opcode in _opcode.hasjrel: instr_offset = offsets[index] target_offset -= instr_offset + ( instr.size // 2 if OFFSET_AS_INSTRUCTION else instr.size ) old_size = instr.size # FIXME: better error report if target_offset is negative instr.arg = target_offset if instr.size != old_size: modified = True return modified def to_concrete_bytecode(self, compute_jumps_passes=None): if compute_jumps_passes is None: compute_jumps_passes = self._compute_jumps_passes first_const = self.bytecode.docstring if first_const is not UNSET: self.add_const(first_const) self.varnames.extend(self.bytecode.argnames) self.concrete_instructions() for pas in range(0, compute_jumps_passes): modified = self.compute_jumps() if not modified: break else: raise RuntimeError( "compute_jumps() failed to converge after" " %d passes" % (pas + 1) ) concrete = ConcreteBytecode( self.instructions, consts=self.consts_list.copy(), names=self.names, varnames=self.varnames, ) concrete._copy_attr_from(self.bytecode) return concrete
22,299
Python
32.086053
100
0.546033
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__init__.py
__version__ = "0.13.0.dev" __all__ = [ "Label", "Instr", "SetLineno", "Bytecode", "ConcreteInstr", "ConcreteBytecode", "ControlFlowGraph", "CompilerFlags", "Compare", ] from _pydevd_frame_eval.vendored.bytecode.flags import CompilerFlags from _pydevd_frame_eval.vendored.bytecode.instr import ( UNSET, Label, SetLineno, Instr, CellVar, FreeVar, # noqa Compare, ) from _pydevd_frame_eval.vendored.bytecode.bytecode import ( BaseBytecode, _BaseBytecodeList, _InstrList, Bytecode, ) # noqa from _pydevd_frame_eval.vendored.bytecode.concrete import ( ConcreteInstr, ConcreteBytecode, # noqa # import needed to use it in bytecode.py _ConvertBytecodeToConcrete, ) from _pydevd_frame_eval.vendored.bytecode.cfg import BasicBlock, ControlFlowGraph # noqa import sys def dump_bytecode(bytecode, *, lineno=False, stream=sys.stdout): def format_line(index, line): nonlocal cur_lineno, prev_lineno if lineno: if cur_lineno != prev_lineno: line = "L.% 3s % 3s: %s" % (cur_lineno, index, line) prev_lineno = cur_lineno else: line = " % 3s: %s" % (index, line) else: line = line return line def format_instr(instr, labels=None): text = instr.name arg = instr._arg if arg is not UNSET: if isinstance(arg, Label): try: arg = "<%s>" % labels[arg] except KeyError: arg = "<error: unknown label>" elif isinstance(arg, BasicBlock): try: arg = "<%s>" % labels[id(arg)] except KeyError: arg = "<error: unknown block>" else: arg = repr(arg) text = "%s %s" % (text, arg) return text indent = " " * 4 cur_lineno = bytecode.first_lineno prev_lineno = None if isinstance(bytecode, ConcreteBytecode): offset = 0 for instr in bytecode: fields = [] if instr.lineno is not None: cur_lineno = instr.lineno if lineno: fields.append(format_instr(instr)) line = "".join(fields) line = format_line(offset, line) else: fields.append("% 3s %s" % (offset, format_instr(instr))) line = "".join(fields) print(line, file=stream) offset += instr.size elif isinstance(bytecode, Bytecode): labels = {} for index, instr in enumerate(bytecode): if isinstance(instr, Label): labels[instr] = "label_instr%s" % index for index, instr in enumerate(bytecode): if isinstance(instr, Label): label = labels[instr] line = "%s:" % label if index != 0: print(file=stream) else: if instr.lineno is not None: cur_lineno = instr.lineno line = format_instr(instr, labels) line = indent + format_line(index, line) print(line, file=stream) print(file=stream) elif isinstance(bytecode, ControlFlowGraph): labels = {} for block_index, block in enumerate(bytecode, 1): labels[id(block)] = "block%s" % block_index for block_index, block in enumerate(bytecode, 1): print("%s:" % labels[id(block)], file=stream) prev_lineno = None for index, instr in enumerate(block): if instr.lineno is not None: cur_lineno = instr.lineno line = format_instr(instr, labels) line = indent + format_line(index, line) print(line, file=stream) if block.next_block is not None: print(indent + "-> %s" % labels[id(block.next_block)], file=stream) print(file=stream) else: raise TypeError("unknown bytecode class")
4,152
Python
30.70229
89
0.526734
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/bytecode.py
# alias to keep the 'bytecode' variable free import sys from _pydevd_frame_eval.vendored import bytecode as _bytecode from _pydevd_frame_eval.vendored.bytecode.instr import UNSET, Label, SetLineno, Instr from _pydevd_frame_eval.vendored.bytecode.flags import infer_flags class BaseBytecode: def __init__(self): self.argcount = 0 if sys.version_info > (3, 8): self.posonlyargcount = 0 self.kwonlyargcount = 0 self.first_lineno = 1 self.name = "<module>" self.filename = "<string>" self.docstring = UNSET self.cellvars = [] # we cannot recreate freevars from instructions because of super() # special-case self.freevars = [] self._flags = _bytecode.CompilerFlags(0) def _copy_attr_from(self, bytecode): self.argcount = bytecode.argcount if sys.version_info > (3, 8): self.posonlyargcount = bytecode.posonlyargcount self.kwonlyargcount = bytecode.kwonlyargcount self.flags = bytecode.flags self.first_lineno = bytecode.first_lineno self.name = bytecode.name self.filename = bytecode.filename self.docstring = bytecode.docstring self.cellvars = list(bytecode.cellvars) self.freevars = list(bytecode.freevars) def __eq__(self, other): if type(self) != type(other): return False if self.argcount != other.argcount: return False if sys.version_info > (3, 8): if self.posonlyargcount != other.posonlyargcount: return False if self.kwonlyargcount != other.kwonlyargcount: return False if self.flags != other.flags: return False if self.first_lineno != other.first_lineno: return False if self.filename != other.filename: return False if self.name != other.name: return False if self.docstring != other.docstring: return False if self.cellvars != other.cellvars: return False if self.freevars != other.freevars: return False if self.compute_stacksize() != other.compute_stacksize(): return False return True @property def flags(self): return self._flags @flags.setter def flags(self, value): if not isinstance(value, _bytecode.CompilerFlags): value = _bytecode.CompilerFlags(value) self._flags = value def update_flags(self, *, is_async=None): self.flags = infer_flags(self, is_async) class _BaseBytecodeList(BaseBytecode, list): """List subclass providing type stable slicing and copying.""" def __getitem__(self, index): value = super().__getitem__(index) if isinstance(index, slice): value = type(self)(value) value._copy_attr_from(self) return value def copy(self): new = type(self)(super().copy()) new._copy_attr_from(self) return new def legalize(self): """Check that all the element of the list are valid and remove SetLineno.""" lineno_pos = [] set_lineno = None current_lineno = self.first_lineno for pos, instr in enumerate(self): if isinstance(instr, SetLineno): set_lineno = instr.lineno lineno_pos.append(pos) continue # Filter out Labels if not isinstance(instr, Instr): continue if set_lineno is not None: instr.lineno = set_lineno elif instr.lineno is None: instr.lineno = current_lineno else: current_lineno = instr.lineno for i in reversed(lineno_pos): del self[i] def __iter__(self): instructions = super().__iter__() for instr in instructions: self._check_instr(instr) yield instr def _check_instr(self, instr): raise NotImplementedError() class _InstrList(list): def _flat(self): instructions = [] labels = {} jumps = [] offset = 0 for index, instr in enumerate(self): if isinstance(instr, Label): instructions.append("label_instr%s" % index) labels[instr] = offset else: if isinstance(instr, Instr) and isinstance(instr.arg, Label): target_label = instr.arg instr = _bytecode.ConcreteInstr(instr.name, 0, lineno=instr.lineno) jumps.append((target_label, instr)) instructions.append(instr) offset += 1 for target_label, instr in jumps: instr.arg = labels[target_label] return instructions def __eq__(self, other): if not isinstance(other, _InstrList): other = _InstrList(other) return self._flat() == other._flat() class Bytecode(_InstrList, _BaseBytecodeList): def __init__(self, instructions=()): BaseBytecode.__init__(self) self.argnames = [] for instr in instructions: self._check_instr(instr) self.extend(instructions) def __iter__(self): instructions = super().__iter__() for instr in instructions: self._check_instr(instr) yield instr def _check_instr(self, instr): if not isinstance(instr, (Label, SetLineno, Instr)): raise ValueError( "Bytecode must only contain Label, " "SetLineno, and Instr objects, " "but %s was found" % type(instr).__name__ ) def _copy_attr_from(self, bytecode): super()._copy_attr_from(bytecode) if isinstance(bytecode, Bytecode): self.argnames = bytecode.argnames @staticmethod def from_code(code): concrete = _bytecode.ConcreteBytecode.from_code(code) return concrete.to_bytecode() def compute_stacksize(self, *, check_pre_and_post=True): cfg = _bytecode.ControlFlowGraph.from_bytecode(self) return cfg.compute_stacksize(check_pre_and_post=check_pre_and_post) def to_code( self, compute_jumps_passes=None, stacksize=None, *, check_pre_and_post=True ): # Prevent reconverting the concrete bytecode to bytecode and cfg to do the # calculation if we need to do it. if stacksize is None: stacksize = self.compute_stacksize(check_pre_and_post=check_pre_and_post) bc = self.to_concrete_bytecode(compute_jumps_passes=compute_jumps_passes) return bc.to_code(stacksize=stacksize) def to_concrete_bytecode(self, compute_jumps_passes=None): converter = _bytecode._ConvertBytecodeToConcrete(self) return converter.to_concrete_bytecode(compute_jumps_passes=compute_jumps_passes)
6,983
Python
32.099526
88
0.587427
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/cfg.py
import sys # alias to keep the 'bytecode' variable free from _pydevd_frame_eval.vendored import bytecode as _bytecode from _pydevd_frame_eval.vendored.bytecode.concrete import ConcreteInstr from _pydevd_frame_eval.vendored.bytecode.flags import CompilerFlags from _pydevd_frame_eval.vendored.bytecode.instr import Label, SetLineno, Instr class BasicBlock(_bytecode._InstrList): def __init__(self, instructions=None): # a BasicBlock object, or None self.next_block = None if instructions: super().__init__(instructions) def __iter__(self): index = 0 while index < len(self): instr = self[index] index += 1 if not isinstance(instr, (SetLineno, Instr)): raise ValueError( "BasicBlock must only contain SetLineno and Instr objects, " "but %s was found" % instr.__class__.__name__ ) if isinstance(instr, Instr) and instr.has_jump(): if index < len(self): raise ValueError( "Only the last instruction of a basic " "block can be a jump" ) if not isinstance(instr.arg, BasicBlock): raise ValueError( "Jump target must a BasicBlock, got %s", type(instr.arg).__name__, ) yield instr def __getitem__(self, index): value = super().__getitem__(index) if isinstance(index, slice): value = type(self)(value) value.next_block = self.next_block return value def copy(self): new = type(self)(super().copy()) new.next_block = self.next_block return new def legalize(self, first_lineno): """Check that all the element of the list are valid and remove SetLineno.""" lineno_pos = [] set_lineno = None current_lineno = first_lineno for pos, instr in enumerate(self): if isinstance(instr, SetLineno): set_lineno = current_lineno = instr.lineno lineno_pos.append(pos) continue if set_lineno is not None: instr.lineno = set_lineno elif instr.lineno is None: instr.lineno = current_lineno else: current_lineno = instr.lineno for i in reversed(lineno_pos): del self[i] return current_lineno def get_jump(self): if not self: return None last_instr = self[-1] if not (isinstance(last_instr, Instr) and last_instr.has_jump()): return None target_block = last_instr.arg assert isinstance(target_block, BasicBlock) return target_block def _compute_stack_size(block, size, maxsize, *, check_pre_and_post=True): """Generator used to reduce the use of function stacks. This allows to avoid nested recursion and allow to treat more cases. HOW-TO: Following the methods of Trampoline (see https://en.wikipedia.org/wiki/Trampoline_(computing)), We yield either: - the arguments that would be used in the recursive calls, i.e, 'yield block, size, maxsize' instead of making a recursive call '_compute_stack_size(block, size, maxsize)', if we encounter an instruction jumping to another block or if the block is linked to another one (ie `next_block` is set) - the required stack from the stack if we went through all the instructions or encountered an unconditional jump. In the first case, the calling function is then responsible for creating a new generator with those arguments, iterating over it till exhaustion to determine the stacksize required by the block and resuming this function with the determined stacksize. """ # If the block is currently being visited (seen = True) or if it was visited # previously by using a larger starting size than the one in use, return the # maxsize. if block.seen or block.startsize >= size: yield maxsize def update_size(pre_delta, post_delta, size, maxsize): size += pre_delta if size < 0: msg = "Failed to compute stacksize, got negative size" raise RuntimeError(msg) size += post_delta maxsize = max(maxsize, size) return size, maxsize # Prevent recursive visit of block if two blocks are nested (jump from one # to the other). block.seen = True block.startsize = size for instr in block: # Ignore SetLineno if isinstance(instr, SetLineno): continue # For instructions with a jump first compute the stacksize required when the # jump is taken. if instr.has_jump(): effect = ( instr.pre_and_post_stack_effect(jump=True) if check_pre_and_post else (instr.stack_effect(jump=True), 0) ) taken_size, maxsize = update_size(*effect, size, maxsize) # Yield the parameters required to compute the stacksize required # by the block to which the jumnp points to and resume when we now # the maxsize. maxsize = yield instr.arg, taken_size, maxsize # For unconditional jumps abort early since the other instruction will # never be seen. if instr.is_uncond_jump(): block.seen = False yield maxsize # jump=False: non-taken path of jumps, or any non-jump effect = ( instr.pre_and_post_stack_effect(jump=False) if check_pre_and_post else (instr.stack_effect(jump=False), 0) ) size, maxsize = update_size(*effect, size, maxsize) if block.next_block: maxsize = yield block.next_block, size, maxsize block.seen = False yield maxsize class ControlFlowGraph(_bytecode.BaseBytecode): def __init__(self): super().__init__() self._blocks = [] self._block_index = {} self.argnames = [] self.add_block() def legalize(self): """Legalize all blocks.""" current_lineno = self.first_lineno for block in self._blocks: current_lineno = block.legalize(current_lineno) def get_block_index(self, block): try: return self._block_index[id(block)] except KeyError: raise ValueError("the block is not part of this bytecode") def _add_block(self, block): block_index = len(self._blocks) self._blocks.append(block) self._block_index[id(block)] = block_index def add_block(self, instructions=None): block = BasicBlock(instructions) self._add_block(block) return block def compute_stacksize(self, *, check_pre_and_post=True): """Compute the stack size by iterating through the blocks The implementation make use of a generator function to avoid issue with deeply nested recursions. """ # In the absence of any block return 0 if not self: return 0 # Ensure that previous calculation do not impact this one. for block in self: block.seen = False block.startsize = -32768 # INT_MIN # Starting with Python 3.10, generator and coroutines start with one object # on the stack (None, anything is an error). initial_stack_size = 0 if sys.version_info >= (3, 10) and self.flags & ( CompilerFlags.GENERATOR | CompilerFlags.COROUTINE | CompilerFlags.ASYNC_GENERATOR ): initial_stack_size = 1 # Create a generator/coroutine responsible of dealing with the first block coro = _compute_stack_size( self[0], initial_stack_size, 0, check_pre_and_post=check_pre_and_post ) # Create a list of generator that have not yet been exhausted coroutines = [] push_coroutine = coroutines.append pop_coroutine = coroutines.pop args = None try: while True: args = coro.send(None) # Consume the stored generators as long as they return a simple # interger that is to be used to resume the last stored generator. while isinstance(args, int): coro = pop_coroutine() args = coro.send(args) # Otherwise we enter a new block and we store the generator under # use and create a new one to process the new block push_coroutine(coro) coro = _compute_stack_size(*args, check_pre_and_post=check_pre_and_post) except IndexError: # The exception occurs when all the generators have been exhausted # in which case teh last yielded value is the stacksize. assert args is not None return args def __repr__(self): return "<ControlFlowGraph block#=%s>" % len(self._blocks) def get_instructions(self): instructions = [] jumps = [] for block in self: target_block = block.get_jump() if target_block is not None: instr = block[-1] instr = ConcreteInstr(instr.name, 0, lineno=instr.lineno) jumps.append((target_block, instr)) instructions.extend(block[:-1]) instructions.append(instr) else: instructions.extend(block) for target_block, instr in jumps: instr.arg = self.get_block_index(target_block) return instructions def __eq__(self, other): if type(self) != type(other): return False if self.argnames != other.argnames: return False instrs1 = self.get_instructions() instrs2 = other.get_instructions() if instrs1 != instrs2: return False # FIXME: compare block.next_block return super().__eq__(other) def __len__(self): return len(self._blocks) def __iter__(self): return iter(self._blocks) def __getitem__(self, index): if isinstance(index, BasicBlock): index = self.get_block_index(index) return self._blocks[index] def __delitem__(self, index): if isinstance(index, BasicBlock): index = self.get_block_index(index) block = self._blocks[index] del self._blocks[index] del self._block_index[id(block)] for index in range(index, len(self)): block = self._blocks[index] self._block_index[id(block)] -= 1 def split_block(self, block, index): if not isinstance(block, BasicBlock): raise TypeError("expected block") block_index = self.get_block_index(block) if index < 0: raise ValueError("index must be positive") block = self._blocks[block_index] if index == 0: return block if index > len(block): raise ValueError("index out of the block") instructions = block[index:] if not instructions: if block_index + 1 < len(self): return self[block_index + 1] del block[index:] block2 = BasicBlock(instructions) block.next_block = block2 for block in self[block_index + 1 :]: self._block_index[id(block)] += 1 self._blocks.insert(block_index + 1, block2) self._block_index[id(block2)] = block_index + 1 return block2 @staticmethod def from_bytecode(bytecode): # label => instruction index label_to_block_index = {} jumps = [] block_starts = {} for index, instr in enumerate(bytecode): if isinstance(instr, Label): label_to_block_index[instr] = index else: if isinstance(instr, Instr) and isinstance(instr.arg, Label): jumps.append((index, instr.arg)) for target_index, target_label in jumps: target_index = label_to_block_index[target_label] block_starts[target_index] = target_label bytecode_blocks = _bytecode.ControlFlowGraph() bytecode_blocks._copy_attr_from(bytecode) bytecode_blocks.argnames = list(bytecode.argnames) # copy instructions, convert labels to block labels block = bytecode_blocks[0] labels = {} jumps = [] for index, instr in enumerate(bytecode): if index in block_starts: old_label = block_starts[index] if index != 0: new_block = bytecode_blocks.add_block() if not block[-1].is_final(): block.next_block = new_block block = new_block if old_label is not None: labels[old_label] = block elif block and isinstance(block[-1], Instr): if block[-1].is_final(): block = bytecode_blocks.add_block() elif block[-1].has_jump(): new_block = bytecode_blocks.add_block() block.next_block = new_block block = new_block if isinstance(instr, Label): continue # don't copy SetLineno objects if isinstance(instr, Instr): instr = instr.copy() if isinstance(instr.arg, Label): jumps.append(instr) block.append(instr) for instr in jumps: label = instr.arg instr.arg = labels[label] return bytecode_blocks def to_bytecode(self): """Convert to Bytecode.""" used_blocks = set() for block in self: target_block = block.get_jump() if target_block is not None: used_blocks.add(id(target_block)) labels = {} jumps = [] instructions = [] for block in self: if id(block) in used_blocks: new_label = Label() labels[id(block)] = new_label instructions.append(new_label) for instr in block: # don't copy SetLineno objects if isinstance(instr, Instr): instr = instr.copy() if isinstance(instr.arg, BasicBlock): jumps.append(instr) instructions.append(instr) # Map to new labels for instr in jumps: instr.arg = labels[id(instr.arg)] bytecode = _bytecode.Bytecode() bytecode._copy_attr_from(self) bytecode.argnames = list(self.argnames) bytecode[:] = instructions return bytecode def to_code(self, stacksize=None): """Convert to code.""" if stacksize is None: stacksize = self.compute_stacksize() bc = self.to_bytecode() return bc.to_code(stacksize=stacksize)
15,391
Python
32.172414
88
0.563316
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_concrete.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import opcode import sys import textwrap import types import unittest from _pydevd_frame_eval.vendored.bytecode import ( UNSET, Label, Instr, SetLineno, Bytecode, CellVar, FreeVar, CompilerFlags, ConcreteInstr, ConcreteBytecode, ) from _pydevd_frame_eval.vendored.bytecode.concrete import OFFSET_AS_INSTRUCTION from _pydevd_frame_eval.vendored.bytecode.tests import get_code, TestCase class ConcreteInstrTests(TestCase): def test_constructor(self): with self.assertRaises(ValueError): # need an argument ConcreteInstr("LOAD_CONST") with self.assertRaises(ValueError): # must not have an argument ConcreteInstr("ROT_TWO", 33) # invalid argument with self.assertRaises(TypeError): ConcreteInstr("LOAD_CONST", 1.0) with self.assertRaises(ValueError): ConcreteInstr("LOAD_CONST", -1) with self.assertRaises(TypeError): ConcreteInstr("LOAD_CONST", 5, lineno=1.0) with self.assertRaises(ValueError): ConcreteInstr("LOAD_CONST", 5, lineno=-1) # test maximum argument with self.assertRaises(ValueError): ConcreteInstr("LOAD_CONST", 2147483647 + 1) instr = ConcreteInstr("LOAD_CONST", 2147483647) self.assertEqual(instr.arg, 2147483647) # test meaningless extended args instr = ConcreteInstr("LOAD_FAST", 8, lineno=3, extended_args=1) self.assertEqual(instr.name, "LOAD_FAST") self.assertEqual(instr.arg, 8) self.assertEqual(instr.lineno, 3) self.assertEqual(instr.size, 4) def test_attr(self): instr = ConcreteInstr("LOAD_CONST", 5, lineno=12) self.assertEqual(instr.name, "LOAD_CONST") self.assertEqual(instr.opcode, 100) self.assertEqual(instr.arg, 5) self.assertEqual(instr.lineno, 12) self.assertEqual(instr.size, 2) def test_set(self): instr = ConcreteInstr("LOAD_CONST", 5, lineno=3) instr.set("NOP") self.assertEqual(instr.name, "NOP") self.assertIs(instr.arg, UNSET) self.assertEqual(instr.lineno, 3) instr.set("LOAD_FAST", 8) self.assertEqual(instr.name, "LOAD_FAST") self.assertEqual(instr.arg, 8) self.assertEqual(instr.lineno, 3) # invalid with self.assertRaises(ValueError): instr.set("LOAD_CONST") with self.assertRaises(ValueError): instr.set("NOP", 5) def test_set_attr(self): instr = ConcreteInstr("LOAD_CONST", 5, lineno=12) # operator name instr.name = "LOAD_FAST" self.assertEqual(instr.name, "LOAD_FAST") self.assertEqual(instr.opcode, 124) self.assertRaises(TypeError, setattr, instr, "name", 3) self.assertRaises(ValueError, setattr, instr, "name", "xxx") # operator code instr.opcode = 100 self.assertEqual(instr.name, "LOAD_CONST") self.assertEqual(instr.opcode, 100) self.assertRaises(ValueError, setattr, instr, "opcode", -12) self.assertRaises(TypeError, setattr, instr, "opcode", "abc") # extended argument instr.arg = 0x1234ABCD self.assertEqual(instr.arg, 0x1234ABCD) self.assertEqual(instr.size, 8) # small argument instr.arg = 0 self.assertEqual(instr.arg, 0) self.assertEqual(instr.size, 2) # invalid argument self.assertRaises(ValueError, setattr, instr, "arg", -1) self.assertRaises(ValueError, setattr, instr, "arg", 2147483647 + 1) # size attribute is read-only self.assertRaises(AttributeError, setattr, instr, "size", 3) # lineno instr.lineno = 33 self.assertEqual(instr.lineno, 33) self.assertRaises(TypeError, setattr, instr, "lineno", 1.0) self.assertRaises(ValueError, setattr, instr, "lineno", -1) def test_size(self): self.assertEqual(ConcreteInstr("ROT_TWO").size, 2) self.assertEqual(ConcreteInstr("LOAD_CONST", 3).size, 2) self.assertEqual(ConcreteInstr("LOAD_CONST", 0x1234ABCD).size, 8) def test_disassemble(self): code = b"\t\x00d\x03" instr = ConcreteInstr.disassemble(1, code, 0) self.assertEqual(instr, ConcreteInstr("NOP", lineno=1)) instr = ConcreteInstr.disassemble(2, code, 1 if OFFSET_AS_INSTRUCTION else 2) self.assertEqual(instr, ConcreteInstr("LOAD_CONST", 3, lineno=2)) code = b"\x90\x12\x904\x90\xabd\xcd" instr = ConcreteInstr.disassemble(3, code, 0) self.assertEqual(instr, ConcreteInstr("EXTENDED_ARG", 0x12, lineno=3)) def test_assemble(self): instr = ConcreteInstr("NOP") self.assertEqual(instr.assemble(), b"\t\x00") instr = ConcreteInstr("LOAD_CONST", 3) self.assertEqual(instr.assemble(), b"d\x03") instr = ConcreteInstr("LOAD_CONST", 0x1234ABCD) self.assertEqual( instr.assemble(), (b"\x90\x12\x904\x90\xabd\xcd"), ) instr = ConcreteInstr("LOAD_CONST", 3, extended_args=1) self.assertEqual( instr.assemble(), (b"\x90\x00d\x03"), ) def test_get_jump_target(self): jump_abs = ConcreteInstr("JUMP_ABSOLUTE", 3) self.assertEqual(jump_abs.get_jump_target(100), 3) jump_forward = ConcreteInstr("JUMP_FORWARD", 5) self.assertEqual( jump_forward.get_jump_target(10), 16 if OFFSET_AS_INSTRUCTION else 17 ) class ConcreteBytecodeTests(TestCase): def test_repr(self): r = repr(ConcreteBytecode()) self.assertIn("ConcreteBytecode", r) self.assertIn("0", r) def test_eq(self): code = ConcreteBytecode() self.assertFalse(code == 1) for name, val in ( ("names", ["a"]), ("varnames", ["a"]), ("consts", [1]), ("argcount", 1), ("kwonlyargcount", 2), ("flags", CompilerFlags(CompilerFlags.GENERATOR)), ("first_lineno", 10), ("filename", "xxxx.py"), ("name", "__x"), ("docstring", "x-x-x"), ("cellvars", [CellVar("x")]), ("freevars", [FreeVar("x")]), ): c = ConcreteBytecode() setattr(c, name, val) # For obscure reasons using assertNotEqual here fail self.assertFalse(code == c) if sys.version_info > (3, 8): c = ConcreteBytecode() c.posonlyargcount = 10 self.assertFalse(code == c) c = ConcreteBytecode() c.consts = [1] code.consts = [1] c.append(ConcreteInstr("LOAD_CONST", 0)) self.assertFalse(code == c) def test_attr(self): code_obj = get_code("x = 5") code = ConcreteBytecode.from_code(code_obj) self.assertEqual(code.consts, [5, None]) self.assertEqual(code.names, ["x"]) self.assertEqual(code.varnames, []) self.assertEqual(code.freevars, []) self.assertListEqual( list(code), [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("STORE_NAME", 0, lineno=1), ConcreteInstr("LOAD_CONST", 1, lineno=1), ConcreteInstr("RETURN_VALUE", lineno=1), ], ) # FIXME: test other attributes def test_invalid_types(self): code = ConcreteBytecode() code.append(Label()) with self.assertRaises(ValueError): list(code) with self.assertRaises(ValueError): code.legalize() with self.assertRaises(ValueError): ConcreteBytecode([Label()]) def test_to_code_lnotab(self): # We use an actual function for the simple case to # ensure we get lnotab right def f(): # # x = 7 # noqa y = 8 # noqa z = 9 # noqa fl = f.__code__.co_firstlineno concrete = ConcreteBytecode() concrete.consts = [None, 7, 8, 9] concrete.varnames = ["x", "y", "z"] concrete.first_lineno = fl concrete.extend( [ SetLineno(fl + 3), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_FAST", 0), SetLineno(fl + 4), ConcreteInstr("LOAD_CONST", 2), ConcreteInstr("STORE_FAST", 1), SetLineno(fl + 5), ConcreteInstr("LOAD_CONST", 3), ConcreteInstr("STORE_FAST", 2), ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("RETURN_VALUE"), ] ) code = concrete.to_code() self.assertEqual(code.co_code, f.__code__.co_code) self.assertEqual(code.co_lnotab, f.__code__.co_lnotab) if sys.version_info >= (3, 10): self.assertEqual(code.co_linetable, f.__code__.co_linetable) def test_negative_lnotab(self): # x = 7 # y = 8 concrete = ConcreteBytecode( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), # line number goes backward! SetLineno(2), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_NAME", 1), ] ) concrete.consts = [7, 8] concrete.names = ["x", "y"] concrete.first_lineno = 5 code = concrete.to_code() expected = b"d\x00Z\x00d\x01Z\x01" self.assertEqual(code.co_code, expected) self.assertEqual(code.co_firstlineno, 5) self.assertEqual(code.co_lnotab, b"\x04\xfd") def test_extended_lnotab(self): # x = 7 # 200 blank lines # y = 8 concrete = ConcreteBytecode( [ ConcreteInstr("LOAD_CONST", 0), SetLineno(1 + 128), ConcreteInstr("STORE_NAME", 0), # line number goes backward! SetLineno(1 + 129), ConcreteInstr("LOAD_CONST", 1), SetLineno(1), ConcreteInstr("STORE_NAME", 1), ] ) concrete.consts = [7, 8] concrete.names = ["x", "y"] concrete.first_lineno = 1 code = concrete.to_code() expected = b"d\x00Z\x00d\x01Z\x01" self.assertEqual(code.co_code, expected) self.assertEqual(code.co_firstlineno, 1) self.assertEqual(code.co_lnotab, b"\x02\x7f\x00\x01\x02\x01\x02\x80\x00\xff") def test_extended_lnotab2(self): # x = 7 # 200 blank lines # y = 8 base_code = compile("x = 7" + "\n" * 200 + "y = 8", "", "exec") concrete = ConcreteBytecode( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), SetLineno(201), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_NAME", 1), ConcreteInstr("LOAD_CONST", 2), ConcreteInstr("RETURN_VALUE"), ] ) concrete.consts = [None, 7, 8] concrete.names = ["x", "y"] concrete.first_lineno = 1 code = concrete.to_code() self.assertEqual(code.co_code, base_code.co_code) self.assertEqual(code.co_firstlineno, base_code.co_firstlineno) self.assertEqual(code.co_lnotab, base_code.co_lnotab) if sys.version_info >= (3, 10): self.assertEqual(code.co_linetable, base_code.co_linetable) def test_to_bytecode_consts(self): # x = -0.0 # x = +0.0 # # code optimized by the CPython 3.6 peephole optimizer which emits # duplicated constants (0.0 is twice in consts). code = ConcreteBytecode() code.consts = [0.0, None, -0.0, 0.0] code.names = ["x", "y"] code.extend( [ ConcreteInstr("LOAD_CONST", 2, lineno=1), ConcreteInstr("STORE_NAME", 0, lineno=1), ConcreteInstr("LOAD_CONST", 3, lineno=2), ConcreteInstr("STORE_NAME", 1, lineno=2), ConcreteInstr("LOAD_CONST", 1, lineno=2), ConcreteInstr("RETURN_VALUE", lineno=2), ] ) code = code.to_bytecode().to_concrete_bytecode() # the conversion changes the constant order: the order comes from # the order of LOAD_CONST instructions self.assertEqual(code.consts, [-0.0, 0.0, None]) code.names = ["x", "y"] self.assertListEqual( list(code), [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("STORE_NAME", 0, lineno=1), ConcreteInstr("LOAD_CONST", 1, lineno=2), ConcreteInstr("STORE_NAME", 1, lineno=2), ConcreteInstr("LOAD_CONST", 2, lineno=2), ConcreteInstr("RETURN_VALUE", lineno=2), ], ) def test_cellvar(self): concrete = ConcreteBytecode() concrete.cellvars = ["x"] concrete.append(ConcreteInstr("LOAD_DEREF", 0)) code = concrete.to_code() concrete = ConcreteBytecode.from_code(code) self.assertEqual(concrete.cellvars, ["x"]) self.assertEqual(concrete.freevars, []) self.assertEqual(list(concrete), [ConcreteInstr("LOAD_DEREF", 0, lineno=1)]) bytecode = concrete.to_bytecode() self.assertEqual(bytecode.cellvars, ["x"]) self.assertEqual(list(bytecode), [Instr("LOAD_DEREF", CellVar("x"), lineno=1)]) def test_freevar(self): concrete = ConcreteBytecode() concrete.freevars = ["x"] concrete.append(ConcreteInstr("LOAD_DEREF", 0)) code = concrete.to_code() concrete = ConcreteBytecode.from_code(code) self.assertEqual(concrete.cellvars, []) self.assertEqual(concrete.freevars, ["x"]) self.assertEqual(list(concrete), [ConcreteInstr("LOAD_DEREF", 0, lineno=1)]) bytecode = concrete.to_bytecode() self.assertEqual(bytecode.cellvars, []) self.assertEqual(list(bytecode), [Instr("LOAD_DEREF", FreeVar("x"), lineno=1)]) def test_cellvar_freevar(self): concrete = ConcreteBytecode() concrete.cellvars = ["cell"] concrete.freevars = ["free"] concrete.append(ConcreteInstr("LOAD_DEREF", 0)) concrete.append(ConcreteInstr("LOAD_DEREF", 1)) code = concrete.to_code() concrete = ConcreteBytecode.from_code(code) self.assertEqual(concrete.cellvars, ["cell"]) self.assertEqual(concrete.freevars, ["free"]) self.assertEqual( list(concrete), [ ConcreteInstr("LOAD_DEREF", 0, lineno=1), ConcreteInstr("LOAD_DEREF", 1, lineno=1), ], ) bytecode = concrete.to_bytecode() self.assertEqual(bytecode.cellvars, ["cell"]) self.assertEqual( list(bytecode), [ Instr("LOAD_DEREF", CellVar("cell"), lineno=1), Instr("LOAD_DEREF", FreeVar("free"), lineno=1), ], ) def test_load_classderef(self): concrete = ConcreteBytecode() concrete.cellvars = ["__class__"] concrete.freevars = ["__class__"] concrete.extend( [ConcreteInstr("LOAD_CLASSDEREF", 1), ConcreteInstr("STORE_DEREF", 1)] ) bytecode = concrete.to_bytecode() self.assertEqual(bytecode.freevars, ["__class__"]) self.assertEqual(bytecode.cellvars, ["__class__"]) self.assertEqual( list(bytecode), [ Instr("LOAD_CLASSDEREF", FreeVar("__class__"), lineno=1), Instr("STORE_DEREF", FreeVar("__class__"), lineno=1), ], ) concrete = bytecode.to_concrete_bytecode() self.assertEqual(concrete.freevars, ["__class__"]) self.assertEqual(concrete.cellvars, ["__class__"]) self.assertEqual( list(concrete), [ ConcreteInstr("LOAD_CLASSDEREF", 1, lineno=1), ConcreteInstr("STORE_DEREF", 1, lineno=1), ], ) code = concrete.to_code() self.assertEqual(code.co_freevars, ("__class__",)) self.assertEqual(code.co_cellvars, ("__class__",)) self.assertEqual( code.co_code, b"\x94\x01\x89\x01", ) def test_explicit_stacksize(self): # Passing stacksize=... to ConcreteBytecode.to_code should result in a # code object with the specified stacksize. We pass some silly values # and assert that they are honored. code_obj = get_code("print('%s' % (a,b,c))") original_stacksize = code_obj.co_stacksize concrete = ConcreteBytecode.from_code(code_obj) # First with something bigger than necessary. explicit_stacksize = original_stacksize + 42 new_code_obj = concrete.to_code(stacksize=explicit_stacksize) self.assertEqual(new_code_obj.co_stacksize, explicit_stacksize) # Then with something bogus. We probably don't want to advertise this # in the documentation. If this fails then decide if it's for good # reason, and remove if so. explicit_stacksize = 0 new_code_obj = concrete.to_code(stacksize=explicit_stacksize) self.assertEqual(new_code_obj.co_stacksize, explicit_stacksize) def test_legalize(self): concrete = ConcreteBytecode() concrete.first_lineno = 3 concrete.consts = [7, 8, 9] concrete.names = ["x", "y", "z"] concrete.extend( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), ConcreteInstr("LOAD_CONST", 1, lineno=4), ConcreteInstr("STORE_NAME", 1), SetLineno(5), ConcreteInstr("LOAD_CONST", 2, lineno=6), ConcreteInstr("STORE_NAME", 2), ] ) concrete.legalize() self.assertListEqual( list(concrete), [ ConcreteInstr("LOAD_CONST", 0, lineno=3), ConcreteInstr("STORE_NAME", 0, lineno=3), ConcreteInstr("LOAD_CONST", 1, lineno=4), ConcreteInstr("STORE_NAME", 1, lineno=4), ConcreteInstr("LOAD_CONST", 2, lineno=5), ConcreteInstr("STORE_NAME", 2, lineno=5), ], ) def test_slice(self): concrete = ConcreteBytecode() concrete.first_lineno = 3 concrete.consts = [7, 8, 9] concrete.names = ["x", "y", "z"] concrete.extend( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), SetLineno(4), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_NAME", 1), SetLineno(5), ConcreteInstr("LOAD_CONST", 2), ConcreteInstr("STORE_NAME", 2), ] ) self.assertEqual(concrete, concrete[:]) def test_copy(self): concrete = ConcreteBytecode() concrete.first_lineno = 3 concrete.consts = [7, 8, 9] concrete.names = ["x", "y", "z"] concrete.extend( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), SetLineno(4), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_NAME", 1), SetLineno(5), ConcreteInstr("LOAD_CONST", 2), ConcreteInstr("STORE_NAME", 2), ] ) self.assertEqual(concrete, concrete.copy()) class ConcreteFromCodeTests(TestCase): def test_extended_arg(self): # Create a code object from arbitrary bytecode co_code = b"\x90\x12\x904\x90\xabd\xcd" code = get_code("x=1") args = ( (code.co_argcount,) if sys.version_info < (3, 8) else (code.co_argcount, code.co_posonlyargcount) ) args += ( code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize, code.co_flags, co_code, code.co_consts, code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_linetable if sys.version_info >= (3, 10) else code.co_lnotab, code.co_freevars, code.co_cellvars, ) code = types.CodeType(*args) # without EXTENDED_ARG opcode bytecode = ConcreteBytecode.from_code(code) self.assertListEqual( list(bytecode), [ConcreteInstr("LOAD_CONST", 0x1234ABCD, lineno=1)] ) # with EXTENDED_ARG opcode bytecode = ConcreteBytecode.from_code(code, extended_arg=True) expected = [ ConcreteInstr("EXTENDED_ARG", 0x12, lineno=1), ConcreteInstr("EXTENDED_ARG", 0x34, lineno=1), ConcreteInstr("EXTENDED_ARG", 0xAB, lineno=1), ConcreteInstr("LOAD_CONST", 0xCD, lineno=1), ] self.assertListEqual(list(bytecode), expected) def test_extended_arg_make_function(self): if (3, 9) <= sys.version_info < (3, 10): from _pydevd_frame_eval.vendored.bytecode.tests.util_annotation import get_code as get_code_future code_obj = get_code_future( """ def foo(x: int, y: int): pass """ ) else: code_obj = get_code( """ def foo(x: int, y: int): pass """ ) # without EXTENDED_ARG concrete = ConcreteBytecode.from_code(code_obj) if sys.version_info >= (3, 10): func_code = concrete.consts[2] names = ["int", "foo"] consts = ["x", "y", func_code, "foo", None] const_offset = 1 name_offset = 1 first_instrs = [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr("LOAD_CONST", 1, lineno=1), ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr("BUILD_TUPLE", 4, lineno=1), ] elif ( sys.version_info >= (3, 7) and concrete.flags & CompilerFlags.FUTURE_ANNOTATIONS ): func_code = concrete.consts[2] names = ["foo"] consts = ["int", ("x", "y"), func_code, "foo", None] const_offset = 1 name_offset = 0 first_instrs = [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("LOAD_CONST", 0 + const_offset, lineno=1), ConcreteInstr("BUILD_CONST_KEY_MAP", 2, lineno=1), ] else: func_code = concrete.consts[1] names = ["int", "foo"] consts = [("x", "y"), func_code, "foo", None] const_offset = 0 name_offset = 1 first_instrs = [ ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr("LOAD_CONST", 0 + const_offset, lineno=1), ConcreteInstr("BUILD_CONST_KEY_MAP", 2, lineno=1), ] self.assertEqual(concrete.names, names) self.assertEqual(concrete.consts, consts) expected = first_instrs + [ ConcreteInstr("LOAD_CONST", 1 + const_offset, lineno=1), ConcreteInstr("LOAD_CONST", 2 + const_offset, lineno=1), ConcreteInstr("MAKE_FUNCTION", 4, lineno=1), ConcreteInstr("STORE_NAME", name_offset, lineno=1), ConcreteInstr("LOAD_CONST", 3 + const_offset, lineno=1), ConcreteInstr("RETURN_VALUE", lineno=1), ] self.assertListEqual(list(concrete), expected) # with EXTENDED_ARG concrete = ConcreteBytecode.from_code(code_obj, extended_arg=True) # With future annotation the int annotation is stringified and # stored as constant this the default behavior under Python 3.10 if sys.version_info >= (3, 10): func_code = concrete.consts[2] names = ["int", "foo"] consts = ["x", "y", func_code, "foo", None] elif concrete.flags & CompilerFlags.FUTURE_ANNOTATIONS: func_code = concrete.consts[2] names = ["foo"] consts = ["int", ("x", "y"), func_code, "foo", None] else: func_code = concrete.consts[1] names = ["int", "foo"] consts = [("x", "y"), func_code, "foo", None] self.assertEqual(concrete.names, names) self.assertEqual(concrete.consts, consts) self.assertListEqual(list(concrete), expected) # The next three tests ensure we can round trip ConcreteBytecode generated # with extended_args=True def test_extended_arg_unpack_ex(self): def test(): p = [1, 2, 3, 4, 5, 6] q, r, *s, t = p return q, r, s, t cpython_stacksize = test.__code__.co_stacksize test.__code__ = ConcreteBytecode.from_code( test.__code__, extended_arg=True ).to_code() self.assertEqual(test.__code__.co_stacksize, cpython_stacksize) self.assertEqual(test(), (1, 2, [3, 4, 5], 6)) def test_expected_arg_with_many_consts(self): def test(): var = 0 var = 1 var = 2 var = 3 var = 4 var = 5 var = 6 var = 7 var = 8 var = 9 var = 10 var = 11 var = 12 var = 13 var = 14 var = 15 var = 16 var = 17 var = 18 var = 19 var = 20 var = 21 var = 22 var = 23 var = 24 var = 25 var = 26 var = 27 var = 28 var = 29 var = 30 var = 31 var = 32 var = 33 var = 34 var = 35 var = 36 var = 37 var = 38 var = 39 var = 40 var = 41 var = 42 var = 43 var = 44 var = 45 var = 46 var = 47 var = 48 var = 49 var = 50 var = 51 var = 52 var = 53 var = 54 var = 55 var = 56 var = 57 var = 58 var = 59 var = 60 var = 61 var = 62 var = 63 var = 64 var = 65 var = 66 var = 67 var = 68 var = 69 var = 70 var = 71 var = 72 var = 73 var = 74 var = 75 var = 76 var = 77 var = 78 var = 79 var = 80 var = 81 var = 82 var = 83 var = 84 var = 85 var = 86 var = 87 var = 88 var = 89 var = 90 var = 91 var = 92 var = 93 var = 94 var = 95 var = 96 var = 97 var = 98 var = 99 var = 100 var = 101 var = 102 var = 103 var = 104 var = 105 var = 106 var = 107 var = 108 var = 109 var = 110 var = 111 var = 112 var = 113 var = 114 var = 115 var = 116 var = 117 var = 118 var = 119 var = 120 var = 121 var = 122 var = 123 var = 124 var = 125 var = 126 var = 127 var = 128 var = 129 var = 130 var = 131 var = 132 var = 133 var = 134 var = 135 var = 136 var = 137 var = 138 var = 139 var = 140 var = 141 var = 142 var = 143 var = 144 var = 145 var = 146 var = 147 var = 148 var = 149 var = 150 var = 151 var = 152 var = 153 var = 154 var = 155 var = 156 var = 157 var = 158 var = 159 var = 160 var = 161 var = 162 var = 163 var = 164 var = 165 var = 166 var = 167 var = 168 var = 169 var = 170 var = 171 var = 172 var = 173 var = 174 var = 175 var = 176 var = 177 var = 178 var = 179 var = 180 var = 181 var = 182 var = 183 var = 184 var = 185 var = 186 var = 187 var = 188 var = 189 var = 190 var = 191 var = 192 var = 193 var = 194 var = 195 var = 196 var = 197 var = 198 var = 199 var = 200 var = 201 var = 202 var = 203 var = 204 var = 205 var = 206 var = 207 var = 208 var = 209 var = 210 var = 211 var = 212 var = 213 var = 214 var = 215 var = 216 var = 217 var = 218 var = 219 var = 220 var = 221 var = 222 var = 223 var = 224 var = 225 var = 226 var = 227 var = 228 var = 229 var = 230 var = 231 var = 232 var = 233 var = 234 var = 235 var = 236 var = 237 var = 238 var = 239 var = 240 var = 241 var = 242 var = 243 var = 244 var = 245 var = 246 var = 247 var = 248 var = 249 var = 250 var = 251 var = 252 var = 253 var = 254 var = 255 var = 256 var = 257 var = 258 var = 259 return var test.__code__ = ConcreteBytecode.from_code( test.__code__, extended_arg=True ).to_code() self.assertEqual(test.__code__.co_stacksize, 1) self.assertEqual(test(), 259) if sys.version_info >= (3, 6): def test_fail_extended_arg_jump(self): def test(): var = None for _ in range(0, 1): var = 0 var = 1 var = 2 var = 3 var = 4 var = 5 var = 6 var = 7 var = 8 var = 9 var = 10 var = 11 var = 12 var = 13 var = 14 var = 15 var = 16 var = 17 var = 18 var = 19 var = 20 var = 21 var = 22 var = 23 var = 24 var = 25 var = 26 var = 27 var = 28 var = 29 var = 30 var = 31 var = 32 var = 33 var = 34 var = 35 var = 36 var = 37 var = 38 var = 39 var = 40 var = 41 var = 42 var = 43 var = 44 var = 45 var = 46 var = 47 var = 48 var = 49 var = 50 var = 51 var = 52 var = 53 var = 54 var = 55 var = 56 var = 57 var = 58 var = 59 var = 60 var = 61 var = 62 var = 63 var = 64 var = 65 var = 66 var = 67 var = 68 var = 69 var = 70 return var # Generate the bytecode with extended arguments bytecode = ConcreteBytecode.from_code(test.__code__, extended_arg=True) bytecode.to_code() class BytecodeToConcreteTests(TestCase): def test_label(self): code = Bytecode() label = Label() code.extend( [ Instr("LOAD_CONST", "hello", lineno=1), Instr("JUMP_FORWARD", label, lineno=1), label, Instr("POP_TOP", lineno=1), ] ) code = code.to_concrete_bytecode() expected = [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("JUMP_FORWARD", 0, lineno=1), ConcreteInstr("POP_TOP", lineno=1), ] self.assertListEqual(list(code), expected) self.assertListEqual(code.consts, ["hello"]) def test_label2(self): bytecode = Bytecode() label = Label() bytecode.extend( [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label), Instr("LOAD_CONST", 5, lineno=2), Instr("STORE_NAME", "x"), Instr("JUMP_FORWARD", label), Instr("LOAD_CONST", 7, lineno=4), Instr("STORE_NAME", "x"), label, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) concrete = bytecode.to_concrete_bytecode() expected = [ ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr( "POP_JUMP_IF_FALSE", 7 if OFFSET_AS_INSTRUCTION else 14, lineno=1 ), ConcreteInstr("LOAD_CONST", 0, lineno=2), ConcreteInstr("STORE_NAME", 1, lineno=2), ConcreteInstr("JUMP_FORWARD", 2 if OFFSET_AS_INSTRUCTION else 4, lineno=2), ConcreteInstr("LOAD_CONST", 1, lineno=4), ConcreteInstr("STORE_NAME", 1, lineno=4), ConcreteInstr("LOAD_CONST", 2, lineno=4), ConcreteInstr("RETURN_VALUE", lineno=4), ] self.assertListEqual(list(concrete), expected) self.assertListEqual(concrete.consts, [5, 7, None]) self.assertListEqual(concrete.names, ["test", "x"]) self.assertListEqual(concrete.varnames, []) def test_label3(self): """ CPython generates useless EXTENDED_ARG 0 in some cases. We need to properly track them as otherwise we can end up with broken offset for jumps. """ source = """ def func(x): if x == 1: return x + 0 elif x == 2: return x + 1 elif x == 3: return x + 2 elif x == 4: return x + 3 elif x == 5: return x + 4 elif x == 6: return x + 5 elif x == 7: return x + 6 elif x == 8: return x + 7 elif x == 9: return x + 8 elif x == 10: return x + 9 elif x == 11: return x + 10 elif x == 12: return x + 11 elif x == 13: return x + 12 elif x == 14: return x + 13 elif x == 15: return x + 14 elif x == 16: return x + 15 elif x == 17: return x + 16 return -1 """ code = get_code(source, function=True) bcode = Bytecode.from_code(code) concrete = bcode.to_concrete_bytecode() self.assertIsInstance(concrete, ConcreteBytecode) # Ensure that we do not generate broken code loc = {} exec(textwrap.dedent(source), loc) func = loc["func"] func.__code__ = bcode.to_code() for i, x in enumerate(range(1, 18)): self.assertEqual(func(x), x + i) self.assertEqual(func(18), -1) # Ensure that we properly round trip in such cases self.assertEqual( ConcreteBytecode.from_code(code).to_code().co_code, code.co_code ) def test_setlineno(self): # x = 7 # y = 8 # z = 9 concrete = ConcreteBytecode() concrete.consts = [7, 8, 9] concrete.names = ["x", "y", "z"] concrete.first_lineno = 3 concrete.extend( [ ConcreteInstr("LOAD_CONST", 0), ConcreteInstr("STORE_NAME", 0), SetLineno(4), ConcreteInstr("LOAD_CONST", 1), ConcreteInstr("STORE_NAME", 1), SetLineno(5), ConcreteInstr("LOAD_CONST", 2), ConcreteInstr("STORE_NAME", 2), ] ) code = concrete.to_bytecode() self.assertEqual( code, [ Instr("LOAD_CONST", 7, lineno=3), Instr("STORE_NAME", "x", lineno=3), Instr("LOAD_CONST", 8, lineno=4), Instr("STORE_NAME", "y", lineno=4), Instr("LOAD_CONST", 9, lineno=5), Instr("STORE_NAME", "z", lineno=5), ], ) def test_extended_jump(self): NOP = bytes((opcode.opmap["NOP"],)) class BigInstr(ConcreteInstr): def __init__(self, size): super().__init__("NOP") self._size = size def copy(self): return self def assemble(self): return NOP * self._size # (invalid) code using jumps > 0xffff to test extended arg label = Label() nb_nop = 2 ** 16 code = Bytecode( [ Instr("JUMP_ABSOLUTE", label), BigInstr(nb_nop), label, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) code_obj = code.to_code() if OFFSET_AS_INSTRUCTION: expected = b"\x90\x80q\x02" + NOP * nb_nop + b"d\x00S\x00" else: expected = b"\x90\x01\x90\x00q\x06" + NOP * nb_nop + b"d\x00S\x00" self.assertEqual(code_obj.co_code, expected) def test_jumps(self): # if test: # x = 12 # else: # x = 37 code = Bytecode() label_else = Label() label_return = Label() code.extend( [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label_else), Instr("LOAD_CONST", 12, lineno=2), Instr("STORE_NAME", "x"), Instr("JUMP_FORWARD", label_return), label_else, Instr("LOAD_CONST", 37, lineno=4), Instr("STORE_NAME", "x"), label_return, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE"), ] ) code = code.to_concrete_bytecode() expected = [ ConcreteInstr("LOAD_NAME", 0, lineno=1), ConcreteInstr( "POP_JUMP_IF_FALSE", 5 if OFFSET_AS_INSTRUCTION else 10, lineno=1 ), ConcreteInstr("LOAD_CONST", 0, lineno=2), ConcreteInstr("STORE_NAME", 1, lineno=2), ConcreteInstr("JUMP_FORWARD", 2 if OFFSET_AS_INSTRUCTION else 4, lineno=2), ConcreteInstr("LOAD_CONST", 1, lineno=4), ConcreteInstr("STORE_NAME", 1, lineno=4), ConcreteInstr("LOAD_CONST", 2, lineno=4), ConcreteInstr("RETURN_VALUE", lineno=4), ] self.assertListEqual(list(code), expected) self.assertListEqual(code.consts, [12, 37, None]) self.assertListEqual(code.names, ["test", "x"]) self.assertListEqual(code.varnames, []) def test_dont_merge_constants(self): # test two constants which are equal but have a different type code = Bytecode() code.extend( [ Instr("LOAD_CONST", 5, lineno=1), Instr("LOAD_CONST", 5.0, lineno=1), Instr("LOAD_CONST", -0.0, lineno=1), Instr("LOAD_CONST", +0.0, lineno=1), ] ) code = code.to_concrete_bytecode() expected = [ ConcreteInstr("LOAD_CONST", 0, lineno=1), ConcreteInstr("LOAD_CONST", 1, lineno=1), ConcreteInstr("LOAD_CONST", 2, lineno=1), ConcreteInstr("LOAD_CONST", 3, lineno=1), ] self.assertListEqual(list(code), expected) self.assertListEqual(code.consts, [5, 5.0, -0.0, +0.0]) def test_cellvars(self): code = Bytecode() code.cellvars = ["x"] code.freevars = ["y"] code.extend( [ Instr("LOAD_DEREF", CellVar("x"), lineno=1), Instr("LOAD_DEREF", FreeVar("y"), lineno=1), ] ) concrete = code.to_concrete_bytecode() self.assertEqual(concrete.cellvars, ["x"]) self.assertEqual(concrete.freevars, ["y"]) code.extend( [ ConcreteInstr("LOAD_DEREF", 0, lineno=1), ConcreteInstr("LOAD_DEREF", 1, lineno=1), ] ) def test_compute_jumps_convergence(self): # Consider the following sequence of instructions: # # JUMP_ABSOLUTE Label1 # JUMP_ABSOLUTE Label2 # ...126 instructions... # Label1: Offset 254 on first pass, 256 second pass # NOP # ... many more instructions ... # Label2: Offset > 256 on first pass # # On first pass of compute_jumps(), Label2 will be at address 254, so # that value encodes into the single byte arg of JUMP_ABSOLUTE. # # On second pass compute_jumps() the instr at Label1 will have offset # of 256 so will also be given an EXTENDED_ARG. # # Thus we need to make an additional pass. This test only verifies # case where 2 passes is insufficient but three is enough. # # On Python > 3.10 we need to double the number since the offset is now # in term of instructions and not bytes. # Create code from comment above. code = Bytecode() label1 = Label() label2 = Label() nop = "NOP" code.append(Instr("JUMP_ABSOLUTE", label1)) code.append(Instr("JUMP_ABSOLUTE", label2)) # Need 254 * 2 + 2 since the arg will change by 1 instruction rather than 2 # bytes. for x in range(4, 510 if OFFSET_AS_INSTRUCTION else 254, 2): code.append(Instr(nop)) code.append(label1) code.append(Instr(nop)) for x in range( 514 if OFFSET_AS_INSTRUCTION else 256, 600 if OFFSET_AS_INSTRUCTION else 300, 2, ): code.append(Instr(nop)) code.append(label2) code.append(Instr(nop)) # This should pass by default. code.to_code() # Try with max of two passes: it should raise with self.assertRaises(RuntimeError): code.to_code(compute_jumps_passes=2) def test_extreme_compute_jumps_convergence(self): """Test of compute_jumps() requiring absurd number of passes. NOTE: This test also serves to demonstrate that there is no worst case: the number of passes can be unlimited (or, actually, limited by the size of the provided code). This is an extension of test_compute_jumps_convergence. Instead of two jumps, where the earlier gets extended after the latter, we instead generate a series of many jumps. Each pass of compute_jumps() extends one more instruction, which in turn causes the one behind it to be extended on the next pass. """ # N: the number of unextended instructions that can be squeezed into a # set of bytes adressable by the arg of an unextended instruction. # The answer is "128", but here's how we arrive at it. max_unextended_offset = 1 << 8 unextended_branch_instr_size = 2 N = max_unextended_offset // unextended_branch_instr_size # When using instruction rather than bytes in the offset multiply by 2 if OFFSET_AS_INSTRUCTION: N *= 2 nop = "UNARY_POSITIVE" # don't use NOP, dis.stack_effect will raise # The number of jumps will be equal to the number of labels. The # number of passes of compute_jumps() required will be one greater # than this. labels = [Label() for x in range(0, 3 * N)] code = Bytecode() code.extend( Instr("JUMP_FORWARD", labels[len(labels) - x - 1]) for x in range(0, len(labels)) ) end_of_jumps = len(code) code.extend(Instr(nop) for x in range(0, N)) # Now insert the labels. The first is N instructions (i.e. 256 # bytes) after the last jump. Then they proceed to earlier positions # 4 bytes at a time. While the targets are in the range of the nop # instructions, 4 bytes is two instructions. When the targets are in # the range of JUMP_FORWARD instructions we have to allow for the fact # that the instructions will have been extended to four bytes each, so # working backwards 4 bytes per label means just one instruction per # label. offset = end_of_jumps + N for index in range(0, len(labels)): code.insert(offset, labels[index]) if offset <= end_of_jumps: offset -= 1 else: offset -= 2 code.insert(0, Instr("LOAD_CONST", 0)) del end_of_jumps code.append(Instr("RETURN_VALUE")) code.to_code(compute_jumps_passes=(len(labels) + 1)) def test_general_constants(self): """Test if general object could be linked as constants.""" class CustomObject: pass class UnHashableCustomObject: __hash__ = None obj1 = [1, 2, 3] obj2 = {1, 2, 3} obj3 = CustomObject() obj4 = UnHashableCustomObject() code = Bytecode( [ Instr("LOAD_CONST", obj1, lineno=1), Instr("LOAD_CONST", obj2, lineno=1), Instr("LOAD_CONST", obj3, lineno=1), Instr("LOAD_CONST", obj4, lineno=1), Instr("BUILD_TUPLE", 4, lineno=1), Instr("RETURN_VALUE", lineno=1), ] ) self.assertEqual(code.to_code().co_consts, (obj1, obj2, obj3, obj4)) def f(): return # pragma: no cover f.__code__ = code.to_code() self.assertEqual(f(), (obj1, obj2, obj3, obj4)) if __name__ == "__main__": unittest.main() # pragma: no cover
49,634
Python
31.784016
126
0.486219
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_instr.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import opcode import unittest from _pydevd_frame_eval.vendored.bytecode import ( UNSET, Label, Instr, CellVar, FreeVar, BasicBlock, SetLineno, Compare, ) from _pydevd_frame_eval.vendored.bytecode.tests import TestCase class SetLinenoTests(TestCase): def test_lineno(self): lineno = SetLineno(1) self.assertEqual(lineno.lineno, 1) def test_equality(self): lineno = SetLineno(1) self.assertNotEqual(lineno, 1) self.assertEqual(lineno, SetLineno(1)) self.assertNotEqual(lineno, SetLineno(2)) class VariableTests(TestCase): def test_str(self): for cls in (CellVar, FreeVar): var = cls("a") self.assertEqual(str(var), "a") def test_repr(self): for cls in (CellVar, FreeVar): var = cls("_a_x_a_") r = repr(var) self.assertIn("_a_x_a_", r) self.assertIn(cls.__name__, r) def test_eq(self): f1 = FreeVar("a") f2 = FreeVar("b") c1 = CellVar("a") c2 = CellVar("b") for v1, v2, eq in ( (f1, f1, True), (f1, f2, False), (f1, c1, False), (c1, c1, True), (c1, c2, False), ): if eq: self.assertEqual(v1, v2) else: self.assertNotEqual(v1, v2) class InstrTests(TestCase): def test_constructor(self): # invalid line number with self.assertRaises(TypeError): Instr("NOP", lineno="x") with self.assertRaises(ValueError): Instr("NOP", lineno=0) # invalid name with self.assertRaises(TypeError): Instr(1) with self.assertRaises(ValueError): Instr("xxx") def test_repr(self): # No arg r = repr(Instr("NOP", lineno=10)) self.assertIn("NOP", r) self.assertIn("10", r) self.assertIn("lineno", r) # Arg r = repr(Instr("LOAD_FAST", "_x_", lineno=10)) self.assertIn("LOAD_FAST", r) self.assertIn("lineno", r) self.assertIn("10", r) self.assertIn("arg", r) self.assertIn("_x_", r) def test_invalid_arg(self): label = Label() block = BasicBlock() # EXTENDED_ARG self.assertRaises(ValueError, Instr, "EXTENDED_ARG", 0) # has_jump() self.assertRaises(TypeError, Instr, "JUMP_ABSOLUTE", 1) self.assertRaises(TypeError, Instr, "JUMP_ABSOLUTE", 1.0) Instr("JUMP_ABSOLUTE", label) Instr("JUMP_ABSOLUTE", block) # hasfree self.assertRaises(TypeError, Instr, "LOAD_DEREF", "x") Instr("LOAD_DEREF", CellVar("x")) Instr("LOAD_DEREF", FreeVar("x")) # haslocal self.assertRaises(TypeError, Instr, "LOAD_FAST", 1) Instr("LOAD_FAST", "x") # hasname self.assertRaises(TypeError, Instr, "LOAD_NAME", 1) Instr("LOAD_NAME", "x") # hasconst self.assertRaises(ValueError, Instr, "LOAD_CONST") # UNSET self.assertRaises(ValueError, Instr, "LOAD_CONST", label) self.assertRaises(ValueError, Instr, "LOAD_CONST", block) Instr("LOAD_CONST", 1.0) Instr("LOAD_CONST", object()) # hascompare self.assertRaises(TypeError, Instr, "COMPARE_OP", 1) Instr("COMPARE_OP", Compare.EQ) # HAVE_ARGUMENT self.assertRaises(ValueError, Instr, "CALL_FUNCTION", -1) self.assertRaises(TypeError, Instr, "CALL_FUNCTION", 3.0) Instr("CALL_FUNCTION", 3) # test maximum argument self.assertRaises(ValueError, Instr, "CALL_FUNCTION", 2147483647 + 1) instr = Instr("CALL_FUNCTION", 2147483647) self.assertEqual(instr.arg, 2147483647) # not HAVE_ARGUMENT self.assertRaises(ValueError, Instr, "NOP", 0) Instr("NOP") def test_require_arg(self): i = Instr("CALL_FUNCTION", 3) self.assertTrue(i.require_arg()) i = Instr("NOP") self.assertFalse(i.require_arg()) def test_attr(self): instr = Instr("LOAD_CONST", 3, lineno=5) self.assertEqual(instr.name, "LOAD_CONST") self.assertEqual(instr.opcode, 100) self.assertEqual(instr.arg, 3) self.assertEqual(instr.lineno, 5) # invalid values/types self.assertRaises(ValueError, setattr, instr, "lineno", 0) self.assertRaises(TypeError, setattr, instr, "lineno", 1.0) self.assertRaises(TypeError, setattr, instr, "name", 5) self.assertRaises(TypeError, setattr, instr, "opcode", 1.0) self.assertRaises(ValueError, setattr, instr, "opcode", -1) self.assertRaises(ValueError, setattr, instr, "opcode", 255) # arg can take any attribute but cannot be deleted instr.arg = -8 instr.arg = object() self.assertRaises(AttributeError, delattr, instr, "arg") # no argument instr = Instr("ROT_TWO") self.assertIs(instr.arg, UNSET) def test_modify_op(self): instr = Instr("LOAD_NAME", "x") load_fast = opcode.opmap["LOAD_FAST"] instr.opcode = load_fast self.assertEqual(instr.name, "LOAD_FAST") self.assertEqual(instr.opcode, load_fast) def test_extended_arg(self): instr = Instr("LOAD_CONST", 0x1234ABCD) self.assertEqual(instr.arg, 0x1234ABCD) def test_slots(self): instr = Instr("NOP") with self.assertRaises(AttributeError): instr.myattr = 1 def test_compare(self): instr = Instr("LOAD_CONST", 3, lineno=7) self.assertEqual(instr, Instr("LOAD_CONST", 3, lineno=7)) self.assertNotEqual(instr, 1) # different lineno self.assertNotEqual(instr, Instr("LOAD_CONST", 3)) self.assertNotEqual(instr, Instr("LOAD_CONST", 3, lineno=6)) # different op self.assertNotEqual(instr, Instr("LOAD_FAST", "x", lineno=7)) # different arg self.assertNotEqual(instr, Instr("LOAD_CONST", 4, lineno=7)) def test_has_jump(self): label = Label() jump = Instr("JUMP_ABSOLUTE", label) self.assertTrue(jump.has_jump()) instr = Instr("LOAD_FAST", "x") self.assertFalse(instr.has_jump()) def test_is_cond_jump(self): label = Label() jump = Instr("POP_JUMP_IF_TRUE", label) self.assertTrue(jump.is_cond_jump()) instr = Instr("LOAD_FAST", "x") self.assertFalse(instr.is_cond_jump()) def test_is_uncond_jump(self): label = Label() jump = Instr("JUMP_ABSOLUTE", label) self.assertTrue(jump.is_uncond_jump()) instr = Instr("POP_JUMP_IF_TRUE", label) self.assertFalse(instr.is_uncond_jump()) def test_const_key_not_equal(self): def check(value): self.assertEqual(Instr("LOAD_CONST", value), Instr("LOAD_CONST", value)) def func(): pass check(None) check(0) check(0.0) check(b"bytes") check("text") check(Ellipsis) check((1, 2, 3)) check(frozenset({1, 2, 3})) check(func.__code__) check(object()) def test_const_key_equal(self): neg_zero = -0.0 pos_zero = +0.0 # int and float: 0 == 0.0 self.assertNotEqual(Instr("LOAD_CONST", 0), Instr("LOAD_CONST", 0.0)) # float: -0.0 == +0.0 self.assertNotEqual( Instr("LOAD_CONST", neg_zero), Instr("LOAD_CONST", pos_zero) ) # complex self.assertNotEqual( Instr("LOAD_CONST", complex(neg_zero, 1.0)), Instr("LOAD_CONST", complex(pos_zero, 1.0)), ) self.assertNotEqual( Instr("LOAD_CONST", complex(1.0, neg_zero)), Instr("LOAD_CONST", complex(1.0, pos_zero)), ) # tuple self.assertNotEqual(Instr("LOAD_CONST", (0,)), Instr("LOAD_CONST", (0.0,))) nested_tuple1 = (0,) nested_tuple1 = (nested_tuple1,) nested_tuple2 = (0.0,) nested_tuple2 = (nested_tuple2,) self.assertNotEqual( Instr("LOAD_CONST", nested_tuple1), Instr("LOAD_CONST", nested_tuple2) ) # frozenset self.assertNotEqual( Instr("LOAD_CONST", frozenset({0})), Instr("LOAD_CONST", frozenset({0.0})) ) def test_stack_effects(self): # Verify all opcodes are handled and that "jump=None" really returns # the max of the other cases. from _pydevd_frame_eval.vendored.bytecode.concrete import ConcreteInstr def check(instr): jump = instr.stack_effect(jump=True) no_jump = instr.stack_effect(jump=False) max_effect = instr.stack_effect(jump=None) self.assertEqual(instr.stack_effect(), max_effect) self.assertEqual(max_effect, max(jump, no_jump)) if not instr.has_jump(): self.assertEqual(jump, no_jump) for name, op in opcode.opmap.items(): with self.subTest(name): # Use ConcreteInstr instead of Instr because it doesn't care # what kind of argument it is constructed with. if op < opcode.HAVE_ARGUMENT: check(ConcreteInstr(name)) else: for arg in range(256): check(ConcreteInstr(name, arg)) # LOAD_CONST uses a concrete python object as its oparg, however, in # dis.stack_effect(opcode.opmap['LOAD_CONST'], oparg), # oparg should be the index of that python object in the constants. # # Fortunately, for an instruction whose oparg isn't equivalent to its # form in binary files(pyc format), the stack effect is a # constant which does not depend on its oparg. # # The second argument of dis.stack_effect cannot be # more than 2**31 - 1. If stack effect of an instruction is # independent of its oparg, we pass 0 as the second argument # of dis.stack_effect. # (As a result we can calculate stack_effect for # any LOAD_CONST instructions, even for large integers) for arg in 2 ** 31, 2 ** 32, 2 ** 63, 2 ** 64, -1: self.assertEqual(Instr("LOAD_CONST", arg).stack_effect(), 1) def test_code_object_containing_mutable_data(self): from _pydevd_frame_eval.vendored.bytecode import Bytecode, Instr from types import CodeType def f(): def g(): return "value" return g f_code = Bytecode.from_code(f.__code__) instr_load_code = None mutable_datum = [4, 2] for each in f_code: if ( isinstance(each, Instr) and each.name == "LOAD_CONST" and isinstance(each.arg, CodeType) ): instr_load_code = each break self.assertIsNotNone(instr_load_code) g_code = Bytecode.from_code(instr_load_code.arg) g_code[0].arg = mutable_datum instr_load_code.arg = g_code.to_code() f.__code__ = f_code.to_code() self.assertIs(f()(), mutable_datum) if __name__ == "__main__": unittest.main() # pragma: no cover
11,676
Python
31.168044
126
0.569544
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_peephole_opt.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') import sys import unittest from _pydevd_frame_eval.vendored.bytecode import Label, Instr, Compare, Bytecode, ControlFlowGraph from _pydevd_frame_eval.vendored.bytecode import peephole_opt from _pydevd_frame_eval.vendored.bytecode.tests import TestCase, dump_bytecode from unittest import mock class Tests(TestCase): maxDiff = 80 * 100 def optimize_blocks(self, code): if isinstance(code, Bytecode): code = ControlFlowGraph.from_bytecode(code) optimizer = peephole_opt.PeepholeOptimizer() optimizer.optimize_cfg(code) return code def check(self, code, *expected): if isinstance(code, Bytecode): code = ControlFlowGraph.from_bytecode(code) optimizer = peephole_opt.PeepholeOptimizer() optimizer.optimize_cfg(code) code = code.to_bytecode() try: self.assertEqual(code, expected) except AssertionError: print("Optimized code:") dump_bytecode(code) print("Expected code:") for instr in expected: print(instr) raise def check_dont_optimize(self, code): code = ControlFlowGraph.from_bytecode(code) noopt = code.to_bytecode() optim = self.optimize_blocks(code) optim = optim.to_bytecode() self.assertEqual(optim, noopt) def test_unary_op(self): def check_unary_op(op, value, result): code = Bytecode( [Instr("LOAD_CONST", value), Instr(op), Instr("STORE_NAME", "x")] ) self.check(code, Instr("LOAD_CONST", result), Instr("STORE_NAME", "x")) check_unary_op("UNARY_POSITIVE", 2, 2) check_unary_op("UNARY_NEGATIVE", 3, -3) check_unary_op("UNARY_INVERT", 5, -6) def test_binary_op(self): def check_bin_op(left, op, right, result): code = Bytecode( [ Instr("LOAD_CONST", left), Instr("LOAD_CONST", right), Instr(op), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_CONST", result), Instr("STORE_NAME", "x")) check_bin_op(10, "BINARY_ADD", 20, 30) check_bin_op(5, "BINARY_SUBTRACT", 1, 4) check_bin_op(5, "BINARY_MULTIPLY", 3, 15) check_bin_op(10, "BINARY_TRUE_DIVIDE", 3, 10 / 3) check_bin_op(10, "BINARY_FLOOR_DIVIDE", 3, 3) check_bin_op(10, "BINARY_MODULO", 3, 1) check_bin_op(2, "BINARY_POWER", 8, 256) check_bin_op(1, "BINARY_LSHIFT", 3, 8) check_bin_op(16, "BINARY_RSHIFT", 3, 2) check_bin_op(10, "BINARY_AND", 3, 2) check_bin_op(2, "BINARY_OR", 3, 3) check_bin_op(2, "BINARY_XOR", 3, 1) def test_combined_unary_bin_ops(self): # x = 1 + 3 + 7 code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 3), Instr("BINARY_ADD"), Instr("LOAD_CONST", 7), Instr("BINARY_ADD"), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_CONST", 11), Instr("STORE_NAME", "x")) # x = ~(~(5)) code = Bytecode( [ Instr("LOAD_CONST", 5), Instr("UNARY_INVERT"), Instr("UNARY_INVERT"), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_CONST", 5), Instr("STORE_NAME", "x")) # "events = [(0, 'call'), (1, 'line'), (-(3), 'call')]" code = Bytecode( [ Instr("LOAD_CONST", 0), Instr("LOAD_CONST", "call"), Instr("BUILD_TUPLE", 2), Instr("LOAD_CONST", 1), Instr("LOAD_CONST", "line"), Instr("BUILD_TUPLE", 2), Instr("LOAD_CONST", 3), Instr("UNARY_NEGATIVE"), Instr("LOAD_CONST", "call"), Instr("BUILD_TUPLE", 2), Instr("BUILD_LIST", 3), Instr("STORE_NAME", "events"), ] ) self.check( code, Instr("LOAD_CONST", (0, "call")), Instr("LOAD_CONST", (1, "line")), Instr("LOAD_CONST", (-3, "call")), Instr("BUILD_LIST", 3), Instr("STORE_NAME", "events"), ) # 'x = (1,) + (0,) * 8' code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("BUILD_TUPLE", 1), Instr("LOAD_CONST", 0), Instr("BUILD_TUPLE", 1), Instr("LOAD_CONST", 8), Instr("BINARY_MULTIPLY"), Instr("BINARY_ADD"), Instr("STORE_NAME", "x"), ] ) zeros = (0,) * 8 result = (1,) + zeros self.check(code, Instr("LOAD_CONST", result), Instr("STORE_NAME", "x")) def test_max_size(self): max_size = 3 with mock.patch.object(peephole_opt, "MAX_SIZE", max_size): # optimized binary operation: size <= maximum size # # (9,) * size size = max_size result = (9,) * size code = Bytecode( [ Instr("LOAD_CONST", 9), Instr("BUILD_TUPLE", 1), Instr("LOAD_CONST", size), Instr("BINARY_MULTIPLY"), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_CONST", result), Instr("STORE_NAME", "x")) # don't optimize binary operation: size > maximum size # # x = (9,) * size size = max_size + 1 code = Bytecode( [ Instr("LOAD_CONST", 9), Instr("BUILD_TUPLE", 1), Instr("LOAD_CONST", size), Instr("BINARY_MULTIPLY"), Instr("STORE_NAME", "x"), ] ) self.check( code, Instr("LOAD_CONST", (9,)), Instr("LOAD_CONST", size), Instr("BINARY_MULTIPLY"), Instr("STORE_NAME", "x"), ) def test_bin_op_dont_optimize(self): # 1 / 0 code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 0), Instr("BINARY_TRUE_DIVIDE"), Instr("POP_TOP"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) # 1 // 0 code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 0), Instr("BINARY_FLOOR_DIVIDE"), Instr("POP_TOP"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) # 1 % 0 code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 0), Instr("BINARY_MODULO"), Instr("POP_TOP"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) # 1 % 1j code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 1j), Instr("BINARY_MODULO"), Instr("POP_TOP"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) def test_build_tuple(self): # x = (1, 2, 3) code = Bytecode( [ Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 2), Instr("LOAD_CONST", 3), Instr("BUILD_TUPLE", 3), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_CONST", (1, 2, 3)), Instr("STORE_NAME", "x")) def test_build_list(self): # test = x in [1, 2, 3] code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 2), Instr("LOAD_CONST", 3), Instr("BUILD_LIST", 3), Instr("COMPARE_OP", Compare.IN), Instr("STORE_NAME", "test"), ] ) self.check( code, Instr("LOAD_NAME", "x"), Instr("LOAD_CONST", (1, 2, 3)), Instr("COMPARE_OP", Compare.IN), Instr("STORE_NAME", "test"), ) def test_build_list_unpack_seq(self): for build_list in ("BUILD_TUPLE", "BUILD_LIST"): # x, = [a] code = Bytecode( [ Instr("LOAD_NAME", "a"), Instr(build_list, 1), Instr("UNPACK_SEQUENCE", 1), Instr("STORE_NAME", "x"), ] ) self.check(code, Instr("LOAD_NAME", "a"), Instr("STORE_NAME", "x")) # x, y = [a, b] code = Bytecode( [ Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr(build_list, 2), Instr("UNPACK_SEQUENCE", 2), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), ] ) self.check( code, Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr("ROT_TWO"), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), ) # x, y, z = [a, b, c] code = Bytecode( [ Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr("LOAD_NAME", "c"), Instr(build_list, 3), Instr("UNPACK_SEQUENCE", 3), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), Instr("STORE_NAME", "z"), ] ) self.check( code, Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr("LOAD_NAME", "c"), Instr("ROT_THREE"), Instr("ROT_TWO"), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), Instr("STORE_NAME", "z"), ) def test_build_tuple_unpack_seq_const(self): # x, y = (3, 4) code = Bytecode( [ Instr("LOAD_CONST", 3), Instr("LOAD_CONST", 4), Instr("BUILD_TUPLE", 2), Instr("UNPACK_SEQUENCE", 2), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), ] ) self.check( code, Instr("LOAD_CONST", (3, 4)), Instr("UNPACK_SEQUENCE", 2), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), ) def test_build_list_unpack_seq_const(self): # x, y, z = [3, 4, 5] code = Bytecode( [ Instr("LOAD_CONST", 3), Instr("LOAD_CONST", 4), Instr("LOAD_CONST", 5), Instr("BUILD_LIST", 3), Instr("UNPACK_SEQUENCE", 3), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), Instr("STORE_NAME", "z"), ] ) self.check( code, Instr("LOAD_CONST", 5), Instr("LOAD_CONST", 4), Instr("LOAD_CONST", 3), Instr("STORE_NAME", "x"), Instr("STORE_NAME", "y"), Instr("STORE_NAME", "z"), ) def test_build_set(self): # test = x in {1, 2, 3} code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("LOAD_CONST", 1), Instr("LOAD_CONST", 2), Instr("LOAD_CONST", 3), Instr("BUILD_SET", 3), Instr("COMPARE_OP", Compare.IN), Instr("STORE_NAME", "test"), ] ) self.check( code, Instr("LOAD_NAME", "x"), Instr("LOAD_CONST", frozenset((1, 2, 3))), Instr("COMPARE_OP", Compare.IN), Instr("STORE_NAME", "test"), ) def test_compare_op_unary_not(self): for op, not_op in ( (Compare.IN, Compare.NOT_IN), # in => not in (Compare.NOT_IN, Compare.IN), # not in => in (Compare.IS, Compare.IS_NOT), # is => is not (Compare.IS_NOT, Compare.IS), # is not => is ): code = Bytecode( [ Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr("COMPARE_OP", op), Instr("UNARY_NOT"), Instr("STORE_NAME", "x"), ] ) self.check( code, Instr("LOAD_NAME", "a"), Instr("LOAD_NAME", "b"), Instr("COMPARE_OP", not_op), Instr("STORE_NAME", "x"), ) # don't optimize: # x = not (a and b is True) label_instr5 = Label() code = Bytecode( [ Instr("LOAD_NAME", "a"), Instr("JUMP_IF_FALSE_OR_POP", label_instr5), Instr("LOAD_NAME", "b"), Instr("LOAD_CONST", True), Instr("COMPARE_OP", Compare.IS), label_instr5, Instr("UNARY_NOT"), Instr("STORE_NAME", "x"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) def test_dont_optimize(self): # x = 3 < 5 code = Bytecode( [ Instr("LOAD_CONST", 3), Instr("LOAD_CONST", 5), Instr("COMPARE_OP", Compare.LT), Instr("STORE_NAME", "x"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) self.check_dont_optimize(code) # x = (10, 20, 30)[1:] code = Bytecode( [ Instr("LOAD_CONST", (10, 20, 30)), Instr("LOAD_CONST", 1), Instr("LOAD_CONST", None), Instr("BUILD_SLICE", 2), Instr("BINARY_SUBSCR"), Instr("STORE_NAME", "x"), ] ) self.check_dont_optimize(code) def test_optimize_code_obj(self): # Test optimize() method with a code object # # x = 3 + 5 => x = 8 noopt = Bytecode( [ Instr("LOAD_CONST", 3), Instr("LOAD_CONST", 5), Instr("BINARY_ADD"), Instr("STORE_NAME", "x"), Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) noopt = noopt.to_code() optimizer = peephole_opt.PeepholeOptimizer() optim = optimizer.optimize(noopt) code = Bytecode.from_code(optim) self.assertEqual( code, [ Instr("LOAD_CONST", 8, lineno=1), Instr("STORE_NAME", "x", lineno=1), Instr("LOAD_CONST", None, lineno=1), Instr("RETURN_VALUE", lineno=1), ], ) def test_return_value(self): # return+return: remove second return # # def func(): # return 4 # return 5 code = Bytecode( [ Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2), Instr("LOAD_CONST", 5, lineno=3), Instr("RETURN_VALUE", lineno=3), ] ) code = ControlFlowGraph.from_bytecode(code) self.check( code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2) ) # return+return + return+return: remove second and fourth return # # def func(): # return 4 # return 5 # return 6 # return 7 code = Bytecode( [ Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2), Instr("LOAD_CONST", 5, lineno=3), Instr("RETURN_VALUE", lineno=3), Instr("LOAD_CONST", 6, lineno=4), Instr("RETURN_VALUE", lineno=4), Instr("LOAD_CONST", 7, lineno=5), Instr("RETURN_VALUE", lineno=5), ] ) code = ControlFlowGraph.from_bytecode(code) self.check( code, Instr("LOAD_CONST", 4, lineno=2), Instr("RETURN_VALUE", lineno=2) ) # return + JUMP_ABSOLUTE: remove JUMP_ABSOLUTE # while 1: # return 7 if sys.version_info < (3, 8): setup_loop = Label() return_label = Label() code = Bytecode( [ setup_loop, Instr("SETUP_LOOP", return_label, lineno=2), Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3), Instr("JUMP_ABSOLUTE", setup_loop, lineno=3), Instr("POP_BLOCK", lineno=3), return_label, Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ] ) code = ControlFlowGraph.from_bytecode(code) end_loop = Label() self.check( code, Instr("SETUP_LOOP", end_loop, lineno=2), Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3), end_loop, Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ) else: setup_loop = Label() return_label = Label() code = Bytecode( [ setup_loop, Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3), Instr("JUMP_ABSOLUTE", setup_loop, lineno=3), Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ] ) code = ControlFlowGraph.from_bytecode(code) self.check( code, Instr("LOAD_CONST", 7, lineno=3), Instr("RETURN_VALUE", lineno=3) ) def test_not_jump_if_false(self): # Replace UNARY_NOT+POP_JUMP_IF_FALSE with POP_JUMP_IF_TRUE # # if not x: # y = 9 label = Label() code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("UNARY_NOT"), Instr("POP_JUMP_IF_FALSE", label), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "y"), label, ] ) code = self.optimize_blocks(code) label = Label() self.check( code, Instr("LOAD_NAME", "x"), Instr("POP_JUMP_IF_TRUE", label), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "y"), label, ) def test_unconditional_jump_to_return(self): # def func(): # if test: # if test2: # x = 10 # else: # x = 20 # else: # x = 30 label_instr11 = Label() label_instr14 = Label() label_instr7 = Label() code = Bytecode( [ Instr("LOAD_GLOBAL", "test", lineno=2), Instr("POP_JUMP_IF_FALSE", label_instr11, lineno=2), Instr("LOAD_GLOBAL", "test2", lineno=3), Instr("POP_JUMP_IF_FALSE", label_instr7, lineno=3), Instr("LOAD_CONST", 10, lineno=4), Instr("STORE_FAST", "x", lineno=4), Instr("JUMP_ABSOLUTE", label_instr14, lineno=4), label_instr7, Instr("LOAD_CONST", 20, lineno=6), Instr("STORE_FAST", "x", lineno=6), Instr("JUMP_FORWARD", label_instr14, lineno=6), label_instr11, Instr("LOAD_CONST", 30, lineno=8), Instr("STORE_FAST", "x", lineno=8), label_instr14, Instr("LOAD_CONST", None, lineno=8), Instr("RETURN_VALUE", lineno=8), ] ) label1 = Label() label3 = Label() label4 = Label() self.check( code, Instr("LOAD_GLOBAL", "test", lineno=2), Instr("POP_JUMP_IF_FALSE", label3, lineno=2), Instr("LOAD_GLOBAL", "test2", lineno=3), Instr("POP_JUMP_IF_FALSE", label1, lineno=3), Instr("LOAD_CONST", 10, lineno=4), Instr("STORE_FAST", "x", lineno=4), Instr("JUMP_ABSOLUTE", label4, lineno=4), label1, Instr("LOAD_CONST", 20, lineno=6), Instr("STORE_FAST", "x", lineno=6), Instr("JUMP_FORWARD", label4, lineno=6), label3, Instr("LOAD_CONST", 30, lineno=8), Instr("STORE_FAST", "x", lineno=8), label4, Instr("LOAD_CONST", None, lineno=8), Instr("RETURN_VALUE", lineno=8), ) def test_unconditional_jumps(self): # def func(): # if x: # if y: # func() label_instr7 = Label() code = Bytecode( [ Instr("LOAD_GLOBAL", "x", lineno=2), Instr("POP_JUMP_IF_FALSE", label_instr7, lineno=2), Instr("LOAD_GLOBAL", "y", lineno=3), Instr("POP_JUMP_IF_FALSE", label_instr7, lineno=3), Instr("LOAD_GLOBAL", "func", lineno=4), Instr("CALL_FUNCTION", 0, lineno=4), Instr("POP_TOP", lineno=4), label_instr7, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ] ) label_return = Label() self.check( code, Instr("LOAD_GLOBAL", "x", lineno=2), Instr("POP_JUMP_IF_FALSE", label_return, lineno=2), Instr("LOAD_GLOBAL", "y", lineno=3), Instr("POP_JUMP_IF_FALSE", label_return, lineno=3), Instr("LOAD_GLOBAL", "func", lineno=4), Instr("CALL_FUNCTION", 0, lineno=4), Instr("POP_TOP", lineno=4), label_return, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ) def test_jump_to_return(self): # def func(condition): # return 'yes' if condition else 'no' label_instr4 = Label() label_instr6 = Label() code = Bytecode( [ Instr("LOAD_FAST", "condition"), Instr("POP_JUMP_IF_FALSE", label_instr4), Instr("LOAD_CONST", "yes"), Instr("JUMP_FORWARD", label_instr6), label_instr4, Instr("LOAD_CONST", "no"), label_instr6, Instr("RETURN_VALUE"), ] ) label = Label() self.check( code, Instr("LOAD_FAST", "condition"), Instr("POP_JUMP_IF_FALSE", label), Instr("LOAD_CONST", "yes"), Instr("RETURN_VALUE"), label, Instr("LOAD_CONST", "no"), Instr("RETURN_VALUE"), ) def test_jump_if_true_to_jump_if_false(self): # Replace JUMP_IF_TRUE_OR_POP jumping to POP_JUMP_IF_FALSE <target> # with POP_JUMP_IF_TRUE <offset after the second POP_JUMP_IF_FALSE> # # if x or y: # z = 1 label_instr3 = Label() label_instr7 = Label() code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("JUMP_IF_TRUE_OR_POP", label_instr3), Instr("LOAD_NAME", "y"), label_instr3, Instr("POP_JUMP_IF_FALSE", label_instr7), Instr("LOAD_CONST", 1), Instr("STORE_NAME", "z"), label_instr7, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) label_instr4 = Label() label_instr7 = Label() self.check( code, Instr("LOAD_NAME", "x"), Instr("POP_JUMP_IF_TRUE", label_instr4), Instr("LOAD_NAME", "y"), Instr("POP_JUMP_IF_FALSE", label_instr7), label_instr4, Instr("LOAD_CONST", 1), Instr("STORE_NAME", "z"), label_instr7, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ) def test_jump_if_false_to_jump_if_false(self): # Replace JUMP_IF_FALSE_OR_POP jumping to POP_JUMP_IF_FALSE <label> # with POP_JUMP_IF_FALSE <label> # # while n > 0 and start > 3: # func() if sys.version_info < (3, 8): label_instr1 = Label() label_instr15 = Label() label_instr17 = Label() label_instr9 = Label() code = Bytecode( [ Instr("SETUP_LOOP", label_instr17), label_instr1, Instr("LOAD_NAME", "n"), Instr("LOAD_CONST", 0), Instr("COMPARE_OP", Compare.GT), # JUMP_IF_FALSE_OR_POP jumps to POP_JUMP_IF_FALSE # which jumps to label_instr15 Instr("JUMP_IF_FALSE_OR_POP", label_instr9), Instr("LOAD_NAME", "start"), Instr("LOAD_CONST", 3), Instr("COMPARE_OP", Compare.GT), label_instr9, Instr("POP_JUMP_IF_FALSE", label_instr15), Instr("LOAD_NAME", "func"), Instr("CALL_FUNCTION", 0), Instr("POP_TOP"), Instr("JUMP_ABSOLUTE", label_instr1), label_instr15, Instr("POP_BLOCK"), label_instr17, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) label_instr1 = Label() label_instr14 = Label() label_instr16 = Label() self.check( code, Instr("SETUP_LOOP", label_instr16), label_instr1, Instr("LOAD_NAME", "n"), Instr("LOAD_CONST", 0), Instr("COMPARE_OP", Compare.GT), Instr("POP_JUMP_IF_FALSE", label_instr14), Instr("LOAD_NAME", "start"), Instr("LOAD_CONST", 3), Instr("COMPARE_OP", Compare.GT), Instr("POP_JUMP_IF_FALSE", label_instr14), Instr("LOAD_NAME", "func"), Instr("CALL_FUNCTION", 0), Instr("POP_TOP"), Instr("JUMP_ABSOLUTE", label_instr1), label_instr14, Instr("POP_BLOCK"), label_instr16, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ) else: label_instr1 = Label() label_instr15 = Label() label_instr9 = Label() code = Bytecode( [ label_instr1, Instr("LOAD_NAME", "n"), Instr("LOAD_CONST", 0), Instr("COMPARE_OP", Compare.GT), # JUMP_IF_FALSE_OR_POP jumps to POP_JUMP_IF_FALSE # which jumps to label_instr15 Instr("JUMP_IF_FALSE_OR_POP", label_instr9), Instr("LOAD_NAME", "start"), Instr("LOAD_CONST", 3), Instr("COMPARE_OP", Compare.GT), label_instr9, Instr("POP_JUMP_IF_FALSE", label_instr15), Instr("LOAD_NAME", "func"), Instr("CALL_FUNCTION", 0), Instr("POP_TOP"), Instr("JUMP_ABSOLUTE", label_instr1), label_instr15, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) label_instr1 = Label() label_instr14 = Label() self.check( code, label_instr1, Instr("LOAD_NAME", "n"), Instr("LOAD_CONST", 0), Instr("COMPARE_OP", Compare.GT), Instr("POP_JUMP_IF_FALSE", label_instr14), Instr("LOAD_NAME", "start"), Instr("LOAD_CONST", 3), Instr("COMPARE_OP", Compare.GT), Instr("POP_JUMP_IF_FALSE", label_instr14), Instr("LOAD_NAME", "func"), Instr("CALL_FUNCTION", 0), Instr("POP_TOP"), Instr("JUMP_ABSOLUTE", label_instr1), label_instr14, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ) def test_nop(self): code = Bytecode( [Instr("LOAD_NAME", "x"), Instr("NOP"), Instr("STORE_NAME", "test")] ) self.check(code, Instr("LOAD_NAME", "x"), Instr("STORE_NAME", "test")) def test_dead_code_jump(self): label = Label() code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("JUMP_ABSOLUTE", label), # dead code Instr("LOAD_NAME", "y"), Instr("STORE_NAME", "test"), label, Instr("STORE_NAME", "test"), ] ) self.check(code, Instr("LOAD_NAME", "x"), Instr("STORE_NAME", "test")) def test_uncond_jump_to_uncond_jump(self): # Replace JUMP_FORWARD t1 jumping to JUMP_FORWARD t2 # with JUMP_ABSOLUTE t2 label = Label() label2 = Label() label3 = Label() label4 = Label() code = Bytecode( [ Instr("LOAD_NAME", "test"), Instr("POP_JUMP_IF_TRUE", label), # redundant jump Instr("JUMP_FORWARD", label2), label, Instr("LOAD_CONST", 1), Instr("STORE_NAME", "x"), Instr("LOAD_NAME", "test"), Instr("POP_JUMP_IF_TRUE", label3), label2, Instr("JUMP_FORWARD", label4), label3, Instr("LOAD_CONST", 1), Instr("STORE_NAME", "x"), label4, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ] ) label = Label() label3 = Label() label4 = Label() self.check( code, Instr("LOAD_NAME", "test"), Instr("POP_JUMP_IF_TRUE", label), # JUMP_FORWARD label2 was replaced with JUMP_ABSOLUTE label4 Instr("JUMP_ABSOLUTE", label4), label, Instr("LOAD_CONST", 1), Instr("STORE_NAME", "x"), Instr("LOAD_NAME", "test"), Instr("POP_JUMP_IF_TRUE", label3), Instr("JUMP_FORWARD", label4), label3, Instr("LOAD_CONST", 1), Instr("STORE_NAME", "x"), label4, Instr("LOAD_CONST", None), Instr("RETURN_VALUE"), ) if __name__ == "__main__": unittest.main() # pragma: no cover
32,993
Python
32.462475
126
0.423453
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__init__.py
import sys import textwrap import types import unittest from _pydevd_frame_eval.vendored.bytecode import ( UNSET, Label, Instr, ConcreteInstr, BasicBlock, # noqa Bytecode, ControlFlowGraph, ConcreteBytecode, ) def _format_instr_list(block, labels, lineno): instr_list = [] for instr in block: if not isinstance(instr, Label): if isinstance(instr, ConcreteInstr): cls_name = "ConcreteInstr" else: cls_name = "Instr" arg = instr.arg if arg is not UNSET: if isinstance(arg, Label): arg = labels[arg] elif isinstance(arg, BasicBlock): arg = labels[id(arg)] else: arg = repr(arg) if lineno: text = "%s(%r, %s, lineno=%s)" % ( cls_name, instr.name, arg, instr.lineno, ) else: text = "%s(%r, %s)" % (cls_name, instr.name, arg) else: if lineno: text = "%s(%r, lineno=%s)" % (cls_name, instr.name, instr.lineno) else: text = "%s(%r)" % (cls_name, instr.name) else: text = labels[instr] instr_list.append(text) return "[%s]" % ",\n ".join(instr_list) def dump_bytecode(code, lineno=False): """ Use this function to write unit tests: copy/paste its output to write a self.assertBlocksEqual() check. """ print() if isinstance(code, (Bytecode, ConcreteBytecode)): is_concrete = isinstance(code, ConcreteBytecode) if is_concrete: block = list(code) else: block = code indent = " " * 8 labels = {} for index, instr in enumerate(block): if isinstance(instr, Label): name = "label_instr%s" % index labels[instr] = name if is_concrete: name = "ConcreteBytecode" print(indent + "code = %s()" % name) if code.argcount: print(indent + "code.argcount = %s" % code.argcount) if sys.version_info > (3, 8): if code.posonlyargcount: print(indent + "code.posonlyargcount = %s" % code.posonlyargcount) if code.kwonlyargcount: print(indent + "code.kwargonlycount = %s" % code.kwonlyargcount) print(indent + "code.flags = %#x" % code.flags) if code.consts: print(indent + "code.consts = %r" % code.consts) if code.names: print(indent + "code.names = %r" % code.names) if code.varnames: print(indent + "code.varnames = %r" % code.varnames) for name in sorted(labels.values()): print(indent + "%s = Label()" % name) if is_concrete: text = indent + "code.extend(" indent = " " * len(text) else: text = indent + "code = Bytecode(" indent = " " * len(text) lines = _format_instr_list(code, labels, lineno).splitlines() last_line = len(lines) - 1 for index, line in enumerate(lines): if index == 0: print(text + lines[0]) elif index == last_line: print(indent + line + ")") else: print(indent + line) print() else: assert isinstance(code, ControlFlowGraph) labels = {} for block_index, block in enumerate(code): labels[id(block)] = "code[%s]" % block_index for block_index, block in enumerate(code): text = _format_instr_list(block, labels, lineno) if block_index != len(code) - 1: text += "," print(text) print() def get_code(source, *, filename="<string>", function=False): source = textwrap.dedent(source).strip() code = compile(source, filename, "exec") if function: sub_code = [ const for const in code.co_consts if isinstance(const, types.CodeType) ] if len(sub_code) != 1: raise ValueError("unable to find function code") code = sub_code[0] return code def disassemble(source, *, filename="<string>", function=False): code = get_code(source, filename=filename, function=function) return Bytecode.from_code(code) class TestCase(unittest.TestCase): def assertBlocksEqual(self, code, *expected_blocks): self.assertEqual(len(code), len(expected_blocks)) for block1, block2 in zip(code, expected_blocks): block_index = code.get_block_index(block1) self.assertListEqual( list(block1), block2, "Block #%s is different" % block_index )
4,996
Python
31.238709
86
0.509207
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/util_annotation.py
from __future__ import annotations import textwrap import types def get_code(source, *, filename="<string>", function=False): source = textwrap.dedent(source).strip() code = compile(source, filename, "exec") if function: sub_code = [ const for const in code.co_consts if isinstance(const, types.CodeType) ] if len(sub_code) != 1: raise ValueError("unable to find function code") code = sub_code[0] return code
485
Python
25.999999
82
0.624742
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_flags.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import unittest from _pydevd_frame_eval.vendored.bytecode import ( CompilerFlags, ConcreteBytecode, ConcreteInstr, Bytecode, ControlFlowGraph, ) from _pydevd_frame_eval.vendored.bytecode.flags import infer_flags class FlagsTests(unittest.TestCase): def test_type_validation_on_inference(self): with self.assertRaises(ValueError): infer_flags(1) def test_flag_inference(self): # Check no loss of non-infered flags code = ControlFlowGraph() code.flags |= ( CompilerFlags.NEWLOCALS | CompilerFlags.VARARGS | CompilerFlags.VARKEYWORDS | CompilerFlags.NESTED | CompilerFlags.FUTURE_GENERATOR_STOP ) code.update_flags() for f in ( CompilerFlags.NEWLOCALS, CompilerFlags.VARARGS, CompilerFlags.VARKEYWORDS, CompilerFlags.NESTED, CompilerFlags.NOFREE, CompilerFlags.OPTIMIZED, CompilerFlags.FUTURE_GENERATOR_STOP, ): self.assertTrue(bool(code.flags & f)) # Infer optimized and nofree code = Bytecode() flags = infer_flags(code) self.assertTrue(bool(flags & CompilerFlags.OPTIMIZED)) self.assertTrue(bool(flags & CompilerFlags.NOFREE)) code.append(ConcreteInstr("STORE_NAME", 1)) flags = infer_flags(code) self.assertFalse(bool(flags & CompilerFlags.OPTIMIZED)) self.assertTrue(bool(flags & CompilerFlags.NOFREE)) code.append(ConcreteInstr("STORE_DEREF", 2)) code.update_flags() self.assertFalse(bool(code.flags & CompilerFlags.OPTIMIZED)) self.assertFalse(bool(code.flags & CompilerFlags.NOFREE)) def test_async_gen_no_flag_is_async_None(self): # Test inference in the absence of any flag set on the bytecode # Infer generator code = ConcreteBytecode() code.append(ConcreteInstr("YIELD_VALUE")) code.update_flags() self.assertTrue(bool(code.flags & CompilerFlags.GENERATOR)) # Infer coroutine code = ConcreteBytecode() code.append(ConcreteInstr("GET_AWAITABLE")) code.update_flags() self.assertTrue(bool(code.flags & CompilerFlags.COROUTINE)) # Infer coroutine or async generator for i, expected in ( ("YIELD_VALUE", CompilerFlags.ASYNC_GENERATOR), ("YIELD_FROM", CompilerFlags.COROUTINE), ): code = ConcreteBytecode() code.append(ConcreteInstr("GET_AWAITABLE")) code.append(ConcreteInstr(i)) code.update_flags() self.assertTrue(bool(code.flags & expected)) def test_async_gen_no_flag_is_async_True(self): # Test inference when we request an async function # Force coroutine code = ConcreteBytecode() code.update_flags(is_async=True) self.assertTrue(bool(code.flags & CompilerFlags.COROUTINE)) # Infer coroutine or async generator for i, expected in ( ("YIELD_VALUE", CompilerFlags.ASYNC_GENERATOR), ("YIELD_FROM", CompilerFlags.COROUTINE), ): code = ConcreteBytecode() code.append(ConcreteInstr(i)) code.update_flags(is_async=True) self.assertTrue(bool(code.flags & expected)) def test_async_gen_no_flag_is_async_False(self): # Test inference when we request a non-async function # Infer generator code = ConcreteBytecode() code.append(ConcreteInstr("YIELD_VALUE")) code.flags = CompilerFlags(CompilerFlags.COROUTINE) code.update_flags(is_async=False) self.assertTrue(bool(code.flags & CompilerFlags.GENERATOR)) # Abort on coroutine code = ConcreteBytecode() code.append(ConcreteInstr("GET_AWAITABLE")) code.flags = CompilerFlags(CompilerFlags.COROUTINE) with self.assertRaises(ValueError): code.update_flags(is_async=False) def test_async_gen_flags(self): # Test inference in the presence of pre-existing flags for is_async in (None, True): # Infer generator code = ConcreteBytecode() code.append(ConcreteInstr("YIELD_VALUE")) for f, expected in ( (CompilerFlags.COROUTINE, CompilerFlags.ASYNC_GENERATOR), (CompilerFlags.ASYNC_GENERATOR, CompilerFlags.ASYNC_GENERATOR), (CompilerFlags.ITERABLE_COROUTINE, CompilerFlags.ITERABLE_COROUTINE), ): code.flags = CompilerFlags(f) code.update_flags(is_async=is_async) self.assertTrue(bool(code.flags & expected)) # Infer coroutine code = ConcreteBytecode() code.append(ConcreteInstr("YIELD_FROM")) for f, expected in ( (CompilerFlags.COROUTINE, CompilerFlags.COROUTINE), (CompilerFlags.ASYNC_GENERATOR, CompilerFlags.COROUTINE), (CompilerFlags.ITERABLE_COROUTINE, CompilerFlags.ITERABLE_COROUTINE), ): code.flags = CompilerFlags(f) code.update_flags(is_async=is_async) self.assertTrue(bool(code.flags & expected)) # Crash on ITERABLE_COROUTINE with async bytecode code = ConcreteBytecode() code.append(ConcreteInstr("GET_AWAITABLE")) code.flags = CompilerFlags(CompilerFlags.ITERABLE_COROUTINE) with self.assertRaises(ValueError): code.update_flags(is_async=is_async) if __name__ == "__main__": unittest.main() # pragma: no cover
6,009
Python
36.5625
126
0.625894
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_misc.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import contextlib import io import sys import textwrap import unittest from _pydevd_frame_eval.vendored import bytecode from _pydevd_frame_eval.vendored.bytecode import Label, Instr, Bytecode, BasicBlock, ControlFlowGraph from _pydevd_frame_eval.vendored.bytecode.concrete import OFFSET_AS_INSTRUCTION from _pydevd_frame_eval.vendored.bytecode.tests import disassemble class DumpCodeTests(unittest.TestCase): maxDiff = 80 * 100 def check_dump_bytecode(self, code, expected, lineno=None): with contextlib.redirect_stdout(io.StringIO()) as stderr: if lineno is not None: bytecode.dump_bytecode(code, lineno=True) else: bytecode.dump_bytecode(code) output = stderr.getvalue() self.assertEqual(output, expected) def test_bytecode(self): source = """ def func(test): if test == 1: return 1 elif test == 2: return 2 return 3 """ code = disassemble(source, function=True) # without line numbers enum_repr = "<Compare.EQ: 2>" expected = f""" LOAD_FAST 'test' LOAD_CONST 1 COMPARE_OP {enum_repr} POP_JUMP_IF_FALSE <label_instr6> LOAD_CONST 1 RETURN_VALUE label_instr6: LOAD_FAST 'test' LOAD_CONST 2 COMPARE_OP {enum_repr} POP_JUMP_IF_FALSE <label_instr13> LOAD_CONST 2 RETURN_VALUE label_instr13: LOAD_CONST 3 RETURN_VALUE """[ 1: ].rstrip( " " ) self.check_dump_bytecode(code, expected) # with line numbers expected = f""" L. 2 0: LOAD_FAST 'test' 1: LOAD_CONST 1 2: COMPARE_OP {enum_repr} 3: POP_JUMP_IF_FALSE <label_instr6> L. 3 4: LOAD_CONST 1 5: RETURN_VALUE label_instr6: L. 4 7: LOAD_FAST 'test' 8: LOAD_CONST 2 9: COMPARE_OP {enum_repr} 10: POP_JUMP_IF_FALSE <label_instr13> L. 5 11: LOAD_CONST 2 12: RETURN_VALUE label_instr13: L. 6 14: LOAD_CONST 3 15: RETURN_VALUE """[ 1: ].rstrip( " " ) self.check_dump_bytecode(code, expected, lineno=True) def test_bytecode_broken_label(self): label = Label() code = Bytecode([Instr("JUMP_ABSOLUTE", label)]) expected = " JUMP_ABSOLUTE <error: unknown label>\n\n" self.check_dump_bytecode(code, expected) def test_blocks_broken_jump(self): block = BasicBlock() code = ControlFlowGraph() code[0].append(Instr("JUMP_ABSOLUTE", block)) expected = textwrap.dedent( """ block1: JUMP_ABSOLUTE <error: unknown block> """ ).lstrip("\n") self.check_dump_bytecode(code, expected) def test_bytecode_blocks(self): source = """ def func(test): if test == 1: return 1 elif test == 2: return 2 return 3 """ code = disassemble(source, function=True) code = ControlFlowGraph.from_bytecode(code) # without line numbers enum_repr = "<Compare.EQ: 2>" expected = textwrap.dedent( f""" block1: LOAD_FAST 'test' LOAD_CONST 1 COMPARE_OP {enum_repr} POP_JUMP_IF_FALSE <block3> -> block2 block2: LOAD_CONST 1 RETURN_VALUE block3: LOAD_FAST 'test' LOAD_CONST 2 COMPARE_OP {enum_repr} POP_JUMP_IF_FALSE <block5> -> block4 block4: LOAD_CONST 2 RETURN_VALUE block5: LOAD_CONST 3 RETURN_VALUE """ ).lstrip() self.check_dump_bytecode(code, expected) # with line numbers expected = textwrap.dedent( f""" block1: L. 2 0: LOAD_FAST 'test' 1: LOAD_CONST 1 2: COMPARE_OP {enum_repr} 3: POP_JUMP_IF_FALSE <block3> -> block2 block2: L. 3 0: LOAD_CONST 1 1: RETURN_VALUE block3: L. 4 0: LOAD_FAST 'test' 1: LOAD_CONST 2 2: COMPARE_OP {enum_repr} 3: POP_JUMP_IF_FALSE <block5> -> block4 block4: L. 5 0: LOAD_CONST 2 1: RETURN_VALUE block5: L. 6 0: LOAD_CONST 3 1: RETURN_VALUE """ ).lstrip() self.check_dump_bytecode(code, expected, lineno=True) def test_concrete_bytecode(self): source = """ def func(test): if test == 1: return 1 elif test == 2: return 2 return 3 """ code = disassemble(source, function=True) code = code.to_concrete_bytecode() # without line numbers expected = f""" 0 LOAD_FAST 0 2 LOAD_CONST 1 4 COMPARE_OP 2 6 POP_JUMP_IF_FALSE {6 if OFFSET_AS_INSTRUCTION else 12} 8 LOAD_CONST 1 10 RETURN_VALUE 12 LOAD_FAST 0 14 LOAD_CONST 2 16 COMPARE_OP 2 18 POP_JUMP_IF_FALSE {12 if OFFSET_AS_INSTRUCTION else 24} 20 LOAD_CONST 2 22 RETURN_VALUE 24 LOAD_CONST 3 26 RETURN_VALUE """.lstrip( "\n" ) self.check_dump_bytecode(code, expected) # with line numbers expected = f""" L. 2 0: LOAD_FAST 0 2: LOAD_CONST 1 4: COMPARE_OP 2 6: POP_JUMP_IF_FALSE {6 if OFFSET_AS_INSTRUCTION else 12} L. 3 8: LOAD_CONST 1 10: RETURN_VALUE L. 4 12: LOAD_FAST 0 14: LOAD_CONST 2 16: COMPARE_OP 2 18: POP_JUMP_IF_FALSE {12 if OFFSET_AS_INSTRUCTION else 24} L. 5 20: LOAD_CONST 2 22: RETURN_VALUE L. 6 24: LOAD_CONST 3 26: RETURN_VALUE """.lstrip( "\n" ) self.check_dump_bytecode(code, expected, lineno=True) def test_type_validation(self): class T: first_lineno = 1 with self.assertRaises(TypeError): bytecode.dump_bytecode(T()) class MiscTests(unittest.TestCase): def skip_test_version(self): import setup self.assertEqual(bytecode.__version__, setup.VERSION) if __name__ == "__main__": unittest.main() # pragma: no cover
7,149
Python
25.383764
126
0.51126
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_cfg.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import io import sys import unittest import contextlib from _pydevd_frame_eval.vendored.bytecode import ( Label, Compare, SetLineno, Instr, Bytecode, BasicBlock, ControlFlowGraph, ) from _pydevd_frame_eval.vendored.bytecode.concrete import OFFSET_AS_INSTRUCTION from _pydevd_frame_eval.vendored.bytecode.tests import disassemble as _disassemble, TestCase def disassemble( source, *, filename="<string>", function=False, remove_last_return_none=False ): code = _disassemble(source, filename=filename, function=function) blocks = ControlFlowGraph.from_bytecode(code) if remove_last_return_none: # drop LOAD_CONST+RETURN_VALUE to only keep 2 instructions, # to make unit tests shorter block = blocks[-1] test = ( block[-2].name == "LOAD_CONST" and block[-2].arg is None and block[-1].name == "RETURN_VALUE" ) if not test: raise ValueError( "unable to find implicit RETURN_VALUE <None>: %s" % block[-2:] ) del block[-2:] return blocks class BlockTests(unittest.TestCase): def test_iter_invalid_types(self): # Labels are not allowed in basic blocks block = BasicBlock() block.append(Label()) with self.assertRaises(ValueError): list(block) with self.assertRaises(ValueError): block.legalize(1) # Only one jump allowed and only at the end block = BasicBlock() block2 = BasicBlock() block.extend([Instr("JUMP_ABSOLUTE", block2), Instr("NOP")]) with self.assertRaises(ValueError): list(block) with self.assertRaises(ValueError): block.legalize(1) # jump target must be a BasicBlock block = BasicBlock() label = Label() block.extend([Instr("JUMP_ABSOLUTE", label)]) with self.assertRaises(ValueError): list(block) with self.assertRaises(ValueError): block.legalize(1) def test_slice(self): block = BasicBlock([Instr("NOP")]) next_block = BasicBlock() block.next_block = next_block self.assertEqual(block, block[:]) self.assertIs(next_block, block[:].next_block) def test_copy(self): block = BasicBlock([Instr("NOP")]) next_block = BasicBlock() block.next_block = next_block self.assertEqual(block, block.copy()) self.assertIs(next_block, block.copy().next_block) class BytecodeBlocksTests(TestCase): maxDiff = 80 * 100 def test_constructor(self): code = ControlFlowGraph() self.assertEqual(code.name, "<module>") self.assertEqual(code.filename, "<string>") self.assertEqual(code.flags, 0) self.assertBlocksEqual(code, []) def test_attr(self): source = """ first_line = 1 def func(arg1, arg2, *, arg3): x = 1 y = 2 return arg1 """ code = disassemble(source, filename="hello.py", function=True) self.assertEqual(code.argcount, 2) self.assertEqual(code.filename, "hello.py") self.assertEqual(code.first_lineno, 3) if sys.version_info > (3, 8): self.assertEqual(code.posonlyargcount, 0) self.assertEqual(code.kwonlyargcount, 1) self.assertEqual(code.name, "func") self.assertEqual(code.cellvars, []) code.name = "name" code.filename = "filename" code.flags = 123 self.assertEqual(code.name, "name") self.assertEqual(code.filename, "filename") self.assertEqual(code.flags, 123) # FIXME: test non-empty cellvars def test_add_del_block(self): code = ControlFlowGraph() code[0].append(Instr("LOAD_CONST", 0)) block = code.add_block() self.assertEqual(len(code), 2) self.assertIs(block, code[1]) code[1].append(Instr("LOAD_CONST", 2)) self.assertBlocksEqual(code, [Instr("LOAD_CONST", 0)], [Instr("LOAD_CONST", 2)]) del code[0] self.assertBlocksEqual(code, [Instr("LOAD_CONST", 2)]) del code[0] self.assertEqual(len(code), 0) def test_setlineno(self): # x = 7 # y = 8 # z = 9 code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ] ) blocks = ControlFlowGraph.from_bytecode(code) self.assertBlocksEqual( blocks, [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ], ) def test_legalize(self): code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), Instr("LOAD_CONST", 8, lineno=4), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9, lineno=6), Instr("STORE_NAME", "z"), ] ) blocks = ControlFlowGraph.from_bytecode(code) blocks.legalize() self.assertBlocksEqual( blocks, [ Instr("LOAD_CONST", 7, lineno=3), Instr("STORE_NAME", "x", lineno=3), Instr("LOAD_CONST", 8, lineno=4), Instr("STORE_NAME", "y", lineno=4), Instr("LOAD_CONST", 9, lineno=5), Instr("STORE_NAME", "z", lineno=5), ], ) def test_repr(self): r = repr(ControlFlowGraph()) self.assertIn("ControlFlowGraph", r) self.assertIn("1", r) def test_to_bytecode(self): # if test: # x = 2 # x = 5 blocks = ControlFlowGraph() blocks.add_block() blocks.add_block() blocks[0].extend( [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", blocks[2], lineno=1), ] ) blocks[1].extend( [ Instr("LOAD_CONST", 5, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("JUMP_FORWARD", blocks[2], lineno=2), ] ) blocks[2].extend( [ Instr("LOAD_CONST", 7, lineno=3), Instr("STORE_NAME", "x", lineno=3), Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ] ) bytecode = blocks.to_bytecode() label = Label() self.assertEqual( bytecode, [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label, lineno=1), Instr("LOAD_CONST", 5, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("JUMP_FORWARD", label, lineno=2), label, Instr("LOAD_CONST", 7, lineno=3), Instr("STORE_NAME", "x", lineno=3), Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ], ) # FIXME: test other attributes def test_label_at_the_end(self): label = Label() code = Bytecode( [ Instr("LOAD_NAME", "x"), Instr("UNARY_NOT"), Instr("POP_JUMP_IF_FALSE", label), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "y"), label, ] ) cfg = ControlFlowGraph.from_bytecode(code) self.assertBlocksEqual( cfg, [ Instr("LOAD_NAME", "x"), Instr("UNARY_NOT"), Instr("POP_JUMP_IF_FALSE", cfg[2]), ], [Instr("LOAD_CONST", 9), Instr("STORE_NAME", "y")], [], ) def test_from_bytecode(self): bytecode = Bytecode() label = Label() bytecode.extend( [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label, lineno=1), Instr("LOAD_CONST", 5, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("JUMP_FORWARD", label, lineno=2), # dead code! Instr("LOAD_CONST", 7, lineno=4), Instr("STORE_NAME", "x", lineno=4), Label(), # unused label label, Label(), # unused label Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ] ) blocks = ControlFlowGraph.from_bytecode(bytecode) label2 = blocks[3] self.assertBlocksEqual( blocks, [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label2, lineno=1), ], [ Instr("LOAD_CONST", 5, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("JUMP_FORWARD", label2, lineno=2), ], [Instr("LOAD_CONST", 7, lineno=4), Instr("STORE_NAME", "x", lineno=4)], [Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4)], ) # FIXME: test other attributes def test_from_bytecode_loop(self): # for x in (1, 2, 3): # if x == 2: # break # continue if sys.version_info < (3, 8): label_loop_start = Label() label_loop_exit = Label() label_loop_end = Label() code = Bytecode() code.extend( ( Instr("SETUP_LOOP", label_loop_end, lineno=1), Instr("LOAD_CONST", (1, 2, 3), lineno=1), Instr("GET_ITER", lineno=1), label_loop_start, Instr("FOR_ITER", label_loop_exit, lineno=1), Instr("STORE_NAME", "x", lineno=1), Instr("LOAD_NAME", "x", lineno=2), Instr("LOAD_CONST", 2, lineno=2), Instr("COMPARE_OP", Compare.EQ, lineno=2), Instr("POP_JUMP_IF_FALSE", label_loop_start, lineno=2), Instr("BREAK_LOOP", lineno=3), Instr("JUMP_ABSOLUTE", label_loop_start, lineno=4), Instr("JUMP_ABSOLUTE", label_loop_start, lineno=4), label_loop_exit, Instr("POP_BLOCK", lineno=4), label_loop_end, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ) ) blocks = ControlFlowGraph.from_bytecode(code) expected = [ [Instr("SETUP_LOOP", blocks[8], lineno=1)], [Instr("LOAD_CONST", (1, 2, 3), lineno=1), Instr("GET_ITER", lineno=1)], [Instr("FOR_ITER", blocks[7], lineno=1)], [ Instr("STORE_NAME", "x", lineno=1), Instr("LOAD_NAME", "x", lineno=2), Instr("LOAD_CONST", 2, lineno=2), Instr("COMPARE_OP", Compare.EQ, lineno=2), Instr("POP_JUMP_IF_FALSE", blocks[2], lineno=2), ], [Instr("BREAK_LOOP", lineno=3)], [Instr("JUMP_ABSOLUTE", blocks[2], lineno=4)], [Instr("JUMP_ABSOLUTE", blocks[2], lineno=4)], [Instr("POP_BLOCK", lineno=4)], [Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4)], ] self.assertBlocksEqual(blocks, *expected) else: label_loop_start = Label() label_loop_exit = Label() code = Bytecode() code.extend( ( Instr("LOAD_CONST", (1, 2, 3), lineno=1), Instr("GET_ITER", lineno=1), label_loop_start, Instr("FOR_ITER", label_loop_exit, lineno=1), Instr("STORE_NAME", "x", lineno=1), Instr("LOAD_NAME", "x", lineno=2), Instr("LOAD_CONST", 2, lineno=2), Instr("COMPARE_OP", Compare.EQ, lineno=2), Instr("POP_JUMP_IF_FALSE", label_loop_start, lineno=2), Instr("JUMP_ABSOLUTE", label_loop_exit, lineno=3), Instr("JUMP_ABSOLUTE", label_loop_start, lineno=4), Instr("JUMP_ABSOLUTE", label_loop_start, lineno=4), label_loop_exit, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ) ) blocks = ControlFlowGraph.from_bytecode(code) expected = [ [Instr("LOAD_CONST", (1, 2, 3), lineno=1), Instr("GET_ITER", lineno=1)], [Instr("FOR_ITER", blocks[6], lineno=1)], [ Instr("STORE_NAME", "x", lineno=1), Instr("LOAD_NAME", "x", lineno=2), Instr("LOAD_CONST", 2, lineno=2), Instr("COMPARE_OP", Compare.EQ, lineno=2), Instr("POP_JUMP_IF_FALSE", blocks[1], lineno=2), ], [Instr("JUMP_ABSOLUTE", blocks[6], lineno=3)], [Instr("JUMP_ABSOLUTE", blocks[1], lineno=4)], [Instr("JUMP_ABSOLUTE", blocks[1], lineno=4)], [Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4)], ] self.assertBlocksEqual(blocks, *expected) class BytecodeBlocksFunctionalTests(TestCase): def test_eq(self): # compare codes with multiple blocks and labels, # Code.__eq__() renumbers labels to get equal labels source = "x = 1 if test else 2" code1 = disassemble(source) code2 = disassemble(source) self.assertEqual(code1, code2) # Type mismatch self.assertFalse(code1 == 1) # argnames mismatch cfg = ControlFlowGraph() cfg.argnames = 10 self.assertFalse(code1 == cfg) # instr mismatch cfg = ControlFlowGraph() cfg.argnames = code1.argnames self.assertFalse(code1 == cfg) def check_getitem(self, code): # check internal Code block indexes (index by index, index by label) for block_index, block in enumerate(code): self.assertIs(code[block_index], block) self.assertIs(code[block], block) self.assertEqual(code.get_block_index(block), block_index) def test_delitem(self): cfg = ControlFlowGraph() b = cfg.add_block() del cfg[b] self.assertEqual(len(cfg.get_instructions()), 0) def sample_code(self): code = disassemble("x = 1", remove_last_return_none=True) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)] ) return code def test_split_block(self): code = self.sample_code() code[0].append(Instr("NOP", lineno=1)) label = code.split_block(code[0], 2) self.assertIs(label, code[1]) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)], [Instr("NOP", lineno=1)], ) self.check_getitem(code) label2 = code.split_block(code[0], 1) self.assertIs(label2, code[1]) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1)], [Instr("STORE_NAME", "x", lineno=1)], [Instr("NOP", lineno=1)], ) self.check_getitem(code) with self.assertRaises(TypeError): code.split_block(1, 1) with self.assertRaises(ValueError) as e: code.split_block(code[0], -2) self.assertIn("positive", e.exception.args[0]) def test_split_block_end(self): code = self.sample_code() # split at the end of the last block requires to add a new empty block label = code.split_block(code[0], 2) self.assertIs(label, code[1]) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)], [], ) self.check_getitem(code) # split at the end of a block which is not the end doesn't require to # add a new block label = code.split_block(code[0], 2) self.assertIs(label, code[1]) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)], [], ) def test_split_block_dont_split(self): code = self.sample_code() # FIXME: is it really useful to support that? block = code.split_block(code[0], 0) self.assertIs(block, code[0]) self.assertBlocksEqual( code, [Instr("LOAD_CONST", 1, lineno=1), Instr("STORE_NAME", "x", lineno=1)] ) def test_split_block_error(self): code = self.sample_code() with self.assertRaises(ValueError): # invalid index code.split_block(code[0], 3) def test_to_code(self): # test resolution of jump labels bytecode = ControlFlowGraph() bytecode.first_lineno = 3 bytecode.argcount = 3 if sys.version_info > (3, 8): bytecode.posonlyargcount = 0 bytecode.kwonlyargcount = 2 bytecode.name = "func" bytecode.filename = "hello.py" bytecode.flags = 0x43 bytecode.argnames = ("arg", "arg2", "arg3", "kwonly", "kwonly2") bytecode.docstring = None block0 = bytecode[0] block1 = bytecode.add_block() block2 = bytecode.add_block() block0.extend( [ Instr("LOAD_FAST", "x", lineno=4), Instr("POP_JUMP_IF_FALSE", block2, lineno=4), ] ) block1.extend( [Instr("LOAD_FAST", "arg", lineno=5), Instr("STORE_FAST", "x", lineno=5)] ) block2.extend( [ Instr("LOAD_CONST", 3, lineno=6), Instr("STORE_FAST", "x", lineno=6), Instr("LOAD_FAST", "x", lineno=7), Instr("RETURN_VALUE", lineno=7), ] ) if OFFSET_AS_INSTRUCTION: # The argument of the jump is divided by 2 expected = ( b"|\x05" b"r\x04" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00" ) else: expected = ( b"|\x05" b"r\x08" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00" ) code = bytecode.to_code() self.assertEqual(code.co_consts, (None, 3)) self.assertEqual(code.co_argcount, 3) if sys.version_info > (3, 8): self.assertEqual(code.co_posonlyargcount, 0) self.assertEqual(code.co_kwonlyargcount, 2) self.assertEqual(code.co_nlocals, 6) self.assertEqual(code.co_stacksize, 1) # FIXME: don't use hardcoded constants self.assertEqual(code.co_flags, 0x43) self.assertEqual(code.co_code, expected) self.assertEqual(code.co_names, ()) self.assertEqual( code.co_varnames, ("arg", "arg2", "arg3", "kwonly", "kwonly2", "x") ) self.assertEqual(code.co_filename, "hello.py") self.assertEqual(code.co_name, "func") self.assertEqual(code.co_firstlineno, 3) # verify stacksize argument is honored explicit_stacksize = code.co_stacksize + 42 code = bytecode.to_code(stacksize=explicit_stacksize) self.assertEqual(code.co_stacksize, explicit_stacksize) def test_get_block_index(self): blocks = ControlFlowGraph() block0 = blocks[0] block1 = blocks.add_block() block2 = blocks.add_block() self.assertEqual(blocks.get_block_index(block0), 0) self.assertEqual(blocks.get_block_index(block1), 1) self.assertEqual(blocks.get_block_index(block2), 2) other_block = BasicBlock() self.assertRaises(ValueError, blocks.get_block_index, other_block) class CFGStacksizeComputationTests(TestCase): def check_stack_size(self, func): code = func.__code__ bytecode = Bytecode.from_code(code) cfg = ControlFlowGraph.from_bytecode(bytecode) self.assertEqual(code.co_stacksize, cfg.compute_stacksize()) def test_empty_code(self): cfg = ControlFlowGraph() del cfg[0] self.assertEqual(cfg.compute_stacksize(), 0) def test_handling_of_set_lineno(self): code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ] ) self.assertEqual(code.compute_stacksize(), 1) def test_invalid_stacksize(self): code = Bytecode() code.extend([Instr("STORE_NAME", "x")]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_stack_size_computation_and(self): def test(arg1, *args, **kwargs): # pragma: no cover return arg1 and args # Test JUMP_IF_FALSE_OR_POP self.check_stack_size(test) def test_stack_size_computation_or(self): def test(arg1, *args, **kwargs): # pragma: no cover return arg1 or args # Test JUMP_IF_TRUE_OR_POP self.check_stack_size(test) def test_stack_size_computation_if_else(self): def test(arg1, *args, **kwargs): # pragma: no cover if args: return 0 elif kwargs: return 1 else: return 2 self.check_stack_size(test) def test_stack_size_computation_for_loop_continue(self): def test(arg1, *args, **kwargs): # pragma: no cover for k in kwargs: if k in args: continue else: return 1 self.check_stack_size(test) def test_stack_size_computation_while_loop_break(self): def test(arg1, *args, **kwargs): # pragma: no cover while True: if arg1: break self.check_stack_size(test) def test_stack_size_computation_with(self): def test(arg1, *args, **kwargs): # pragma: no cover with open(arg1) as f: return f.read() self.check_stack_size(test) def test_stack_size_computation_try_except(self): def test(arg1, *args, **kwargs): # pragma: no cover try: return args[0] except Exception: return 2 self.check_stack_size(test) def test_stack_size_computation_try_finally(self): def test(arg1, *args, **kwargs): # pragma: no cover try: return args[0] finally: return 2 self.check_stack_size(test) def test_stack_size_computation_try_except_finally(self): def test(arg1, *args, **kwargs): # pragma: no cover try: return args[0] except Exception: return 2 finally: print("Interrupt") self.check_stack_size(test) def test_stack_size_computation_try_except_else_finally(self): def test(arg1, *args, **kwargs): # pragma: no cover try: return args[0] except Exception: return 2 else: return arg1 finally: print("Interrupt") self.check_stack_size(test) def test_stack_size_computation_nested_try_except_finally(self): def test(arg1, *args, **kwargs): # pragma: no cover k = 1 try: getattr(arg1, k) except AttributeError: pass except Exception: try: assert False except Exception: return 2 finally: print("unexpected") finally: print("attempted to get {}".format(k)) self.check_stack_size(test) def test_stack_size_computation_nested_try_except_else_finally(self): def test(*args, **kwargs): try: v = args[1] except IndexError: try: w = kwargs["value"] except KeyError: return -1 else: return w finally: print("second finally") else: return v finally: print("first finally") # A direct comparison of the stack depth fails because CPython # generate dead code that is used in stack computation. cpython_stacksize = test.__code__.co_stacksize test.__code__ = Bytecode.from_code(test.__code__).to_code() self.assertLessEqual(test.__code__.co_stacksize, cpython_stacksize) with contextlib.redirect_stdout(io.StringIO()) as stdout: self.assertEqual(test(1, 4), 4) self.assertEqual(stdout.getvalue(), "first finally\n") with contextlib.redirect_stdout(io.StringIO()) as stdout: self.assertEqual(test([], value=3), 3) self.assertEqual(stdout.getvalue(), "second finally\nfirst finally\n") with contextlib.redirect_stdout(io.StringIO()) as stdout: self.assertEqual(test([], name=None), -1) self.assertEqual(stdout.getvalue(), "second finally\nfirst finally\n") def test_stack_size_with_dead_code(self): # Simply demonstrate more directly the previously mentioned issue. def test(*args): # pragma: no cover return 0 try: a = args[0] except IndexError: return -1 else: return a test.__code__ = Bytecode.from_code(test.__code__).to_code() self.assertEqual(test.__code__.co_stacksize, 1) self.assertEqual(test(1), 0) def test_huge_code_with_numerous_blocks(self): def base_func(x): pass def mk_if_then_else(depth): instructions = [] for i in range(depth): label_else = Label() instructions.extend( [ Instr("LOAD_FAST", "x"), Instr("POP_JUMP_IF_FALSE", label_else), Instr("LOAD_GLOBAL", "f{}".format(i)), Instr("RETURN_VALUE"), label_else, ] ) instructions.extend([Instr("LOAD_CONST", None), Instr("RETURN_VALUE")]) return instructions bytecode = Bytecode(mk_if_then_else(5000)) bytecode.compute_stacksize() if __name__ == "__main__": unittest.main() # pragma: no cover
28,547
Python
33.107527
126
0.507374
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_code.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') import unittest from _pydevd_frame_eval.vendored.bytecode import ConcreteBytecode, Bytecode, ControlFlowGraph from _pydevd_frame_eval.vendored.bytecode.tests import get_code class CodeTests(unittest.TestCase): """Check that bytecode.from_code(code).to_code() returns code.""" def check(self, source, function=False): ref_code = get_code(source, function=function) code = ConcreteBytecode.from_code(ref_code).to_code() self.assertEqual(code, ref_code) code = Bytecode.from_code(ref_code).to_code() self.assertEqual(code, ref_code) bytecode = Bytecode.from_code(ref_code) blocks = ControlFlowGraph.from_bytecode(bytecode) code = blocks.to_bytecode().to_code() self.assertEqual(code, ref_code) def test_loop(self): self.check( """ for x in range(1, 10): x += 1 if x == 3: continue x -= 1 if x > 7: break x = 0 print(x) """ ) def test_varargs(self): self.check( """ def func(a, b, *varargs): pass """, function=True, ) def test_kwargs(self): self.check( """ def func(a, b, **kwargs): pass """, function=True, ) def test_kwonlyargs(self): self.check( """ def func(*, arg, arg2): pass """, function=True, ) # Added because Python 3.10 added some special beahavior with respect to # generators in term of stack size def test_generator_func(self): self.check( """ def func(arg, arg2): yield """, function=True, ) def test_async_func(self): self.check( """ async def func(arg, arg2): pass """, function=True, ) if __name__ == "__main__": unittest.main() # pragma: no cover
2,425
Python
24.80851
126
0.516289
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_bytecode.py
import pytest from tests_python.debugger_unittest import IS_PY36_OR_GREATER, IS_CPYTHON from tests_python.debug_constants import TEST_CYTHON pytestmark = pytest.mark.skipif(not IS_PY36_OR_GREATER or not IS_CPYTHON or not TEST_CYTHON, reason='Requires CPython >= 3.6') #!/usr/bin/env python3 import sys import textwrap import unittest from _pydevd_frame_eval.vendored.bytecode import Label, Instr, FreeVar, Bytecode, SetLineno, ConcreteInstr from _pydevd_frame_eval.vendored.bytecode.tests import TestCase, get_code class BytecodeTests(TestCase): maxDiff = 80 * 100 def test_constructor(self): code = Bytecode() self.assertEqual(code.name, "<module>") self.assertEqual(code.filename, "<string>") self.assertEqual(code.flags, 0) self.assertEqual(code, []) def test_invalid_types(self): code = Bytecode() code.append(123) with self.assertRaises(ValueError): list(code) with self.assertRaises(ValueError): code.legalize() with self.assertRaises(ValueError): Bytecode([123]) def test_legalize(self): code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), Instr("LOAD_CONST", 8, lineno=4), Instr("STORE_NAME", "y"), Label(), SetLineno(5), Instr("LOAD_CONST", 9, lineno=6), Instr("STORE_NAME", "z"), ] ) code.legalize() self.assertListEqual( code, [ Instr("LOAD_CONST", 7, lineno=3), Instr("STORE_NAME", "x", lineno=3), Instr("LOAD_CONST", 8, lineno=4), Instr("STORE_NAME", "y", lineno=4), Label(), Instr("LOAD_CONST", 9, lineno=5), Instr("STORE_NAME", "z", lineno=5), ], ) def test_slice(self): code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ] ) sliced_code = code[:] self.assertEqual(code, sliced_code) for name in ( "argcount", "posonlyargcount", "kwonlyargcount", "first_lineno", "name", "filename", "docstring", "cellvars", "freevars", "argnames", ): self.assertEqual( getattr(code, name, None), getattr(sliced_code, name, None) ) def test_copy(self): code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ] ) copy_code = code.copy() self.assertEqual(code, copy_code) for name in ( "argcount", "posonlyargcount", "kwonlyargcount", "first_lineno", "name", "filename", "docstring", "cellvars", "freevars", "argnames", ): self.assertEqual(getattr(code, name, None), getattr(copy_code, name, None)) def test_from_code(self): code = get_code( """ if test: x = 1 else: x = 2 """ ) bytecode = Bytecode.from_code(code) label_else = Label() label_exit = Label() if sys.version_info < (3, 10): self.assertEqual( bytecode, [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label_else, lineno=1), Instr("LOAD_CONST", 1, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("JUMP_FORWARD", label_exit, lineno=2), label_else, Instr("LOAD_CONST", 2, lineno=4), Instr("STORE_NAME", "x", lineno=4), label_exit, Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ], ) # Control flow handling appears to have changed under Python 3.10 else: self.assertEqual( bytecode, [ Instr("LOAD_NAME", "test", lineno=1), Instr("POP_JUMP_IF_FALSE", label_else, lineno=1), Instr("LOAD_CONST", 1, lineno=2), Instr("STORE_NAME", "x", lineno=2), Instr("LOAD_CONST", None, lineno=2), Instr("RETURN_VALUE", lineno=2), label_else, Instr("LOAD_CONST", 2, lineno=4), Instr("STORE_NAME", "x", lineno=4), Instr("LOAD_CONST", None, lineno=4), Instr("RETURN_VALUE", lineno=4), ], ) def test_from_code_freevars(self): ns = {} exec( textwrap.dedent( """ def create_func(): x = 1 def func(): return x return func func = create_func() """ ), ns, ns, ) code = ns["func"].__code__ bytecode = Bytecode.from_code(code) self.assertEqual( bytecode, [ Instr("LOAD_DEREF", FreeVar("x"), lineno=5), Instr("RETURN_VALUE", lineno=5), ], ) def test_from_code_load_fast(self): code = get_code( """ def func(): x = 33 y = x """, function=True, ) code = Bytecode.from_code(code) self.assertEqual( code, [ Instr("LOAD_CONST", 33, lineno=2), Instr("STORE_FAST", "x", lineno=2), Instr("LOAD_FAST", "x", lineno=3), Instr("STORE_FAST", "y", lineno=3), Instr("LOAD_CONST", None, lineno=3), Instr("RETURN_VALUE", lineno=3), ], ) def test_setlineno(self): # x = 7 # y = 8 # z = 9 code = Bytecode() code.first_lineno = 3 code.extend( [ Instr("LOAD_CONST", 7), Instr("STORE_NAME", "x"), SetLineno(4), Instr("LOAD_CONST", 8), Instr("STORE_NAME", "y"), SetLineno(5), Instr("LOAD_CONST", 9), Instr("STORE_NAME", "z"), ] ) concrete = code.to_concrete_bytecode() self.assertEqual(concrete.consts, [7, 8, 9]) self.assertEqual(concrete.names, ["x", "y", "z"]) self.assertListEqual( list(concrete), [ ConcreteInstr("LOAD_CONST", 0, lineno=3), ConcreteInstr("STORE_NAME", 0, lineno=3), ConcreteInstr("LOAD_CONST", 1, lineno=4), ConcreteInstr("STORE_NAME", 1, lineno=4), ConcreteInstr("LOAD_CONST", 2, lineno=5), ConcreteInstr("STORE_NAME", 2, lineno=5), ], ) def test_to_code(self): code = Bytecode() code.first_lineno = 50 code.extend( [ Instr("LOAD_NAME", "print"), Instr("LOAD_CONST", "%s"), Instr("LOAD_GLOBAL", "a"), Instr("BINARY_MODULO"), Instr("CALL_FUNCTION", 1), Instr("RETURN_VALUE"), ] ) co = code.to_code() # hopefully this is obvious from inspection? :-) self.assertEqual(co.co_stacksize, 3) co = code.to_code(stacksize=42) self.assertEqual(co.co_stacksize, 42) def test_negative_size_unary(self): opnames = ( "UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "UNARY_INVERT", ) for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr(opname)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_unary_with_disable_check_of_pre_and_post(self): opnames = ( "UNARY_POSITIVE", "UNARY_NEGATIVE", "UNARY_NOT", "UNARY_INVERT", ) for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr(opname)]) co = code.to_code(check_pre_and_post=False) self.assertEqual(co.co_stacksize, 0) def test_negative_size_binary(self): opnames = ( "BINARY_POWER", "BINARY_MULTIPLY", "BINARY_MATRIX_MULTIPLY", "BINARY_FLOOR_DIVIDE", "BINARY_TRUE_DIVIDE", "BINARY_MODULO", "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT", "BINARY_AND", "BINARY_XOR", "BINARY_OR", ) for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr(opname)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_binary_with_disable_check_of_pre_and_post(self): opnames = ( "BINARY_POWER", "BINARY_MULTIPLY", "BINARY_MATRIX_MULTIPLY", "BINARY_FLOOR_DIVIDE", "BINARY_TRUE_DIVIDE", "BINARY_MODULO", "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_SUBSCR", "BINARY_LSHIFT", "BINARY_RSHIFT", "BINARY_AND", "BINARY_XOR", "BINARY_OR", ) for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr(opname)]) co = code.to_code(check_pre_and_post=False) self.assertEqual(co.co_stacksize, 1) def test_negative_size_call(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("CALL_FUNCTION", 0)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_unpack(self): opnames = ( "UNPACK_SEQUENCE", "UNPACK_EX", ) for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr(opname, 1)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_build(self): opnames = ( "BUILD_TUPLE", "BUILD_LIST", "BUILD_SET", ) if sys.version_info >= (3, 6): opnames = (*opnames, "BUILD_STRING") for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr(opname, 1)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_build_map(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr("BUILD_MAP", 1)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_negative_size_build_map_with_disable_check_of_pre_and_post(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr("BUILD_MAP", 1)]) co = code.to_code(check_pre_and_post=False) self.assertEqual(co.co_stacksize, 1) @unittest.skipIf(sys.version_info < (3, 6), "Inexistent opcode") def test_negative_size_build_const_map(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", ("a",)), Instr("BUILD_CONST_KEY_MAP", 1)]) with self.assertRaises(RuntimeError): code.compute_stacksize() @unittest.skipIf(sys.version_info < (3, 6), "Inexistent opcode") def test_negative_size_build_const_map_with_disable_check_of_pre_and_post(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", ("a",)), Instr("BUILD_CONST_KEY_MAP", 1)]) co = code.to_code(check_pre_and_post=False) self.assertEqual(co.co_stacksize, 1) def test_empty_dup(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("DUP_TOP")]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_not_enough_dup(self): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr("DUP_TOP_TWO")]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_not_enough_rot(self): opnames = ["ROT_TWO", "ROT_THREE"] if sys.version_info >= (3, 8): opnames.append("ROT_FOUR") for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr(opname)]) with self.assertRaises(RuntimeError): code.compute_stacksize() def test_not_enough_rot_with_disable_check_of_pre_and_post(self): opnames = ["ROT_TWO", "ROT_THREE"] if sys.version_info >= (3, 8): opnames.append("ROT_FOUR") for opname in opnames: with self.subTest(): code = Bytecode() code.first_lineno = 1 code.extend([Instr("LOAD_CONST", 1), Instr(opname)]) co = code.to_code(check_pre_and_post=False) self.assertEqual(co.co_stacksize, 1) def test_for_iter_stack_effect_computation(self): with self.subTest(): code = Bytecode() code.first_lineno = 1 lab1 = Label() lab2 = Label() code.extend( [ lab1, Instr("FOR_ITER", lab2), Instr("STORE_FAST", "i"), Instr("JUMP_ABSOLUTE", lab1), lab2, ] ) with self.assertRaises(RuntimeError): # Use compute_stacksize since the code is so broken that conversion # to from concrete is actually broken code.compute_stacksize(check_pre_and_post=False) if __name__ == "__main__": unittest.main() # pragma: no cover
15,909
Python
31.535787
126
0.471117
omniverse-code/kit/exts/omni.kit.debug.python/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_resolver.py
from _pydev_bundle import pydev_log from _pydevd_bundle.pydevd_utils import hasattr_checked, DAPGrouper, Timer from io import StringIO import traceback from os.path import basename from functools import partial from _pydevd_bundle.pydevd_constants import IS_PY36_OR_GREATER, \ MethodWrapperType, RETURN_VALUES_DICT, DebugInfoHolder, IS_PYPY, GENERATED_LEN_ATTR_NAME from _pydevd_bundle.pydevd_safe_repr import SafeRepr # Note: 300 is already a lot to see in the outline (after that the user should really use the shell to get things) # and this also means we'll pass less information to the client side (which makes debugging faster). MAX_ITEMS_TO_HANDLE = 300 TOO_LARGE_MSG = 'Too large to show contents. Max items to show: ' + str(MAX_ITEMS_TO_HANDLE) TOO_LARGE_ATTR = 'Unable to handle:' #======================================================================================================================= # UnableToResolveVariableException #======================================================================================================================= class UnableToResolveVariableException(Exception): pass try: from collections import OrderedDict except: OrderedDict = dict try: import java.lang # @UnresolvedImport except: pass #======================================================================================================================= # See: pydevd_extension_api module for resolver interface #======================================================================================================================= def sorted_attributes_key(attr_name): if attr_name.startswith('__'): if attr_name.endswith('__'): # __ double under before and after __ return (3, attr_name) else: # __ double under before return (2, attr_name) elif attr_name.startswith('_'): # _ single under return (1, attr_name) else: # Regular (Before anything) return (0, attr_name) #======================================================================================================================= # DefaultResolver #======================================================================================================================= class DefaultResolver: ''' DefaultResolver is the class that'll actually resolve how to show some variable. ''' def resolve(self, var, attribute): return getattr(var, attribute) def get_contents_debug_adapter_protocol(self, obj, fmt=None): if MethodWrapperType: dct, used___dict__ = self._get_py_dictionary(obj) else: dct = self._get_jy_dictionary(obj)[0] lst = sorted(dct.items(), key=lambda tup: sorted_attributes_key(tup[0])) if used___dict__: eval_name = '.__dict__[%s]' else: eval_name = '.%s' ret = [] for attr_name, attr_value in lst: entry = (attr_name, attr_value, eval_name % attr_name) ret.append(entry) return ret def get_dictionary(self, var, names=None, used___dict__=False): if MethodWrapperType: return self._get_py_dictionary(var, names, used___dict__=used___dict__)[0] else: return self._get_jy_dictionary(var)[0] def _get_jy_dictionary(self, obj): ret = {} found = java.util.HashMap() original = obj if hasattr_checked(obj, '__class__') and obj.__class__ == java.lang.Class: # get info about superclasses classes = [] classes.append(obj) c = obj.getSuperclass() while c != None: classes.append(c) c = c.getSuperclass() # get info about interfaces interfs = [] for obj in classes: interfs.extend(obj.getInterfaces()) classes.extend(interfs) # now is the time when we actually get info on the declared methods and fields for obj in classes: declaredMethods = obj.getDeclaredMethods() declaredFields = obj.getDeclaredFields() for i in range(len(declaredMethods)): name = declaredMethods[i].getName() ret[name] = declaredMethods[i].toString() found.put(name, 1) for i in range(len(declaredFields)): name = declaredFields[i].getName() found.put(name, 1) # if declaredFields[i].isAccessible(): declaredFields[i].setAccessible(True) # ret[name] = declaredFields[i].get( declaredFields[i] ) try: ret[name] = declaredFields[i].get(original) except: ret[name] = declaredFields[i].toString() # this simple dir does not always get all the info, that's why we have the part before # (e.g.: if we do a dir on String, some methods that are from other interfaces such as # charAt don't appear) try: d = dir(original) for name in d: if found.get(name) != 1: ret[name] = getattr(original, name) except: # sometimes we're unable to do a dir pass return ret def get_names(self, var): used___dict__ = False try: names = dir(var) except Exception: names = [] if not names: if hasattr_checked(var, '__dict__'): names = list(var.__dict__) used___dict__ = True return names, used___dict__ def _get_py_dictionary(self, var, names=None, used___dict__=False): ''' :return tuple(names, used___dict__), where used___dict__ means we have to access using obj.__dict__[name] instead of getattr(obj, name) ''' # On PyPy we never show functions. This is because of a corner case where PyPy becomes # absurdly slow -- it takes almost half a second to introspect a single numpy function (so, # the related test, "test_case_16_resolve_numpy_array", times out... this probably isn't # specific to numpy, but to any library where the CPython bridge is used, but as we # can't be sure in the debugger, we play it safe and don't show it at all). filter_function = IS_PYPY if not names: names, used___dict__ = self.get_names(var) d = {} # Be aware that the order in which the filters are applied attempts to # optimize the operation by removing as many items as possible in the # first filters, leaving fewer items for later filters timer = Timer() cls = type(var) for name in names: try: name_as_str = name if name_as_str.__class__ != str: name_as_str = '%r' % (name_as_str,) if not used___dict__: attr = getattr(var, name) else: attr = var.__dict__[name] # filter functions? if filter_function: if inspect.isroutine(attr) or isinstance(attr, MethodWrapperType): continue except: # if some error occurs getting it, let's put it to the user. strIO = StringIO() traceback.print_exc(file=strIO) attr = strIO.getvalue() finally: timer.report_if_getting_attr_slow(cls, name_as_str) d[name_as_str] = attr return d, used___dict__ class DAPGrouperResolver: def get_contents_debug_adapter_protocol(self, obj, fmt=None): return obj.get_contents_debug_adapter_protocol() _basic_immutable_types = (int, float, complex, str, bytes, type(None), bool, frozenset) def _does_obj_repr_evaluate_to_obj(obj): ''' If obj is an object where evaluating its representation leads to the same object, return True, otherwise, return False. ''' try: if isinstance(obj, tuple): for o in obj: if not _does_obj_repr_evaluate_to_obj(o): return False return True else: return isinstance(obj, _basic_immutable_types) except: return False #======================================================================================================================= # DictResolver #======================================================================================================================= class DictResolver: sort_keys = not IS_PY36_OR_GREATER def resolve(self, dct, key): if key in (GENERATED_LEN_ATTR_NAME, TOO_LARGE_ATTR): return None if '(' not in key: # we have to treat that because the dict resolver is also used to directly resolve the global and local # scopes (which already have the items directly) try: return dct[key] except: return getattr(dct, key) # ok, we have to iterate over the items to find the one that matches the id, because that's the only way # to actually find the reference from the string we have before. expected_id = int(key.split('(')[-1][:-1]) for key, val in dct.items(): if id(key) == expected_id: return val raise UnableToResolveVariableException() def key_to_str(self, key, fmt=None): if fmt is not None: if fmt.get('hex', False): safe_repr = SafeRepr() safe_repr.convert_to_hex = True return safe_repr(key) return '%r' % (key,) def init_dict(self): return {} def get_contents_debug_adapter_protocol(self, dct, fmt=None): ''' This method is to be used in the case where the variables are all saved by its id (and as such don't need to have the `resolve` method called later on, so, keys don't need to embed the reference in the key). Note that the return should be ordered. :return list(tuple(name:str, value:object, evaluateName:str)) ''' ret = [] i = 0 found_representations = set() for key, val in dct.items(): i += 1 key_as_str = self.key_to_str(key, fmt) if key_as_str not in found_representations: found_representations.add(key_as_str) else: # If the key would be a duplicate, add the key id (otherwise # VSCode won't show all keys correctly). # See: https://github.com/microsoft/debugpy/issues/148 key_as_str = '%s (id: %s)' % (key_as_str, id(key)) found_representations.add(key_as_str) if _does_obj_repr_evaluate_to_obj(key): s = self.key_to_str(key) # do not format the key eval_key_str = '[%s]' % (s,) else: eval_key_str = None ret.append((key_as_str, val, eval_key_str)) if i > MAX_ITEMS_TO_HANDLE: ret.append((TOO_LARGE_ATTR, TOO_LARGE_MSG, None)) break # in case the class extends built-in type and has some additional fields from_default_resolver = defaultResolver.get_contents_debug_adapter_protocol(dct, fmt) if from_default_resolver: ret = from_default_resolver + ret if self.sort_keys: ret = sorted(ret, key=lambda tup: sorted_attributes_key(tup[0])) ret.append((GENERATED_LEN_ATTR_NAME, len(dct), partial(_apply_evaluate_name, evaluate_name='len(%s)'))) return ret def get_dictionary(self, dct): ret = self.init_dict() i = 0 for key, val in dct.items(): i += 1 # we need to add the id because otherwise we cannot find the real object to get its contents later on. key = '%s (%s)' % (self.key_to_str(key), id(key)) ret[key] = val if i > MAX_ITEMS_TO_HANDLE: ret[TOO_LARGE_ATTR] = TOO_LARGE_MSG break # in case if the class extends built-in type and has some additional fields additional_fields = defaultResolver.get_dictionary(dct) ret.update(additional_fields) ret[GENERATED_LEN_ATTR_NAME] = len(dct) return ret def _apply_evaluate_name(parent_name, evaluate_name): return evaluate_name % (parent_name,) #======================================================================================================================= # TupleResolver #======================================================================================================================= class TupleResolver: # to enumerate tuples and lists def resolve(self, var, attribute): ''' @param var: that's the original attribute @param attribute: that's the key passed in the dict (as a string) ''' if attribute in (GENERATED_LEN_ATTR_NAME, TOO_LARGE_ATTR): return None try: return var[int(attribute)] except: return getattr(var, attribute) def get_contents_debug_adapter_protocol(self, lst, fmt=None): ''' This method is to be used in the case where the variables are all saved by its id (and as such don't need to have the `resolve` method called later on, so, keys don't need to embed the reference in the key). Note that the return should be ordered. :return list(tuple(name:str, value:object, evaluateName:str)) ''' l = len(lst) ret = [] format_str = '%0' + str(int(len(str(l - 1)))) + 'd' if fmt is not None and fmt.get('hex', False): format_str = '0x%0' + str(int(len(hex(l).lstrip('0x')))) + 'x' for i, item in enumerate(lst): ret.append((format_str % i, item, '[%s]' % i)) if i > MAX_ITEMS_TO_HANDLE: ret.append((TOO_LARGE_ATTR, TOO_LARGE_MSG, None)) break # Needed in case the class extends the built-in type and has some additional fields. from_default_resolver = defaultResolver.get_contents_debug_adapter_protocol(lst, fmt=fmt) if from_default_resolver: ret = from_default_resolver + ret ret.append((GENERATED_LEN_ATTR_NAME, len(lst), partial(_apply_evaluate_name, evaluate_name='len(%s)'))) return ret def get_dictionary(self, var, fmt={}): l = len(var) d = {} format_str = '%0' + str(int(len(str(l - 1)))) + 'd' if fmt is not None and fmt.get('hex', False): format_str = '0x%0' + str(int(len(hex(l).lstrip('0x')))) + 'x' for i, item in enumerate(var): d[format_str % i] = item if i > MAX_ITEMS_TO_HANDLE: d[TOO_LARGE_ATTR] = TOO_LARGE_MSG break # in case if the class extends built-in type and has some additional fields additional_fields = defaultResolver.get_dictionary(var) d.update(additional_fields) d[GENERATED_LEN_ATTR_NAME] = len(var) return d #======================================================================================================================= # SetResolver #======================================================================================================================= class SetResolver: ''' Resolves a set as dict id(object)->object ''' def get_contents_debug_adapter_protocol(self, obj, fmt=None): ret = [] for i, item in enumerate(obj): ret.append((str(id(item)), item, None)) if i > MAX_ITEMS_TO_HANDLE: ret.append((TOO_LARGE_ATTR, TOO_LARGE_MSG, None)) break # Needed in case the class extends the built-in type and has some additional fields. from_default_resolver = defaultResolver.get_contents_debug_adapter_protocol(obj, fmt=fmt) if from_default_resolver: ret = from_default_resolver + ret ret.append((GENERATED_LEN_ATTR_NAME, len(obj), partial(_apply_evaluate_name, evaluate_name='len(%s)'))) return ret def resolve(self, var, attribute): if attribute in (GENERATED_LEN_ATTR_NAME, TOO_LARGE_ATTR): return None try: attribute = int(attribute) except: return getattr(var, attribute) for v in var: if id(v) == attribute: return v raise UnableToResolveVariableException('Unable to resolve %s in %s' % (attribute, var)) def get_dictionary(self, var): d = {} for i, item in enumerate(var): d[str(id(item))] = item if i > MAX_ITEMS_TO_HANDLE: d[TOO_LARGE_ATTR] = TOO_LARGE_MSG break # in case if the class extends built-in type and has some additional fields additional_fields = defaultResolver.get_dictionary(var) d.update(additional_fields) d[GENERATED_LEN_ATTR_NAME] = len(var) return d def change_var_from_name(self, container, name, new_value): # The name given in this case must be the id(item), so, we can actually # iterate in the set and see which item matches the given id. try: # Check that the new value can actually be added to a set (i.e.: it's hashable/comparable). set().add(new_value) except: return None for item in container: if str(id(item)) == name: container.remove(item) container.add(new_value) return str(id(new_value)) return None #======================================================================================================================= # InstanceResolver #======================================================================================================================= class InstanceResolver: def resolve(self, var, attribute): field = var.__class__.getDeclaredField(attribute) field.setAccessible(True) return field.get(var) def get_dictionary(self, obj): ret = {} declaredFields = obj.__class__.getDeclaredFields() for i in range(len(declaredFields)): name = declaredFields[i].getName() try: declaredFields[i].setAccessible(True) ret[name] = declaredFields[i].get(obj) except: pydev_log.exception() return ret #======================================================================================================================= # JyArrayResolver #======================================================================================================================= class JyArrayResolver: ''' This resolves a regular Object[] array from java ''' def resolve(self, var, attribute): if attribute == GENERATED_LEN_ATTR_NAME: return None return var[int(attribute)] def get_dictionary(self, obj): ret = {} for i in range(len(obj)): ret[ i ] = obj[i] ret[GENERATED_LEN_ATTR_NAME] = len(obj) return ret #======================================================================================================================= # MultiValueDictResolver #======================================================================================================================= class MultiValueDictResolver(DictResolver): def resolve(self, dct, key): if key in (GENERATED_LEN_ATTR_NAME, TOO_LARGE_ATTR): return None # ok, we have to iterate over the items to find the one that matches the id, because that's the only way # to actually find the reference from the string we have before. expected_id = int(key.split('(')[-1][:-1]) for key in list(dct.keys()): val = dct.getlist(key) if id(key) == expected_id: return val raise UnableToResolveVariableException() #======================================================================================================================= # DjangoFormResolver #======================================================================================================================= class DjangoFormResolver(DefaultResolver): def get_dictionary(self, var, names=None): # Do not call self.errors because it is a property and has side effects. names, used___dict__ = self.get_names(var) has_errors_attr = False if "errors" in names: has_errors_attr = True names.remove("errors") d = defaultResolver.get_dictionary(var, names=names, used___dict__=used___dict__) if has_errors_attr: try: errors_attr = getattr(var, "_errors") except: errors_attr = None d["errors"] = errors_attr return d #======================================================================================================================= # DequeResolver #======================================================================================================================= class DequeResolver(TupleResolver): def get_dictionary(self, var): d = TupleResolver.get_dictionary(self, var) d['maxlen'] = getattr(var, 'maxlen', None) return d #======================================================================================================================= # OrderedDictResolver #======================================================================================================================= class OrderedDictResolver(DictResolver): sort_keys = False def init_dict(self): return OrderedDict() #======================================================================================================================= # FrameResolver #======================================================================================================================= class FrameResolver: ''' This resolves a frame. ''' def resolve(self, obj, attribute): if attribute == '__internals__': return defaultResolver.get_dictionary(obj) if attribute == 'stack': return self.get_frame_stack(obj) if attribute == 'f_locals': return obj.f_locals return None def get_dictionary(self, obj): ret = {} ret['__internals__'] = defaultResolver.get_dictionary(obj) ret['stack'] = self.get_frame_stack(obj) ret['f_locals'] = obj.f_locals return ret def get_frame_stack(self, frame): ret = [] if frame is not None: ret.append(self.get_frame_name(frame)) while frame.f_back: frame = frame.f_back ret.append(self.get_frame_name(frame)) return ret def get_frame_name(self, frame): if frame is None: return 'None' try: name = basename(frame.f_code.co_filename) return 'frame: %s [%s:%s] id:%s' % (frame.f_code.co_name, name, frame.f_lineno, id(frame)) except: return 'frame object' defaultResolver = DefaultResolver() dictResolver = DictResolver() tupleResolver = TupleResolver() instanceResolver = InstanceResolver() jyArrayResolver = JyArrayResolver() setResolver = SetResolver() multiValueDictResolver = MultiValueDictResolver() djangoFormResolver = DjangoFormResolver() dequeResolver = DequeResolver() orderedDictResolver = OrderedDictResolver() frameResolver = FrameResolver() dapGrouperResolver = DAPGrouperResolver() class InspectStub: def isbuiltin(self, _args): return False def isroutine(self, object): return False try: import inspect except: inspect = InspectStub() def get_var_scope(attr_name, attr_value, evaluate_name, handle_return_values): if attr_name.startswith("'"): if attr_name.endswith("'"): attr_name = attr_name[1:-1] else: i = attr_name.find("__' (") if i >= 0: # Handle attr_name such as: >>'__name__' (1732494379184)<< attr_name = attr_name[1: i + 2] if handle_return_values and attr_name == RETURN_VALUES_DICT: return '' elif attr_name == GENERATED_LEN_ATTR_NAME: return '' if attr_name.startswith('__') and attr_name.endswith('__'): return DAPGrouper.SCOPE_SPECIAL_VARS if attr_name.startswith('_') or attr_name.endswith('__'): return DAPGrouper.SCOPE_PROTECTED_VARS try: if inspect.isroutine(attr_value) or isinstance(attr_value, MethodWrapperType): return DAPGrouper.SCOPE_FUNCTION_VARS elif inspect.isclass(attr_value): return DAPGrouper.SCOPE_CLASS_VARS except: # It's possible that isinstance throws an exception when dealing with user-code. if DebugInfoHolder.DEBUG_TRACE_LEVEL > 0: pydev_log.exception() return ''
25,500
Python
34.222376
120
0.504549