Segno

https://segno.readthedocs.io/en/stable/
Admin
Pure Python QR Code and Micro QR Code generator with no dependencies, conforming to ISO/IEC...
Tokens:22,933
Snippets:241
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install qrcode-artistic Plugin

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Install the qrcode-artistic plugin using pip. This plugin is required for advanced graphic operations like animated QR codes or QR codes with background images.

```bash
pip install qrcode-artistic

```

--------------------------------

### Serialize QR Code to EPS and PDF

Source: https://segno.readthedocs.io/en/stable/command-line.html

The `--output` or `-o` parameter supports various formats. This example shows creating an EPS file ('mrs.eps') and a PDF file ('dedodo.pdf').

```bash
$ segno --output=mrs.eps "Mrs. Robinson"

```

```bash
$ segno --output=dedodo.pdf "De Do Do Do, De Da Da Da"

```

```bash
$ segno --output=tin-pan-alley.svgz "Tin Pan Alley"

```

--------------------------------

### Change Light Module Color

Source: https://segno.readthedocs.io/en/stable/command-line.html

Use the `--light` argument to change the color of the light modules. This example sets the light modules to 'transparent'.

```bash
$ segno --light=transparent --scale 4 --output=hotel.png "Hotel California"
```

--------------------------------

### Get QR Code Version

Source: https://segno.readthedocs.io/en/stable/make.html

Demonstrates how the `segno.make()` function automatically selects the minimal QR code version for the given input and how to retrieve it.

```python
import segno
qrcode = segno.make('Rain')
qrcode.version
'M3'
```

--------------------------------

### Combine URL Background and BytesIO Output (GIF)

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Generate an artistic QR code using a background image from a URL and save the output directly to a `io.BytesIO` stream without writing to disk. This example creates a GIF output.

```python
import io
from urllib.request import urlopen
import segno
qrcode = segno.make('The Beatles', error='h')
url = 'https://media.giphy.com/media/mUPQmck5YEisg/giphy.gif'
bg_file = urlopen(url)
out = io.BytesIO()
qrcode.to_artistic(background=bg_file, target=out, scale=5, kind='gif')

```

--------------------------------

### Advanced Module Coloring

Source: https://segno.readthedocs.io/en/stable/command-line.html

The SVG, PNG, and PPM serializers support more advanced coloring options, allowing specific colors for different module types like finder patterns and data modules. This example sets dark, data-dark, and data-light colors.

```bash
$ segno --dark darkred --data-dark darkorange --data-light yellow --scale 5 -o qrcode_yellow-submarine.png Yellow Submarine
```

--------------------------------

### Change Both Dark and Light Module Colors

Source: https://segno.readthedocs.io/en/stable/command-line.html

Specify both `--dark` and `--light` arguments to customize the colors of both dark and light modules. This example uses 'darkblue' for dark modules and 'yellow' for light modules.

```bash
$ segno --dark=darkblue --light=yellow --scale 4 --output=dontgiveup.svg "Don't Give Up"
```

--------------------------------

### Serialize QR Code to SVG

Source: https://segno.readthedocs.io/en/stable/command-line.html

Generate an SVG file for the QR code by specifying the filename with an '.svg' extension using the `--output` or `-o` parameter. This example creates 'satellite.svg'.

```bash
$ segno -o=satellite.svg "Satellite Of Love"

```

--------------------------------

### Rotate QR Code with Pillow

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Create a QR code and then use the 'to_pil' method to get a Pillow Image instance. This instance can be further manipulated, such as rotating the QR code.

```python
import segno
qrcode = segno.make('Yellow Submarine', error='h')
img = qrcode.to_pil(scale=3).rotate(45, expand=True)
img.save('yellow-submarine-rotated.png')

```

--------------------------------

### Change Dark Module Color

Source: https://segno.readthedocs.io/en/stable/command-line.html

Use the `--dark` argument to change the color of the dark modules in a QR code. This example sets the dark modules to 'darkblue'.

```bash
$ segno --dark=darkblue --scale 4 --output=excited.png "So Excited"
```

--------------------------------

### Convert QR Code Matrix to Boolean List

Source: https://segno.readthedocs.io/en/stable/api.html

Converts the QR code matrix into a list of lists using boolean values (True for dark module, False for light module). This example demonstrates iterating through the matrix with a specified scale and default border.

```Python
import segno
qrcode = segno.make('The Beatles')
width, height = qrcode.symbol_size(scale=2)
res = []
# Scaling factor 2, default border
for row in qrcode.matrix_iter(scale=2):
    res.append([col == 0x1 for col in row])
width == len(res[0])
height == len(res)
```

--------------------------------

### Create QR Code using make_qr

