MRE

Um pacote em Python para fazer expressão regular (RegEx). Possui o objetivo de transformar a criação de um RegEx em algo mais fácil de se ler.

Instalação do MRE

Instalando o pacote MRE usando o pip:

pip install mre

Sumário

Classes
Comentários
Exemplos

Classes

Regex
Quantifier
Set
Group
Lookahead
Anchor
Helper
- Range

Essa é a classe pai de todas as classes do pacote, o RegEx que se esta manipulando fica na variável self.rgx. O seu construtor pode receber qualquer quantidade de entradas, porém espera-se que sejam dos tipos: str, int e a própria classe Regex. Para entender melhor:

str: concatena à variável self.rgx;
int: realiza backreferences;
Regex: concatena o valor armazenado em self.rgx do objeto que se recebe na variável self.rgx do objeto que está recebendo.

Formas de se declarar um Regex:

from mre import Regex, Group

rgx_one = Regex("Hello world")  # Hello world
rgx_two = Regex("Hello", " world")  # Hello world
rgx_three = Regex("Hello") + " " + Regex("world")  # Hello world
rgx_four = Regex('<', Group('h[1-6]'), '>')  # <(h[1-6])>
rgx_five = Regex('<', Regex.SLASH, 1, '>')  # <\/\1>

Constantes

Constantes presentes na classe Regex:

Constante	Valor
`ANY`	`.`
`DOT`	`\\.`
`DIGIT`	`\\d`
`WHITESPACE`	`\\s`
`WORD_CHARS`	`\\w`
`SLASH`	`\\/.`
`NOT_DIGIT`	`\\D`
`NOT_WHITESPACE`	`\\S`
`NOT_WORD_CHARS`	`\\W`
`ZERO_OR_ONE`	`?`
`ZERO_OR_MULTIPLE`	`*`
`ONE_OR_MULTIPLE`	`+`
`HYPHEN`	`\\-`

Métodos

Além das funções, também haverá a descrição das sobrecargas.

str

Retorna o valor salvo em self.rgx.

from mre import Regex

regex = Regex("Hello world")
print(regex)  # "Hello world"

eq

A comparação pode ser entre str ou Regex:

== str: compara self.rgx ao valor da variável recebida;
== Regex: compara self.rgx (acessado através do método get) ao valor da variável self.rgx do objeto recebido (também acessado através do método get).

from mre import Regex

regex_one = Regex("Hello world")

print(regex_one == "Hello world")  # True
print(regex_one == "Hello world!")  # False

print(regex_one == Regex("Hello world"))  # True
print(regex_one == Regex("Hello world!"))  # False

iadd

Espera-se variáveis de dois tipos: str e Regex. Para entender melhor:

+= str: concatena self.rgx ao valor da variável recebida;
+= Regex: concatena self.rgx ao valor da variável self.rgx do objeto recebido (acessado através do método get).

Essa sobrecarga altera diretamente a variável self.rgx, sendo assim nos casos de operação. Por exemplo, num objeto Set irá alterar o valor entre os colchetes.

from mre import Regex, Set

regex = Regex("Hello")
regex += " world"
print(regex)  # "Hello world"

regex_set = Set("Hello")  # [Hello]
regex_set += " world"
print(regex_set)  # "[Hello world]"

add

Espera-se variáveis de dois tipos: str e Regex. Diferentemente da sobrecarga __iadd__, essa sobrecarga retorna um novo objeto Regex.

+ str: concatena self.rgx (acessado através do método get) ao valor da variável recebida;
+ Regex: concatena self.rgx (acessado através do método get) ao valor da variável self.rgx do objeto recebido (também acessado através do método get).

from mre import Regex

regex_one = Regex("Hello") + " " + Regex("world")
print(regex_one)  # "Hello world"

regex_two = Regex("Hello") + Regex(" world")
print(regex_two)  # "Hello world"

get

Retorna o valor armazenado em self.rgx.

from mre import Regex

regex = Regex("Valor armazenado")
print(regex.get())  # "Valor armazenado"

quantifier

Possui os seguintes parâmetros:

Parâmetro	Tipo	Valor padrão
`n`	`int`	`0`
`m`	`int`	`0`
`without_maximum`	`bool`	`False`

Serve para quantificar as vezes que o RegEx deve/pode aparecer (de n até m). Retorna um novo objeto Regex.

Em casos específicos, há a adição de um símbolo. Esses casos são:

