o MEg" @sUddlZddlZddlZddlZddlZddlZddlmZmZddl mZddl m Z m Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ej&d krdd lm'Z'm(Z(m)Z)n dd l*m'Z'm(Z(m)Z)ddl+m,Z,m-Z-ddl.m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlddl?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMddlNmOZOddlPmQZQmRZRddlSmTZTdd lUmVZVmWZWdd!lXmYZYmZZZdd"l[m\Z\m]Z]er0dd#l^m_Z_dd$l`maZadd%lbmcZcedd&kZeee$efd'fgd'fZge'd(Zhe'd)ZiGd*d+d+ZjejZkd,Zle6jme6jnd-ZoGd.d/d/e Zpe Gd0d1d1Zqe)Gd2d3d3e(Zre)Gd4d5d5e(Zse$esereffZt ee$eteOfZu e:ZvGd6d7d7ewZxGd8d9d9ZyGd:d;d;ZzGdd?d?Z|Gd@dAdAZ}GdBdCdCZ~GdDdEdEZd|dGedHedIedIefffdJdKZdHefdLdMZe6jne6jme6je6jedNZdOdPeDZe GdQdRdRejZGdSdTdTeZdae!dUedV<d}dWdXZdHefdYdZZer1dd[lmZed\d]Gd^d_d_Zed`kreZedadbdcdFd\ddddedfdgdhdidjedkdleeedgdFdmgdndodpdqd\drgdsdtdpdugdvdwdpdxdydzed{dSdS)~N)ABCabstractmethod)abc) dataclassfield)datetime)wraps)getpass)islice) monotonic) TracebackType)IO TYPE_CHECKINGAnyCallableDictIterableListMapping NamedTupleOptionalTextIOTypeUnioncast))LiteralProtocolruntime_checkable)errorsthemes)_emoji_replace)FormatTimeCallable LogRender)Align AlignMethod) ColorSystem)Control)NullHighlighterReprHighlighterrender) Measurementmeasure_renderables)Pager SystemPager)Pretty is_expandable)Region) render_scope)Screen)Segment)Style StyleTypeStyled)DEFAULT_TERMINAL_THEME TerminalTheme)TextTextType)Theme ThemeStack)WindowsConsoleFeatures)LiveStatusWindowsr>)defaultleftcenterrightfull)foldcropellipsisignorec@s eZdZdS)NoChangeN)__name__ __module__ __qualname__rTrTf/var/www/eduai.edurigo.com/doc_train/edurigo_ai/Puru/venv/lib/python3.10/site-packages/rich/console.pyrPJsrPa9 
{code}
 )256color16colorc@s$eZdZUdZeed< eed<dS)ConsoleDimensionszSize of the terminal.widthheightN)rQrRrS__doc__int__annotations__rTrTrTrUrXis rXc@seZdZUdZeed< eed< eed< eed< eed< eed< dZ e e ed < dZ e e ed < d Ze eed < dZe eed < dZe eed< dZe eed< edefddZdddZeeeeeeeeed deeefdeeefdeeefd ee e efd ee e efd ee eefd ee eefdee eefdee eefddfddZdeddfddZdededdfddZdS)ConsoleOptionsz$Options for __rich_console__ method.sizelegacy_windows min_width max_width is_terminalencodingNjustifyoverflowFno_wrap highlightmarkuprZreturncCs|jd S)z+Check if renderables should use ascii only.utf)rd startswithselfrTrTrU ascii_onlyszConsoleOptions.ascii_onlycCstt}|j|_|S)zdReturn a copy of the options. Returns: ConsoleOptions: a copy of self. )r^__new____dict__copy)rnoptionsrTrTrUrrs  zConsoleOptions.copy) rYrarbrerfrgrhrirZrYc Cs|} t|tstd|| _| _t|ts|| _t|ts"|| _t|ts*|| _t|ts2|| _t|ts:|| _t|tsB|| _ t|tsJ|| _ t| ts[| durUdntd| | _ | S)zUpdate values, return a copy.rN) rr isinstancerPmaxrarbrerfrgrhrirZ) rnrYrarbrerfrgrhrirZrsrTrTrUupdates(         zConsoleOptions.updatecCs|}td||_|_|S)zUpdate just the width, return a copy. Args: width (int): New width (sets both min_width and max_width) Returns: ~ConsoleOptions: New console options instance. r)rrrurarb)rnrYrsrTrTrU update_widths zConsoleOptions.update_widthcCs$|}td||_|_||_|S)aUpdate the width and height, and return a copy. Args: width (int): New width (sets both min_width and max_width). height (int): New height. Returns: ~ConsoleOptions: New console options instance. r)rrrurarbrZ)rnrYrZrsrTrTrUupdate_dimensionss z ConsoleOptions.update_dimensions)rjr^)rQrRrSr[rXr]boolr\strrer JustifyMethodrfOverflowMethodrgrhrirZpropertyrorr NO_CHANGErrPrvrwrxrTrTrTrUr^rsz          # r^c@s&eZdZdZdedeffddZdS)RichCastz5An object that may be 'cast' to a console renderable.rjConsoleRenderablecCdSNrTrmrTrTrU__rich__szRichCast.__rich__N)rQrRrSr[rrzrrTrTrTrUrsrc@s&eZdZdZ      d dd Zd S) rz-An object that supports the console protocol.consoleConsolersr^rj RenderResultcCrrrTrnrrsrTrTrU__rich_console__sz"ConsoleRenderable.__rich_console__N)rrrsr^rjr)rQrRrSr[rrTrTrTrUrsrc@seZdZdZdS) CaptureErrorz(An error in the Capture context manager.N)rQrRrSr[rTrTrTrUrsrc@s>eZdZdZddeddfddZdd d d deefd d ZdS)NewLinez$A renderable to generate new line(s)r countrjNcCs ||_dSr)rrnrrTrTrU__init__s zNewLine.__init__rrrsr^ccstd|jVdS)N )r7rrrTrTrUrszNewLine.__rich_console__r ) rQrRrSr[r\rrr7rrTrTrTrUrsrc@sHeZdZdZdeeedededdfddZd d d ede fd d Z dS) ScreenUpdatez)Render a list of lines at a given offset.linesxyrjNcC||_||_||_dSr)_linesrr)rnrrrrTrTrUr  zScreenUpdate.__init__rrrsccs@|j}tj}t|j|jD]\}}|||V|EdHqdSr)rr)move_to enumeraterr)rnrrsrroffsetlinerTrTrUrs  zScreenUpdate.__rich_console__) rQrRrSr[rr7r\rr^rrrTrTrTrUr s"rc@s\eZdZdZdddZddd Zd eeed eed ee ddfd dZ de fddZ dS)CapturezContext manager to capture the result of printing to the console. See :meth:`~rich.console.Console.capture` for how to use. Args: console (Console): A console instance to capture output. rrrjNcCs||_d|_dSr)_console_result)rnrrTrTrUr$s zCapture.__init__cC|j|Sr)r begin_capturermrTrTrU __enter__( zCapture.__enter__exc_typeexc_valexc_tbcCs|j|_dSr)r end_capturerrnrrrrTrTrU__exit__,szCapture.__exit__cCs|jdur td|jS)zGet the result of the capture.Nz.decorator.._replace)rrr)rrr)rrU decoratorszrender_group..decorator)rrrr)rrrTrrU render_groups   rcCsVztWn tyYdSwt}|jj}dt|jvs!|dkr#dS|dkr)dSdS)z-Check if we're running in a Jupyter notebook.Fz google.colabZMQInteractiveShellTTerminalInteractiveShell) get_ipython NameError __class__rQrz)ipythonshellrTrTrU _is_jupyters r)standard256 truecolorwindowscCsi|]\}}||qSrTrT).0namesystemrTrTrU rc@s<eZdZUdZeed<eedZe e ed<dZ e ed<dS)ConsoleThreadLocalsz(Thread local values for Console context. theme_stack)default_factoryrr buffer_indexN) rQrRrSr[rAr]rrrrr7rr\rTrTrTrUrs rc@s.eZdZdZedeedeefddZdS) RenderHookz(Provides hooks in to the render process.rrjcCsdS)aLCalled with a list of objects to render. This method can return a new list of renderables, or modify and return the same list. Args: renderables (List[ConsoleRenderable]): A number of renderable objects. Returns: List[ConsoleRenderable]: A replacement list of renderables. NrT)rnrrTrTrUprocess_renderablesszRenderHook.process_renderablesN)rQrRrSr[rrrrrTrTrTrUrsrrB_windows_console_featurescCs"tdurtSddlm}|atS)Nr get_windows_console_features)r_windowsrrrTrTrUrs  rcCstotj S)zDetect legacy Windows.)WINDOWSrvtrTrTrTrUdetect_legacy_windows#r)initF)stripc:@seZdZUdZejZeeefe d<ddddddddddddddddddddde dddddd d e e d d e e d e e de e de de ede de eede de ede ede ede e dede de de de de de deeefd e d!d"e e d#e d$e egefd%e egefde eeeff6d&d'Zd(efd)d*Zed(eefd+d,Zejd-eed(dfd.d,Zed(eefd/d0Zed(efd1d2Zejd3ed(dfd4d2Zed(e fd5d6Z!d(e e"fd7d8Z#dd9d:Z$dd;d<Z%dd?d@Z&ddAdBZ'dCe(d(dfdDdEZ)ddFdGZ*ddHdIZ+dJe,dKe,dLe,d(dfdMdNZ-ddOdPZ.d(efdQdRZ/ddSdedTe d(dfdUdVZ0ddWdXZ1ddSdedTe d(e2fdYdZZ3ed(e efd[d\Z4ed(efd]d^Z5ed(e fd_d`Z6ed(e fdadbZ7ed(e8fdcddZ9ed(e:fdedfZ;ed(efdgdhZd(e?fdmdnZ@ ddoe eAdpe dqe d(eBfdrdsZCddued(dfdvdwZDddxe d(dfdydzZEd{d|d}d~ddeFdedededed(df ddZGdde d(e fddZHdde d(e fddZIed(e fddZJ dde de ed(dfddZKdddeFde e8d(eLfddZM ddeFde e8d(eNefddZO ddddddeFde e8de ePde de d(eeef ddZQdddddddddedeeePfde eRde eSde e de e de e d e eTd(dfddZUdddeeePfde eePefd(ePfddZVddddddeNe,dedede eRde e de e de e d(eeWfddZX ddddddeYdedeeePfdeZd(df ddZ[de\d(dfddZ]dddddde,dedede eeePfde e d(df ddÄZ^ddddddddddddddĜ de,dedede eeePfde eRde eSde e de e de e de e de ede ede de e d(dfddȄZ_dddɜdeFde e`de e8d(dfdd̄Za ͐ddeeededed(dfdd҄Zbdddddd՜de edede ede de d(df ddڄZcdddddddddtdۜ de,dedede eeePfde eRde e de e de e de ded(dfdd߄ZddddZedeNed(efddZf dddddddeYde de de de egd(ef ddZhdddde dpe d(efddZiddddede dpe d(dfddZjdddddde ekde de ede d(ef ddZlddemdddede ekde dede d(df ddZndS(ra A high level console interface. Args: color_system (str, optional): The color system supported by your terminal, either ``"standard"``, ``"256"`` or ``"truecolor"``. Leave as ``"auto"`` to autodetect. force_terminal (Optional[bool], optional): Enable/disable terminal control codes, or None to auto-detect terminal. Defaults to None. force_jupyter (Optional[bool], optional): Enable/disable Jupyter rendering, or None to auto-detect Jupyter. Defaults to None. force_interactive (Optional[bool], optional): Enable/disable interactive mode, or None to auto detect. Defaults to None. soft_wrap (Optional[bool], optional): Set soft wrap default on print method. Defaults to False. theme (Theme, optional): An optional style theme object, or ``None`` for default theme. stderr (bool, optional): Use stderr rather than stdout if ``file`` is not specified. Defaults to False. file (IO, optional): A file object where the console should write to. Defaults to stdout. quiet (bool, Optional): Boolean to suppress all output. Defaults to False. width (int, optional): The width of the terminal. Leave as default to auto-detect width. height (int, optional): The height of the terminal. Leave as default to auto-detect height. style (StyleType, optional): Style to apply to all output, or None for no style. Defaults to None. no_color (Optional[bool], optional): Enabled no color mode, or None to auto detect. Defaults to None. tab_size (int, optional): Number of spaces used to replace a tab character. Defaults to 8. record (bool, optional): Boolean to enable recording of terminal output, required to call :meth:`export_html` and :meth:`export_text`. Defaults to False. markup (bool, optional): Boolean to enable :ref:`console_markup`. Defaults to True. emoji (bool, optional): Enable emoji code. Defaults to True. highlight (bool, optional): Enable automatic highlighting. Defaults to True. log_time (bool, optional): Boolean to enable logging of time by :meth:`log` methods. Defaults to True. log_path (bool, optional): Boolean to enable the logging of the caller by :meth:`log`. Defaults to True. log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to "[%X] ". highlighter (HighlighterType, optional): Default highlighter. legacy_windows (bool, optional): Enable legacy Windows mode, or ``None`` to auto detect. Defaults to ``None``. safe_box (bool, optional): Restrict box options that don't render on legacy Windows. get_datetime (Callable[[], datetime], optional): Callable that gets the current time as a datetime.datetime object (used by Console.log), or None for datetime.now. get_time (Callable[[], time], optional): Callable that gets the current time in seconds, default uses time.monotonic. _environautoNFrTz[%X]) color_systemforce_terminal force_jupyterforce_interactive soft_wraprstderrfilequietrYrZrno_colortab_sizerecordriemojirhlog_timelog_pathlog_time_format highlighterr`safe_box get_datetimeget_timerr)rrrrrrrrrrrrrrYrZrrr r rir rhr r rrHighlighterTyper`rrrcCs|dur||_|durtn||_|jr| pd} | pd} | dur2|jd}|dur2|r2t|} | durH|jd}|durH|rHt|} ||_| |_| |_||_ ||_ ||_ ||_ ||_ |durktoj|j n||_|||_||_| |_||_|durd|_n|dkr||_nt||_t|_t|||d|_|pt|_||_|ptj |_!|pt"|_#| |_$| dur| nd|jv|_%|dur|j&o|j' n||_(t|_)t*t+|durt,j-n|d|_.g|_/g|_0d|_1d |_2dS) N]dCOLUMNSLINESr) show_time show_path time_formatNO_COLOR)rF)3rr is_jupyterrisdigitr\r_width_heightr r _markup_emoji _highlightrr`_force_terminal_filerr _color_system_detect_color_system COLOR_SYSTEMS threadingRLockrr% _log_render_null_highlighterrrrnowrr rrrrcis_dumb_terminalis_interactive_record_buffer_lockrrAr"DEFAULT_thread_locals_record_buffer _render_hooks_live_is_alt_screen)rnrrrrrrrrrrYrZrrr r rir rhr r rrr`rrrrcolumnsrrTrTrUrSs~"            zConsole.__init__rjcCsd|jdt|jdS)Nz)rYrzr%rmrTrTrU__repr__szConsole.__repr__cCs(|jp |jr tjntj}t|d|}|S)z Get the file object to write to.rich_proxied_file)r$rsysstdoutgetattr)rnrrTrTrUrs z Console.filenew_filecCs ||_dS)zSet a new file object.N)r$)rnr>rTrTrUrs cC|jjSzGet a thread local buffer.)r1rrmrTrTrUrzConsole._buffercCr?r@r1rrmrTrTrU _buffer_indexrAzConsole._buffer_indexvaluecCs ||j_dSrrB)rnrDrTrTrUrC cCr?)z!Get the thread local theme stack.)r1rrmrTrTrU _theme_stackrAzConsole._theme_stackcCs|jrtjS|jr |jrdStr"|jrtjSt}|jrtjStj S|j dd }|dvr4tjS|j dd }|d\}}}t |tj}|S)z"Detect color system from env vars.N COLORTERMr)r24bitTERM-)rr( TRUECOLORrcr-rr`rr EIGHT_BITrrrlower partition _TERM_COLORSSTANDARD)rnwindows_console_features color_termterm _term_name_hyphencolorsrrTrTrUr&s( zConsole._detect_color_systemcCs|jd7_dS)z4Enter in to a buffer context, and buffer all output.r N)rCrmrTrTrUrzConsole._enter_buffercCs|jd8_|dS)z5Leave buffer context, and render content if required.r N)rC _check_bufferrmrTrTrUrs zConsole._exit_bufferliverCcCsF|j|jdurtd||_WddS1swYdS)zSet Live instance. Used by Live context manager. Args: live (Live): Live instance using this Console. Raises: errors.LiveError: If this Console has a Live context currently active. Nz+Only one live display may be active at once)rr4r! LiveError)rnrYrTrTrUset_lives   "zConsole.set_livecCs2|j d|_WddS1swYdS)zClear the Live instance.N)rr4rmrTrTrU clear_lives"zConsole.clear_livehookcCs|j|dS)zpAdd a new render hook to the stack. Args: hook (RenderHook): Render hook instance. N)r3append)rnr]rTrTrUpush_render_hookszConsole.push_render_hookcC|jdS)z'Pop the last renderhook from the stack.N)r3poprmrTrTrUpop_render_hookrzConsole.pop_render_hookcCs ||S)z,Own context manager to enter buffer context.rrmrTrTrUr!szConsole.__enter__r exc_value tracebackcC |dS)zExit buffer context.N)r)rnrrdrerTrTrUr&rEzConsole.__exit__cCrf)z`Begin capturing console output. Call :meth:`end_capture` to exit capture mode and return output.NrcrmrTrTrUr*rEzConsole.begin_capturecCs$||j}|jdd=||S)zhEnd capture mode and return captured string. Returns: str: Console output. N)rrr)rn render_resultrTrTrUr.s  zConsole.end_capturerrcCs|jj||ddS)aPush a new theme on to the top of the stack, replacing the styles from the previous theme. Generally speaking, you should call :meth:`~rich.console.Console.use_theme` to get a context manager, rather than calling this method directly. Args: theme (Theme): A theme instance. inherit (bool, optional): Inherit existing styles. Defaults to True. rhN)rFrrnrrrTrTrUr9s zConsole.push_themecCr`)z9Remove theme from top of stack, restoring previous theme.N)rFrrmrTrTrUrDrzConsole.pop_themecCs t|||S)aUse a different theme for the duration of the context manager. Args: theme (Theme): Theme instance to user. inherit (bool, optional): Inherit existing console styles. Defaults to True. Returns: ThemeContext: [description] )rrirTrTrU use_themeHs zConsole.use_themecCs|jdur t|jSdS)zpGet color system string. Returns: Optional[str]: "standard", "256" or "truecolor". N)r%_COLOR_SYSTEMS_NAMESrmrTrTrUrTs  zConsole.color_systemcCst|jddpdS)zGet the encoding of the console file, e.g. ``"utf-8"``. Returns: str: A standard encoding string. rdutf-8)r=rrMrmrTrTrUrdaszConsole.encodingcCs0|jdur|jSt|jdd}|durdS|S)zCheck if the console is writing to a terminal. Returns: bool: True if the console writing to a device capable of understanding terminal codes, otherwise False. NisattyF)r#r=r)rnrmrTrTrUrcjs zConsole.is_terminalcCs$|jdd}|dv}|jo|S)zxDetect dumb terminal. Returns: bool: True if writing to a dumb terminal, otherwise False. rIr)dumbunknown)rrrMrc)rn_termis_dumbrTrTrUr-ws  zConsole.is_dumb_terminalcCst|j|jd|j|j|jdS)zGet default console options.r )r_r`rarbrdrc)r^r_r`rYrdrcrmrTrTrUrsszConsole.optionsc Cs|jdur|jdurt|j|jS|jrtddSd}d}tr&t\}}n2z ttj \}}Wn%t t t fyWz ttj \}}Wn t t t fyTYnwYnw|p[d}|p_d}t|jdurk||jn|j|jduru|S|jS)zGet the size of the console. Returns: ConsoleDimensions: A named tuple containing the dimensions. NP)rrrXr-rshutilget_terminal_sizeosr;stdinfilenoAttributeError ValueErrorOSErrorr<r`)rnrYrZrTrTrUr_s4  z Console.sizecCs|j\}}|S)zsGet the width of the console. Returns: int: The width (in characters) of the console. r_)rnrY_rTrTrUrY z Console.widthcCs|j\}}|S)zpGet the height of the console. Returns: int: The height (in lines) of the console. r|)rnr}rZrTrTrUrZr~zConsole.heightcCs|tdS)z3Play a 'bell' sound (if supported by the terminal).N)controlr)bellrmrTrTrUrrWz Console.bellcCs t|}|S)aA context manager to *capture* the result of print() or log() in a string, rather than writing it to the console. Example: >>> from rich.console import Console >>> console = Console() >>> with console.capture() as capture: ... console.print("[bold magenta]Hello World[/]") >>> print(capture.get()) Returns: Capture: Context manager with disables writing to the terminal. )r)rncapturerTrTrUrszConsole.capturerrrcCst||||dS)aA context manager to display anything printed within a "pager". The pager application is defined by the system and will typically support at least pressing a key to scroll. Args: pager (Pager, optional): A pager object, or None to use :class:~rich.pager.SystemPager`. Defaults to None. styles (bool, optional): Show styles in pager. Defaults to False. links (bool, optional): Show links in pager. Defaults to False. Example: >>> from rich.console import Console >>> from rich.__main__ import make_test_card >>> console = Console() >>> with console.pager(): console.print(make_test_card()) Returns: PagerContext: A context manager. )rrr)r)rnrrrrTrTrUrsz Console.pagerr rcCs"|dksJd|t|dS)zqWrite new line(s). Args: count (int, optional): Number of new lines. Defaults to 1. rzcount must be >= 0N)rrrrTrTrUrsz Console.linehomecCs.|r|ttdS|tdS)zClear the screen. Args: home (bool, optional): Also move the cursor to 'home' position. Defaults to True. N)rr)clearr)rnrrTrTrUrsz Console.cleardotszstatus.spinnerg?g)@)spinner spinner_stylespeedrefresh_per_secondstatusrrrrrEcCs$ddlm}|||||||d}|S)aDisplay a status and spinner. Args: status (RenderableType): A status renderable (str or Text typically). console (Console, optional): Console instance to use, or None for global console. Defaults to None. spinner (str, optional): Name of spinner animation (see python -m rich.spinner). Defaults to "dots". spinner_style (StyleType, optional): Style of spinner. Defaults to "status.spinner". speed (float, optional): Speed factor for spinner animation. Defaults to 1.0. refresh_per_second (float, optional): Number of refreshes per second. Defaults to 12.5. Returns: Status: A Status object that may be used as a context manager. r rD)rrrrr)rrE)rnrrrrrrEstatus_renderablerTrTrUrs zConsole.statusrcCs$|jr|js|t|dSdS)zqShow or hide the cursor. Args: show (bool, optional): Set visibility of the cursor. TF)rcr`rr)r)rnrrTrTrUr)s zConsole.show_cursorenablecCs.d}|jr|js|t|d}||_|S)aEnables alternative screen mode. Note, if you enable this mode, you should ensure that is disabled before the application exits. See :meth:`~rich.Console.screen` for a context manager that handles this for you. Args: enable (bool, optional): Enable (True) or disable (False) alternate screen. Defaults to True. Returns: bool: True if the control codes were written. FT)rcr`rr) alt_screenr5)rnrchangedrTrTrUr4s  zConsole.set_alt_screencCs|jS)zCheck if the alt screen was enabled. Returns: bool: True if the alt screen was enabled, otherwise False. )r5rmrTrTrU is_alt_screenIszConsole.is_alt_screenrrcCst|||pddS)auContext manager to enable and disable 'alternative screen' mode. Args: hide_cursor (bool, optional): Also hide the cursor. Defaults to False. style (Style, optional): Optional style for screen. Defaults to None. Returns: ~ScreenContext: Context which enables alternate screen on enter, and disables it on exit. r)rr)r)rnrrrTrTrUrRs zConsole.screenrsrrscCst||p|j|}|S)aMeasure a renderable. Returns a :class:`~rich.measure.Measurement` object which contains information regarding the number of characters required to print the renderable. Args: renderable (RenderableType): Any renderable or string. options (Optional[ConsoleOptions], optional): Options to use when measuring, or None to use default options. Defaults to None. Returns: Measurement: A measurement of the renderable. )r.rrs)rnrrs measurementrTrTrUmeasure`szConsole.measurec cs|p|j}|jdkr dSt|dr|}t|dr"|||}nt|tr8|j||j|j d}|||}n t d|dzt |}Wnt yWt d|d wt}|D]}t||rg|Vq\|||EdHq\dS) akRender an object in to an iterable of `Segment` instances. This method contains the logic for rendering objects with the console protocol. You are unlikely to need to use it directly, unless you are extending the library. Args: renderable (RenderableType): An object supporting the console protocol, or an object that may be converted to a string. options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None. Returns: Iterable[Segment]: An iterable of segments that may be rendered. r Nrr)rhrizUnable to render zC; A str, Segment or object with __rich_console__ method is requiredzobject z is not renderable)rsrbhasattrrrrtrz render_strrhrir!NotRenderableErroriter TypeErrorr7r-) rnrrs_optionsrender_iterabletext_renderable iter_render_Segment render_outputrTrTrUr-qs:           zConsole.render)rpad new_linesrrc Cs|j]|p|j}|||}|rt||}tttj||j||dd|j }|j durW|j t |} | dkrW|rFtd|j|tdgntd|j|gg} | | | |WdS1scwYdS)aGRender objects in to a list of lines. The output of render_lines is useful when further formatting of rendered console text is required, such as the Panel class which draws a border around any renderable object. Args: renderable (RenderableType): Any object renderable in the console. options (Optional[ConsoleOptions], optional): Console options, or None to use self.options. Default to ``None``. style (Style, optional): Optional style to apply to renderables. Defaults to ``None``. pad (bool, optional): Pad lines shorter than render width. Defaults to ``True``. new_lines (bool, optional): Include " " characters at end of lines. Returns: List[List[Segment]]: A list of lines, where a line is a list of Segment objects. )include_new_linesrNrr7r) rrsr-r7 apply_stylerr split_and_crop_linesrbrZrextend) rnrrsrrrrender_options _renderedr extra_linespad_linerTrTrU render_liness6    $zConsole.render_linesr)rrerfr rirhrtextrerfr>cCs|p|duo|j} |p|duo|j} |p|duo|j} | r+t||| d} || _|| _nt| r2t|n||||d} | r@|p?|jnd} | durS| t | }| | |S| S)aConvert a string to a Text instance. This is is called automatically if you print or log a string. Args: text (str): Text to render. style (Union[str, Style], optional): Style to apply to rendered text. justify (str, optional): Justify method: "default", "left", "center", "full", or "right". Defaults to ``None``. overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to ``None``. emoji (Optional[bool], optional): Enable emoji, or ``None`` to use Console default. markup (Optional[bool], optional): Enable markup, or ``None`` to use Console default. highlight (Optional[bool], optional): Enable highlighting, or ``None`` to use Console default. highlighter (HighlighterType, optional): Optional highlighter to apply. Returns: ConsoleRenderable: Renderable object. N)rr )rerfr) r!r r" render_markuprerfr>r#rrz copy_styles)rnrrrerfr rirhr emoji_enabledmarkup_enabledhighlight_enabled rich_text _highlighterhighlight_textrTrTrUrs*   zConsole.render_str)rGrrGc Cst|tr|Sz|j|}|durt|}|jr|WS|WStjyI}z|dur9| |WYd}~St d|d|dd}~ww)a!Get a Style instance by it's theme name or parse a definition. Args: name (str): The name of a style or a style definition. Returns: Style: A Style object. Raises: MissingStyle: If no style could be parsed from name. NzFailed to get style z; ) rtr8rFrparselinkrrr!StyleSyntaxError get_style MissingStyle)rnrrGrerrorrTrTrUr s"   zConsole.get_stylerer rirhobjectsseprcs>g}|jgj} dvrdtddffdd } | t} |s)|dur,|jr,|j} dfdd } |D]L} t| d rDt| } t| d d}|rO|} t| t r`| |j | ||| d q9t| t rm| | q9t | r}| t | | d q9| | t | q9| |jdur||jfd d|D}|S)aCombine a number of renderables and text into one renderable. Args: objects (Iterable[Any]): Anything that Rich can render. sep (str): String to write between print data. end (str): String to write at end of print data. justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``. emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Returns: List[ConsoleRenderable]: A list of things to render. )rHrIrJrrjNcst|ttdSr)r&rr')r)_appendrerTrU align_appendKsz2Console._collect_renderables..align_appendcs2rtd}|dd=dSdS)N)rer)r>join)sep_text)r^rrerrrTrU check_textTs z0Console._collect_renderables..check_text&jwevpw_eors4dfo6mwo345ermk7kdnfnwerwerr)r rir)rcg|]}t|qSrTr:rrrrTrU wrz0Console._collect_renderables..rjN)r^rr+r"rrreprr=rtrzrrr3r2rr)rnrrrrer rirhr append_textrrrr rich_castrT)rr^rrerrrrU_collect_renderables*sL      zConsole._collect_renderablesu─z rule.linerI) charactersraligntitlerrcCs*ddlm}|||||d}||dS)uDraw a line with optional centered title. Args: title (str, optional): Text to render over the rule. Defaults to "". characters (str, optional): Character(s) to form the line. Defaults to "─". style (str, optional): Style of line. Defaults to "rule.line". align (str, optional): How to align the title, one of "left", "center", or "right". Defaults to "center". r )Rule)rrrrN)rulerr)rnrrrrrrrTrTrUr{s z Console.rulercGs.|js|D] }|j|jq|dSdS)zInsert non-printing control codes. Args: control_codes (str): Control codes, such as those that may move the cursor. N)r-rr^segmentrX)rnr_controlrTrTrUrs  zConsole.controlr7r)rrrrhc Gs4|dd|D}|j|||ddddd|d dS)aOutput to the terminal. This is a low-level way of writing to the terminal which unlike :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will optionally apply highlighting and a basic style. Args: sep (str, optional): String to write between print data. Defaults to " ". end (str, optional): String to write at end of print data. Defaults to "\\n". style (Union[str, Style], optional): A style to apply to output. Defaults to None. highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``. css|]}t|VqdSr)rz)r_objectrTrTrU szConsole.out..FTrO)rrhr rirgrfrMrN)rr)rnrrrrhr raw_outputrTrTrUouts z Console.out) rrrrerfrgr rirhrYrZrMrrgrMc  Gs`|stf}| dur |j} | r|durd}|durd}d} ||j||||||| d}|jD]}||}q/|jj||| durFt| |jnt | ||d}g}|j }|j }|durf|D] }||||q[n|D]}|t |||||qh| r|jj }t j||jddD]}||qn|j |WddSWddS1swYdS)aPrint to the console. Args: objects (positional args): Objects to log to the terminal. sep (str, optional): String to write between print data. Defaults to " ". end (str, optional): String to write at end of print data. Defaults to "\\n". style (Union[str, Style], optional): A style to apply to output. Defaults to None. justify (str, optional): Justify method: "default", "left", "right", "center", or "full". Defaults to ``None``. overflow (str, optional): Overflow method: "ignore", "crop", "fold", or "ellipsis". Defaults to None. no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to None. emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to ``None``. markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to ``None``. highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``. width (Optional[int], optional): Width of output, or ``None`` to auto-detect. Defaults to ``None``. crop (Optional[bool], optional): Crop output to width of terminal. Defaults to True. soft_wrap (bool, optional): Enable soft wrap mode which disables word wrapping and cropping of text or None for Console default. Defaults to ``None``. NTrOFr)rerfrYrZrgrir)rrrr3rrsrvminrYr~rr-r7rrrr)rnrrrrerfrgr rirhrYrZrMrrrr]r new_segmentsrr-r buffer_extendrrTrTrUrsl#   $"z Console.print)regionrsrc Csz|jstd|p |j}|dur!d}}||j|jp|j}n |\}}}}|||}|j||d} || ||dS)aUpdate the screen at a given offset. Args: renderable (RenderableType): A Rich renderable. region (Region, optional): Region of screen to update, or None for entire screen. Defaults to None. x (int, optional): x offset. Defaults to 0. y (int, optional): y offset. Defaults to 0. Raises: errors.NoAltScreen: If the Console isn't in alt screen mode. 0Alt screen must be enabled to call update_screenNrr) rr! NoAltScreenrsrxrbrZrupdate_screen_lines) rnrrrsrrrrYrZrrTrTrU update_screens    zConsole.update_screenrrrrcCs>|jstdt|||}||}|j||dS)aUpdate lines of the screen at a given offset. Args: lines (List[List[Segment]]): Rendered lines (as produced by :meth:`~rich.Console.render_lines`). x (int, optional): x offset (column no). Defaults to 0. y (int, optional): y offset (column no). Defaults to 0. Raises: errors.NoAltScreen: If the Console isn't in alt screen mode. rN)rr!rrr-rrrX)rnrrr screen_updaterrTrTrUr7s      zConsole.update_screen_linesrrrYrr word_wrap show_localsrrrcCs,ddlm}||||||d}||dS)a Prints a rich render of the last exception and traceback. Args: width (Optional[int], optional): Number of characters used to render code. Defaults to 88. extra_lines (int, optional): Additional lines of code to render. Defaults to 3. theme (str, optional): Override pygments theme used in traceback word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False. show_locals (bool, optional): Enable display of local variables. Defaults to False. r ) TracebackrN)rerr)rnrYrrrrrrerTrTrUprint_exceptionKs zConsole.print_exception) rrrrer rirh log_locals _stack_offsetrrc  s^| stf} ||j| ||||||d} dur"fdd| D} t| } | jdr0dntj| j} | j tj d}| j }|rYdd| j j D}| t|d d |j|| |||| d g} |jD]}|| } qjg}|j}|j}|j}| D] }||||q|jj}tj||jd d D]}||qWddS1swYdS)aLog rich content to the terminal. Args: objects (positional args): Objects to log to the terminal. sep (str, optional): String to write between print data. Defaults to " ". end (str, optional): String to write at end of print data. Defaults to "\\n". style (Union[str, Style], optional): A style to apply to output. Defaults to None. justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``. overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to None. emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to None. markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to None. highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to None. log_locals (bool, optional): Boolean to enable logging of locals where ``log()`` was called. Defaults to False. _stack_offset (int, optional): Offset of caller from end of call stack. Defaults to 1. rNcrrTr:rrrTrUrrzConsole.log...z [i]locals)r)r pathline_no link_pathFr)rrinspectstackfilenamerlrvrabspath rpartitionrlinenoframef_localsitemsr^r5r*rr3rrr-rsrr7rrY)rnrrrrer rirhrrrrcallerrrr locals_mapr]rrr-rrrrrTrrUloghsd       "z Console.logc CsF|jr |jdd=dS|j|jdkry|jr2ddlm}||j||jdd|jdd=nW||jdd}|jdd=|rz trX|j j }| dD]}||qPn|j ||j Wn,t yx}z|jd|_d}~wwWddSWddSWddSWddS1swYdS)z$Check if the buffer may be rendered.Nrr )displayTzG *** You may need to add PYTHONIOENCODING=utf-8 to your environment ***)rrrrCrjupyterrrrrwrite splitlinesflushUnicodeEncodeErrorreason)rnrrrrrrTrTrUrXsB       "zConsole._check_bufferrc Csg}|j}|j}|j}|jr'|j|j|Wdn1s"wY|j }|jr5|r5t |}|D]\}}} |rI||j |||dq7|rM| sQ||q7d |} | S)z)Render buffered output, and clear buffer.N)rr`r) r^r%r`r r/r2rrcrr7 remove_colorr-r) rnroutputr^rr` not_terminalrrrrenderedrTrTrUrs2   zConsole._render_buffer)rir passwordstreampromptrrc Csd}|r%|}|j|||ddWdn1swY|}|jr0|j|d}|r:t||d}|S|rH|j||}|St|}|S)anDisplays a prompt and waits for input from the user. The prompt may contain color / style. Args: prompt (Union[str, Text]): Text to render in the prompt. markup (bool, optional): Enable console markup (requires a str prompt). Defaults to True. emoji (bool, optional): Enable emoji (requires a str prompt). Defaults to True. password: (bool, optional): Hide typed text. Defaults to False. stream: (TextIO, optional): Optional file to read input from (rather than stdin). Defaults to None. Returns: str: Text read from stdin. r)rir rN)r) rrrr`rrr readlineinput) rnrrir rr prompt_strrresultrTrTrUrs$    z Console.inputrrrcCs|jsJd|j2|rddd|jD}n ddd|jD}|r4|jdd=Wd|SWd|S1s?wY|S)aGenerate text from console contents (requires record=True argument in constructor). Args: clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``. styles (bool, optional): If ``True``, ansi escape codes will be included. ``False`` for plain text. Defaults to ``False``. Returns: str: String containing console contents. ITo export console contents set record=True in the constructor or instancercss(|]\}}}|r||n|VqdSrr,)rrrr}rTrTrUr/s  z&Console.export_text..css|] }|js|jVqdSr)rr)rrrTrTrUr4s N)r r/rr2)rnrrrrTrTrU export_texts*     zConsole.export_textrcCsL|j||d}t|ddd}||WddS1swYdS)aGenerate text from console and save to a given location (requires record=True argument in constructor). Args: path (str): Path to write text files. clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``. styles (bool, optional): If ``True``, ansi style codes will be included. ``False`` for plain text. Defaults to ``False``. r wtrlrdN)r openr)rnrrrr write_filerTrTrU save_text=s  "zConsole.save_textrr code_format inline_stylesrrc Cs|jsJdg}|j}|pt}d}dtdtfdd} |dur!tn|} |j|rbtt|j D].\} } } | | } | r\| |}| j rOd| j d | d } |rZd |d | d n| } || q2ndi}tt|j D]8\} } } | | } | r| |}| |t |d }| j rd|d| j d | d } n d|d | d } || qmg}|j}|D]\}}|r|d|d|dqd|}| jd|||jj|jjd}|r|j dd=Wd|SWd|S1swY|S)aGenerate HTML from console contents (requires record=True argument in constructor). Args: theme (TerminalTheme, optional): TerminalTheme object containing console colors. clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``. code_format (str, optional): Format string to render HTML, should contain {foreground} {background} and {code}. inline_styles (bool, optional): If ``True`` styles will be inlined in to spans, which makes files larger but easier to cut and paste markup. If ``False``, styles will be embedded in a style tag. Defaults to False. Returns: str: String containing console contents as HTML. r rrrjcSs|ddddddS)z Escape html.&z&rz<r8z>)replace)rrTrTrUescapeisz#Console.export_html..escapeNz zz r?rr@rArrBrYrCrrErrrzrr{r|rPr~rrLrPrOrXr^rrrrr+ ExceptionrrrrrrrrryrrrKr'rrklocalrrrr]rrcoloramarrrQrrrrrTrTrTrUs        @               k  !'/$!     "