Source: https://segno.readthedocs.io/en/stable/make.html

Demonstrates using the `segno.make_qr()` factory function to create a standard QR Code and retrieve its designator.

```python
import segno
qrcode = segno.make_qr('The Beatles')  # Same content but as QR Code
qrcode.designator
'1-Q'
```

--------------------------------

### segno.make_qr

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a QR Code. This is the main entry point to create QR Codes. Aside from content, all parameters are optional and an optimal (minimal) QR code with a maximal error correction level is generated.

```APIDOC
## Function: segno.make_qr

### Description
Creates a QR Code. This is the main entry point to create QR Codes. Aside from content, all parameters are optional and an optimal (minimal) QR code with a maximal error correction level is generated.

### Parameters
#### Path Parameters
* **content** (str, int, bytes) - Required - The data to encode. Either a Unicode string, an integer or bytes. If bytes are provided, the encoding parameter should be used to specify the used encoding.
* **error** (str or None) - Optional - Error correction level. If `None` (default), error correction level `L` is used. Valid values: `None`, “L”, “M”, “Q”, “H”.
* **version** (int, str or None) - Optional - QR Code version. If the value is `None` (default), the minimal version which fits for the input data will be used. Valid values: an integer between 1 and 40.
* **mode** (str or None) - Optional - "numeric", "alphanumeric", "byte", "kanji" or "hanzi". If the value is `None` (default) the appropriate mode will automatically be determined.
* **mask** (int or None) - Optional - Data mask. If the value is `None` (default), the appropriate data mask is chosen automatically.
* **encoding** (str or None) - Optional - Indicates the encoding in mode “byte”. By default (encoding is `None`) the implementation tries to use the standard conform ISO/IEC 8859-1 encoding and if it does not fit, it will use UTF-8.
* **eci** (bool) - Optional - Indicates if binary data which does not use the default encoding (ISO/IEC 8859-1) should enforce the ECI mode. Defaults to `False`.
* **boost_error** (bool) - Optional - Indicates if the error correction level may be increased if it does not affect the version (default: `True`).

### Raises
`ValueError` or `DataOverflowError`: In case the data does not fit into a QR Code or it does not fit into the provided `version`.

### Return type
QRCode
```

--------------------------------

### Create Micro QR Code

Source: https://segno.readthedocs.io/en/stable/make.html

Shows how to use the `segno.make_micro()` factory function to specifically create a Micro QR Code and retrieve its designator.

```python
import segno
micro_qrcode = segno.make_micro('The Beatles')  # Micro QR Code
micro_qrcode.designator  # Get the version and error level
'M4-M'
```

--------------------------------

### Specify QR Code Version with make

Source: https://segno.readthedocs.io/en/stable/make.html

Shows how to create a QR code with a specified version number using the `version` argument in `segno.make()` and retrieving its version and designator.

```python
import segno
qrcode = segno.make('Light My Fire', version=1)
qrcode.version
1
qrcode.designator
'1-M'
```

--------------------------------

### Create QR Code and Save in Multiple Formats

Source: https://segno.readthedocs.io/en/stable/make.html

Demonstrates creating a QR code from text and saving it to various file formats like SVG, PNG, EPS, and TXT.

```python
import segno
qrcode = segno.make('Henry Lee')
qrcode.save('henry-lee.svg')  # SVG document
qrcode.save('henry-lee.png')  # PNG image
qrcode.save('henry-lee.eps')  # EPS document
qrcode.save('henry-lee.txt')  # Text output
```

--------------------------------

### segno.make

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a (Micro) QR Code. This is the main entry point to create QR Codes and Micro QR Codes. Aside from content, all parameters are optional and an optimal (minimal) (Micro) QR code with a maximal error correction level is generated.

