Struct BytesLiteralFlags 

pub struct BytesLiteralFlags(/* private fields */);

Flags that can be queried to obtain information regarding the prefixes and quotes used for a bytes literal.

Notes on usage

If you’re using a Generator from the ruff_python_codegen crate to generate a lint-rule fix from an existing bytes literal, consider passing along the BytesLiteral::flags field. If you don’t have an existing literal but have a Checker from the ruff_linter crate available, consider using Checker::default_bytes_flags to create instances of this struct; this method will properly handle surrounding f-strings. For usage that doesn’t fit into one of these categories, the public constructor BytesLiteralFlags::empty can be used.

Implementations

impl BytesLiteralFlags

pub fn empty() -> BytesLiteralFlags

Construct a new BytesLiteralFlags with no flags set.

See BytesLiteralFlags::with_quote_style, BytesLiteralFlags::with_triple_quotes, and BytesLiteralFlags::with_prefix for ways of setting the quote style (single or double), enabling triple quotes, and adding prefixes (such as r), respectively.

See the documentation for BytesLiteralFlags for additional caveats on this constructor, and situations in which alternative ways to construct this struct should be used, especially when writing lint rules.

pub fn with_quote_style(self, quote_style: Quote) -> BytesLiteralFlags

pub fn with_triple_quotes( self, triple_quotes: TripleQuotes, ) -> BytesLiteralFlags

pub fn with_unclosed(self, unclosed: bool) -> BytesLiteralFlags

pub fn with_prefix(self, prefix: ByteStringPrefix) -> BytesLiteralFlags

pub fn with_invalid(self) -> BytesLiteralFlags

pub const fn prefix(self) -> ByteStringPrefix

Trait Implementations

impl Clone for BytesLiteralFlags

fn clone(&self) -> BytesLiteralFlags

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BytesLiteralFlags

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<AnyStringFlags> for BytesLiteralFlags

fn from(value: AnyStringFlags) -> BytesLiteralFlags

Converts to this type from the input type.

impl From<BytesLiteralFlags> for AnyStringFlags

fn from(value: BytesLiteralFlags) -> AnyStringFlags

Converts to this type from the input type.

impl GetSize for BytesLiteralFlags

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

where TRACKER: GetSizeTracker,

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl Hash for BytesLiteralFlags

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BytesLiteralFlags

fn eq(&self, other: &BytesLiteralFlags) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StringFlags for BytesLiteralFlags

fn triple_quotes(self) -> TripleQuotes

Return true if the bytestring is triple-quoted, i.e., it begins and ends with three consecutive quote characters. For example: b"""{bar}"""

fn quote_style(self) -> Quote

Return the quoting style (single or double quotes) used by the bytestring’s opener and closer:

• b"a" -> QuoteStyle::Double
• b'a' -> QuoteStyle::Single

fn prefix(self) -> AnyStringPrefix

fn is_unclosed(self) -> bool

fn is_triple_quoted(self) -> bool

Is the string triple-quoted, i.e., does it begin and end with three consecutive quote characters?

fn quote_str(self) -> &'static str

A str representation of the quotes used to start and close. This does not include any prefixes the string has in its opener.

fn quote_len(self) -> TextSize

The length of the quotes used to start and close the string. This does not include the length of any prefixes the string has in its opener.

fn opener_len(self) -> TextSize

The total length of the string’s opener, i.e., the length of the prefixes plus the length of the quotes used to open the string.

fn closer_len(self) -> TextSize

The total length of the string’s closer. This is always equal to self.quote_len(), except when the string is unclosed, in which case the length is zero.

fn as_any_string_flags(self) -> AnyStringFlags

fn display_contents(self, contents: &str) -> DisplayFlags<'_>

impl Copy for BytesLiteralFlags

impl Eq for BytesLiteralFlags

impl StructuralPartialEq for BytesLiteralFlags