n	m	without_maximum	Símbolo	Acesso
`0`	`1`	-	`?`	`Regex.ZERO_OR_ONE`
`0`	-	`True`	`*`	`Regex.ZERO_OR_MULTIPLE`
`1`	-	`True`	`+`	`Regex.ONE_OR_MULTIPLE`

Além desses casos específicos, a quantificação poderá ocorrer das formas:

{n}: deve ocorrer n vezes;
{n, m}: pode ocorrer de n até m vezes.

from mre import Regex

digits = Regex("[0-9]")

print(digits.quantifier(3))  # "[0-9]{3}"
print(digits.quantifier(3, 5))  # "[0-9]{3,5}"
print(digits.quantifier(0, 1))  # "[0-9]?"
print(digits.quantifier(0, without_maximum=True))  # "[0-9]*"
print(digits.quantifier(1, without_maximum=True))  # "[0-9]+"

backreferences

Possui um parâmetro do tipo int (group_n) que serve para indicar qual grupo se deseja realizar a backreference. Retorna um Regex que realiza backreferences ao grupo indicado.

Um meio alternativo de chamar esse método é inserindo um int no construtor.

from mre import Regex

regex_one = Regex().backreferences(1)
regex_two = Regex(2)

print(regex_one)  # "\1"
print(regex_two)  # "\2"

Quantifier

Essa classe serve como uma alternativa a chamada do método Regex.quantifier. O seu construtor recebe 4 parâmetros:

Parâmetro	Tipo	Valor padrão
`regex`	`str`, `int`, `Regex`	`""`
`n`	`int`	`0`
`m`	`int`	`0`
`without_maximum`	`bool`	`False`

O primeiro é referente ao RegEx que se deseja construir, os 3 restantes são para a chamada do método Regex.quantifier.

from mre import Regex, Quantifier

digits_one = Regex("[0-9]").quantifier(3, 5)
digits_two = Quantifier("[0-9]", 3, 5)

print(digits_one)  # "[0-9]{3,5}"
print(digits_two)  # "[0-9]{3,5}"

Set

Essa classe representa um conjunto no RegEx. O seu construtor é o mesmo da classe Regex.

from mre import Set

regex_set = Set("0-9")

print(regex_set)  # "[0-9]"
print(regex_set.quantifier(3))  # "[0-9]{3}"

Métodos

Essa classe herda os métodos da classe Regex, sobrescrevendo apenas os métodos a seguir.

get

Retorna o valor armazenado em self.rgx, mas entre colchetes.

from mre import Set

regex_set = Set("0-9")
print(regex_set.get())  # "[0-9]"

quantifier

Retorna um novo objeto Regex com o quantificador referente ao conjunto.

from mre import Set

regex_set = Set("0-9")

print(regex_set)  # "[0-9]"
print(regex_set.quantifier(3))  # "[0-9]{3}"

print(type(regex_set))  # <class 'mre.Set.Set'>
print(type(regex_set.quantifier(3)))  # <class 'mre.Regex.Regex'>

Group

Essa classe representa um grupo no RegEx. O seu construtor recebe 2 parâmetros:

Parâmetro	Tipo	Valor padrão
`regex`	`str`, `int`, `Regex`	`""`
`non_capturing`	`bool`	`False`

Se o argumento referente a non_capturing for True, será adicionado os símbolos que indicam que a RegEx Engine não deve retornar o valor daquele grupo (?:).

from mre import Group

regex_group_one = Group('<h1>') + Group('[\w\s]+') + Group('</h1>')
regex_group_two = Group('<h1>', True) + Group('[\w\s]+') + Group('</h1>', True)

print(regex_group_one)  # (<h1>)([\w\s]+)(</h1>)
print(regex_group_two)  # (?:<h1>)([\w\s]+)(?:</h1>)

Métodos

Essa classe herda os métodos da classe Regex, sobrescrevendo os métodos get e quantifier. Possui adicionalmente os métodos name e backreference_named.

get

Retorna o valor armazenado em self.rgx, mas entre parênteses.

from mre import Group

regex_group_one = Group("<h1>")
regex_group_two = Group("</h1>", True)

print(regex_group_one.get())  # "(<h1>)"
print(regex_group_two.get())  # "(?:</h1>)"

quantifier

Retorna um novo objeto Regex com o quantificador referente ao grupo.

from mre import Group

regex_group = Group("<h1>")

print(regex_group)  # "(<h1>)"
print(regex_group.quantifier(3))  # "(<h1>){3}"

print(type(regex_group))  # <class 'mre.Group.Group'>
print(type(regex_group.quantifier(3)))  # <class 'mre.Regex.Regex'>

name