```APIDOC
## Function: segno.make

### Description
Creates a (Micro) QR Code. This is the main entry point to create QR Codes and Micro QR Codes. Aside from content, all parameters are optional and an optimal (minimal) (Micro) QR code with a maximal error correction level is generated.

### Parameters
#### Path Parameters
* **content** (str, int, bytes) - Required - The data to encode. Either a Unicode string, an integer or bytes. If bytes are provided, the encoding parameter should be used to specify the used encoding.
* **error** (str or None) - Optional - Error correction level. If `None` (default), error correction level `L` is used. Valid values: `None`, “L”, “M”, “Q”, “H” (error correction level “H” isn’t available for Micro QR Codes).
* **version** (int, str or None) - Optional - QR Code version. If the value is `None` (default), the minimal version which fits for the input data will be used. Valid values: “M1”, “M2”, “M3”, “M4” (for Micro QR codes) or an integer between 1 and 40 (for QR codes).
* **mode** (str or None) - Optional - "numeric", "alphanumeric", "byte", "kanji" or "hanzi". If the value is `None` (default) the appropriate mode will automatically be determined.
* **mask** (int or None) - Optional - Data mask. If the value is `None` (default), the appropriate data mask is chosen automatically.
* **encoding** (str or None) - Optional - Indicates the encoding in mode “byte”. By default (encoding is `None`) the implementation tries to use the standard conform ISO/IEC 8859-1 encoding and if it does not fit, it will use UTF-8.
* **eci** (bool) - Optional - Indicates if binary data which does not use the default encoding (ISO/IEC 8859-1) should enforce the ECI mode. Defaults to `False`.
* **micro** (bool or None) - Optional - If `version` is `None` (default) this parameter can be used to allow the creation of a Micro QR code. If set to `False`, a QR code is generated. If set to `None` (default) a Micro QR code may be generated if applicable. If set to `True` the algorithm generates a Micro QR Code or raises an exception if the mode is not compatible or the content is too large for Micro QR codes.
* **boost_error** (bool) - Optional - Indicates if the error correction level may be increased if it does not affect the version (default: `True`).

### Raises
`ValueError` or `DataOverflowError`: In case the data does not fit into a (Micro) QR Code or it does not fit into the provided `version`.

### Return type
QRCode
```

--------------------------------

### Specify QR Code Version

Source: https://segno.readthedocs.io/en/stable/make.html

Demonstrates creating a QR code with a specific version and retrieving its version and designator.

```python
import segno
qrcode = segno.make('Light My Fire')
qrcode.version
'M4'
qrcode.designator
'M4-M'
```

--------------------------------

### Create Static QR Code with Image Background

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Generate a static QR code with a JPG image as the background using the 'to_artistic' method. The output is saved as a JPG file.

```python
import segno
qrcode = segno.make('The Beatles -- Let It Be', error='h')
qrcode.to_artistic(background='src/letitbe.jpg', target='letitbe.jpg', scale=5)

```

--------------------------------

### make_wifi

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a QR code for Wi-Fi network configuration, including SSID, password, security type, and hidden status.

```APIDOC
## make_wifi(ssid, password=None, security=None, hidden=False)

### Description
Creates a WIFI configuration QR code.

### Parameters
#### Path Parameters
- **ssid** (str) - The SSID of the network.
#### Query Parameters
- **password** (str or None) - The password.
- **security** (str or None) - Authentication type; the value should be “WEP” or “WPA”. Set to `None` to omit the value. “nopass” is equivalent to setting the value to `None` but in the former case, the value is not omitted.
- **hidden** (bool) - Indicates if the network is hidden (default: `False`)

### Return type
segno.QRCode
```

--------------------------------

### show

Source: https://segno.readthedocs.io/en/stable/api.html

Displays the QR code by saving it to a temporary file and opening it with the default viewer. The file is deleted after a specified time unless delete_after is set to None.

```APIDOC
## show

### Description
Displays this QR code. This method is mainly intended for debugging purposes. This method saves the QR code as an image (by default with a scaling factor of 10) to a temporary file and opens it with the standard PNG viewer application or within the standard webbrowser. The temporary file is deleted afterwards (unless `delete_after` is set to `None`). If this method does not show any result, try to increase the `delete_after` value or set it to `None`

### Parameters
#### Path Parameters
- **delete_after** (int or None) - Optional - Time in seconds to wait till the temporary file is deleted.
- **scale** (int) - Optional - Integer indicating the size of a single module.
- **border** (int or None) - Optional - Integer indicating the size of the quiet zone. If set to `None` (default), the recommended border size will be used.
- **dark** - Optional - The color of the dark modules (default: black).
- **light** - Optional - The color of the light modules (default: white).

### Raises
`ValueError` if the scaling factor or the border is invalid (i.e. negative).
```

--------------------------------

### Display QR Code

Source: https://segno.readthedocs.io/en/stable/api.html

Displays the QR code as an image to a temporary file and opens it with the default viewer. The temporary file is deleted after a specified time unless delete_after is None. Useful for debugging.

```python
qr.show(_delete_after =20_, _scale =10_, _border =None_, _dark ='#000'_, _light ='#fff'_)
```

--------------------------------

### Serialize QR Code to PNG

Source: https://segno.readthedocs.io/en/stable/command-line.html

Save the QR code to a PNG file using the `--output` or `-o` parameter followed by the desired filename. This command generates 'white-room.png'.

```bash
$ segno --output=white-room.png "White Room"

```

--------------------------------

### Create Animated QR Code

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Generate an animated QR code by using the 'to_artistic' method with a GIF file as the background. The output is saved as a GIF file.

