Pyjo.Parameters - Parameters

from Pyjo.Parameters import Parameters

# Parse
params = Parameters('foo=bar&baz=23')
print(params.param('baz'))

# Or import the module, as in Google Python Style Guide

import Pyjo.Parameters

# Parse
params = Pyjo.Parameters.new('foo=bar&baz=23')
print(params.param('baz'))

# Build
params = Pyjo.Parameters.new('foo', 'bar', 'baz', 23)
params.pairs.append(('i', '♥ pyjoyment'))
print(params)

Pyjo.Parameters is a container for form parameters used by Pyjo.URL, based on RFC 3986 and the HTML Living Standard.

The parameters are pairs of a name and a value, as tuples. Methods that take parameters take them as tuples, as names followed by their values, or as keyword arguments:

params.append(('foo', 'bar'), ('baz', 23))
params.append('foo', 'bar', 'baz', 23)
params.append(foo='bar', baz=23)

See also

Pyjoyment, https://mojolicious.org.

Ported from Mojo::Parameters of Mojolicious 9.49.

Classes

class Pyjo.Parameters.Pyjo_Parameters(*args: Anything, **kwargs: Anything)

Pyjo.Parameters inherits all methods from Pyjo.Base and Pyjo.String.Mixin and implements the following new ones.

__bool__() → bool

boolean = bool(params)

Always true.

__getitem__(index: int) → tuple[str, str]

pair = params[0]

Alias for pairs. Note that this will normalize the parameters.

print(params[0])

__iter__() → Iterator[tuple[str, str]]

pairs = list(params)

Alias for pairs. Note that this will normalize the parameters.

for name, value in params:
    print(name, value)

__len__() → int

size = len(params)

Alias for pairs. Note that this will normalize the parameters.

__str__() → str

string = str(params)

Alias for to_str().

append(*args: Anything, **kwargs: Anything) → Self

params = params.append('foo', 'ba&r')
params = params.append('foo', ['ba&r', 'baz'])
params = params.append('foo', ['bar', 'baz'], 'bar', 23)
params = params.append(Pyjo.Parameters.new())

Append parameters. Note that this method will normalize the parameters.

# "foo=bar&foo=baz"
Pyjo.Parameters.new('foo=bar').append(Pyjo.Parameters.new('foo=baz'))

# "foo=bar&foo=baz"
Pyjo.Parameters.new('foo=bar').append('foo', 'baz')

# "foo=bar&foo=baz&foo=yada"
Pyjo.Parameters.new('foo=bar').append('foo', ['baz', 'yada'])

# "foo=bar&foo=baz&foo=yada&bar=23"
Pyjo.Parameters.new('foo=bar').append('foo', ['baz', 'yada'], 'bar', 23)

charset: str | None

charset = params.charset
params.charset = 'UTF-8'

Charset used for encoding and decoding parameters, defaults to UTF-8.

# Disable encoding and decoding
params.charset = None

clone() → Self

params2 = params.clone()

Return a new Pyjo.Parameters object cloned from these parameters.

every_param(name: Anything) → list[str]

values = params.every_param('foo')

Similar to param(), but returns all values sharing the same name as a list. Note that this method will normalize the parameters.

# Get first value
print(params.every_param('foo')[0])

merge(*args: Anything, **kwargs: Anything) → Self

params = params.merge('foo', 'ba&r')
params = params.merge('foo', ['ba&r', 'baz'])
params = params.merge('foo', ['bar', 'baz'], 'bar', 23)
params = params.merge(Pyjo.Parameters.new())

Merge parameters. Note that this method will normalize the parameters.

# "foo=baz"
Pyjo.Parameters.new('foo=bar').merge(Pyjo.Parameters.new('foo=baz'))

# "yada=yada&foo=baz"
Pyjo.Parameters.new('foo=bar&yada=yada').merge('foo', 'baz')

# "yada=yada"
Pyjo.Parameters.new('foo=bar&yada=yada').merge('foo', None)

names() → list[str]

names = params.names()

Return a list with all parameter names.

# Names of all parameters
for name in params.names():
    print(name)

property pairs: list[tuple[str, str]]

pairs = params.pairs
params.pairs = [('foo', 'b&ar'), ('baz', '23')]

Parsed parameter pairs. Note that this method will normalize the parameters.

# Remove all parameters
params.pairs = []

param(name: Anything, /) → str | None

param(name: Anything, value: Anything, /, *values: Anything) → Self

value = params.param('foo')
params = params.param('foo', 'ba&r')
params = params.param('foo', 'ba&r', 'baz')
params = params.param('foo', ['ba;r', 'baz'])

Access parameter values. If there are multiple values sharing the same name, and you want to access more than just the last one, you can use every_param(). Note that this method will normalize the parameters.

parse(*args: Anything, **kwargs: Anything) → Self

params = params.parse('foo=b%3Bar&baz=23')
params = params.parse(parse_qsl('foo=b%3Bar&baz=23'))

Parse parameters, given as characters or as bytes encoded with charset. A list of pairs, as urllib.parse.parse_qsl() gives, or a dict, as urllib.parse.parse_qs() gives, is appended.

remove(name: Anything) → Self

params = params.remove('foo')

Remove parameters. Note that this method will normalize the parameters.

# "bar=yada"
Pyjo.Parameters.new('foo=bar&foo=baz&bar=yada').remove('foo')

to_dict() → dict[str, str | list[str]]

d = params.to_dict()

Turn parameters into a dict. Note that this method will normalize the parameters.

# "baz"
Pyjo.Parameters.new('foo=bar&foo=baz').to_dict()['foo'][1]

to_str() → str

string = params.to_str()

Turn parameters into a string.

# "foo=bar&baz=23"
Pyjo.Parameters.new().set(pairs=[('foo', 'bar'), ('baz', '23')]).to_str()

to_urllib() → list[tuple[str, str]]

pairs = params.to_urllib()

Turn parameters into a list of pairs, as urllib.parse.parse_qsl() gives, for the standard library.

# "foo=bar&foo=baz"
urlencode(Pyjo.Parameters.new('foo=bar&foo=baz').to_urllib())