pub thousands_sep: String,

pub decimal_point: String,

/// Grouping pattern from `lconv.grouping`.

/// Each element is a group size. The last non-zero element repeats.

/// e.g. `[3, 0]` means groups of 3 repeating forever.

pub grouping: Vec<u8>,

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8)

where

Self: Sized;

Str = b's',

Repr = b'r',

Ascii = b'b',

Bytes = b'a',

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {

let Some(conversion) = Self::from_string(text) else {

return (None, text);

};

let mut chars = text.code_points();

chars.next(); // Consume the bang

chars.next(); // Consume one r,s,a char

(Some(conversion), chars.as_wtf8())

}

pub fn from_char(c: CodePoint) -> Option<Self> {

match c.to_char_lossy() {

's' => Some(Self::Str),

'r' => Some(Self::Repr),

'a' => Some(Self::Ascii),

'b' => Some(Self::Bytes),

_ => None,

}

}

fn from_string(text: &Wtf8) -> Option<Self> {

let mut chars = text.code_points();

if chars.next()? != '!' {

return None;

}

Self::from_char(chars.next()?)

}

Left,

Right,

AfterSign,

Center,

fn from_char(c: CodePoint) -> Option<Self> {

match c.to_char_lossy() {

'<' => Some(Self::Left),

'>' => Some(Self::Right),

'=' => Some(Self::AfterSign),

'^' => Some(Self::Center),

_ => None,

}

}

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {

let mut chars = text.code_points();

if let Some(maybe_align) = chars.next().and_then(Self::from_char) {

(Some(maybe_align), chars.as_wtf8())

} else {

(None, text)

}

}

Plus,

Minus,

MinusOrSpace,

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {

let mut chars = text.code_points();

match chars.next().and_then(CodePoint::to_char) {

Some('-') => (Some(Self::Minus), chars.as_wtf8()),

Some('+') => (Some(Self::Plus), chars.as_wtf8()),

Some(' ') => (Some(Self::MinusOrSpace), chars.as_wtf8()),

_ => (None, text),

}

}

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {

let mut chars = text.code_points();

match chars.next().and_then(CodePoint::to_char) {

Some('_') => (Some(Self::Underscore), chars.as_wtf8()),

Some(',') => (Some(Self::Comma), chars.as_wtf8()),

_ => (None, text),

}

}

match fg {

FormatGrouping::Comma => ',',

FormatGrouping::Underscore => '_',

}

String,

Binary,

Character,

Decimal,

Octal,

Number(Case),

Hex(Case),

Exponent(Case),

GeneralFormat(Case),

FixedPoint(Case),

Percentage,

Unknown(char),

match from {

FormatType::String => 's',

FormatType::Binary => 'b',

FormatType::Character => 'c',

FormatType::Decimal => 'd',

FormatType::Octal => 'o',

FormatType::Number(Case::Lower) => 'n',

FormatType::Number(Case::Upper) => 'N',

FormatType::Hex(Case::Lower) => 'x',

FormatType::Hex(Case::Upper) => 'X',

FormatType::Exponent(Case::Lower) => 'e',

FormatType::Exponent(Case::Upper) => 'E',

FormatType::GeneralFormat(Case::Lower) => 'g',

FormatType::GeneralFormat(Case::Upper) => 'G',

FormatType::FixedPoint(Case::Lower) => 'f',

FormatType::FixedPoint(Case::Upper) => 'F',

FormatType::Percentage => '%',

FormatType::Unknown(c) => *c,

}

fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {

let mut chars = text.code_points();

match chars.next().and_then(CodePoint::to_char) {

Some('s') => (Some(Self::String), chars.as_wtf8()),

Some('b') => (Some(Self::Binary), chars.as_wtf8()),

Some('c') => (Some(Self::Character), chars.as_wtf8()),

Some('d') => (Some(Self::Decimal), chars.as_wtf8()),

Some('o') => (Some(Self::Octal), chars.as_wtf8()),

Some('n') => (Some(Self::Number(Case::Lower)), chars.as_wtf8()),

Some('N') => (Some(Self::Number(Case::Upper)), chars.as_wtf8()),

Some('x') => (Some(Self::Hex(Case::Lower)), chars.as_wtf8()),

Some('X') => (Some(Self::Hex(Case::Upper)), chars.as_wtf8()),

Some('e') => (Some(Self::Exponent(Case::Lower)), chars.as_wtf8()),

Some('E') => (Some(Self::Exponent(Case::Upper)), chars.as_wtf8()),

Some('f') => (Some(Self::FixedPoint(Case::Lower)), chars.as_wtf8()),

Some('F') => (Some(Self::FixedPoint(Case::Upper)), chars.as_wtf8()),

Some('g') => (Some(Self::GeneralFormat(Case::Lower)), chars.as_wtf8()),

Some('G') => (Some(Self::GeneralFormat(Case::Upper)), chars.as_wtf8()),

Some('%') => (Some(Self::Percentage), chars.as_wtf8()),

Some(c) => (Some(Self::Unknown(c)), chars.as_wtf8()),

_ => (None, text),

}

}