```python
import segno
qrcode = segno.make('The Beatles -- Albums', error='h')
qrcode.to_artistic(background='src/albums.gif', target='albums.gif', scale=8)

```

--------------------------------

### Disallow Micro QR Codes with make

Source: https://segno.readthedocs.io/en/stable/make.html

Shows how to use the `micro=False` argument with `segno.make()` to ensure a QR Code is generated instead of a Micro QR Code.

```python
import segno
qrcode = segno.make('The Beatles', micro=False)  # Disallow Micro QR Codes
qrcode.designator
'1-Q'
```

--------------------------------

### Use Compact QR Code Representation

Source: https://segno.readthedocs.io/en/stable/command-line.html

Employ the `--compact` flag for a more condensed visual representation of the QR code in the terminal output.

```bash
$ segno --compact "Little wing"

```

--------------------------------

### make_wifi_data

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a string representing Wi-Fi network configuration, suitable for QR code generation.

```APIDOC
## make_wifi_data(ssid, password=None, security=None, hidden=False)

### Description
Creates WIFI configuration string.

### Parameters
#### Path Parameters
- **ssid** (str) - The SSID of the network.
#### Query Parameters
- **password** (str or None) - The password.
- **security** (str or None) - Authentication type; the value should be “WEP” or “WPA”. Set to `None` to omit the value. “nopass” is equivalent to setting the value to `None` but in the former case, the value is not omitted.
- **hidden** (bool) - Indicates if the network is hidden (default: `False`)

### Return type
str
```

--------------------------------

### Create Micro QR Code

Source: https://segno.readthedocs.io/en/stable/command-line.html

To generate a Micro QR code, use the `--micro` flag. This is useful for smaller data payloads where a compact QR code is desired.

```bash
$ segno --micro "Little wing"

```

--------------------------------

### Create a Micro QR Code with Custom Colors

Source: https://segno.readthedocs.io/en/stable/colorful-qrcodes.html

Generates a PNG Micro QR code with custom colors for dark and data-dark modules. Suitable for smaller QR code requirements where specific colors are needed.

```python
import segno
micro_qrcode = segno.make('Rain', error='q')
micro_qrcode.save('micro_qrode_rain.png', scale=4, dark='darkblue', data_dark='steelblue')
```

--------------------------------

### Serialize QR Code to Text

Source: https://segno.readthedocs.io/en/stable/command-line.html

Output the QR code as a text-based representation using the `--output` or `-o` parameter with a '.txt' extension. This is useful for terminal display or plain text storage.

```bash
$ segno --output=thrill-gone.txt "The Thrill Is Gone"

```

```text
000000000000000000000000000000000
000000000000000000000000000000000
000000000000000000000000000000000
000000000000000000000000000000000
000011111110101110110011111110000
000010000010111011110010000010000
000010111010100010010010111010000
000010111010111011000010111010000
000010111010100010110010111010000
000010000010001111011010000010000
000011111110101010101011111110000
000000000000110101001000000000000
000001101011000000111010111110000
000010010101000100001110000110000
000000001111000101000100111110000
000000000100010000001100110100000
000011101011001000001010000000000
000001000000100010011110010110000
000010001111000101001011101110000
000001110000100000010101100100000
000010001011110111101111111110000
000000000000110001011000100000000
000011111110110011011010101110000
000010000010001011111000100110000
000010111010101100101111100010000
000010111010010110101001111000000
000010111010101101101011101010000
000010000010111011001111100100000
000011111110010011011110110110000
000000000000000000000000000000000
000000000000000000000000000000000
000000000000000000000000000000000
000000000000000000000000000000000

```

--------------------------------

### Create Colorful QR Code with Pillow

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Utilize the 'to_pil' method to create a QR code with custom colors for data and background. The 'dark' and 'data_dark' parameters control the dark modules, while 'data_light' sets the light modules.

```python
import segno
qrcode = segno.make('Yellow Submarine', error='h')
img = qrcode.to_pil(scale=4, dark='darkred', data_dark='darkorange',
                   data_light='yellow')
img.save('yellow-submarine.png')

```

--------------------------------

### Enforce QR Code Generation (Not Micro QR)

Source: https://segno.readthedocs.io/en/stable/make.html

Illustrates how to explicitly prevent the generation of a Micro QR Code and ensure a standard QR Code is created, even if the content fits into a Micro QR Code.

```python
import segno
qrcode = segno.make('Rain', micro=False)
qrcode.version
1
```

--------------------------------

### Create a QR Code with Custom Colors

Source: https://segno.readthedocs.io/en/stable/colorful-qrcodes.html

Generates a PNG QR code with custom colors for dark, data-dark, and data-light modules. Useful for branding or visual distinction.

