file_path
stringlengths 20
202
| content
stringlengths 9
3.85M
| size
int64 9
3.85M
| lang
stringclasses 9
values | avg_line_length
float64 3.33
100
| max_line_length
int64 8
993
| alphanum_fraction
float64 0.26
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/preference/model.py
|
import omni.ui as ui
from ..viewport_menu_model import ViewportMenuModel, AbstractViewportMenuItem
from ..menu_item.viewport_menubar_item import ViewportMenubar
from ..style import DEFAULT_MENUBAR_NAME
__all__ = ["PreferenceModel"]
class PreferenceModel(ui.AbstractItemModel):
"""
Wrapper model for preference page.
Only show default menubar in preference page. So using this wrapper to get menu items for default menubar only.
"""
def __init__(self, model: ViewportMenuModel):
self._model = model
self.__sub_menubar_changed = self._model.subscribe_item_changed_fn(self.__on_menuabr_changed)
super().__init__()
def destroy(self):
self.__sub_menubar_changed = None
def get_item_children(self, parent_item=None):
if parent_item is None:
for item in self._model.get_item_children():
if item.name == DEFAULT_MENUBAR_NAME:
# Only show default menubar
return self._model.get_item_children(item)
return []
def get_item_value_model_count(self, item: AbstractViewportMenuItem):
"""The number of columns"""
return 1
def get_item_value_model(self, item: AbstractViewportMenuItem, column_id: int):
if item and column_id == 0:
return ui.SimpleStringModel(item.name)
return ui.SimpleStringModel("")
"""Enable drag and drop"""
def get_drag_mime_data(self, item):
"""Returns Multipurpose Internet Mail Extensions (MIME) data for be able to drop this item somewhere"""
# As we don't do Drag and Drop to the operating system, we return the string.
return item.name
def drop_accepted(self, target_item, source, drop_location=-1):
"""Reimplemented from AbstractItemModel. Called to highlight target when drag and drop."""
if isinstance(source, AbstractViewportMenuItem) and target_item:
return True
else:
return False
def drop(self, target_item, source, drop_location=-1):
"""Reimplemented from AbstractItemModel. Called when dropping something to the item."""
if isinstance(source, AbstractViewportMenuItem):
self._drop_item(target_item, source, drop_location)
def _drop_item(self, target: AbstractViewportMenuItem, source: AbstractViewportMenuItem, drop_location=-1):
items = self.get_item_children()
source_index = items.index(source)
target_index = items.index(target)
if source_index > target_index:
# Drop forward, source in front of target
if target.order_model.as_int < 0:
# Left, make order of source smaller than target
source.order_model.set_value(target.order_model.as_int - 1)
# Make sure other items in front of source has smaller order
last = source
for item in reversed(items[0 : target_index]):
if item.order_model.as_int >= last.order_model.as_int:
item.order_model.set_value(last.order_model.as_int - 1)
last = item
else:
break
else:
# Right, replace order of source with target
source.order_model.set_value(target.order_model.as_int)
# Make sure other items behind source (include target) bas bigger order
last = source
for item in items[target_index:]:
if item.order_model.as_int <= last.order_model.as_int:
item.order_model.set_value(last.order_model.as_int + 1)
last = item
else:
break
else:
# Drop backward, source behind of target
if target.order_model.as_int < 0:
# Left, replace order of source with target
source.order_model.set_value(target.order_model.as_int)
# Make sure items bwtween source and target has smaller order
last = source
for item in reversed(items[source_index + 1 : target_index + 1]):
if item.order_model.as_int >= last.order_model.as_int:
item.order_model.set_value(last.order_model.as_int - 1)
break
else:
# Right, make order of next items bigger
source.order_model.set_value(target.order_model.as_int + 1)
last = source
for item in items[target_index + 1:]:
if item.order_model.as_int <= last.order_model.as_int:
item.order_model.set_value(last.order_model.as_int + 1)
last = item
else:
break
self._model._item_changed(source)
self._model._item_changed(None)
self._item_changed(source)
self._item_changed(None)
def __on_menuabr_changed(self, model: ui.AbstractItemModel, item: ui.AbstractItem):
# OM-77174: update preference treeview when
# menubar item changed
# Item is None means menubar item is removed
if item is None or isinstance(item, ViewportMenubar):
self._item_changed(None)
| 5,347 |
Python
| 43.941176 | 115 | 0.588741 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/preference/menubar_treeview_delegate.py
|
import omni.ui as ui
from typing import Dict, Callable
from ..menu_item.viewport_menu_item import ViewportMenuItem
from ..viewport_menu_model import ViewportMenuModel
from ..model.combobox_model import SettingComboBoxModel
from ..model.reset_button import ResetButton
__all__ = ["AlignmentImages", "MenubarTreeViewDelegate"]
class AlignmentImages():
def __init__(self, left: bool, on_alignment_changed: Callable[[bool], None], icon_size: int = 20):
self._on_alignment_clicked = on_alignment_changed
with ui.VStack(width=0):
ui.Spacer()
with ui.HStack(spacing=10, height=0):
self._left = ui.ImageWithProvider(width=icon_size, height=icon_size, style_type_name_override="TreeView.Item.Alignment", name="left", checked=not left)
self._right = ui.ImageWithProvider(width=icon_size, height=icon_size, style_type_name_override="TreeView.Item.Alignment", name="right", checked=left)
ui.Spacer()
if left:
self._right.set_mouse_pressed_fn(lambda x, y, b, a: on_alignment_changed(False))
else:
self._left.set_mouse_pressed_fn(lambda x, y, b, a: on_alignment_changed(True))
class MenubarTreeViewDelegate(ui.AbstractItemDelegate):
"""
Delegate is the representation layer. TreeView calls the methods
of the delegate to create custom widgets for each item.
"""
def __init__(self):
super().__init__()
self._widgets: Dict[ViewportMenuItem, ui.Widget] = {}
def destroy(self):
self._widgets.clear()
def build_branch(self, model, item, column_id, level, expanded):
"""Create a branch widget that opens or closes subtree"""
pass
def build_widget(self, model: ViewportMenuModel, item: ViewportMenuItem, column_id, level, expanded):
"""Create a widget per column per item"""
if "ViewportMenuSpacer" in item.name:
# Do not show spacer here
return
if column_id == 0:
self._widgets[item] = ui.HStack(height=20)
with self._widgets[item]:
# NAME
name_model = model.get_item_value_model(item, 0)
ui.Label(name_model.as_string, style_type_name_override="TreeView.Item.Label")
ui.Spacer()
with ui.HStack(spacing=10, width=ui.Percent(60)):
# Visible
with ui.VStack(width=0):
ui.Spacer()
ui.CheckBox(item.visible_model, width=10, height=0, style_type_name_override="TreeView.Item.CheckBox")
ui.Spacer()
# Alignment
AlignmentImages(item.order_model.as_int < 0, lambda l, m=model, i=item: self._on_alignment_changed(m, i, l))
# Expand
if item.expand_model:
expand_combox_model = SettingComboBoxModel(item.expand_model.path, ["Expanded", "Collapsed"], values=[True, False])
ui.ComboBox(expand_combox_model, style_type_name_override="TreeView.Item.ComboBox")
# Line
ui.Line(width=ui.Fraction(1), style_type_name_override="TreeView.Item.Line")
# Reset button
models = [item.visible_model, item.order_model]
if item.expand_model:
models.append(item.expand_model)
reset_btn = ResetButton(models, on_reset_fn=lambda m=model, i=item: self._on_reset(m, i))
item.visible_model.set_reset_button(reset_btn)
item.order_model.set_reset_button(reset_btn)
if item.expand_model:
item.expand_model.set_reset_button(reset_btn)
def _on_alignment_changed(self, model: ViewportMenuModel, item: ViewportMenuItem, left: bool):
item.order_model.set_value(-item.order_model.as_int)
# Need to update both item and whole treeview
model._item_changed(item)
model._item_changed(None)
def _on_reset(self, model: ViewportMenuModel, item: ViewportMenuItem):
# Need to update both item and whole treeview
model._item_changed(item)
model._item_changed(None)
| 4,296 |
Python
| 42.40404 | 167 | 0.600093 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/preference/menubar_page.py
|
from omni.kit.window.preferences import PreferenceBuilder
import omni.ui as ui
from typing import Optional
from .menubar_treeview_delegate import MenubarTreeViewDelegate
from .model import PreferenceModel
from ..viewport_menu_model import ViewportMenuModel
from ..style import VIEWPORT_PREFERENCE_STYLE
__all__ = ["ViewportMenubarPage"]
class ViewportMenubarPage(PreferenceBuilder):
"""
Represent a pereference page to show and edit viewport menubar settings.
"""
def __init__(self, model: ViewportMenuModel):
super().__init__("Viewport")
self._model = PreferenceModel(model)
self._tree_view: Optional[ui.TreeView] = None
def destroy(self):
if self._tree_view:
self._delegate.destroy()
self._tree_view.destroy()
self._tree_view = None
self._model.destroy()
def build(self):
self._delegate = MenubarTreeViewDelegate()
with self.add_frame("Viewport Toolbar"):
with ui.ScrollingFrame(style_type_name_override="TreeView.Frame", style=VIEWPORT_PREFERENCE_STYLE):
self._tree_view = ui.TreeView(self._model, delegate=self._delegate, root_visible=False)
| 1,196 |
Python
| 35.272726 | 111 | 0.686455 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/color_menu_item.py
|
from ..delegate.color_menu_delegate import ColorMenuDelegate
from ..model.list_model import ColorModel
from .viewport_menu_item import ViewportMenuItem
from typing import List, Optional
import carb.settings
import omni.kit.app
import omni.ui as ui
import asyncio
__all__ = ["AbstractColorMenuItem", "FloatArraySettingColorMenuItem"]
class AbstractColorMenuItem(ui.MenuItem):
def __init__(self, colors: List[float], name: str = "", default: Optional[List[float]] = None, has_reset: bool = False):
self.model = ColorModel(colors, default=default, on_color_changed_fn=self.on_color_changed)
super().__init__(name, delegate=ColorMenuDelegate(model=self.model, has_reset=has_reset), hide_on_click=False)
def destroy(self):
if self.model:
self.model.destroy()
self.model = None
def on_color_changed(self, colors: List[float]) -> None:
pass
def reset(self) -> None:
pass
class FloatArraySettingColorMenuItem(AbstractColorMenuItem):
def __init__(self, setting_path: str, default: List[float], name: str = "", start_index: int = 0, has_reset: bool = False):
self._settings = carb.settings.get_settings()
self.__path = setting_path
self.__start_index = start_index
self.__default = default
self.__color_size = len(default)
# Future used to collapse carb-settings change events for individual color components
self.__future = None
# Fill in default color if the setting key does not exists at all
color_array = self._settings.get(self.__path)
if color_array is None:
color_array = [0] * (start_index + self.__color_size)
for index, value in enumerate(self.__default):
color_array[start_index + index] = value
self._settings.set(self.__path, color_array)
self.__color_subs = None
self.__create_color_subs()
super().__init__(self._get_color(), default=self.__default, name=name, has_reset=has_reset)
def __del__(self):
self.destroy()
def destroy(self):
self.__color_subs = None
super().destroy()
def __get_color_paths(self):
for i in range(self.__start_index, self.__start_index + self.__color_size):
yield f"{self.__path}/{i}"
def __create_color_subs(self):
# Create the carb-settings event watchers on the individual color components
self.__color_subs = [omni.kit.app.SettingChangeSubscription(path, self.__on_change) for path in self.__get_color_paths()]
def __on_change(self, item: carb.dictionary.Item, event_type: carb.settings.ChangeEventType) -> None:
# Since the value is a color (3/4 elements), batch the model updated into a single call
# Skip any event thats not a change
if event_type != carb.settings.ChangeEventType.CHANGED:
return
# Check if an operation is already waiting to run
if self.__future and not self.__future.done():
return
# Create the Future to signal the model is up to date
self.__future = asyncio.Future()
async def update_model():
if not self.__future.done():
self.__future.set_result(True)
colors = self._get_color()
if colors != self.model.colors:
self.model.colors = colors
asyncio.ensure_future(update_model())
def _get_color(self) -> List[float]:
return [self._settings.get(path) for path in self.__get_color_paths()]
def destroy(self):
self.__color_subs = None
super().destroy()
def on_color_changed(self, colors: List[float]) -> None:
setting_colors = self._settings.get(self.__path)
if setting_colors is None:
# TODO: create default here? or required be filled outside
return
if setting_colors[self.__start_index : self.__start_index + self.__color_size] != colors:
for index, value in enumerate(colors):
setting_colors[self.__start_index + index] = value
# Kill the change subscription before the carb.settings.set call.
# This is to optimize the array change, which will delete and recreate elemetns individually.
# This is particularly noticable for large arrays (1000+), but since colors are arrays of 4 do it always.
try:
self.__color_subs = None
self._settings.set(self.__path, setting_colors)
finally:
self.__create_color_subs()
def reset(self) -> None:
self.model.restore_default()
| 4,660 |
Python
| 38.5 | 129 | 0.623176 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_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__ = ["ViewportMenuContainer"]
from ..viewport_menu_model import get_items, deregister
from ..viewport_menu_model import pop_from_scope
from ..viewport_menu_model import push_to_scope
from ..viewport_menu_model import ViewportMenuModel
from .viewport_menu_item import ViewportMenuItem
from typing import Dict
import omni.ui as ui
class ViewportMenuContainer(ViewportMenuItem):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# When visible and order changed, trigger UI updates
self._visible_sub = self.visible_model.subscribe_value_changed_fn(lambda m: self._invalidate())
self._order_sub = self.order_model.subscribe_value_changed_fn(lambda m: self._invalidate())
def destroy(self):
self._visible_sub = None
self._order_sub = None
# Clean children
self._clean()
super().destroy()
def build_fn(self, factory: Dict):
"""Reimplement it to have own customized item"""
children = self._children
# TODO: Lazy menu
with ui.Menu(self.name, delegate=self._delegate, style=self._style):
for child in children:
child.build_fn(factory)
def __enter__(self):
# Clean all existing child items
# For multiple viewport window, menu contrainer may build multiple times
# Make sure child items not duplicated
self._clean()
push_to_scope(self)
def __exit__(self, exc_type, exc_value, traceback):
pop_from_scope()
@property
def _children(self):
# TODO: Sorting code
return get_items(self.name)
def _invalidate(self) -> None:
ViewportMenuModel()._item_changed(None)
def _clean(self):
for child in self._children:
child.destroy()
| 2,244 |
Python
| 32.507462 | 103 | 0.67246 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_menu_item.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__ = ["ViewportMenuItem"]
from ..viewport_menu_model import AbstractViewportMenuItem
from typing import Callable, Dict, Optional
import omni.ui as ui
class ViewportMenuItem(AbstractViewportMenuItem):
def __init__(
self,
name: str = "",
icon: str = "", # glyph?
hide_on_click: bool = True,
appear_after: str = "", # order/priority?
onclick_fn: Callable = None,
delegate: ui.MenuDelegate = None,
visible_setting_path: Optional[str] = None,
order_setting_path: Optional[str] = None,
expand_setting_path: Optional[str] = None,
style: Dict = {},
order: int = None # deprecated legacy interface
):
self._icon = icon
self._hide_on_click = hide_on_click
self._appear_after = appear_after
self._onclick_fn = onclick_fn
self._delegate = delegate
self._style = style
self._menu_item: Optional[ui.MenuItem] = None
super().__init__(
name,
visible_setting_path=visible_setting_path,
order_setting_path=order_setting_path,
expand_setting_path=expand_setting_path,
)
if (order_setting_path is None) and (order is not None):
import carb
carb.log_warn(f"ViewportMenuItem order argument is deprecated, use order_setting_path")
self.order_model = ui.SimpleIntModel(order)
def destroy(self):
self._onclick_fn = None
self._delegate = None
super().destroy()
@property
def visible(self) -> bool:
return self.visible_model.as_bool
@visible.setter
def visible(self, value: bool) -> None:
self.visible_model.set_value(value)
if self._menu_item:
self._menu_item.visible = value
@property
def menu_item(self) -> ui.MenuItem:
return self._menu_item
def build_fn(self, factory: Dict):
"""Reimplement it to have own customized item"""
self._menu_item = ui.MenuItem(
self.name,
triggered_fn=self._onclick_fn,
delegate=self._delegate,
hide_on_click=self._hide_on_click,
visible=self.visible_model.as_bool,
style=self._style,
)
def invalidate(self):
pass
| 2,752 |
Python
| 31.773809 | 99 | 0.619549 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/selectable_menu_item.py
|
from typing import Callable
from ..delegate.viewport_menu_delegate import ViewportMenuDelegate
from omni import ui
__all__ = ["SelectableMenuItem"]
class SelectableMenuItem(ui.MenuItem):
"""Menu item could be selected and show icon when selected.
kwargs:
model (ui.AbstractValueModel): Model for selected status. Defaults to a ui.SimpleBoolModel when not provided.
toggle (bool): Whether this item can be toggled to (on/off) or always triggers on
For other kwargs, please refer to ui.MenuItem
"""
def __init__(self, name: str,
model: ui.AbstractValueModel = None,
delegate: ui.MenuDelegate = None,
hide_on_click: bool = False,
toggle: bool = True,
triggered_fn: Callable = None,
trigger_will_set_model: bool = False,
**kwargs):
if model is None:
model = ui.SimpleBoolModel()
if delegate is None:
delegate = ViewportMenuDelegate()
self._triggered_fn = triggered_fn
self.__trigger_will_set_model = trigger_will_set_model
kwargs['triggered_fn'] = self._on_triggered
if toggle:
kwargs['selected'] = kwargs.get('selected', model.as_bool)
else:
kwargs['checkable'] = kwargs.get('checkable', True)
kwargs['checked'] = kwargs.get('checked', model.as_bool)
super().__init__(
name,
delegate=delegate,
hide_on_click=hide_on_click,
**kwargs
)
self._sub = model.subscribe_value_changed_fn(self._on_value_changed)
self.model = model
self.__toggle = toggle
def __del__(self):
self.destroy()
def destroy(self) -> None:
self.set_triggered_fn(None)
model, self.model, self._sub = self.model, None, None
if model:
if hasattr(model, 'destroy'):
model.destroy()
super().destroy()
def _on_triggered(self) -> None:
if not self.__trigger_will_set_model:
if self.__toggle:
self.model.set_value(not self.model.as_bool)
else:
self.model.set_value(True)
if self._triggered_fn:
self._triggered_fn()
def _on_value_changed(self, model: ui.AbstractValueModel) -> None:
# When value changed, update selected status
value = model.as_bool
attr_name = 'selected' if self.__toggle else 'checked'
if getattr(self.delegate, attr_name) != value:
setattr(self.delegate, attr_name, value)
| 2,635 |
Python
| 33.233766 | 117 | 0.576471 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_menu_separator.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__ = ["ViewportMenuSeparator"]
from .viewport_menu_item import ViewportMenuItem
from typing import Dict
import omni.ui as ui
class ViewportMenuSeparator(ViewportMenuItem):
"""A simple separator"""
def build_fn(self, factory: Dict):
ui.Separator(
delegate=ui.MenuDelegate(
on_build_item=lambda _: ui.Line(
height=0, alignment=ui.Alignment.V_CENTER, style_type_name_override="Menu.Separator"
)
)
)
| 938 |
Python
| 33.777777 | 104 | 0.702559 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/category_menu_collection.py
|
import omni.kit.app
from omni import ui
from ..model.category_model import SimpleCategoryModel, CategoryStateItem, CategoryCollectionItem, CategoryCustomItem
from ..delegate.category_menu_delegate import CategoryMenuDelegate, CategoryStatus
from ..utils import menu_is_tearable
from .selectable_menu_item import SelectableMenuItem
from typing import Callable, Dict, Optional
__all__ = ["CategoryMenuCollection"]
class CategoryMenuCollection(ui.MenuItemCollection):
"""
A Menu with ratio sub menu items.
Args:
text (str): Menu text
model (SimpleCategoryModel): Model for sub menu items
item (CategoryCollectionItem): Item for this collection
"""
def __init__(self, model: SimpleCategoryModel, item: CategoryCollectionItem, identifier: str = None,
trigger_fns: Optional[Dict[str, Callable]] = None):
# XXX: trigger_fns is a workaround for omni.kit.viewport.menubar.display
# do not expect it will always exists!
self.__trigger_fns: Optional[Dict[str, Callable]] = trigger_fns
self.__identifier = identifier
self._model = model
self._item = item
self._delegate = CategoryMenuDelegate(item.status, icon_clicked_fn=self._on_icon_clicked)
self._sub = self._item.status_model.subscribe_value_changed_fn(self._on_status_changed)
super().__init__(item.text, delegate=self._delegate,
on_build_fn=self._build_menu_items,
hide_on_click=False,
tearable=menu_is_tearable(identifier),
shown_changed_fn=item.shown_changed_fn)
def destroy(self) -> None:
self._sub = None
if self._item:
self._item.destroy()
self._item = None
self.__trigger_fns = None
super().destroy()
def _build_menu_items(self):
custom_items = []
def attach_trigger_fn(item, name: str):
if self.__trigger_fns and item and name:
# Try to pull a triggered_fn from the ones provided
trigger_fn = self.__trigger_fns.get(name)
if trigger_fn:
item.set_triggered_fn(trigger_fn)
show_separator = False
for item in self._model.get_item_children(self._item):
name: str = getattr(item, "text", "")
if isinstance(item, CategoryStateItem):
item = SelectableMenuItem(item.text, model=item.value_model)
show_separator = True
if isinstance(item, CategoryCollectionItem):
item = CategoryMenuCollection(self._model, item)
show_separator = True
elif isinstance(item, CategoryCustomItem):
item = custom_items.append(item)
attach_trigger_fn(item, name)
if custom_items:
# Custom items have different states from other category items
# Show a separator here if required
if show_separator:
ui.Separator()
for item in custom_items:
name: str = getattr(item, "text", "")
item = item.build_fn()
attach_trigger_fn(item, name)
def _on_status_changed(self, model: ui.AbstractValueModel) -> None:
self._delegate.status = self._item.status
def _on_icon_clicked(self, x, y, button, modifiers) -> None:
import carb
if button != int(carb.input.MouseInput.LEFT_BUTTON):
return
# XXX: trigger_fns workaround to avoid status-model subscriptions firing multiple times.
#
# There is a checken-egg problem here, where if the trigger_fn is run first the it must know about
# all-items current state to follow the all, empty, mixed model...but if run after then, the trigger_fn
# has no idea of what item transitioned to what state. Opting to deal with the first issue as this is
# only used for "Show By Type" where the bigger win is performance from batching all state transition into
# one UsdStage Traversal.
# But that means the status must be saved first, as triggered_fn may change child item state, which would affect
# how the models urrent state is chosen when it is run afterward.
cur_status = self._delegate.status
if cur_status == CategoryStatus.EMPTY or cur_status == CategoryStatus.MIXED:
cur_status = CategoryStatus.ALL
else:
cur_status = CategoryStatus.EMPTY
if self.__trigger_fns:
trigger_fn = self.__trigger_fns.get(self.__identifier)
if trigger_fn:
trigger_fn()
self._item.status = cur_status
| 4,729 |
Python
| 42 | 120 | 0.621062 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_menu_spacer.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__ = ["ViewportMenuSpacer"]
from .viewport_menu_item import ViewportMenuItem
from typing import Dict
import omni.ui as ui
class ViewportMenuSpacer(ViewportMenuItem):
"""A simple spacer"""
def __init__(self):
self.__spacer: Dict[int, ui.Spacer] = {}
super().__init__(order_setting_path="/exts/omni.kit.viewport.menubar.core/spacer/order")
def build_fn(self, factory_args: Dict):
viewport_api_id = factory_args['viewport_api'].id
self.__spacer[viewport_api_id] = ui.Spacer()
def get_computed_width(self, factory_args: Dict) -> float:
viewport_api_id = factory_args['viewport_api'].id
return self.__spacer[viewport_api_id].computed_width if viewport_api_id in self.__spacer else 0
| 1,185 |
Python
| 39.89655 | 103 | 0.720675 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/category_menu_container.py
|
from ..model.category_model import CategoryCustomItem, SimpleCategoryModel, CategoryStateItem, CategoryCollectionItem, CategoryStatus
from .category_menu_collection import CategoryMenuCollection
from .selectable_menu_item import SelectableMenuItem
from typing import Callable, Dict, Optional
__all__ = ["CategoryMenuContainer"]
class CategoryMenuContainer:
def __init__(self, model: SimpleCategoryModel, identifier: Optional[str] = None,
trigger_fns: Optional[Dict[str, Callable]] = None):
self._model = model
self.__identifier = identifier
self.build(trigger_fns)
def build(self, trigger_fns: Optional[Dict[str, Callable]] = None):
# XXX: trigger_fns is a workaround for omni.kit.viewport.menubar.display
# do not expect it will always exists!
for item in self._model.get_item_children():
name: str = getattr(item, "text", "")
if isinstance(item, CategoryCollectionItem):
identifier = f"{self.__identifier}.{name}" if self.__identifier else None
item = CategoryMenuCollection(self._model, item, identifier=identifier, trigger_fns=trigger_fns)
elif isinstance(item, CategoryStateItem):
item = SelectableMenuItem(name=name, model=item.value_model)
elif isinstance(item, CategoryCustomItem):
item = item.build_fn()
# Try to pull a triggered_fn from the ones provided
if trigger_fns and item and name:
trigger_fn = trigger_fns.get(name)
if trigger_fn:
item.set_triggered_fn(trigger_fn)
| 1,650 |
Python
| 46.171427 | 133 | 0.65697 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_menubar_item.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__ = ["ViewportMenubar"]
import asyncio
from dataclasses import dataclass, fields, field
from functools import partial
from ..viewport_menu_model import AbstractViewportMenuItem, AbstractViewportMenubarItem, ViewportMenuModel, push_to_scope, pop_from_scope, MenuDisplayStatus
from .viewport_menu_spacer import ViewportMenuSpacer
from typing import Callable, Dict, Optional, List
import omni.kit.app
import omni.ui as ui
from ..style import VIEWPORT_MENUBAR_STYLE
@dataclass
class MenubarContext:
frame: ui.Frame = None
background_rectangle: ui.Rectangle = None
resize_future: asyncio.Future = None
spacer_width: float = -1
sub_menu_expand: Dict = field(default_factory=dict)
def __init__(self, **kwargs):
names = set([f.name for f in fields(self)])
for k, v in kwargs.items():
if k in names:
setattr(self, k, v)
if not hasattr(self, "sub_menu_expand"):
self.sub_menu_expand = {}
class ViewportMenubar(AbstractViewportMenubarItem):
""""
Default viewport menubar, at the top of viewport.
Args:
name (str): Name of viewport menubar.
direction (ui.Direction): Layout direction of menu items in this menubar. Default ui.Direction.LEFT_TO_RIGHT.
spacing (ui.Length): Spacing between items. Default 10 pixles.
background_visible (bool): Show background for menu bar. Default False.
"""
def __init__(self,
name: str="",
direction: ui.Direction=ui.Direction.LEFT_TO_RIGHT,
spacing: ui.Length = 10,
style: Dict = {},
background_visible: bool = False,
visible_setting_path: Optional[str] = None,
):
self._direction = direction
self.__spacing = spacing
self._style = VIEWPORT_MENUBAR_STYLE.copy()
self._style.update(style)
self.__background_visible: bool = background_visible
self.__show_separator: bool = False
self.__context: Dict[int, MenubarContext] = {}
super().__init__(name=name, visible_setting_path=visible_setting_path)
@property
def visible(self) -> bool:
return self.visible_model.as_bool
@visible.setter
def visible(self, value: bool) -> None:
old_value = self.visible_model.as_bool
if old_value != value:
self.visible_model.set_value(value)
ViewportMenuModel()._item_changed(None)
@property
def background_visible(self) -> bool:
return self.__background_visible
@background_visible.setter
def background_visible(self, visible: bool) -> None:
self.__background_visible = visible
for context in self.__context.values():
context.background_rectangle.visible = self.__background_visible
@property
def style(self) -> Dict:
return self._style
@property
def spacing(self) -> ui.Length:
return self.__spacing
@spacing.setter
def spacing(self, value: ui.Length) -> None:
self.__spacing == value
for context in self.__context.values():
context.frame.rebuild()
@property
def show_separator(self) -> bool:
return self.__show_separator
@show_separator.setter
def show_separator(self, visible: bool) -> None:
self.__show_separator = visible
for context in self.__context.values():
context.frame.rebuild()
def destroy(self):
for context in self.__context.values():
if context.resize_future and not context.resize_future.done():
context.resize_future.cancel()
self.__context = {}
super().destroy()
def build_fn(self, menu_items: List[AbstractViewportMenuItem], factory_args: Dict, content_clipping=True):
# Using Frame with horizontal_clipping to prevent expanding of widgets when the menu bar is big
extra_kwargs = {}
if self._direction == ui.Direction.LEFT_TO_RIGHT:
extra_kwargs = {"height": 0}
elif self._direction == ui.Direction.TOP_TO_BOTTOM:
extra_kwargs = {"width": 0}
viewport_api_id = factory_args['viewport_api'].id
self.__context[viewport_api_id] = MenubarContext()
with ui.ZStack(style=self._style, height=0):
self.__context[viewport_api_id].background_rectangle = ui.Rectangle(style_type_name_override="MenuBar.Window", visible=self.__background_visible)
self.__context[viewport_api_id].frame = ui.Frame(horizontal_clipping=True, **extra_kwargs)
with self.__context[viewport_api_id].frame:
self._build_menubar(menu_items, factory_args, content_clipping=content_clipping)
self.__menu_items = menu_items
self.__available_clip_levels = [MenuDisplayStatus.EXPAND, MenuDisplayStatus.LABEL]
self.__clip_level = MenuDisplayStatus.MIN
self.__clip_size = {}
for level in self.__available_clip_levels:
self.__clip_size[level] = {}
self.__context[viewport_api_id].frame.set_computed_content_size_changed_fn(partial(self.__resize_menubar, factory_args))
def _build_menubar(self, menu_items: List[AbstractViewportMenuItem], factory_args: Dict, content_clipping=True):
viewport_api_id = factory_args['viewport_api'].id
# Filter out all hidden children
visible_menu_items = [item for item in menu_items if item.visible_model.as_bool]
# If all that remains is an empty list or a list of only ViewportMenuSpacer, then no menu
if sum(1 for item in visible_menu_items if (not isinstance(item, ViewportMenuSpacer))) == 0:
self.__context[viewport_api_id].frame.clear()
return
with ui.Menu(direction=self._direction, menu_compatibility=False, content_clipping=content_clipping):
first = True
for item in visible_menu_items:
if not first:
if self.__show_separator:
ui.Separator(
delegate=ui.MenuDelegate(
on_build_item=lambda _: ui.Line(
width=0,
alignment=ui.Alignment.H_CENTER,
style_type_name_override="Menu.Separator",
)
)
)
else:
if self._direction == ui.Direction.LEFT_TO_RIGHT:
ui.Spacer(width=self.__spacing)
else:
ui.Spacer(height=self.__spacing)
first = False
item.build_fn(factory_args)
if item.expand_model:
self.__context[viewport_api_id].sub_menu_expand[item] = item.expand_model.subscribe_value_changed_fn(lambda _, f=factory_args: self.__on_menu_expand_changed(f))
def invalidate(self):
pass
def __enter__(self):
# Clean all existing child items
# For multiple viewport window, menu contrainer may build multiple times
# Make sure child items not duplicated
# self._clean()
push_to_scope(self)
def __exit__(self, exc_type, exc_value, traceback):
pop_from_scope()
def __resize_menubar(self, factory_args: dict) -> None:
viewport_api_id = factory_args['viewport_api'].id
if self.__context[viewport_api_id].resize_future and not self.__context[viewport_api_id].resize_future.done():
return
self.__context[viewport_api_id].resize_future = asyncio.ensure_future(self.__resize_menubar_async(factory_args))
async def __resize_menubar_async(self, factory_args: dict) -> None:
viewport_api_id = factory_args['viewport_api'].id
menu_items = [item for item in self.__menu_items if item.visible_model.as_bool and not isinstance(item, ViewportMenuSpacer)]
# We need to know spacer size to check if items need resize
# Here use the default spacer item
spacer_items = [item for item in self.__menu_items if isinstance(item, ViewportMenuSpacer) and item.order_model.as_int == 0]
if spacer_items:
spacer_item = spacer_items[0]
else:
return
resize_again = True
while resize_again:
spacer_width = spacer_item.get_computed_width(factory_args)
resize_again = False
if spacer_width == 0:
# No more space left, check if something need to contract
resize_again = self.__check_contract(menu_items, factory_args)
elif spacer_width < self.__context[viewport_api_id].spacer_width or self.__context[viewport_api_id].spacer_width < 0:
# Spacer becomes small, check contract
# Some menu items such as Camera settings, maybe not expanded but need to check if enough space for expand settings
# Otherwise need to hide expand button
require_size = 0
for item in menu_items:
require_size += item.get_require_size(factory_args, expand=False)
if require_size > spacer_width:
resize_again = self.__check_contract(menu_items, factory_args)
elif spacer_width > self.__context[viewport_api_id].spacer_width:
# Spacer becomes bigger, check if we can expand menu items
require_size = 0
expand_items: List[AbstractViewportMenuItem] = []
for item in menu_items:
require_size += item.get_require_size(factory_args, expand=True)
expand_items.append(item)
if require_size < spacer_width:
for item in expand_items:
item.expand(factory_args)
resize_again = True
self.__context[viewport_api_id].spacer_width = spacer_width
if resize_again:
# Already resized, wait for menubar updated
# Need at least 2 frames for a new Viewport window
for i in range(2):
await omni.kit.app.get_app().next_update_async()
def __check_contract(self, menu_items: List[AbstractViewportMenuItem], factory_args: dict) -> bool:
contract_items: Dict[MenuDisplayStatus, List[AbstractViewportMenuItem]] = {}
# Figure how to contract
# Since there are different display status for different menu items
# Contract expand first and lable next
max_contract_status = MenuDisplayStatus.MIN
for item in menu_items:
display_status = item.get_display_status(factory_args)
if display_status == MenuDisplayStatus.MIN:
# Already in min display status, nothing to contract
continue
else:
if item.can_contract(factory_args):
# Record items can contract here but contract later
if display_status not in contract_items:
contract_items[display_status] = []
contract_items[display_status].append(item)
max_contract_status = max(display_status, max_contract_status)
contracted = False
# Only contract for one status: expand or label
if max_contract_status != MenuDisplayStatus.MIN:
for item in contract_items[max_contract_status]:
item.contract(factory_args)
contracted = True
return contracted
def __on_menu_expand_changed(self, factory_args: Dict):
# OM-64798: Menu item expand status changed, need to reset saved spacer width
viewport_api_id = factory_args['viewport_api'].id
spacer_items = [item for item in self.__menu_items if isinstance(item, ViewportMenuSpacer) and item.order_model.as_int == 0]
if spacer_items:
spacer_item = spacer_items[0]
async def __update_spacer_width():
await omni.kit.app.get_app().next_update_async()
self.__context[viewport_api_id].spacer_width = spacer_item.get_computed_width(factory_args)
asyncio.ensure_future(__update_spacer_width())
else:
return
| 12,770 |
Python
| 42.736301 | 180 | 0.61206 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/radio_menu_collection.py
|
from omni import ui
from ..model.combobox_model import ComboBoxModel
from ..delegate.viewport_menu_delegate import ViewportMenuDelegate
from ..utils import menu_is_tearable
from .viewport_menu_separator import ViewportMenuSeparator
__all__ = ["RadioMenuCollection"]
class RadioMenuCollection(ui.MenuItemCollection):
"""
A Menu with ratio sub menu items.
Args:
text (str): Menu text
model (ComboBoxModel): Model for sub menu items
hide_on_click (bool): Whether to hide the menu when an item is clicked
can_toggle_off (bool): Whether clicking an already selected item will togle it to off
delegate (ui.MenuDelegate): Delegate to show this menu collection
"""
def __init__(
self,
text: str,
model: ComboBoxModel,
identifier: str = None,
hide_on_click: bool = False,
can_toggle_off: bool = False,
delegate: ui.MenuDelegate = None
):
self._model = model
self._hide_on_click = hide_on_click
self.__menu_items = []
self.__in_triggered = False
self.__can_toggle_off = can_toggle_off
super().__init__(text, delegate=delegate, on_build_fn=self._build_menu_items, tearable=menu_is_tearable(identifier))
def __destroy_menu_items(self, value=None):
if self.__menu_items:
for menu_item in self.__menu_items:
menu_item.destroy()
self.__menu_items = value
def destroy(self) -> None:
model, self._model, self._sub = self._model, None, None
if model and hasattr(model, 'destroy'):
model.destroy()
self.__destroy_menu_items(None)
super().destroy()
def _build_menu_items(self):
self.__destroy_menu_items([])
with self:
for index, item in enumerate(self._model.get_item_children(None)):
menu_item = self.build_menu_item(item)
if not isinstance(menu_item, ViewportMenuSeparator):
menu_item.checkable = True
menu_item.checked=index == self._model.current_index.as_int
menu_item.set_triggered_fn(lambda i=index: self._item_chosen(i))
menu_item.hide_on_click=self._hide_on_click
# Only need to save the menu-item if cannot toggle to off
if not bool(self.__can_toggle_off):
self.__menu_items.append(menu_item)
# When current is changed outside, update menu items
self._sub = self._model.current_index.subscribe_value_changed_fn(self._on_current_changed)
self._sub_model = self._model.subscribe_item_changed_fn(self._on_item_changed)
def build_menu_item(self, item: ui.AbstractItem) -> ui.MenuItem:
return ui.MenuItem(
item.model.as_string,
delegate=ViewportMenuDelegate(),
)
def _item_chosen(self, index: int):
try:
self.__in_triggered = True
# Set the current index if it has changed
current_index = self._model.current_index.as_int if (self._model and self._model.current_index) else None
if current_index != index:
self._model.current_index.set_value(index)
elif (not bool(self.__can_toggle_off)) and self.__menu_items and index < len(self.__menu_items):
# Force the check state on in the case that it hasn't
import asyncio
async def force_checked_state(index: int, checked: bool):
self.__menu_items[index].checked = checked
asyncio.ensure_future(force_checked_state(index, True))
finally:
self.__in_triggered = False
def _on_current_changed(self, model: ui.AbstractValueModel):
if not self.__in_triggered:
self.invalidate()
def _on_item_changed(self, model: ui.AbstractValueModel, item: ui.AbstractItem):
self.invalidate()
| 3,965 |
Python
| 40.3125 | 124 | 0.607818 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/menu_item/viewport_button_item.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__ = ["ViewportButtonItem"]
from ..viewport_menu_model import AbstractViewportMenuItem, ViewportMenuModel
import asyncio
from typing import Callable, Dict, Optional, List
import omni.kit.app
import omni.ui as ui
from ..style import VIEWPORT_MENUBAR_STYLE
class ViewportButtonItem(AbstractViewportMenuItem):
"""
Build a button in viewport menubar:
Left click: toggle
Right click: flyout window or menu options
Kwargs:
build_menu_fn (Callable[[None], List[ui.MenuItem]]): Callback to create flyout menu when right click
build_window_fn (Callable[[None], ui.Window]): Callback to create flyout window when right click
alignment (ui.Alignment): How flyout window/menu align with button.
"""
def __init__(
self,
text: str = "",
name: str = "",
onclick_fn: Callable = None,
build_menu_fn: Callable[[None], List[ui.MenuItem]] = None,
build_window_fn: Callable[[None], ui.Window] = None,
visible_setting_path: Optional[str] = None,
order_setting_path: Optional[str] = None,
expand_setting_path: Optional[str] = None,
alignment: ui.Alignment = ui.Alignment.RIGHT_BOTTOM,
enabled: bool = True,
has_triangle: bool = False,
triangle_size: float = 6,
style: Dict = {},
):
self._text = text
self._onclick_fn = onclick_fn
self._build_menu_fn = build_menu_fn
self._build_window_fn = build_window_fn
self._style = style
self._alignment = alignment
self._enabled = enabled
self._selected = False
self._checked = False
self._has_triangle = has_triangle
self._triangle_size = triangle_size
self._menu: Optional[ui.MenuItem] = None
self._window: Optional[ui.Window] = None
self._button: Optional[ui.Button] = None
super().__init__(
name,
visible_setting_path=visible_setting_path,
order_setting_path=order_setting_path,
expand_setting_path=expand_setting_path,
)
# When visible and order changed, trigger UI updates
self._visible_sub = self.visible_model.subscribe_value_changed_fn(lambda m: self._invalidate())
self._order_sub = self.order_model.subscribe_value_changed_fn(lambda m: self._invalidate())
def destroy(self):
self._visible_sub = None
self._order_sub = None
self._onclick_fn = None
if self._menu:
self._menu.hide()
self._menu = None
if self._window:
self._window.visible = False
self._window = None
super().destroy()
@property
def visible(self) -> bool:
return self.visible_model.as_bool
@visible.setter
def visible(self, value: bool) -> None:
self.visible_model.set_value(value)
if self._menu:
self._menu.hide()
@property
def menu_item(self) -> ui.Menu:
return self._menu
@property
def window(self) -> ui.Window:
return self._window
@property
def name(self) -> str:
return self._name
@name.setter
def name(self, value: str) -> None:
self._name = value
if self._button:
self._button.name = value
@property
def enabled(self) -> bool:
return self._enabled
@enabled.setter
def enabled(self, value: bool) -> None:
self._enabled = value
if self._button:
self._button.enabled = value
@property
def selected(self) -> bool:
return self._selected
@selected.setter
def selected(self, value: bool) -> None:
self._selected = value
if self._button:
self._button.selected = value
@property
def checked(self) -> bool:
return self._checked
@checked.setter
def checked(self, value: bool) -> None:
self._checked = value
if self._button:
self._button.checked = value
def build_fn(self, factory: Dict):
"""Reimplement it to have own customized item"""
self._container = ui.ZStack(width=0)
with self._container:
if self._has_triangle:
with ui.VStack():
with ui.HStack():
ui.Spacer()
with ui.VStack(width=self._triangle_size):
ui.Spacer()
ui.Triangle(
width=self._triangle_size,
height=self._triangle_size,
alignment=ui.Alignment.RIGHT_TOP,
style_type_name_override="MenuBar.Item.Triangle",
)
ui.Spacer(width=2)
ui.Spacer(height=2)
ui.Rectangle(style_type_name_override="MenuBar.Item.Background")
self._button = ui.Button(
self._text,
name=self.name,
enabled=self._enabled,
selected=self._selected,
checked=self._checked,
width=0,
image_width=20,
visible=self.visible_model.as_bool,
style=self._style,
style_type_name_override="Menu.Button",
)
ui.Rectangle(style_type_name_override="Menubar.Hover")
self._container.set_mouse_pressed_fn(lambda x, y, b, a: self._on_mouse_clicked_fn(b))
def _build_menu(self):
style = VIEWPORT_MENUBAR_STYLE.copy()
style.update(self._style)
self._menu = ui.Menu("Button_Menu_" + str(hash(self)), menu_compatibility=False, style=style)
with self._menu:
self._menu_items = self._build_menu_fn()
def invalidate(self):
if self._menu:
self._menu.invalidate()
def _on_mouse_clicked_fn(self, button):
if button == 1:
self.on_right_clicked_fn()
elif button == 0:
if self._onclick_fn:
self._onclick_fn()
def on_right_clicked_fn(self):
"""Show flyout window/menu"""
if self._build_menu_fn:
self._show_menu()
elif self._build_window_fn:
self._show_window()
def _show_menu(self):
if self._menu is None:
self._build_menu()
(x, y) = (0, 0)
if self._alignment == ui.Alignment.RIGHT_BOTTOM:
x = self._container.screen_position_x + self._container.computed_content_width
y = self._container.screen_position_y + self._container.computed_content_height
if self._menu_items:
menu_window_width = self._menu_items[0].computed_content_width
if menu_window_width <= 0:
self._menu.show_at(-500, -100)
self._menu.hide()
async def __delay_change_menu_window_position(x, y):
await omni.kit.app.get_app().next_update_async()
x -= self._menu_items[0].computed_content_width
self._menu.show_at(x, y)
asyncio.ensure_future(__delay_change_menu_window_position(x, y))
return
else:
x -= self._menu_items[0].computed_content_width
elif self._alignment == ui.Alignment.LEFT_BOTTOM:
x = self._container.screen_position_x
y = self._container.screen_position_y + self._container.computed_content_height
self._menu.show_at(x, y)
def _show_window(self):
if self._window is None:
self._window = self._build_window_fn()
(x, y) = (0, 0)
if self._alignment == ui.Alignment.RIGHT_BOTTOM:
x = self._container.screen_position_x + self._container.computed_content_width
y = self._container.screen_position_y + self._container.computed_content_height
if self._window:
window_width = self._window.frame.computed_width
if window_width <= 0:
self._window.position_x = -500
self._window.position_y = -100
self._window.visible = True
async def __delay_change_window_position(x, y):
while self._window.frame.computed_width <= 0:
await omni.kit.app.get_app().next_update_async()
x -= self._window.frame.computed_width
self._window.position_x = x
self._window.position_y = y
self._window.visible = True
asyncio.ensure_future(__delay_change_window_position(x, y))
return
else:
x -= window_width
elif self._alignment == ui.Alignment.LEFT_BOTTOM:
x = self._container.screen_position_x
y = self._container.screen_position_y + self._container.computed_content_height
self._window.position_x = x
self._window.position_y = y
self._window.visible = True
def _invalidate(self) -> None:
ViewportMenuModel()._item_changed(None)
| 9,718 |
Python
| 35.130111 | 108 | 0.557625 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/spinner_menu_delegate.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__ = ["SpinnerMenuDelegate"]
from typing import Union, Optional
import omni.ui as ui
from omni.ui import color as cl, constant as fl
from omni.kit.widget.spinner import FloatSpinner
SPINNER_STYLE = {
"Spinner.Field": {"background_color": 0, "color": cl.viewport_menubar_light},
"Spinner.Field:disabled": {"color": cl.viewport_menubar_medium},
"Spinner.Arrow": {"background_color": cl.viewport_menubar_light},
"Spinner.Arrow:disabled": {"background_color": cl.viewport_menubar_medium},
}
class SpinnerMenuDelegate(ui.MenuDelegate):
"""Example of menu item with the spinner"""
def __init__(
self,
model=None,
tooltip=None,
width=ui.Fraction(1),
height=0,
min: Union[float, int, None] = None,
max: Union[float, int, None] = None,
step: Union[float, int] = 1,
enabled: bool = True,
text: bool = True,
icon_name: Optional[str] = None,
icon_width: ui.Length = 30,
icon_height: ui.Length = 30,
use_in_menubar: bool = False,
):
super().__init__()
self.__width = width
self.__height = height
self.__spinner_width = 60
self.__model = model
self.__tooltip = tooltip or ""
self._min = min
self._max = max
self._step = step
self.__enabled = enabled
self.__frame: Optional[ui.Widget] = None
self.__text = text
self.__icon_name = icon_name
self.__icon_width = icon_width
self.__icon_height = icon_height
self.__use_in_menubar = use_in_menubar
def __del__(self):
self.destroy()
def destroy(self):
self.__model = None
@property
def enabled(self) -> bool:
return self.__enabled
@enabled.setter
def enabled(self, value) -> None:
self.__enabled = value
if self.__frame:
self.__frame.enabled = value
self.__frame.enabled = value
def build_item(self, item):
extra_kwargs = {"style_type_name_override": "Menu.Item"} if not self.__use_in_menubar else {}
self.__frame = ui.Frame(width=self.__width, enabled=self.__enabled, **extra_kwargs)
with self.__frame:
with ui.HStack(height=self.__height):
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, tooltip=self.__tooltip, style_type_name_override="Menu.Item.Label")
with ui.VStack(width=self.__spinner_width):
ui.Spacer()
self.__spinner = FloatSpinner(
self.__model, min=self._min, max=self._max, step=self._step, style=SPINNER_STYLE
)
ui.Spacer()
ui.Spacer(width=5)
self.__spinner.enabled = self.__enabled
| 3,463 |
Python
| 34.71134 | 182 | 0.595437 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/slider_menu_delegate.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__ = ["SliderMenuDelegate"]
from typing import Optional, Union
import omni.ui as ui
from .abstract_widget_menu_delegate import AbstractWidgetMenuDelegate
class SliderMenuDelegate(AbstractWidgetMenuDelegate):
"""
Example of menu item with the slider
kwargs:
model (Optional[ui.AbstractValueModel]): Slider data model, default None
min (Union[float, int, None]): Min value of slider, default None
max (Union[float, int, None]): Max value of slider, default None
tooltip (Optional[str]): Tooltip of slider, default None
width (int): Width of slider, in pixles, default 270
slider_class (Union[ui.FloatSlider, ui.IntSlider]): Slider class, default ui.FloatSlider
show_checkbox_if_min (bool): Show checkbox instead of slider if value == min.
default_value_on (Union[float, int, None]): When checkbox is ON, value to display in slider. Default None
"""
def __init__(
self,
model: Optional[ui.AbstractValueModel] = None,
min: Union[float, int, None] = None,
max: Union[float, int, None] = None,
tooltip: Optional[str] = None,
width: int = 300,
slider_class: Union[ui.FloatSlider, ui.IntSlider] = ui.FloatSlider,
show_checkbox_if_min: bool = False,
default_value_on: Union[float, int, None] = None,
enabled: bool = True,
reserve_status: bool = False,
has_reset: bool = False,
step: Union[float, int, None] = None,
):
super().__init__(model=model, enabled=enabled, reserve_status=reserve_status, has_reset=has_reset)
self.__width = width
self.__space = 5
self.__slider_width = 90
self.__min = min
self.__max = max
self.__tooltip = tooltip or ""
self.__slider_class = slider_class
self.__show_checkbox_if_min = show_checkbox_if_min
self.__default_value_on = default_value_on
self.__slider = None
self.__step = step
def __del__(self):
self.destroy()
def destroy(self):
self._model = None
def build_widget(self, item: ui.MenuHelper):
ui.Label(item.text, tooltip=self.__tooltip, style_type_name_override="Menu.Item.Label")
ui.Spacer(width=self.__space)
with ui.ZStack(content_clipping=True, width=0):
if self.__show_checkbox_if_min and self.__min is not None:
self.__checkbox = ui.CheckBox(width=self.__slider_width, visible=False)
self.__checkbox.model.add_value_changed_fn(self.__on_checkbox_changed)
self.__slider_container = ui.VStack(width=self.__slider_width)
with self.__slider_container:
ui.Spacer()
kwargs = {"height": 0}
use_drag = False
min_value, max_value = self.__min, self.__max
# If only one of min/max ws provided, warn as the slider might be odd
if (min_value is None) != (max_value is None):
import carb
carb.log_warn("SliderMenuDelegate with only one of min/max provided")
if min_value is not None and self.__max is not None:
kwargs["min"] = min_value
kwargs["max"] = max_value
if max_value - min_value > 100:
use_drag = True
else:
use_drag = True
if min_value is not None:
kwargs["min"] = min_value
if max_value is not None:
kwargs["max"] = max_value
if self.__step is not None:
kwargs["step"] = self.__step
elif (self.__slider_class == ui.FloatSlider) and (min_value is not None) and (max_value is not None):
kwargs["step"] = self.calculate_step(min_value, max_value, None)
kwargs["precision"] = 3
if use_drag:
if self.__slider_class == ui.FloatSlider:
slider_class = ui.FloatDrag
if self.__slider_class == ui.IntSlider:
slider_class = ui.IntDrag
else:
slider_class = self.__slider_class
self.__slider = slider_class(self._model, **kwargs)
if self.__show_checkbox_if_min and self.__min is not None:
self.__slider.model.add_value_changed_fn(self.__on_slider_changed)
value = self.__slider.model.as_float
if value == self.__min:
self.__checkbox.visible = True
self.__slider.visible = False
ui.Spacer()
@property
def min(self) -> Union[float, int]:
return self.__min
@min.setter
def min(self, value: Union[float, int]) -> None:
self.__min = value
if self.__slider:
self.__slider.min = value
@property
def max(self) -> Union[float, int]:
return self.__max
@max.setter
def max(self, value: Union[float, int]) -> None:
self.__max = value
if self.__slider:
self.__slider.max = value
def calculate_step(self, min: float, max: float, slider: ui.Widget):
# TODO: Flag to normalize against slider.computed_width
import math
exponent = math.floor(math.log10(abs(max - min)))
return (10 ** exponent) / 100
def set_range(self, min: float, max: float):
self.__min, self.__max = min, max
slider = self.__slider
if slider:
slider.min = self.__min
slider.max = self.__max
# Auto compute step based on range and width
if self.__step is None:
slider.step = self.calculate_step(min, max, slider)
def __on_checkbox_changed(self, model: ui.AbstractValueModel) -> None:
if model.as_bool:
self.__checkbox.visible = False
self.__slider.visible = True
if self.__default_value_on is not None:
self.__slider.model.set_value(self.__default_value_on)
def __on_slider_changed(self, model: ui.AbstractValueModel) -> None:
if self.__min is not None:
if model.as_float == self.__min:
self.__checkbox.visible = True
self.__checkbox.model.set_value(False)
self.__slider.visible = False
| 6,945 |
Python
| 38.465909 | 117 | 0.565731 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/icon_menu_delegate.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__ = ["IconMenuDelegate"]
from typing import Optional, Callable
import omni.ui as ui
class IconMenuDelegate(ui.MenuDelegate):
"""
The menu delegate that draws in the menu bar the given icon and
optionally the text.
"""
def __init__(
self,
name: str,
text: bool = False,
width: ui.Length = 30,
height: ui.Length = 30,
has_triangle: bool = True,
triangle_size: float = 6,
checked: bool = False,
enabled: bool = True,
triggered_fn: Callable[[None], None] = None,
right_clicked_fn: Callable[[None], None] = None,
tooltip: Optional[str] = None,
build_custom_widgets: Callable[[ui.MenuItem], None] = None
):
super().__init__(propagate=False)
self._name = name
self._text = text
self._width = width
self._icon_width = width
self._height = height
self._has_triangle = has_triangle
self._triangle_size = triangle_size
self._checked = checked
self._enabled = enabled
self.__label = None
self.__tooltip = tooltip or ""
self._triggered_fn = triggered_fn
self._right_clicked_fn = right_clicked_fn
self._container: Optional[ui.Widget] = None
self.__label_size = 0
self.__build_custom_widgets = build_custom_widgets
def build_item(self, item: ui.MenuItem):
icon_type = "Menu.Item.Icon"
self._container = ui.ZStack(checked=self._checked, height=self._height)
with self._container:
if self._has_triangle:
with ui.VStack():
with ui.HStack():
ui.Spacer()
with ui.VStack(width=self._triangle_size):
ui.Spacer()
ui.Triangle(
width=self._triangle_size,
height=self._triangle_size,
alignment=ui.Alignment.RIGHT_TOP,
style_type_name_override="MenuBar.Item.Triangle",
)
ui.Spacer(width=2)
ui.Spacer(height=2)
ui.Rectangle(style_type_name_override="MenuBar.Item.Background")
spacer_width = 4
with ui.HStack(height=self._height, spacing=spacer_width):
self.icon = self._build_icon()
if self._text:
self.__label_container = ui.HStack(spacing=4)
with self.__label_container:
self.__label = ui.Label(item.text, height=self._height)
if self.__build_custom_widgets:
self.__build_custom_widgets(item)
ui.Spacer(width=4)
def __label_size_changed(menu_item):
if self.__label_container.computed_width + spacer_width > self.__label_size:
self.__label_size = self.__label_container.computed_width + spacer_width
self.__label_container.set_computed_content_size_changed_fn(lambda m=item: __label_size_changed(m))
ui.Rectangle(style_type_name_override="Menubar.Hover")
if self._triggered_fn or self._right_clicked_fn:
self._container.set_mouse_released_fn(lambda x, y, b, a: self._on_mouse_released(b))
@property
def text_size(self) -> float:
"""
Size of text displayed.
"""
return self.__label_size
@property
def text_visible(self) -> bool:
return self._text
@text_visible.setter
def text_visible(self, value: bool) -> None:
# Here only set status but need menu invilidate outside to refresh
self._text = value
@property
def checked(self) -> bool:
return self._container.checked if self._container else self._checked
@checked.setter
def checked(self, value) -> None:
self._checked = value
if self._container:
self._container.checked = value
@property
def enabled(self) -> bool:
return self._enabled
@enabled.setter
def enabled(self, value) -> None:
self._enabled = value
if self._container:
self._container.enabled = value
@property
def text(self):
return self.__label.text if self.__label else ''
@text.setter
def text(self, txt: str):
if self.__label:
self.__label.text = str(txt)
def destroy(self):
self.__build_custom_widgets = None
def _on_mouse_released(self, button: int) -> None:
if button == 0:
if self._triggered_fn:
self._triggered_fn()
elif button == 1:
if self._right_clicked_fn:
self._right_clicked_fn()
def _build_icon(self):
return ui.ImageWithProvider(
style_type_name_override="Menu.Item.Icon",
name=self._name,
width=self._icon_width,
height=self._height,
tooltip=self.__tooltip,
)
| 5,594 |
Python
| 33.96875 | 119 | 0.556489 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/viewport_menu_delegate.py
|
from typing import Union, Optional, Callable, List
import omni.ui as ui
STATUS_ICON_WIDTH = 20
MENU_ARROW_SIZE = 8
__all__ = ["OptionBoxStyle", "ViewportMenuDelegate"]
class ViewportMenuDelegate(ui.MenuDelegate):
"""The menu delegate that draws in the menu or menuitem the given status.
kwargs:
icon_name (str): Show icon after menu text. Default "" to do not show.
icon_width (int): Menu icon width. Defautl 16
reserve_status (bool): Reserve space for status icon. Default True.
force_checked (bool): Force to show checked status. It is strange that when a menu is checked, sub menu items
checked flag will be cleared. Use this flag to show correct sub menu item status.
"""
def __init__(
self,
icon_name: str = "",
icon_width: int = 16,
reserve_status: bool = True,
force_checked: bool = False,
icon_clicked_fn: Callable[[None], None] = None,
build_custom_widgets: Callable[[ui.MenuDelegate, Union[ui.MenuItem, ui.Menu]], None] = None
):
self._icon_name = icon_name
self._icon_width = icon_width
self._reserve_status = reserve_status
self._force_checked = force_checked
self._icon_clicked_fn = icon_clicked_fn
self.icon: Optional[ui.Widget] = None
self._container: Optional[ui.Widget] = None
self._build_custom_widgets = build_custom_widgets
super().__init__(propagate=False)
def __icon_clicked(self, x, y, *arg, **kwargs):
if self._icon_clicked_fn is None or self.icon is None:
return
left = self.icon.screen_position_x
top = self.icon.screen_position_y
if (x < left) or (y < top):
return
right = left + self.icon.computed_width
bottom = top + self.icon.computed_height
if (x > right) or (y > bottom):
return
self._icon_clicked_fn(x, y, *arg, **kwargs)
def build_item(self, item: Union[ui.MenuItem, ui.Menu]):
icon_type = "Menu.Item.Status"
if self._force_checked:
item.checked = self._force_checked
self._container = ui.HStack(
style_type_name_override="MenuBar.Item", selected=item.selected, checked=(item.checkable and item.checked)
)
with self._container:
selected = item.selected or (item.checkable and item.checked)
# Status icon before menu text
if selected or self._reserve_status:
self.icon = ui.ImageWithProvider(style_type_name_override=icon_type, width=STATUS_ICON_WIDTH, mouse_released_fn=self.__icon_clicked)
# Text
ui.Label(item.text, style_type_name_override="Menu.Item.Text")
if self._icon_name or self._build_custom_widgets or isinstance(item, ui.Menu):
ui.Spacer()
# Icon after menu text
if self._icon_name:
ui.Spacer(width=10)
ui.ImageWithProvider(
style_type_name_override="Menu.Item.Icon", name=self._icon_name, width=self._icon_width
)
if self._build_custom_widgets:
self._build_custom_widgets(self, item)
if isinstance(item, ui.Menu):
# For menu, show arrow for children
ui.Spacer(width=10)
with ui.VStack(width=MENU_ARROW_SIZE / 2):
ui.Spacer()
ui.Triangle(
height=MENU_ARROW_SIZE,
alignment=ui.Alignment.RIGHT_CENTER,
style_type_name_override="MenuBar.Item.Triangle",
)
ui.Spacer()
ui.Spacer(width=3)
def get_selected(self) -> bool:
return self._container.selected if self._container else False
def set_selected(self, value: bool) -> bool:
'''Set the 'selected' state and return whether it changed or not.'''
value = bool(value)
if self._container and (self.get_selected() != value):
self._container.selected = value
return True
return False
def get_checked(self) -> bool:
return self._container.checked if self._container else False
def set_checked(self, value: bool) -> bool:
'''Set the 'checked' state and return whether it changed or not.'''
value = bool(value)
if self._container and (self.get_checked() != value):
self._container.checked = value
return True
return False
def __on_additional_btn_clicked(self, button: ui.Button) -> None:
if self._on_additional_btn_clicked_fn:
self._on_additional_btn_clicked_fn(button)
@property
def selected(self) -> bool:
return self.get_selected()
@selected.setter
def selected(self, value: bool) -> None:
self.set_selected(value)
@property
def checked(self) -> bool:
return self.get_checked()
@checked.setter
def checked(self, value: bool) -> None:
self.set_checked(value)
| 5,113 |
Python
| 36.057971 | 148 | 0.587326 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/separator_menu_delegate.py
|
import omni.ui as ui
class SeparatorDelegate(ui.MenuDelegate):
"""Generic menu delegate with separator between menu items"""
def __init__(self):
super().__init__()
def __del__(self):
self.destroy()
def destroy(self):
pass
def build_item(self, item):
self.__frame = ui.Frame(style_type_name_override="Menu.Item")
with self.__frame:
ui.Line(width=2, alignment=ui.Alignment.V_CENTER, style_type_name_override="Menu.Item.Separator")
| 507 |
Python
| 24.399999 | 109 | 0.619329 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/category_menu_delegate.py
|
from typing import Callable
from .viewport_menu_delegate import ViewportMenuDelegate
from ..model.category_model import CategoryStatus
import omni.ui as ui
import carb.windowing
__all__ = ["CategoryMenuDelegate"]
class CategoryMenuDelegate(ViewportMenuDelegate):
def __init__(self, status: CategoryStatus, icon_clicked_fn: Callable[[None], None]=None):
self._status = status
super().__init__(icon_clicked_fn=icon_clicked_fn)
def build_item(self, item: ui.MenuItem):
# icons required
super().build_item(item)
if self.icon:
self.icon.name = self._status
self.icon.set_mouse_hovered_fn(self._on_icon_hovered)
@property
def status(self) -> CategoryStatus:
return self._status
@status.setter
def status(self, value: CategoryStatus) -> None:
self._status = value
if self.icon:
self.icon.name = self._status
def _on_icon_hovered(self, hovered):
try:
import omni.kit.window.cursor
main_curosr = omni.kit.window.cursor.get_main_window_cursor()
if main_curosr:
if hovered:
main_curosr.override_cursor_shape(carb.windowing.CursorStandardShape.HAND)
else:
main_curosr.clear_overridden_cursor_shape()
except ImportError:
carb.log_info("omni.kit.window.cursor not available, omni.kit.viewport.menubar cursor won't be changed")
pass
| 1,500 |
Python
| 33.906976 | 116 | 0.632 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/color_menu_delegate.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__ = ["ColorMenuDelegate"]
import omni.ui as ui
from .abstract_widget_menu_delegate import AbstractWidgetMenuDelegate
class ColorMenuDelegate(AbstractWidgetMenuDelegate):
"""Example of menu item with color widget"""
def __init__(self, model=None, tooltip=None, has_reset: bool = False):
super().__init__(model=model, width=210 + 90, has_reset=has_reset)
self.__color_widget_width = 20
self.__model = model
self.__tooltip = tooltip or ""
def __del__(self):
self.destroy()
def destroy(self):
self.__model = None
def build_widget(self, item: ui.MenuHelper):
ui.Label(item.text, tooltip=self.__tooltip, style_type_name_override="Menu.Item.Label")
ui.ColorWidget(self.__model, width=self.__color_widget_width, height=0)
ui.Spacer(width=70)
| 1,271 |
Python
| 37.545453 | 95 | 0.70417 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/checkbox_menu_delegate.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__ = ["CheckboxMenuDelegate"]
from typing import Optional
import omni.ui as ui
from .abstract_widget_menu_delegate import AbstractWidgetMenuDelegate
class CheckboxMenuDelegate(AbstractWidgetMenuDelegate):
"""Example of menu item with the slider"""
def __init__(
self,
model=None,
tooltip=None,
width: int = 300,
height=0,
enabled: bool = True,
use_in_menubar: bool = False,
has_reset: bool = False,
):
super().__init__(model, width=width, height=height, enabled=enabled, has_reset=has_reset, use_in_menubar=use_in_menubar)
self.__checkbox_width = 90 if width > 90 else 0
self.__model = model
self.__tooltip = tooltip or ""
def __del__(self):
self.destroy()
def destroy(self):
self.__model = None
def build_widget(self, item: ui.MenuHelper):
ui.Label(item.text, tooltip=self.__tooltip, style_type_name_override="Menu.Item.Label")
with ui.VStack(width=self.__checkbox_width):
ui.Spacer()
ui.CheckBox(self.__model, height=0)
ui.Spacer()
| 1,568 |
Python
| 32.382978 | 128 | 0.663265 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/abstract_widget_menu_delegate.py
|
import abc
import omni.ui as ui
from typing import Optional
from ..model.reset_button import ResetButton
MENU_ARROW_SIZE = 8
class AbstractWidgetMenuDelegate(ui.MenuDelegate):
def __init__(
self,
model = None,
width: ui.Length = ui.Fraction(1),
height: ui.Length = ui.Fraction(1),
enabled: bool = True,
has_reset: bool = False,
reserve_status: bool = False,
use_in_menubar: bool = False,
content_clipping: bool = True,
visible: bool = True,
):
super().__init__()
self._model = model
self.__width = width
self.__height = height
self.__enabled = enabled
self.__has_reset = has_reset
self.__reserve_status = reserve_status
self.__use_in_menubar = use_in_menubar
self.__content_clipping = content_clipping
self.__visible = visible
self.__frame: Optional[ui.Widget] = None
def destroy(self):
pass
def build_item(self, item):
extra_kwargs = {"style_type_name_override": "Menu.Item"} if not self.__use_in_menubar else {}
self.__frame = ui.Frame(width=self.__width, enabled=self.__enabled, visible=self.__visible, **extra_kwargs)
with self.__frame:
with ui.HStack(height=self.__height, content_clipping=self.__content_clipping):
if self.__reserve_status:
ui.Spacer(width=16)
self.build_widget(item)
if isinstance(item, ui.Menu):
# For menu, show arrow for children
ui.Spacer(width=10)
with ui.VStack(width=MENU_ARROW_SIZE / 2):
ui.Spacer()
ui.Triangle(
height=MENU_ARROW_SIZE,
alignment=ui.Alignment.RIGHT_CENTER,
style_type_name_override="MenuBar.Item.Triangle",
)
ui.Spacer()
ui.Spacer(width=3)
if self.__has_reset:
ui.Spacer(width=4)
with ui.VStack(width=0):
ui.Spacer(height=2)
self._reset_button = ResetButton([self._model])
self._model.set_reset_button(self._reset_button)
ui.Spacer()
@abc.abstractmethod
def build_widget(self, item: ui.MenuHelper):
pass
@property
def visible(self) -> bool:
return self.__frame.visible if self.__frame else self.__visible
@visible.setter
def visible(self, value: bool) -> None:
self.__visible = value
if self.__frame:
self.__frame.visible = value
@property
def enabled(self) -> bool:
return self.__enabled
@enabled.setter
def enabled(self, value) -> None:
self.__enabled = value
if self.__frame:
self.__frame.enabled = value
| 3,006 |
Python
| 32.043956 | 115 | 0.524285 |
omniverse-code/kit/exts/omni.kit.viewport.menubar.core/omni/kit/viewport/menubar/core/delegate/label_menu_delegate.py
|
import omni.ui as ui
class LabelMenuDelegate(ui.MenuDelegate):
"""
The menu delegate that show menu item text as a label.
kwargs:
enable (bool): Label enabled or not. Default True.
width (ui.Length): Label width. Default ui.Fraction(1).
height (ui.Length): Label height. Default 26 pixels.
alignment (ui.Alignment): Label alignment. Default ui.Alignment.CENTER.
"""
def __init__(
self,
enabled: bool = True,
width: ui.Length = ui.Fraction(1),
height: ui.Length = 26,
alignment: ui.Alignment = ui.Alignment.LEFT
):
super().__init__(propagate=False)
self.__enabled = enabled
self.__height = height
self.__width = width
self.__alignment = alignment
def build_item(self, item: ui.MenuItem):
self.__frame = ui.Frame(width=self.__width, height=self.__height, style_type_name_override="Menu.Item", enabled=self.__enabled)
with self.__frame:
ui.Label(item.text, style_type_name_override="Menu.Item.Label", alignment=self.__alignment)
| 1,105 |
Python
| 35.866665 | 135 | 0.61448 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.