conversion: Option<FormatConversion>,

fill: Option<CodePoint>,

align: Option<FormatAlign>,

sign: Option<FormatSign>,

alternate_form: bool,

width: Option<usize>,

grouping_option: Option<FormatGrouping>,

precision: Option<usize>,

format_type: Option<FormatType>,

for (index, character) in text.code_point_indices() {

if !character.is_char_and(|c| c.is_ascii_digit()) {

return index;

}

}

text.len()

let char_indices: Vec<(usize, CodePoint)> = text.code_point_indices().take(3).collect();

if char_indices.is_empty() {

(None, None, text)

} else if char_indices.len() == 1 {

let (maybe_align, remaining) = FormatAlign::parse(text);

(None, maybe_align, remaining)

} else {

let (maybe_align, remaining) = FormatAlign::parse(&text[char_indices[1].0..]);

if maybe_align.is_some() {

(Some(char_indices[0].1), maybe_align, remaining)

} else {

let (only_align, only_align_remaining) = FormatAlign::parse(text);

(None, only_align, only_align_remaining)

}

}

let num_digits: usize = get_num_digits(text);

if num_digits == 0 {

return Ok((None, text));

}

if let Some(num) = parse_usize(&text[..num_digits]) {

Ok((Some(num), &text[num_digits..]))

} else {

// NOTE: this condition is different from CPython

Err(FormatSpecError::DecimalDigitsTooMany)

}

let mut chars = text.code_points();

match chars.next().and_then(CodePoint::to_char) {

Some('#') => (true, chars.as_wtf8()),

_ => (false, text),

}

let mut chars = text.code_points();

match chars.next().and_then(CodePoint::to_char) {

Some('0') => (true, chars.as_wtf8()),

_ => (false, text),

}

let mut chars = text.code_points();

Ok(match chars.next().and_then(CodePoint::to_char) {

Some('.') => {

let (size, remaining) = parse_number(chars.as_wtf8())?;

if let Some(size) = size {

if size > i32::MAX as usize {

return Err(FormatSpecError::PrecisionTooBig);

}

(Some(size), remaining)

} else {

(None, text)

}

}

_ => (None, text),

})

pub fn parse(text: impl AsRef<Wtf8>) -> Result<Self, FormatSpecError> {

Self::_parse(text.as_ref())

}

fn _parse(text: &Wtf8) -> Result<Self, FormatSpecError> {

// get_integer in CPython

let (conversion, text) = FormatConversion::parse(text);

let (mut fill, mut align, text) = parse_fill_and_align(text);

let (sign, text) = FormatSign::parse(text);

let (alternate_form, text) = parse_alternate_form(text);

let (zero, text) = parse_zero(text);

let (width, text) = parse_number(text)?;

let (grouping_option, text) = FormatGrouping::parse(text);

if let Some(grouping) = &grouping_option {

Self::validate_separator(grouping, text)?;

}

let (precision, text) = parse_precision(text)?;

let (format_type, text) = FormatType::parse(text);

if !text.is_empty() {

return Err(FormatSpecError::InvalidFormatSpecifier);

}

if zero && fill.is_none() {

fill.replace('0'.into());

align = align.or(Some(FormatAlign::AfterSign));

}

Ok(Self {

conversion,

fill,

align,

sign,

alternate_form,

width,

grouping_option,

precision,

format_type,

})

}

fn validate_separator(grouping: &FormatGrouping, text: &Wtf8) -> Result<(), FormatSpecError> {

let mut chars = text.code_points().peekable();

match chars.peek().and_then(|cp| CodePoint::to_char(*cp)) {

Some(c) if c == ',' || c == '_' => {

if c == char::from(grouping) {

Err(FormatSpecError::UnspecifiedFormat(c, c))

} else {

Err(FormatSpecError::ExclusiveFormat(',', '_'))

}

}

_ => Ok(()),

}

}