```python
import segno
qrcode = segno.make('Yellow Submarine', version=7, error='h')
qrcode.save('qrcode_yellow-submarine.png', scale=4, dark='darkred',
            data_dark='darkorange', data_light='yellow')
```

--------------------------------

### Serialize QR Code to File

Source: https://segno.readthedocs.io/en/stable/api.html

Serializes the QR code in one of the supported formats. The serialization format depends on the filename extension. Common keywords include scale, which affects module size.

```python
qr.save(_out_ , _kind =None_, _** kw_)
```

--------------------------------

### Create Animated WebP QR Code

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Save an animated QR code as a WebP file if Pillow supports animated WebP images. Use the 'to_artistic' method with a GIF background and specify the target file as a .webp.

```python
import segno
qrcode = segno.make('The Beatles -- Abbey Road', error='h')
qrcode.to_artistic(background='src/abbey-road-walking.gif',
                   target='abbey-road.webp', scale=4)

```

--------------------------------

### Create Structured Append QR Codes (Version)

Source: https://segno.readthedocs.io/en/stable/command-line.html

Use the `--seq` argument to enable Structured Append mode for splitting a message across multiple QR codes. The `--version` argument specifies the QR code version.

```bash
$ segno --seq -v 1 --scale 3 -o polythene-pam.png "Well you should see Polythene Pam"
```

--------------------------------

### Output QR Code to Terminal

Source: https://segno.readthedocs.io/en/stable/command-line.html

Use this command to print a QR code directly to the terminal. No special options are required for basic text output.

```bash
$ segno "Little wing"

```

--------------------------------

### Update Colormap Usage in Segno

Source: https://segno.readthedocs.io/en/stable/changes.html

Demonstrates the updated way to specify module colors in Segno's save method, replacing the deprecated 'colormap' parameter with direct keyword arguments for 'dark', 'light', and 'data_dark'.

```python
colormap = {mt.TYPE_FINDER_PATTERN_DARK: 'darkred',
            mt.TYPE_ALIGNMENT_PATTERN_DARK: 'darkred',
            mt.TYPE_TIMING_DARK: 'darkred',
            mt.TYPE_DARKMODULE: 'darkred',
            mt.TYPE_DATA_DARK: 'darkorange',
            mt.TYPE_DATA_LIGHT: 'yellow',
            mt.TYPE_FORMAT_DARK: 'darkred'}

qr.save('qrcode.png', scale=5, colormap=colormap)
```

```python
qr.save('qrcode.png', scale=5, dark='darkred', data_dark='darkorange',
        data_light='yellow')
```

--------------------------------

### Set Default Data Mask

Source: https://segno.readthedocs.io/en/stable/make.html

Generates a QR code and lets Segno automatically select the optimal data mask pattern. The default mask is 0.

```python
import segno
qrcode = segno.make('Ai Du')
qrcode.mask
```

--------------------------------

### segno.helpers.make_epc_qr

Source: https://segno.readthedocs.io/en/stable/api.html

Creates an European Payments Council Quick Response Code (EPC QR Code) version 002 with specific payment details.

```APIDOC
## segno.helpers.make_epc_qr

### Description
Creates and returns an European Payments Council Quick Response Code (EPC QR Code) version 002. The returned `segno.QRCode` uses always the error correction level “M” and utilizes max. version 13 to fulfill the constraints of the EPC QR Code standard.

Note: Either the `text` or `reference` must be provided but not both.
Note: Neither the IBAN, BIC, nor remittance reference number or any other information is validated (aside from checks regarding the allowed string lengths).

### Parameters
#### Path Parameters
* **name** (str) - Required - Name of the recipient.
* **iban** (str) - Required - International Bank Account Number (IBAN)
* **amount** (int, float, decimal.Decimal) - Required - The amount (in EUR) to transfer. The currency is always Euro, no other currencies are supported.
* **text** (str) - Optional - Remittance Information (unstructured)
* **reference** (str) - Optional - Remittance Information (structured)
* **bic** (str) - Optional - Bank Identifier Code (BIC). Optional, only required for non-EEA countries.
* **purpose** (str) - Optional - SEPA purpose code.
* **encoding** (str or int) - Optional - By default, this function tries to find the best, minimal encoding. If another encoding should be used, the encoding name or the encoding constant (an integer) can be provided: `1`: “UTF-8”, `2`: “ISO 8859-1”, `3`: “ISO 8859-2”, `4`: “ISO 8859-4”, `5`: “ISO 8859-5”, `6`: “ISO 8859-7”, `7`: “ISO 8859-10”, `8`: “ISO 8859-15”. The encoding is case-insensitive.

### Return type
segno.QRCode
```

--------------------------------

### Create Basic EPC QR Code