Retorna um novo objeto Group com a propriedade de nome representada por ?<> a qual é retornado no método get.

from mre import Group

regex_named_group = Group("<h1>").name("tag")

print(regex_named_group.get())  # "(?P<tag><h1>)"

backreference_named

Retorna um novo objeto Group com a propriedade de nome de referência representada por ?P= a qual é retornado no método get.

from mre import Group

reference_named_group = Group().backreference_named("tag")

print(reference_named_group.get())  # "(?P=tag)"

Lookahead

Esta classe representa uma instrução lookahead em um RegEx, herda os métodos de Group. O seu construtor recebe 2 parâmetros:

Parâmetro	Tipo	Valor padrão
`regex`	`str`, `int`, `Regex`	`""`
`must_not_include`	`bool`	`False`

Se o argumento para must_not_include for True, serão adicionados símbolos que indicam que RegEx Engine deve afirmar que o valor do lookahead existe após o símbolo atual (?=). Se o argumento para must_not_include for False, serão adicionados símbolos que indicam que RegEx Engine deve afirmar que o valor do lookahead existe antes do símbolo atual (?!).

from mre import Lookahead

regex_lookahead_one = Lookahead('liquid') + " cooling"
print(regex_lookahead_one)  # (?=liquid) cooling

regex_lookahead_two = Lookahead('liquid', True) + " cooling"
print(regex_lookahead_two)  # (?!liquid) cooling

Anchor

Essa classe representa um RegEx com âncora (o RegEx deve começar e terminar como foi definido). O seu construtor recebe 2 parâmetros:

Parâmetro	Tipo	Valor padrão
`regex`	`str`, `int`, `Regex`	`""`
`negate`	`bool`	`False`

Se o argumento referente a negate for True, será adicionado os símbolos do inverso do padrão, ou seja, a RegEx não deve começar e terminar como definido.

from mre import Anchor

regex_anchor_one = Anchor("\\d{4}-\\w+.txt")
regex_anchor_two = Anchor("\\d{4}-\\w+.txt", True)

print(regex_anchor_one)  # "^\d{4}-\w+.txt$"
print(regex_anchor_two)  # "\b\d{4}-\w+.txt\B"

Métodos

Essa classe herda os métodos da classe Regex, sobrescrevendo apenas os métodos a seguir.

get

Retorna o valor armazenado em self.rgx, mas entre parênteses.

from mre import Anchor

regex_anchor_one = Anchor("<h1>Hello world<\/h1>")
print(regex_anchor_one.get())  # "^<h1>Hello world</h1>$"

regex_anchor_two = Anchor("<h1>Hello world<\/h1>", True)
print(regex_anchor_two.get())  # "\b<h1>Hello world</h1>\B"

helper.Range

Essa classe serve para ajudar na criação de um RegEx que indique uma classe de caracteres a partir de um range. O seu construtor recebe 2 parâmetros:

Parâmetro	Tipo	Valor padrão
`minimum`	`str`, `int`	`0`
`maximum`	`str`, `int`	`"z"`

Idealmente usar essa classe junto a classe Set, pois dentro de um conjunto, o hífen possui um valor "mágico" que o permite dar essa função de atribuir range, fora do conjunto o hífen tem apenas valor de hífen. Logo, se quiser, por exemplo, todas as letras minúsculas, deve usar [a-z] e não apenas a-z, pois assim você esta apenas dizendo que quer a, - e z.

from mre.helper import Range

# Todos os dígitos
digits = Range(0, 9)
print(digits)  # "0-9"

# Todas as letras
letters = Range('A', 'z')
print(letters)  # "A-z"

Métodos

Essa classe herda os métodos da classe Regex, além de possuir seus próprios métodos.

digits

Possui 2 parâmetros:

Parâmetro	Tipo	Valor padrão
`minimum`	`int`	`0`
`maximum`	`int`	`9`

Retorna um range que define os dígitos entre minimum e maximum.

from mre.helper import Range

regex_range_one = Range(0, 9)
regex_range_two = Range.digits()
regex_range_three = Range(0, 6)
regex_range_four = Range.digits(0, 6)

print(regex_range_one)  # "0-9"
print(regex_range_two)  # "0-9"
print(regex_range_three)  # "0-6"
print(regex_range_four)  # "0-6"

letters

Possui 4 parâmetros:

Parâmetro	Tipo	Valor padrão
`minimum`	`char`	`A`
`maximum`	`char`	`z`
`uppercase`	`bool`	`False`
`lowercase`	`bool`	`False`

Retorna um range que define as letras entre minimum e maximum.