fn compute_fill_string(fill_char: CodePoint, fill_chars_needed: i32) -> Wtf8Buf {

(0..fill_chars_needed).map(|_| fill_char).collect()

}

fn add_magnitude_separators_for_char(

magnitude_str: String,

inter: i32,

sep: char,

disp_digit_cnt: i32,

) -> String {

// Don't add separators to the floating decimal point of numbers

let mut parts = magnitude_str.splitn(2, '.');

let magnitude_int_str = parts.next().unwrap().to_string();

let dec_digit_cnt = magnitude_str.len() as i32 - magnitude_int_str.len() as i32;

let int_digit_cnt = disp_digit_cnt - dec_digit_cnt;

let mut result = Self::separate_integer(magnitude_int_str, inter, sep, int_digit_cnt);

if let Some(part) = parts.next() {

result.push_str(&format!(".{part}"))

}

result

}

fn separate_integer(

magnitude_str: String,

inter: i32,

sep: char,

disp_digit_cnt: i32,

) -> String {

let magnitude_len = magnitude_str.len() as i32;

let offset = (disp_digit_cnt % (inter + 1) == 0) as i32;

let disp_digit_cnt = disp_digit_cnt + offset;

let pad_cnt = disp_digit_cnt - magnitude_len;

let sep_cnt = disp_digit_cnt / (inter + 1);

let diff = pad_cnt - sep_cnt;

if pad_cnt > 0 && diff > 0 {

// separate with 0 padding

let padding = "0".repeat(diff as usize);

let padded_num = format!("{padding}{magnitude_str}");

Self::insert_separator(padded_num, inter, sep, sep_cnt)

} else {

// separate without padding

let sep_cnt = (magnitude_len - 1) / inter;

Self::insert_separator(magnitude_str, inter, sep, sep_cnt)

}

}

fn insert_separator(mut magnitude_str: String, inter: i32, sep: char, sep_cnt: i32) -> String {

let magnitude_len = magnitude_str.len() as i32;

for i in 1..=sep_cnt {

magnitude_str.insert((magnitude_len - inter * i) as usize, sep);

}

magnitude_str

}

fn validate_format(&self, default_format_type: FormatType) -> Result<(), FormatSpecError> {

let format_type = self.format_type.as_ref().unwrap_or(&default_format_type);

match (&self.grouping_option, format_type) {

(

Some(FormatGrouping::Comma),

FormatType::String

| FormatType::Character

| FormatType::Binary

| FormatType::Octal

| FormatType::Hex(_)

| FormatType::Number(_),

) => {

let ch = char::from(format_type);

Err(FormatSpecError::UnspecifiedFormat(',', ch))

}

(

Some(FormatGrouping::Underscore),

FormatType::String | FormatType::Character | FormatType::Number(_),

) => {

let ch = char::from(format_type);

Err(FormatSpecError::UnspecifiedFormat('_', ch))

}

_ => Ok(()),

}

}

const fn get_separator_interval(&self) -> usize {

match self.format_type {

Some(FormatType::Binary | FormatType::Octal | FormatType::Hex(_)) => 4,

Some(

FormatType::Decimal

| FormatType::FixedPoint(_)

| FormatType::GeneralFormat(_)

| FormatType::Exponent(_)

| FormatType::Percentage

| FormatType::Number(_),

) => 3,

None => 3,

_ => panic!("Separators only valid for numbers!"),

}

}

fn add_magnitude_separators(&self, magnitude_str: String, prefix: &str) -> String {

match &self.grouping_option {

Some(fg) => {

let sep = char::from(fg);

let inter = self.get_separator_interval().try_into().unwrap();

let magnitude_len = magnitude_str.len();

let disp_digit_cnt = if self.fill == Some('0'.into())

&& self.align == Some(FormatAlign::AfterSign)

{

let width = self.width.unwrap_or(magnitude_len) as i32 - prefix.len() as i32;

cmp::max(width, magnitude_len as i32)

} else {

magnitude_len as i32

};

Self::add_magnitude_separators_for_char(magnitude_str, inter, sep, disp_digit_cnt)

}

None => magnitude_str,

}

}

/// Returns true if this format spec uses the locale-aware 'n' format type.

pub fn has_locale_format(&self) -> bool {

matches!(self.format_type, Some(FormatType::Number(Case::Lower)))

}