Source: https://segno.readthedocs.io/en/stable/epc-qrcodes.html

Use `make_epc_qr` to generate an EPC QR code with default settings. The error correction level is fixed to 'M' and the QR code version must not exceed 13.

```python
from segno import helpers
qrcode = helpers.make_epc_qr(name='Wikimedia Foerdergesellschaft',
                             iban='DE33100205000001194700',
                             amount=20, text='Spende fuer Wikipedia')
qrcode.save('spende-wikipedia.png', scale=3)
```

--------------------------------

### segno.helpers.make_mecard

Source: https://segno.readthedocs.io/en/stable/api.html

Returns a QR code that encodes contact information in the MeCard format.

```APIDOC
## segno.helpers.make_mecard

### Description
Returns a QR code which encodes a MeCard.

### Parameters
#### Path Parameters
* **name** (str) - Required - Name. If it contains a comma, the first part is treated as lastname and the second part is treated as forename.
* **reading** (str or None) - Optional - Designates a text string to be set as the kana name in the phonebook.
* **email** (str, iterable of strings, or None) - Optional - E-mail address. Multiple values are allowed.
* **phone** (str, iterable of strings, or None) - Optional - Phone number. Multiple values are allowed.
* **videophone** (str, iterable of strings, or None) - Optional - Phone number for video calls. Multiple values are allowed.
* **memo** (str or None) - Optional - A notice for the contact.
* **nickname** (str or None) - Optional - Nickname.
* **birthday** (str or None) - Optional - Birthday.
* **url** (str or None) - Optional - URL.
* **pobox** (str or None) - Optional - P.O. Box.
* **roomno** (str or None) - Optional - Room number.
* **houseno** (str or None) - Optional - House number.
* **city** (str or None) - Optional - City.
* **prefecture** (str or None) - Optional - Prefecture.
* **zipcode** (str or None) - Optional - Zip code.
* **country** (str or None) - Optional - Country.

### Return type
segno.QRCode
```

--------------------------------

### Customize QR Code Appearance

Source: https://segno.readthedocs.io/en/stable/make.html

Shows how to customize the appearance of a QR code, including removing the border, changing the dark module color, and setting the background color.

```python
import segno
qrcode = segno.make('You Know My Name (Look Up The Number)')
qrcode.save('you-know-my-name-no-border.svg', border=0)  # no border / quiet zone
qrcode.save('you-know-my-name-color-green.svg',
            dark='green')  # default border, dark modules are green
qrcode.save('you-know-my-name-background-grey.svg',
            light='#eee')  # default border, background grey
```

--------------------------------

### Set Minimum Error Correction Level (L)

Source: https://segno.readthedocs.io/en/stable/make.html

Generates a QR code with a minimum error correction level of 'L'. Segno may automatically boost this to 'Q' if space allows.

```python
import segno
qrcode = segno.make('Parisienne Walkways',
                    error='l')  # Explicit (minimum) error correction level
qrcode.designator
```

--------------------------------

### Create a Sequence of QR Codes

Source: https://segno.readthedocs.io/en/stable/api.html

Generates a sequence of QR codes using Structured Append mode. This is useful for splitting content over multiple QR codes. The number of QR codes can be controlled by `symbol_count` or `version`. Note that Structured Append is not available for Micro QR codes.

```Python
for i, qrcode in enumerate(segno.make_sequence(data, symbol_count=2)):
     qrcode.save('seq-%d.svg' % i, scale=10, color='darkblue')
```

--------------------------------

### Scale QR Code Output

Source: https://segno.readthedocs.io/en/stable/command-line.html

Use the `--scale` or `-s` option to increase the size of the generated QR code. This is particularly useful for image formats like PNG and SVG to ensure readability.

```bash
$ segno --scale=10 --output=money-talks.png "Money Talks"

```

```bash
$ segno -s 10 --output=private-investigations.svg Private Investigations

```

--------------------------------

### Specify QR Code Version

Source: https://segno.readthedocs.io/en/stable/command-line.html

Enforce a specific QR code version using the `--version` or `-v` option. This is useful when a particular size or capacity is required, overriding automatic version selection.

```bash
$ segno --version=5 Layla

```

```bash
$ segno -v=5 Layla

```

--------------------------------

### Create Structured Append QR Codes (Shortcut)

Source: https://segno.readthedocs.io/en/stable/command-line.html

A shortcut `-sc` can be used for the `--symbol-count` argument when creating Structured Append QR codes. This provides a more concise way to specify the number of symbols.

```bash
$ segno --seq -sc 2 -s 3 -o julia.png "Half of what I say is meaningless"
```

--------------------------------