from mre.helper import Range

# Todas as letras
regex_range_one = Range('A', 'z')
regex_range_two = Range.letters()
regex_range_three = Range.letters('A', 'z')
regex_range_four = Range.letters(uppercase=True, lowercase=True)
# Todas as letras maiúsculas
regex_range_five = Range.letters(uppercase=True)
# Todas as letras minúsculas
regex_range_six = Range.letters(lowercase=True)

print(regex_range_one)  # "A-z"
print(regex_range_two)  # "A-z"
print(regex_range_three)  # "A-z"
print(regex_range_four)  # "A-z"
print(regex_range_five)  # "A-Z"
print(regex_range_six)  # "a-z"

Comentários

Existem dois modos de realizar comentários no seu Regex:

Utilizando o método comment;
Utilizando a classe Comment.

Utilizando o método:

from mre import Regex, Set

# Todos os dígitos
digits = Set(Regex("0-9"))
# Adiciona comentário
digits = digits.comment('Get all digits')

# Output: [0-9](?#Get all digits)

Utilizando a classe:

from mre import Regex, Set, Comment

# Todos os dígitos
digits = Set(Regex("0-9"))
# Comentário do CEP
cep_comment = Comment('Get zip code Brazil on input')
# CEP regex
rgx_cep = Regex(
    digits.quantifier(5),
    Regex("-").quantifier(0, 1),
    digits.quantifier(3),
    cep_comment
)

# Output: [0-9]{5}-?[0-9]{3}(?#Get zip code Brazil on input)

Exemplos

2 formas de fazer o RegEx de CEP ([0-9]{5}-?[0-9]{3})

from mre import Regex, Set

# Todos os dígitos
digits = Set(Regex("0-9"))

rgx_cep = Regex(
    digits.quantifier(5),
    Regex("-").quantifier(0, 1),
    digits.quantifier(3),
)

from mre import Regex, Quantifier, Set
from mre.helper import Range

# Todos os dígitos [0-9]
digits = Set(Range.digits())
# O hífen pode aparecer nenhuma ou uma vez
hyphen = Quantifier("-", 0, 1)

rgx_cep = Regex(
    digits.quantifier(5), hyphen,
    digits.quantifier(3),
)

RegEx de CPF ([0-9]{3}.?[0-9]{3}.?[0-9]{3}-?[0-9]{2}):

from mre import Regex, Set
from mre.helper import Range

# Todos os dígitos
all_digits = Set(Range(0, 9))
# O ponto pode aparecer nenhuma ou uma vez
dot = Regex(Regex.DOT).quantifier(0, 1)
# O hífen pode aparecer nenhuma ou uma vez
hyphen = Regex('-').quantifier(0, 1)

rgx_cpf = Regex(
    all_digits.quantifier(3), dot,
    all_digits.quantifier(3), dot,
    all_digits.quantifier(3), hyphen,
    all_digits.quantifier(2),
)

RegEx de CNPJ (\d{2}\.?\d{3}\.?\d{3}\/?\d{4}\-?\d{2}):

from mre import Regex, Quantifier

# Todos os dígitos
digits = Regex(Regex.DIGIT)
# O ponto pode aparecer nenhuma ou uma vez
dot = Regex(Regex.DOT).quantifier(0, 1)
# A barra pode aparecer nenhuma ou uma vez
slash = Regex(Regex.SLASH).quantifier(0, 1)
# O hífen pode aparecer nenhuma ou uma vez
hyphen = Quantifier("-", 0, 1)

rgx_cnpj = Regex(
    digits.quantifier(2), dot,
    digits.quantifier(3), dot,
    digits.quantifier(3), slash,
    digits.quantifier(4), hyphen,
    digits.quantifier(2),
)

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

pt_BR.md

pt_BR.md

MRE

Instalação do MRE

Sumário

Classes

Regex

Constantes

Métodos

str

eq

iadd

add

get

quantifier

backreferences

Quantifier

Set

Métodos

get

quantifier

Group

Métodos

get

quantifier

name

backreference_named

Lookahead

Anchor

Métodos

get

helper.Range

Métodos

digits

letters

Comentários

Exemplos

Files

pt_BR.md

Latest commit

History

pt_BR.md

File metadata and controls

MRE

Instalação do MRE

Sumário

Métodos

__str__

__eq__

__iadd__

__add__

get

quantifier

backreferences

Set

Métodos

get

quantifier

Group

Métodos

get

quantifier

name

backreference_named

Métodos

get

Métodos

digits

letters

str

eq

iadd

add