/// Insert locale-aware thousands separators into an integer string.

/// Follows CPython's GroupGenerator logic for variable-width grouping.

fn insert_locale_grouping(int_part: &str, locale: &LocaleInfo) -> String {

if locale.grouping.is_empty() || locale.thousands_sep.is_empty() || int_part.len() <= 1 {

return int_part.to_string();

}

let mut group_idx = 0;

let mut group_size = locale.grouping[0] as usize;

if group_size == 0 {

return int_part.to_string();

}

// Collect groups of digits from right to left

let len = int_part.len();

let mut groups: Vec<&str> = Vec::new();

let mut pos = len;

loop {

if pos <= group_size {

groups.push(&int_part[..pos]);

break;

}

groups.push(&int_part[pos - group_size..pos]);

pos -= group_size;

// Advance to next group size

if group_idx + 1 < locale.grouping.len() {

let next = locale.grouping[group_idx + 1] as usize;

if next != 0 {

group_size = next;

group_idx += 1;

}

// 0 means repeat previous group size forever

}

}

// Groups were collected right-to-left, reverse to get left-to-right

groups.reverse();

groups.join(&locale.thousands_sep)

}

/// Apply locale-aware grouping and decimal point replacement to a formatted number.

fn apply_locale_formatting(magnitude_str: String, locale: &LocaleInfo) -> String {

let mut parts = magnitude_str.splitn(2, '.');

let int_part = parts.next().unwrap();

let grouped = Self::insert_locale_grouping(int_part, locale);

if let Some(frac_part) = parts.next() {

format!("{grouped}{}{frac_part}", locale.decimal_point)

} else {

grouped

}

}

/// Format an integer with locale-aware 'n' format.

pub fn format_int_locale(

&self,

num: &BigInt,

locale: &LocaleInfo,

) -> Result<String, FormatSpecError> {

self.validate_format(FormatType::Decimal)?;

let magnitude = num.abs();

let raw_magnitude_str = match self.format_type {

Some(FormatType::Number(Case::Lower)) => self.format_int_radix(magnitude, 10),

_ => return self.format_int(num),

}?;

let magnitude_str = Self::apply_locale_formatting(raw_magnitude_str, locale);

let format_sign = self.sign.unwrap_or(FormatSign::Minus);

let sign_str = match num.sign() {

Sign::Minus => "-",

_ => match format_sign {

FormatSign::Plus => "+",

FormatSign::Minus => "",

FormatSign::MinusOrSpace => " ",

},

};

self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)

}

/// Format a float with locale-aware 'n' format.

pub fn format_float_locale(

&self,

num: f64,

locale: &LocaleInfo,

) -> Result<String, FormatSpecError> {

self.validate_format(FormatType::FixedPoint(Case::Lower))?;

let precision = self.precision.unwrap_or(6);

let magnitude = num.abs();

let raw_magnitude_str = match &self.format_type {

Some(FormatType::Number(case)) => {

let precision = if precision == 0 { 1 } else { precision };

Ok(float::format_general(

precision,

magnitude,

*case,

self.alternate_form,

false,

))

}

_ => return self.format_float(num),

}?;

let magnitude_str = Self::apply_locale_formatting(raw_magnitude_str, locale);

let format_sign = self.sign.unwrap_or(FormatSign::Minus);

let sign_str = if num.is_sign_negative() && !num.is_nan() {

"-"

} else {

match format_sign {

FormatSign::Plus => "+",

FormatSign::Minus => "",

FormatSign::MinusOrSpace => " ",

}

};

self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)

}

/// Format a complex number with locale-aware 'n' format.