### segno.make_sequence

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a sequence of QR codes using the Structured Append mode. This function is useful for splitting content across multiple QR codes, with a maximum of 16 codes. It is not available for Micro QR codes.

```APIDOC
## segno.make_sequence

### Description
Creates a sequence of QR codes using the Structured Append mode. If the content fits into one QR code and neither `version` nor `symbol_count` is provided, this function may return a sequence with one QR Code which does not use the Structured Append mode. Otherwise a sequence of 2 .. n (max. n = 16) QR codes is returned which use the Structured Append mode. The Structured Append mode allows to split the content over a number (max. 16) QR Codes. The Structured Append mode isn’t available for Micro QR Codes, therefor the returned sequence contains QR codes, only. Since this function returns an iterable object, it may be used as follows:
```
for i, qrcode in enumerate(segno.make_sequence(data, symbol_count=2)):
     qrcode.save('seq-%d.svg' % i, scale=10, color='darkblue')
```
The number of QR codes is determined by the version or symbol_count parameter. See `make()` for a description of the other parameters.

### Parameters
- **_content_** (any) - Required - The content to be encoded in the QR code sequence.
- **_error_** (str, optional) - Error correction level ('L', 'M', 'Q').
- **_version_** (str or int, optional) - QR Code version.
- **_mode_** (str, optional) - Encoding mode ('numeric', 'alphanumeric', 'byte', 'kanji', 'hanzi').
- **_mask_** (int, optional) - Data mask pattern reference.
- **_encoding_** (str, optional) - Encoding used for the content.
- **_boost_error_** (bool, optional) - If True, the error correction level is boosted if possible.
- **_symbol_count_** (int, optional) - Number of symbols (QR codes) in the sequence.

### Return type
QRCodeSequence
```

--------------------------------

### segno.helpers.make_make_email_data

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a mailto: URL or a complete email message string, including CC, BCC, subject, and body.

```APIDOC
## segno.helpers.make_make_email_data

### Description
Creates either a simple “mailto:” URL or complete e-mail message with (blind) carbon copies and a subject and a body.

### Parameters
#### Path Parameters
* **to** (str or iterable of strings) - Required - The email address (recipient). Multiple values are allowed.
* **cc** (str, iterable of strings, or None) - Optional - The carbon copy recipient. Multiple values are allowed.
* **bcc** (str, iterable of strings, or None) - Optional - The blind carbon copy recipient. Multiple values are allowed.
* **subject** (str or None) - Optional - The subject.
* **body** (str or None) - Optional - The message body.

### Return type
str
```

--------------------------------

### save

Source: https://segno.readthedocs.io/en/stable/api.html

Serializes the QR code in a supported format, determined by the filename extension. Supports common keywords like 'scale'.

```APIDOC
## save

### Description
Serializes the QR code in one of the supported formats. The serialization format depends on the filename extension.

### Parameters
#### Path Parameters
- **out** - Required - The destination for the serialized QR code (e.g., filename).
- **kind** - Optional - The serialization format (e.g., 'png', 'svg').
- **kw** - Optional - Additional keyword arguments specific to the chosen format.

#### Common keywords
- **scale** (int or float) - Optional - Integer or float indicating the size of a single module. Default: 1. The interpretation of the scaling factor depends on the serializer. For pixel-based output (like PNG) the scaling factor is interpreted as pixel-size (1 = 1 pixel). EPS interprets `1` as 1 point (1/72 inch) per module. Some serializers (like SVG) accept float values. If the serializer does not accept float values, the value will be converted to an integer value (note: int(1.6) == 1).
```

--------------------------------

### Specify Micro QR Code Version

Source: https://segno.readthedocs.io/en/stable/command-line.html

To specify a Micro QR code version, use the `-v` or `--version` flag followed by the Micro QR code identifier (e.g., 'm4' or 'M4').

```bash
$ segno -v m4 Layla

```

```bash
$ segno --version M4 Layla

```

--------------------------------

### Create MeCard QR Code

Source: https://segno.readthedocs.io/en/stable/contact-information.html

Generates a QR code object encoding contact information using the MeCard format. Supports multiple email addresses and URLs.

```python
from segno import helpers
qrcode = helpers.make_mecard(name='Doe,John', email='me@example.org', phone='+1234567')
qrcode.designator
# Some params accept multiple values, like email, phone, url
qrcode = helpers.make_mecard(name='Doe,John',
                             email=('me@example.org', 'another@example.org'),
                             url=['http://www.example.org', 'https://example.org/~joe'])
qrcode.save('my-mecard.svg', scale=4)
```

--------------------------------

### segno.helpers.make_email

Source: https://segno.readthedocs.io/en/stable/api.html

Encodes an email address or a complete email message, including CC, BCC, subject, and body, into a QR code.

