Write data to STDOUT

@param string text
@param string text_color
@param string bg_color
979512
public static function write($text, $text_color = null, $bg_color = null)
    {
        if (null !== $text_color || null !== $bg_color) {
            $text = self::color($text, $text_color, $bg_color);
        }

        fwrite(STDOUT, $text);
    }
195002
public static function write( $str, $color = null, $background = null ) 
	{
		if ( !is_null( $color ) ) 
		{
			$str = static::color( $str, $color, $background );
		}
		
		fwrite( STDOUT, $str );
	}
949367
def Write(self, string):
    
    if sys.version_info[0] < 3:
      super(StdoutOutputWriter, self).Write(string)
    else:
      # sys.stdout.write() on Python 3 by default will error if string is
      # of type bytes.
      sys.stdout.write(string)
17545
def text(self, x, y, text, attr=None):
        '''
        self.pos(x, y)
        self.write_color(text, attr)
1127327
def cprint(text, fg=grey, bg=blackbg, w=norm, cr=False, encoding='utf8'):
    ''' 
    '''
    colorstart(fg, bg, w)
    out(text)
    colorend(cr)
450628
def info(text, *args, **kwargs):
    ''''''
    text = text.format(*args, **kwargs)
    print(' '.join((purple('>>>'), text)))
    sys.stdout.flush()
697185
public function writeLine($text = "", $color = null, $bgColor = null)
    {
        $this->adapter->writeLine($text, $color, $bgColor);
    }
511972
def fprint(fmt, *args, **kwargs):
    
    if not fmt:
        return

    hascolor = False
    target = kwargs.get("target", sys.stdout)

    # Format the string before feeding it to the parser
    fmt = fmt.format(*args, **kwargs)

    for txt, markups in _color_format_parser.parse(fmt):
        if markups != (None, None):
            _color_manager.set_color(*markups)
            hascolor = True
        else:
            if hascolor:
                _color_manager.set_defaults()
                hascolor = False

        target.write(txt)
        target.flush()  # Needed for Python 3.x

    _color_manager.set_defaults()
    target.write(kwargs.get('end', '\n'))
    _color_manager.set_defaults()
661483
public void print(String text) {
        try {
            out.write(text);
        } catch(IOException ioe) {
            throw new GroovyRuntimeException(ioe);
        }
    }
144363
def success(text):
    ''''''
    print(' '.join((green('✔'), white(text))))
    sys.stdout.flush()
937287
public function printMessage($text, $fg = Console::FG_YELLOW, $bg = Console::BG_BLACK)
    {
        if (Yii::$app instanceof \yii\console\Application && Yii::$app->controller->interactive) {
            Yii::$app->controller->stdout($text . PHP_EOL, $fg, $bg);
        }
    }
887292
public void _writeString(String text) throws IOException
	{

		int len = text.length();
		if (len > _outputEnd) { // Let's reserve space for entity at begin/end
			_writeLongString(text);
			return;
		}

		// Ok: we know String will fit in buffer ok
		// But do we need to flush first?
		if ((_outputTail + len) > _outputEnd) {
			_flushBuffer();
		}
		text.getChars(0, len, _outputBuffer, _outputTail);

		if (_characterEscapes != null) {
			_writeStringCustom(len);
		} else if (_maximumNonEscapedChar != 0) {
			_writeStringASCII(len, _maximumNonEscapedChar);
		} else {
			_writeString2(len);
		}
	}
476997
def write_stdout function #, string
      # TODO save and restore r0
      function.mov( :r0 ,  1 ) # 1 == stdout
      function.mov( :r1 , receiver_register )
      function.mov( receiver_register , :r3 )
      syscall( function.insertion_point , 4 ) # 4 == write
    end
576854
def write(self, b: bytes) -> None:
        """"""
        if not isinstance(b, bytes):
            raise TypeError('a bytes-like object is required, not {}'.format(type(b)))
        if not self.std_sim_instance.pause_storage:
            self.byte_buf += b
        if self.std_sim_instance.echo:
            self.std_sim_instance.inner_stream.buffer.write(b)

            # Since StdSim wraps TextIO streams, we will flush the stream if line buffering is on
            # and the bytes being written contain a new line character. This is helpful when StdSim
            # is being used to capture output of a shell command because it causes the output to print
            # to the screen more often than if we waited for the stream to flush its buffer.
            if self.std_sim_instance.line_buffering:
                if any(newline in b for newline in ByteBuf.NEWLINES):
                    self.std_sim_instance.flush()
213267
public static function stdout($text, $raw = false)
    {
        if ($raw) {
            return fwrite(STDOUT, $text);
        } elseif (extension_loaded('posix') && posix_isatty(STDOUT)) {
            return fwrite(STDOUT, static::colorize($text));
        } else {
            return fwrite(STDOUT, static::decolorize($text));
        }
    }
506285
public void write(String text, int offset, int length) {
        buffer.append(text, offset, offset + length);
    }
859380
def pdebug(*args, **kwargs):
    """"""
    if should_msg(kwargs.get("groups", ["debug"])):
        # initialize colorama only if uninitialized
        global colorama_init
        if not colorama_init:
            colorama_init = True
            colorama.init()

        args = indent_text(*args, **kwargs)

        # write to stdout
        sys.stderr.write(colorama.Fore.CYAN)
        sys.stderr.write("".join(args))
        sys.stderr.write(colorama.Fore.RESET)
        sys.stderr.write("\n")