from __future__ import annotations
import contextlib
from typing import Literal
from prettyqt import gui
from prettyqt.qt import QtGui
from prettyqt.utils import bidict
MOVE_MODE = bidict(move=QtGui.QTextCursor.MoveMode.MoveAnchor,
keep=QtGui.QTextCursor.MoveMode.KeepAnchor)
MoveModeStr = Literal["move", "keep"]
MOVE_OPERATION = bidict(
no_move=QtGui.QTextCursor.MoveOperation.NoMove,
start=QtGui.QTextCursor.MoveOperation.Start,
start_of_line=QtGui.QTextCursor.MoveOperation.StartOfLine,
start_of_block=QtGui.QTextCursor.MoveOperation.StartOfBlock,
start_of_word=QtGui.QTextCursor.MoveOperation.StartOfWord,
previous_block=QtGui.QTextCursor.MoveOperation.PreviousBlock,
previous_char=QtGui.QTextCursor.MoveOperation.PreviousCharacter,
previous_word=QtGui.QTextCursor.MoveOperation.PreviousWord,
up=QtGui.QTextCursor.MoveOperation.Up,
left=QtGui.QTextCursor.MoveOperation.Left,
word_left=QtGui.QTextCursor.MoveOperation.WordLeft,
end=QtGui.QTextCursor.MoveOperation.End,
end_of_line=QtGui.QTextCursor.MoveOperation.EndOfLine,
end_of_word=QtGui.QTextCursor.MoveOperation.EndOfWord,
end_of_block=QtGui.QTextCursor.MoveOperation.EndOfBlock,
next_block=QtGui.QTextCursor.MoveOperation.NextBlock,
from __future__ import annotations
from typing import Literal
from prettyqt import constants, gui, widgets
from prettyqt.qt import QtWidgets
from prettyqt.utils import InvalidParamError, bidict
SHAPE_MODE = bidict(
mask=QtWidgets.QGraphicsPixmapItem.ShapeMode.MaskShape,
bounding_rect=QtWidgets.QGraphicsPixmapItem.ShapeMode.BoundingRectShape,
heuristic_mask=QtWidgets.QGraphicsPixmapItem.ShapeMode.HeuristicMaskShape,
)
ShapeModeStr = Literal["mask", "bounding_rect", "heuristic_mask"]
QtWidgets.QGraphicsPixmapItem.__bases__ = (widgets.GraphicsItem, )
class GraphicsPixmapItem(QtWidgets.QGraphicsPixmapItem):
def serialize_fields(self):
return dict(
offset=self.offset(),
pixmap=self.get_pixmap(),
shape_mode=self.get_shape_mode(),
transformation_mode=self.get_transformation_mode(),
)
def set_transformation_mode(self, mode: constants.TransformationModeStr):
"""Set transformation mode.
from __future__ import annotations
from typing import Literal
from prettyqt import widgets
from prettyqt.qt import QtWidgets
from prettyqt.utils import InvalidParamError, bidict
MODE = bidict(
hex=QtWidgets.QLCDNumber.Mode.Hex,
decimal=QtWidgets.QLCDNumber.Mode.Dec,
octal=QtWidgets.QLCDNumber.Mode.Oct,
binary=QtWidgets.QLCDNumber.Mode.Bin,
)
ModeStr = Literal["hex", "decimal", "octal", "binary"]
SEGMENT_STYLE = bidict(
outline=QtWidgets.QLCDNumber.SegmentStyle.Outline,
filled=QtWidgets.QLCDNumber.SegmentStyle.Filled,
flat=QtWidgets.QLCDNumber.SegmentStyle.Flat,
)
SegmentStyleStr = Literal["outline", "filled", "flat"]
QtWidgets.QLCDNumber.__bases__ = (widgets.Frame, )
class LCDNumber(QtWidgets.QLCDNumber):
def serialize_fields(self):
return dict(
from __future__ import annotations
from typing import Literal
from prettyqt import core
from prettyqt.qt import QtCore
from prettyqt.utils import InvalidParamError, bidict
DELETION_POLICY = bidict(
keep=QtCore.QAbstractAnimation.DeletionPolicy.KeepWhenStopped,
delete=QtCore.QAbstractAnimation.DeletionPolicy.DeleteWhenStopped,
)
DeletionPolicyStr = Literal["keep", "delete"]
DIRECTION = bidict(
forward=QtCore.QAbstractAnimation.Direction.Forward,
backward=QtCore.QAbstractAnimation.Direction.Backward,
)
DirectionStr = Literal["forward", "backward"]
STATE = bidict(
stopped=QtCore.QAbstractAnimation.State.Stopped,
paused=QtCore.QAbstractAnimation.State.Paused,
running=QtCore.QAbstractAnimation.State.Running,
)
StateStr = Literal["stopped", "paused", "running"]
QtCore.QAbstractAnimation.__bases__ = (core.Object, )
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
from qtpy import QtWidgets, QtCore
from prettyqt import widgets, core
from prettyqt.utils import bidict
SCROLL_HINTS = bidict(ensure_visible=QtWidgets.QAbstractItemView.EnsureVisible,
position_at_top=QtWidgets.QAbstractItemView.PositionAtTop,
position_at_bottom=QtWidgets.QAbstractItemView.PositionAtBottom,
position_at_center=QtWidgets.QAbstractItemView.PositionAtCenter)
QtWidgets.QListWidget.__bases__ = (widgets.ListView,)
class NoData(object):
pass
class ListWidget(QtWidgets.QListWidget):
value_changed = core.Signal(object)
def __init__(self, parent=None, selection_mode="single"):
super().__init__(parent)
self.itemSelectionChanged.connect(self.on_index_change)
from prettyqt.qt import QtGui
from prettyqt.utils import InvalidParamError, bidict, mappers, types
mod = QtGui.QImageIOHandler
IMAGE_OPTION = bidict(
size=mod.ImageOption.Size,
clip_rect=mod.ImageOption.ClipRect,
scaled_size=mod.ImageOption.ScaledSize,
scaled_clip_rect=mod.ImageOption.ScaledClipRect,
description=mod.ImageOption.Description,
compression_ratio=mod.ImageOption.CompressionRatio,
gamma=mod.ImageOption.Gamma,
quality=mod.ImageOption.Quality,
name=mod.ImageOption.Name,
subtype=mod.ImageOption.SubType,
incremental_reading=mod.ImageOption.IncrementalReading,
endianness=mod.ImageOption.Endianness,
animation=mod.ImageOption.Animation,
background_color=mod.ImageOption.BackgroundColor,
# image_format=mod.ImageOption.ImageFormat,
supported_sub_types=mod.ImageOption.SupportedSubTypes,
optimized_write=mod.ImageOption.OptimizedWrite,
progressive_scan_write=mod.ImageOption.ProgressiveScanWrite,
image_transformation=mod.ImageOption.ImageTransformation,
)
ImageOptionStr = Literal["size", "clip_rect", "scaled_size",
"scaled_clip_rect", "description",
"compression_ratio", "gamma", "quality", "name",
"subtype", "incremental_reading", "endianness",
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
import pathlib
from typing import List, Optional
from qtpy import QtWidgets
from prettyqt import core, widgets
from prettyqt.utils import bidict
MODES = bidict(existing_file=QtWidgets.QFileDialog.ExistingFile,
existing_files=QtWidgets.QFileDialog.ExistingFiles,
any_file=QtWidgets.QFileDialog.AnyFile,
directory=QtWidgets.QFileDialog.Directory)
LABELS = bidict(look_in=QtWidgets.QFileDialog.LookIn,
filename=QtWidgets.QFileDialog.FileName,
filetype=QtWidgets.QFileDialog.FileType,
accept=QtWidgets.QFileDialog.Accept,
reject=QtWidgets.QFileDialog.Reject)
ACCEPT_MODES = bidict(save=QtWidgets.QFileDialog.AcceptSave,
open=QtWidgets.QFileDialog.AcceptOpen)
VIEW_MODES = bidict(detail=QtWidgets.QFileDialog.Detail,
list=QtWidgets.QFileDialog.List)
FILTERS = bidict(dirs=core.Dir.Dirs,
from __future__ import annotations
from typing import Literal
from prettyqt import constants, core, widgets
from prettyqt.qt import QtCore, QtWidgets
from prettyqt.utils import InvalidParamError, bidict
SIZE_CONSTRAINT = bidict(
default=QtWidgets.QLayout.SizeConstraint.SetDefaultConstraint,
fixed=QtWidgets.QLayout.SizeConstraint.SetFixedSize,
minimum=QtWidgets.QLayout.SizeConstraint.SetMinimumSize,
maximum=QtWidgets.QLayout.SizeConstraint.SetMaximumSize,
min_and_max=QtWidgets.QLayout.SizeConstraint.SetMinAndMaxSize,
none=QtWidgets.QLayout.SizeConstraint.SetNoConstraint,
)
SizeConstraintStr = Literal["default", "fixed", "minimum", "maximum",
"min_and_max", "none"]
QtWidgets.QLayout.__bases__ = (core.Object, widgets.LayoutItem)
class Layout(QtWidgets.QLayout):
def __getitem__(
self,
index: str | int) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
if isinstance(index, int):
item = self.itemAt(index)
widget = item.widget()
if widget is None:
from __future__ import annotations
from typing import Literal
from prettyqt import constants, gui, widgets
from prettyqt.qt import QtCharts
from prettyqt.utils import InvalidParamError, bidict
MARKER_SHAPES = bidict(
default=QtCharts.QLegend.MarkerShape.MarkerShapeDefault,
rectangle=QtCharts.QLegend.MarkerShape.MarkerShapeRectangle,
circle=QtCharts.QLegend.MarkerShape.MarkerShapeCircle,
from_series=QtCharts.QLegend.MarkerShape.MarkerShapeFromSeries,
)
MarkerShapeStr = Literal["default", "rectangle", "circle", "from_series"]
QtCharts.QLegend.__bases__ = (widgets.GraphicsWidget, )
class Legend:
def __init__(self, item: QtCharts.QLegend):
self.item = item
def __getattr__(self, val):
return getattr(self.item, val)
def serialize_fields(self):
return dict(
alignment=self.get_alignment(),
background_visible=self.isBackgroundVisible(),
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
from qtpy import QtWidgets, QtCore
from prettyqt import widgets, core
from prettyqt.utils import bidict
MODES = bidict(maximum=QtWidgets.QLayout.SetMaximumSize,
fixed=QtWidgets.QLayout.SetFixedSize)
ALIGNMENTS = bidict(left=QtCore.Qt.AlignLeft,
right=QtCore.Qt.AlignRight,
top=QtCore.Qt.AlignTop,
bottom=QtCore.Qt.AlignBottom)
QtWidgets.QLayout.__bases__ = (core.Object, QtWidgets.QLayoutItem)
class Layout(QtWidgets.QLayout):
def __repr__(self):
return f"{self.__class__.__name__}: {len(self)} children"
def set_margin(self, margin: int):
self.setContentsMargins(margin, margin, margin, margin)
def set_size_mode(self, mode: str):
"""set the size mode of the layout
from __future__ import annotations
from typing import Literal
from prettyqt import constants, core, widgets
from prettyqt.qt import QtCore, QtWidgets
from prettyqt.utils import InvalidParamError, bidict, types
INPUT = bidict(
press=QtWidgets.QScroller.Input.InputPress,
move=QtWidgets.QScroller.Input.InputMove,
release=QtWidgets.QScroller.Input.InputRelease,
)
InputStr = Literal["press", "move", "release"]
SCROLLER_GESTURE_TYPE = bidict(
touch=QtWidgets.QScroller.ScrollerGestureType.TouchGesture,
left_mouse_button=QtWidgets.QScroller.ScrollerGestureType.LeftMouseButtonGesture,
middle_mouse_button=QtWidgets.QScroller.ScrollerGestureType.MiddleMouseButtonGesture,
right_mouse_button=QtWidgets.QScroller.ScrollerGestureType.RightMouseButtonGesture,
)
ScrollGestureTypeStr = Literal[
"touch", "left_mouse_button", "middle_mouse_button", "right_mouse_button"
]
STATE = bidict(
inactive=QtWidgets.QScroller.State.Inactive,
pressed=QtWidgets.QScroller.State.Pressed,
from __future__ import annotations
import os
import pathlib
from typing import Any, Literal
from prettyqt.qt import QtCore
from prettyqt.utils import bidict, types
COMPONENT_FORMATTING_OPTIONS = bidict(
pretty_decoded=QtCore.QUrl.ComponentFormattingOption.PrettyDecoded,
encode_spaces=QtCore.QUrl.ComponentFormattingOption.EncodeSpaces,
encode_unicode=QtCore.QUrl.ComponentFormattingOption.EncodeUnicode,
encode_delimiters=QtCore.QUrl.ComponentFormattingOption.EncodeDelimiters,
encode_reserved=QtCore.QUrl.ComponentFormattingOption.EncodeReserved,
decode_reserved=QtCore.QUrl.ComponentFormattingOption.DecodeReserved,
fully_encoded=QtCore.QUrl.ComponentFormattingOption.FullyEncoded,
fully_decoded=QtCore.QUrl.ComponentFormattingOption.FullyDecoded,
)
ComponentFormattingStr = Literal["pretty_decoded", "encode_spaces",
"encode_unicode", "encode_delimiters",
"encode_reserved", "decode_reserved",
"fully_encoded", "fully_decoded", ]
PARSING_MODES = bidict(
tolerant=QtCore.QUrl.ParsingMode.TolerantMode,
strict=QtCore.QUrl.ParsingMode.StrictMode,
decoded=QtCore.QUrl.ParsingMode.DecodedMode,
)
from __future__ import annotations
from typing import Literal
from prettyqt import gui
from prettyqt.qt import QtCore, QtGui
from prettyqt.utils import InvalidParamError, bidict, types
IMAGE_WRITER_ERROR = bidict(
device=QtGui.QImageWriter.ImageWriterError.DeviceError,
unsupported_format=QtGui.QImageWriter.ImageWriterError.
UnsupportedFormatError,
invalid_image=QtGui.QImageWriter.ImageWriterError.InvalidImageError,
unknown=QtGui.QImageWriter.ImageWriterError.UnknownError,
)
ImageWriterErrorStr = Literal["device", "unsupported_format", "invalid_image",
"unknown"]
class ImageWriter(QtGui.QImageWriter):
def __setitem__(self, key: str, val: str):
self.setText(key, val)
def get_error(self) -> ImageWriterErrorStr:
"""Return error type.
Returns:
error type
"""
return IMAGE_WRITER_ERROR.inverse[self.error()]
from __future__ import annotations
import datetime
from typing import Literal
from prettyqt import widgets
from prettyqt.qt import QtCore, QtWidgets
from prettyqt.utils import InvalidParamError, bidict, types
SELECTION_MODE = bidict(
none=QtWidgets.QCalendarWidget.SelectionMode.NoSelection,
single=QtWidgets.QCalendarWidget.SelectionMode.SingleSelection,
)
SelectionModeStr = Literal["none", "single"]
VERTICAL_HEADER_FORMAT = bidict(
none=QtWidgets.QCalendarWidget.VerticalHeaderFormat.NoVerticalHeader,
week_numbers=QtWidgets.QCalendarWidget.VerticalHeaderFormat.ISOWeekNumbers,
)
VerticalHeaderFormatStr = Literal["none", "week_numbers"]
HORIZONTAL_HEADER_FORMAT = bidict(
single_letter=QtWidgets.QCalendarWidget.HorizontalHeaderFormat.
SingleLetterDayNames,
short=QtWidgets.QCalendarWidget.HorizontalHeaderFormat.ShortDayNames,
long=QtWidgets.QCalendarWidget.HorizontalHeaderFormat.LongDayNames,
none=QtWidgets.QCalendarWidget.HorizontalHeaderFormat.NoHorizontalHeader,
)
from prettyqt.qt import QtWidgets
from prettyqt.utils import bidict
mod = QtWidgets.QTreeWidgetItemIterator
ITERATOR_FLAGS = bidict(
all=mod.IteratorFlag.All,
hidden=mod.IteratorFlag.Hidden,
not_hidden=mod.IteratorFlag.NotHidden,
selected=mod.IteratorFlag.Selected,
unselected=mod.IteratorFlag.Unselected,
selectable=mod.IteratorFlag.Selectable,
not_selectable=mod.IteratorFlag.NotSelectable,
drag_enabled=mod.IteratorFlag.DragEnabled,
drag_disabled=mod.IteratorFlag.DragDisabled,
drop_enabled=mod.IteratorFlag.DropEnabled,
drop_disabled=mod.IteratorFlag.DropDisabled,
has_children=mod.IteratorFlag.HasChildren,
no_children=mod.IteratorFlag.NoChildren,
checked=mod.IteratorFlag.Checked,
not_checked=mod.IteratorFlag.NotChecked,
enabled=mod.IteratorFlag.Enabled,
disabled=mod.IteratorFlag.Disabled,
editable=mod.IteratorFlag.Editable,
not_editable=mod.IteratorFlag.NotEditable,
user_flag=mod.IteratorFlag.UserFlag,
)
class TreeWidgetItemIterator(QtWidgets.QTreeWidgetItemIterator):
def __init__(
self,
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
from qtpy import QtWidgets, QtCore
from prettyqt import widgets, core
from prettyqt.utils import bidict
TICK_POSITIONS = bidict(none=QtWidgets.QSlider.NoTicks,
both_sides=QtWidgets.QSlider.TicksBothSides,
above=QtWidgets.QSlider.TicksAbove,
below=QtWidgets.QSlider.TicksBelow)
ORIENTATIONS = bidict(horizontal=QtCore.Qt.Horizontal,
vertical=QtCore.Qt.Vertical)
QtWidgets.QSlider.__bases__ = (widgets.AbstractSlider,)
class Slider(QtWidgets.QSlider):
value_changed = core.Signal(int)
def __init__(self, orientation="horizontal", parent=None):
super().__init__(ORIENTATIONS[orientation], parent)
self.valueChanged.connect(self.on_value_change)
def __getstate__(self):
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
from qtpy import QtWidgets, QtCore
from prettyqt import widgets
from prettyqt.utils import bidict
TEXT_DIRECTIONS = bidict(top_to_bottom=QtWidgets.QProgressBar.TopToBottom,
bottom_to_top=QtWidgets.QProgressBar.BottomToTop)
ALIGNMENTS = bidict(left=QtCore.Qt.AlignLeft,
right=QtCore.Qt.AlignRight,
top=QtCore.Qt.AlignTop,
bottom=QtCore.Qt.AlignBottom)
QtWidgets.QProgressBar.__bases__ = (widgets.Widget,)
class ProgressBar(QtWidgets.QProgressBar):
"""Progress dialog
wrapper for QtWidgets.QProgressBar
"""
def __init__(self, text_visible=True, parent=None):
super().__init__(parent=parent)
self.setTextVisible(text_visible)
from __future__ import annotations
from typing import Literal
from prettyqt import core
from prettyqt.qt import QtPositioning
from prettyqt.utils import bidict
QtPositioning.QGeoAreaMonitorSource.__bases__ = (core.Object, )
mod = QtPositioning.QGeoAreaMonitorSource
ERRORS = bidict(
access_error=mod.Error.AccessError,
insufficient_pos_info=mod.Error.InsufficientPositionInfo,
none=mod.Error.NoError,
unknown_source=mod.Error.UnknownSourceError,
)
ErrorStr = Literal["access_error", "insufficient_pos_info", "none",
"unknown_source"]
AREA_MONITOR_FEATURES = bidict(
persistent_area=mod.AreaMonitorFeature.PersistentAreaMonitorFeature,
any_area=mod.AreaMonitorFeature.AnyAreaMonitorFeature,
)
AreaMonitorFeatureStr = Literal["persistent_area", "any_area"]
class GeoAreaMonitorSource(QtPositioning.QGeoAreaMonitorSource):
# -*- coding: utf-8 -*-
"""
@author: Philipp Temminghoff
"""
from qtpy import QtWidgets
from prettyqt.utils import bidict
SIZE_POLICIES = bidict(
fixed=QtWidgets.QSizePolicy.Fixed,
minimum=QtWidgets.QSizePolicy.Minimum,
maximum=QtWidgets.QSizePolicy.Maximum,
preferred=QtWidgets.QSizePolicy.Preferred,
expanding=QtWidgets.QSizePolicy.Expanding,
minimum_expanding=QtWidgets.QSizePolicy.MinimumExpanding,
ignored=QtWidgets.QSizePolicy.Ignored)
CONTROL_TYPES = bidict(default=QtWidgets.QSizePolicy.DefaultType,
buttonbox=QtWidgets.QSizePolicy.ButtonBox,
checkbox=QtWidgets.QSizePolicy.CheckBox,
combobox=QtWidgets.QSizePolicy.ComboBox,
frame=QtWidgets.QSizePolicy.Frame,
groupbox=QtWidgets.QSizePolicy.GroupBox,
label=QtWidgets.QSizePolicy.Label,
line=QtWidgets.QSizePolicy.Line,
lineedit=QtWidgets.QSizePolicy.LineEdit,
pushbutton=QtWidgets.QSizePolicy.PushButton,
radiobutton=QtWidgets.QSizePolicy.RadioButton,
slider=QtWidgets.QSizePolicy.Slider,
spinbox=QtWidgets.QSizePolicy.SpinBox,
from __future__ import annotations
import sys
import traceback
from typing import Literal
from prettyqt import core, gui, iconprovider, widgets
from prettyqt.qt import QtCore, QtWidgets
from prettyqt.utils import InvalidParamError, bidict, types
ICONS = bidict(
none=QtWidgets.QMessageBox.Icon.NoIcon,
information=QtWidgets.QMessageBox.Icon.Information,
warning=QtWidgets.QMessageBox.Icon.Warning,
critical=QtWidgets.QMessageBox.Icon.Critical,
question=QtWidgets.QMessageBox.Icon.Question,
)
IconStr = Literal["none", "information", "warning", "critical", "question"]
BUTTONS = bidict(
none=QtWidgets.QMessageBox.StandardButton.NoButton,
cancel=QtWidgets.QMessageBox.StandardButton.Cancel,
ok=QtWidgets.QMessageBox.StandardButton.Ok,
save=QtWidgets.QMessageBox.StandardButton.Save,
open=QtWidgets.QMessageBox.StandardButton.Open,
close=QtWidgets.QMessageBox.StandardButton.Close,
discard=QtWidgets.QMessageBox.StandardButton.Discard,
apply=QtWidgets.QMessageBox.StandardButton.Apply,
reset=QtWidgets.QMessageBox.StandardButton.Reset,
from __future__ import annotations
from prettyqt.qt import QtQml
from prettyqt.utils import bidict
mod = QtQml.QQmlImageProviderBase
FLAGS = bidict(
force_async_image_loading=mod.Flag.ForceAsynchronousImageLoading, )
IMAGE_TYPE = bidict(
image=mod.ImageType.Image,
pixmap=mod.ImageType.Pixmap,
texture=mod.ImageType.Texture,
image_response=mod.ImageType.ImageResponse,
)
class QmlImageProviderBase(QtQml.QQmlImageProviderBase):
pass
from __future__ import annotations
from typing import Literal
import prettyqt
from prettyqt import constants, gui
from prettyqt.qt import QtGui
from prettyqt.utils import InvalidParamError, bidict, mappers
FORMAT_TYPE = bidict(
invalid=QtGui.QTextFormat.FormatType.InvalidFormat,
block=QtGui.QTextFormat.FormatType.BlockFormat,
char=QtGui.QTextFormat.FormatType.CharFormat,
list=QtGui.QTextFormat.FormatType.ListFormat,
frame=QtGui.QTextFormat.FormatType.FrameFormat,
user=QtGui.QTextFormat.FormatType.UserFormat,
)
FormatTypeStr = Literal["invalid", "block", "char", "list", "frame", "user"]
OBJECT_TYPE = bidict(
none=QtGui.QTextFormat.ObjectTypes.NoObject,
image=QtGui.QTextFormat.ObjectTypes.ImageObject,
table=QtGui.QTextFormat.ObjectTypes.TableObject,
table_cell=QtGui.QTextFormat.ObjectTypes.TableCellObject,
user=QtGui.QTextFormat.ObjectTypes.UserObject,
)
ObjectTypeStr = Literal["none", "image", "table", "table_cell", "user"]
PAGE_BREAK_FLAG = mappers.FlagMap(
from __future__ import annotations
from typing import Literal
from prettyqt import gui
from prettyqt.qt import QtGui
from prettyqt.utils import InvalidParamError, bidict
POSITIONS = bidict(
in_flow=QtGui.QTextFrameFormat.Position.InFlow,
flow_left=QtGui.QTextFrameFormat.Position.FloatLeft,
flow_right=QtGui.QTextFrameFormat.Position.FloatRight,
)
PositionStr = Literal["in_flow", "flow_right", "flow_left"]
BORDER_STYLES = bidict(
none=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_None,
dotted=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Dotted,
dashed=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Dashed,
solid=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Solid,
double=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Double,
dot_dash=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_DotDash,
dot_dot_dash=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_DotDotDash,
groove=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Groove,
ridge=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Ridge,
inset=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Inset,
outset=QtGui.QTextFrameFormat.BorderStyle.BorderStyle_Outset,
)
BorderStyleStr = Literal["none", "dotted", "dashed", "solid", "double",
from __future__ import annotations
from typing import Literal
from prettyqt.qt import QtGui
from prettyqt.utils import bidict
WORD_WRAP_MODE = bidict(
none=QtGui.QTextOption.WrapMode.NoWrap,
word=QtGui.QTextOption.WrapMode.WordWrap,
manual=QtGui.QTextOption.WrapMode.ManualWrap,
anywhere=QtGui.QTextOption.WrapMode.WrapAnywhere,
boundary_or_anywhere=QtGui.QTextOption.WrapMode.
WrapAtWordBoundaryOrAnywhere,
)
WordWrapModeStr = Literal["none", "word", "manual", "anywhere",
"boundary_or_anywhere"]
TAB_TYPE = bidict(
left=QtGui.QTextOption.TabType.LeftTab,
right=QtGui.QTextOption.TabType.RightTab,
center=QtGui.QTextOption.TabType.CenterTab,
delimiter=QtGui.QTextOption.TabType.DelimiterTab,
)
TabTypeStr = Literal["left", "right", "center", "delimiter"]
FLAG = bidict(
include_trailing_whitespaces=QtGui.QTextOption.Flag.IncludeTrailingSpaces,
show_tabs_and_spaces=QtGui.QTextOption.Flag.ShowTabsAndSpaces,
Item = QtWebEngineCore.QWebEngineDownloadRequest
DOWNLOAD_INTERRUPT_REASONS = bidict(
none=Item.DownloadInterruptReason.NoReason,
file_failed=Item.DownloadInterruptReason.FileFailed,
file_access_denied=Item.DownloadInterruptReason.FileAccessDenied,
file_no_space=Item.DownloadInterruptReason.FileNoSpace,
filename_too_long=Item.DownloadInterruptReason.FileNameTooLong,
file_too_large=Item.DownloadInterruptReason.FileTooLarge,
file_virus_infected=Item.DownloadInterruptReason.FileVirusInfected,
file_transient_error=Item.DownloadInterruptReason.FileTransientError,
file_blocked=Item.DownloadInterruptReason.FileBlocked,
file_security_check_failed=Item.DownloadInterruptReason.
FileSecurityCheckFailed,
file_too_short=Item.DownloadInterruptReason.FileTooShort,
file_hash_mismatch=Item.DownloadInterruptReason.FileHashMismatch,
network_fialed=Item.DownloadInterruptReason.NetworkFailed,
network_timeout=Item.DownloadInterruptReason.NetworkTimeout,
network_disconnected=Item.DownloadInterruptReason.NetworkDisconnected,
network_server_down=Item.DownloadInterruptReason.NetworkServerDown,
network_invalid_request=Item.DownloadInterruptReason.NetworkInvalidRequest,
server_failed=Item.DownloadInterruptReason.ServerFailed,
server_bad_content=Item.DownloadInterruptReason.ServerBadContent,
server_unauthorized=Item.DownloadInterruptReason.ServerUnauthorized,
server_cert_problem=Item.DownloadInterruptReason.ServerCertProblem,
server_forbidden=Item.DownloadInterruptReason.ServerForbidden,
server_unreachable=Item.DownloadInterruptReason.ServerUnreachable,
user_canceled=Item.DownloadInterruptReason.UserCanceled,
)
DownloadInterruptReasonStr = Literal["none", "file_failed",
from __future__ import annotations
from prettyqt import positioning
from prettyqt.qt import QtCore, QtPositioning
from prettyqt.utils import bidict
QNmeaPositionInfoSource = QtPositioning.QNmeaPositionInfoSource
UPDATE_MODES = bidict(
real_time=QtPositioning.QNmeaPositionInfoSource.UpdateMode.RealTimeMode,
simulation=QtPositioning.QNmeaPositionInfoSource.UpdateMode.SimulationMode,
)
QtPositioning.QNmeaPositionInfoSource.__bases__ = (
positioning.GeoPositionInfoSource, )
class NmeaPositionInfoSource(QtPositioning.QNmeaPositionInfoSource):
def __init__(
self,
update_mode: QtPositioning.QNmeaPositionInfoSource.UpdateMode | str,
parent: QtCore.QObject,
):
if isinstance(update_mode,
QtPositioning.QNmeaPositionInfoSource.UpdateMode):
mode = update_mode
else:
mode = UPDATE_MODES[update_mode]
super().__init__(mode, parent)
def __repr__(self):
from __future__ import annotations
from typing import Literal
from prettyqt import widgets
from prettyqt.qt import QtWidgets
from prettyqt.utils import bidict
SWIPE_DIRECTION = bidict(
none=QtWidgets.QSwipeGesture.SwipeDirection.NoDirection,
left=QtWidgets.QSwipeGesture.SwipeDirection.Left,
right=QtWidgets.QSwipeGesture.SwipeDirection.Right,
up=QtWidgets.QSwipeGesture.SwipeDirection.Up,
down=QtWidgets.QSwipeGesture.SwipeDirection.Down,
)
HorizontalDirectionStr = Literal["none", "left", "right"]
VerticalDirectionStr = Literal["none", "up", "down"]
QtWidgets.QSwipeGesture.__bases__ = (widgets.Gesture, )
class SwipeGesture(QtWidgets.QSwipeGesture):
def get_horizontal_direction(self) -> HorizontalDirectionStr:
"""Return horizontal direction of the gesture.
Returns:
horizontal direction
"""
return SWIPE_DIRECTION.inverse[self.horizontalDirection()]
from __future__ import annotations
from typing import Literal
from prettyqt import core
from prettyqt.qt import QtGui
from prettyqt.utils import InvalidParamError, bidict
NAMED_COLOR_SPACE = bidict(
srgb=QtGui.QColorSpace.NamedColorSpace.SRgb,
srgb_linear=QtGui.QColorSpace.NamedColorSpace.SRgbLinear,
adobe_rgb=QtGui.QColorSpace.NamedColorSpace.AdobeRgb,
display_p3=QtGui.QColorSpace.NamedColorSpace.DisplayP3,
pro_photo_rgb=QtGui.QColorSpace.NamedColorSpace.ProPhotoRgb,
)
NamedColorSpaceStr = Literal["srgb", "srgb_linear", "adobe_rgb", "display_p3",
"pro_photo_rgb"]
PRIMARIES = bidict(
custom=QtGui.QColorSpace.Primaries.Custom,
srgb=QtGui.QColorSpace.Primaries.SRgb,
adobe_rgb=QtGui.QColorSpace.Primaries.AdobeRgb,
dci_p3_d65=QtGui.QColorSpace.Primaries.DciP3D65,
pro_photo_rgb=QtGui.QColorSpace.Primaries.ProPhotoRgb,
)
PrimariesStr = Literal["custom", "srgb", "adobe_rgb", "dci_p3_d65",
"pro_photo_rgb"]
TRANSFER_FUNCTION = bidict(
from __future__ import annotations
import os
import pathlib
from typing import Iterator, Sequence
from prettyqt import constants, core
from prettyqt.qt import QtCore, QtWidgets
from prettyqt.utils import InvalidParamError, bidict, types
if core.VersionNumber.get_qt_version() >= (5, 14, 0):
OPTIONS = bidict(
dont_watch_changes=QtWidgets.QFileSystemModel.Option.DontWatchForChanges,
dont_resolve_symlinks=QtWidgets.QFileSystemModel.Option.DontResolveSymlinks,
no_custom_icons=QtWidgets.QFileSystemModel.Option.DontUseCustomDirectoryIcons,
)
QtWidgets.QFileSystemModel.__bases__ = (core.AbstractItemModel,)
class FileSystemModel(QtWidgets.QFileSystemModel):
"""Class to populate a filesystem treeview."""
DATA_ROLE = constants.USER_ROLE + 33 # type: ignore
content_type = "files"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setReadOnly(False)
from __future__ import annotations
from typing import Literal
from prettyqt import core
from prettyqt.qt import QtCore
from prettyqt.utils import bidict
TYPE = bidict(
read=QtCore.QSocketNotifier.Type.Read,
write=QtCore.QSocketNotifier.Type.Write,
exception=QtCore.QSocketNotifier.Type.Exception,
)
TypeStr = Literal["read", "write", "exception"]
QtCore.QSocketNotifier.__bases__ = (core.Object, )
class SocketNotifier(QtCore.QSocketNotifier):
# def __repr__(self):
# return f"{type(self).__name__}({self.socket()}, {self.type()})"
def get_type(self) -> TypeStr:
"""Return socket event type.
Returns:
socket event type
"""
return TYPE.inverse[self.type()]