pub fn format_complex_locale(

&self,

num: &Complex64,

locale: &LocaleInfo,

) -> Result<String, FormatSpecError> {

// Reuse format_complex_re_im with 'g' type to get the base formatted parts,

// then apply locale grouping. This matches CPython's format_complex_internal:

// 'n' → 'g', add_parens=0, skip_re=0.

let locale_spec = FormatSpec {

format_type: Some(FormatType::GeneralFormat(Case::Lower)),

..*self

};

let (formatted_re, formatted_im) = locale_spec.format_complex_re_im(num)?;

// Apply locale grouping to both parts

let grouped_re = if formatted_re.is_empty() {

formatted_re

} else {

// Split sign from magnitude, apply grouping, recombine

let (sign, mag) = if formatted_re.starts_with('-')

|| formatted_re.starts_with('+')

|| formatted_re.starts_with(' ')

{

formatted_re.split_at(1)

} else {

("", formatted_re.as_str())

};

format!(

"{sign}{}",

Self::apply_locale_formatting(mag.to_string(), locale)

)

};

// formatted_im is like "+1234j" or "-1234j" or "1234j"

// Split sign, magnitude, and 'j' suffix

let im_str = &formatted_im;

let (im_sign, im_rest) = if im_str.starts_with('+') || im_str.starts_with('-') {

im_str.split_at(1)

} else {

("", im_str.as_str())

};

let im_mag = im_rest.strip_suffix('j').unwrap_or(im_rest);

let im_grouped = Self::apply_locale_formatting(im_mag.to_string(), locale);

let grouped_im = format!("{im_sign}{im_grouped}j");

// No parentheses for 'n' format (CPython: add_parens=0)

let magnitude_str = format!("{grouped_re}{grouped_im}");

self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right)

}

pub fn format_bool(&self, input: bool) -> Result<String, FormatSpecError> {

let x = u8::from(input);

match &self.format_type {

Some(

FormatType::Binary

| FormatType::Decimal

| FormatType::Octal

| FormatType::Number(Case::Lower)

| FormatType::Hex(_)

| FormatType::GeneralFormat(_)

| FormatType::Character,

) => self.format_int(&BigInt::from_u8(x).unwrap()),

Some(FormatType::Exponent(_) | FormatType::FixedPoint(_) | FormatType::Percentage) => {

self.format_float(x as f64)

}

None => {

let first_letter = (input.to_string().as_bytes()[0] as char).to_uppercase();

Ok(first_letter.collect::<String>() + &input.to_string()[1..])

}

Some(FormatType::Unknown(c)) => Err(FormatSpecError::UnknownFormatCode(*c, "int")),

_ => Err(FormatSpecError::InvalidFormatSpecifier),

}

}

pub fn format_float(&self, num: f64) -> Result<String, FormatSpecError> {

self.validate_format(FormatType::FixedPoint(Case::Lower))?;

let precision = self.precision.unwrap_or(6);

let magnitude = num.abs();

let raw_magnitude_str: Result<String, FormatSpecError> = match &self.format_type {

Some(FormatType::FixedPoint(case)) => Ok(float::format_fixed(

precision,

magnitude,

*case,

self.alternate_form,

)),

Some(FormatType::Decimal)

| Some(FormatType::Binary)

| Some(FormatType::Octal)

| Some(FormatType::Hex(_))

| Some(FormatType::String)

| Some(FormatType::Character)

| Some(FormatType::Number(Case::Upper))

| Some(FormatType::Unknown(_)) => {

let ch = char::from(self.format_type.as_ref().unwrap());

Err(FormatSpecError::UnknownFormatCode(ch, "float"))

}

Some(FormatType::GeneralFormat(case)) | Some(FormatType::Number(case)) => {

let precision = if precision == 0 { 1 } else { precision };

Ok(float::format_general(

precision,

magnitude,

*case,

self.alternate_form,

false,

))

}

Some(FormatType::Exponent(case)) => Ok(float::format_exponent(

precision,

magnitude,

*case,

self.alternate_form,

)),

Some(FormatType::Percentage) => match magnitude {

magnitude if magnitude.is_nan() => Ok("nan%".to_owned()),

magnitude if magnitude.is_infinite() => Ok("inf%".to_owned()),

_ => {

let result = format!("{:.*}", precision, magnitude * 100.0);

let point = float::decimal_point_or_empty(precision, self.alternate_form);

Ok(format!("{result}{point}%"))

}

},

None => match magnitude {

magnitude if magnitude.is_nan() => Ok("nan".to_owned()),

magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),

_ => match self.precision {

Some(precision) => Ok(float::format_general(

precision,

magnitude,

Case::Lower,

self.alternate_form,

true,

)),

None => Ok(float::to_string(magnitude)),

},

},

};

let format_sign = self.sign.unwrap_or(FormatSign::Minus);

let sign_str = if num.is_sign_negative() && !num.is_nan() {

"-"

} else {

match format_sign {

FormatSign::Plus => "+",

FormatSign::Minus => "",

FormatSign::MinusOrSpace => " ",

}

};

let magnitude_str = self.add_magnitude_separators(raw_magnitude_str?, sign_str);