```APIDOC
## segno.helpers.make_email

### Description
Encodes either a simple e-mail address or a complete message with (blind) carbon copies and a subject and a body.

### Parameters
#### Path Parameters
* **to** (str or iterable of strings) - Required - The email address (recipient). Multiple values are allowed.
* **cc** (str, iterable of strings, or None) - Optional - The carbon copy recipient. Multiple values are allowed.
* **bcc** (str, iterable of strings, or None) - Optional - The blind carbon copy recipient. Multiple values are allowed.
* **subject** (str or None) - Optional - The subject.
* **body** (str or None) - Optional - The message body.

### Return type
segno.QRCode
```

--------------------------------

### Default Error Correction Level Boosting

Source: https://segno.readthedocs.io/en/stable/boost-error-correction-level.html

Demonstrates the default behavior where Segno selects the highest possible error correction level for the minimal QR code version. This results in a QR code with error correction level 'M'.

```python
>>> import segno
>>> qrcode = segno.make('The Long and Winding Road')
>>> qrcode.designator
'2-M'
```

--------------------------------

### Save Artistic QR Code to BytesIO (JPG)

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Write the artistic QR code to a `io.BytesIO` stream instead of a file. This is useful for in-memory operations. Specify the 'kind' parameter for the output format.

```python
import io
import segno
qrcode = segno.make('The Beatles -- Let It Be', error='h')
out = io.BytesIO()
qrcode.to_artistic(background='src/letitbe.jpg', target=out, scale=5, kind='jpg')

```

--------------------------------

### Use URL for Background Image

Source: https://segno.readthedocs.io/en/stable/artistic-qrcodes.html

Specify a background image for the artistic QR code using a URL. The `urlopen` function is used to fetch the image, which is then passed as a file-like object to the 'background' parameter.

```python
from urllib.request import urlopen
import segno
qrcode = segno.make('Ringo Starr', error='h')
url = 'https://media.giphy.com/media/HNo1tVKdFaoco/giphy.gif'
bg_file = urlopen(url)
qrcode.to_artistic(background=bg_file, target='ringo.gif', scale=10)

```

--------------------------------

### QRCodeSequence Class

Source: https://segno.readthedocs.io/en/stable/api.html

The QRCodeSequence class handles QR code sequences.

```APIDOC
## QRCodeSequence Class

### `QRCodeSequence.terminal()`

Outputs the QR code sequence to the terminal.

### `QRCodeSequence.save()`

Saves the QR code sequence to a file.
```

--------------------------------

### segno.make_micro

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a Micro QR code. This function is used to generate Micro QR codes, a smaller variant of standard QR codes. It accepts various parameters to customize the QR code generation, such as error correction level, version, mode, and mask.

```APIDOC
## segno.make_micro

### Description
Creates a Micro QR code. See `make()` for a description of the parameters.
Note: Error correction level “H” isn’t available for Micro QR codes. If used, this function raises a `segno.ErrorLevelError`.

### Parameters
- **_content_** (any) - Required - The content to be encoded in the QR code.
- **_error_** (str, optional) - Error correction level ('L', 'M', 'Q').
- **_version_** (str or int, optional) - QR Code version.
- **_mode_** (str, optional) - Encoding mode ('numeric', 'alphanumeric', 'byte', 'kanji', 'hanzi').
- **_mask_** (int, optional) - Data mask pattern reference.
- **_encoding_** (str, optional) - Encoding used for the content.
- **_boost_error_** (bool, optional) - If True, the error correction level is boosted if possible.

### Return type
QRCode
```

--------------------------------

### segno.helpers.make_geo_data

Source: https://segno.readthedocs.io/en/stable/api.html

Creates a geo location URI string.

```APIDOC
## segno.helpers.make_geo_data

### Description
Creates a geo location URI.

### Parameters
#### Path Parameters
* **lat** (float) - Required - Latitude
* **lng** (float) - Required - Longitude

### Return type
str
```

--------------------------------

### Handle Data Overflow Error

Source: https://segno.readthedocs.io/en/stable/make.html

Illustrates the `segno.DataOverflowError` that is raised when the provided data is too large to fit into a Micro QR Code.

```python
import segno
qrcode = segno.make_micro('The Curse of Millhaven')
Traceback(
    ...
)DataOverflowError: Data too large. No Micro QR Code can handle the provided data
```

--------------------------------

### Create QR Code with Hanzi Mode

Source: https://segno.readthedocs.io/en/stable/api.html

Use the 'hanzi' mode explicitly when encoding Chinese characters. This mode is not part of the standard and may not be supported by all readers.

```python
import segno
qrcode = segno.make('书读百遍其义自现', mode='hanzi')
```
Tokens:
Raw