bentopy 0.2.0a10__cp313-cp313-manylinux_2_34_x86_64.whl

init/main.rs

@@ -0,0 +1,235 @@
+use std::borrow::Cow;
+use std::collections::HashSet;
+use std::io::{BufWriter, Read, Write};
+use std::path::PathBuf;
+
+use anyhow::{Context, Result, bail};
+use clap::{Parser, Subcommand};
+
+use bentopy::core::config::{Config, Segment, legacy};
+use bentopy::core::version::VERSION;
+
+const BIN_NAME: &str = env!("CARGO_BIN_NAME");
+
+#[derive(Debug, Parser)]
+#[command(about, version = VERSION)]
+struct Args {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Debug, Subcommand)]
+enum Command {
+    /// Create an example file describing the bentopy input file format with placeholders.
+    Example {
+        #[arg(short, long, default_value = "example.bent")]
+        output: PathBuf,
+    },
+    /// Check whether an input file is set up correctly and provide lints for common problems.
+    ///
+    /// First, the syntax of the file is validated, before checking for common problems:
+    ///
+    /// There should be at least one compartment.
+    /// There should be no duplicate compartment names.
+    /// There should be at least one segment.
+    /// Segments should refer to compartments that exist.
+    /// There should be no duplicate rule names.
+    /// Segments should refer to rules that exist.
+    Validate {
+        #[arg(short, long)]
+        input: PathBuf,
+        #[arg(short, long, default_value_t)]
+        verbose: bool,
+    },
+    /// Convert from the .json legacy input file format to .bent files.
+    ///
+    /// Note that this command can also read .bent files and produce a .bent file from that. This
+    /// can be considered a formatting step.
+    Convert {
+        #[arg(short, long)]
+        input: PathBuf,
+        #[arg(short, long)]
+        output: PathBuf,
+    },
+}
+
+fn main() -> Result<()> {
+    let Args { command } = Args::parse();
+    match command {
+        Command::Example { output } => example(output),
+        Command::Validate { input, verbose } => validate(input, verbose),
+        Command::Convert { input, output } => convert(input, output),
+    }
+}
+
+fn example(output: PathBuf) -> Result<()> {
+    let example = include_str!("example.bent");
+    let mut file = std::fs::File::create(&output)?;
+    writeln!(file, "# Created by {BIN_NAME}, version {VERSION}.")?;
+    file.write_all(example.as_bytes())?;
+    eprintln!("Wrote example file to {output:?}.");
+    Ok(())
+}
+
+fn validate(input: PathBuf, verbose: bool) -> Result<()> {
+    let mut file = std::fs::File::open(&input)?;
+    let mut s = String::new();
+    file.read_to_string(&mut s)?;
+
+    // Try to parse the config.
+    let config = Config::parse_bent(&input.to_string_lossy(), &s)
+        .context(format!("could not parse {input:?} as a bentopy input file"))?;
+    eprintln!("Successfully parsed {input:?}.");
+
+    // If desired, print a crazy expanded debug struct.
+    if verbose {
+        eprintln!("Printing debug representation of this configuration:");
+        println!("{config:#?}");
+    }
+
+    // TODO: Write out a nice little report explaining the system. Maybe this is actually a
+    // bentopy-init explain thing but whatever. It's a good idea.
+
+    // TODO: Implement these.
+    // eprintln!("NOTE: This is a work-in-progress utility. Notable lacking lints are:");
+    // eprintln!("      - check if the referenced structures exist,");
+    // eprintln!("      - check if the compartment combinations are well-formed,");
+    // eprintln!("      - check if the constraint combinations are well-formed,");
+    // eprintln!("      - check if the referenced masks actually exist,");
+    // eprintln!("      - check if the referenced masks are of a congruent size,");
+    // eprintln!("      - check if the referenced itp includes actually exist,");
+    // eprintln!("      - check if the segment names exist in the referenced itps,");
+    // eprintln!("      - check if the analytical compartment geometries lie within the dimensions,");
+    // eprintln!("      - check for orphan rules and compartments,");
+    // eprintln!("      - check if the rules apply within the dimensions.");
+
+    // Now, we actually check if it is semantically correct.
+    let mut problems: usize = 0;
+    // There should be at least one compartment.
+    if config.compartments.is_empty() {
+        println!("Error: No compartments declared. At least one compartment should be declared.");
+        problems += 1;
+    }
+    // There should be no duplicate compartment names.
+    let mut compartment_ids = HashSet::with_capacity(config.compartments.len());
+    for compartment in &config.compartments {
+        let id = compartment.id.as_str();
+        if !compartment_ids.insert(id) {
+            println!("Warning: Compartment id {id} is defined multiple times.");
+            problems += 1;
+        }
+    }
+    // There should be at least one segment.
+    if config.compartments.is_empty() {
+        println!("Warning: No segments declared. At least one segment should be declared.");
+        problems += 1;
+    }
+    // Segments should refer to compartments that exist.
+    for segment in &config.segments {
+        let name = segment.name();
+        for id in &segment.compartment_ids {
+            if !compartment_ids.contains(id.as_str()) {
+                println!("Error: Segment {name} refers to an undeclared compartment: {id}.");
+                problems += 1;
+            }
+        }
+    }
+    // There should be no duplicate rule names.
+    let mut rules = HashSet::with_capacity(config.constraints.len());
+    for constraint in &config.constraints {
+        let id = constraint.id.as_str();
+        if !rules.insert(id) {
+            println!("Warning: Constraint name {id} is defined multiple times.");
+            problems += 1;
+        }
+    }
+    // Segments should refer to rules that exist.
+    for segment in &config.segments {
+        let name = segment.name();
+        for id in segment.rules.iter() {
+            if !rules.contains(id.as_str()) {
+                println!("Error: Segment {name} refers to an undeclared constraint: {id}.");
+                problems += 1;
+            }
+        }
+    }
+
+    // Report the number of problems.
+    match problems {
+        0 => println!("It appears there are no problems with this file."),
+        1 => println!("Detected one problem."),
+        n => println!("Detected {n} problems."),
+    }
+
+    Ok(())
+}
+
+fn convert(input: PathBuf, output: PathBuf) -> Result<()> {
+    enum Kind {
+        Bent,
+        Json,
+    }
+
+    let kind = match input.extension().and_then(|s| s.to_str()) {
+        Some("bent") => Kind::Bent,
+        Some("json") => Kind::Json,
+        _ => bail!(
+            "Cannot read {input:?}. \
+                The convert subcommand only supports reading .bent and .json files.",
+        ),
+    };
+
+    if output.extension().is_some_and(|s| s != "bent") {
+        bail!(
+            "Cannot write configuration to {output:?}. \
+                The convert subcommand only supports writing .bent files.",
+        );
+    }
+
+    let mut file = std::fs::File::open(&input)?;
+    let mut s = String::new();
+    file.read_to_string(&mut s)?;
+
+    let path = &input.to_string_lossy();
+    let config = match kind {
+        Kind::Bent => {
+            let config = Config::parse_bent(path, &s)
+                .context(format!("could not parse {path:?} as a bentopy input file"))?;
+            eprintln!("Successfully parsed {path:?}.");
+            config
+        }
+        Kind::Json => {
+            let config: legacy::Config = serde_json::from_str(&s).context(format!(
+                "could not parse {path:?} as a legacy json input file"
+            ))?;
+            eprintln!("Successfully parsed {path:?} (legacy input file).");
+            eprint!("Attempting to convert to new input configuration format... ");
+            let config = config.into();
+            eprintln!("Done.");
+            config
+        }
+    };
+
+    eprintln!("Writing to {output:?}.");
+    let out = std::fs::File::create(&output)?;
+    let mut out = BufWriter::new(out);
+    writeln!(out, "# Converted {input:?} to {output:?} using {BIN_NAME}.")?;
+    bentopy::core::config::bent::write(&config, &mut out)?;
+
+    Ok(())
+}
+
+// TODO: Make this into a method on Segment itself. It would also be nice in bent::writer.
+trait Name {
+    fn name(&self) -> Cow<'_, str>;
+}
+
+impl Name for Segment {
+    fn name(&self) -> Cow<'_, str> {
+        let name = &self.name;
+        match &self.tag {
+            Some(tag) => Cow::Owned(format!("{name}:{tag}")),
+            None => Cow::Borrowed(name),
+        }
+    }
+}

mask/config.py

@@ -0,0 +1,153 @@
+import argparse
+from pathlib import Path
+
+EPILOG = """
+Compartments are determined using the MDVContainment package created by Bart Bruininks.
+More information is available at <https://github.com/BartBruininks/mdvcontainment>.
+"""
+DESCRIPTION = "Set up masks based on structures and compartment segmentations."
+
+DEFAULT_CONTAINMENT_RESOLUTION = 1.0
+DEFAULT_MASK_RESOLUTION = 0.5
+
+
+def process_labels(labels: str) -> list[int]:
+    return [int(label) for label in labels.split(",")]
+
+
+def setup_parser(parser=None):
+    if parser is None:
+        parser = argparse.ArgumentParser(
+            description=DESCRIPTION,
+            epilog=EPILOG,
+        )
+    else:
+        parser.description = DESCRIPTION
+        parser.epilog = EPILOG
+    parser.add_argument(
+        "input",
+        type=Path,
+        help="Input structure file to subject to segmentation.",
+    )
+    parser.add_argument(
+        "output",
+        type=Path,
+        nargs="?",
+        help="Output path for the resulting voxel mask.",
+    )
+    parser.add_argument(
+        "--no-interactive",
+        dest="interactive",
+        action="store_false",
+        help="""Do not ask for command line input at runtime. May be desirable 
+        when all inputs are known and in a scripted context.
+        (normally interactive)""",
+    )
+    morph = parser.add_mutually_exclusive_group()
+    morph.add_argument(
+        "--morph",
+        type=str,
+        help="""Morphological operations to apply to the initial boolean voxel
+        representation based on the provided structure. Provide a string of 'd'
+        for dilation steps and 'e' for erosion steps, in the order you wish to
+        apply them.
+
+        For example, the string 'de' is equivalent to the --closing flag, while
+        'ed' is a morphological opening operation. See
+        <https://en.wikipedia.org/wiki/Closing_(morphology)> for more
+        information.
+        """,
+    )
+    morph.add_argument(
+        "--closing",
+        action="store_true",
+        help="""Use binary closing to fill small holes in compartments. For
+        analysis of CG Martini structures with a voxel resolution 0.5 nm this
+        is highly recommended.
+
+        If the resolution exceeds the condensed phase distance (i.e., about
+        double the LJ sigma), closing is not required. A voxel resolution below
+        sigma is not recommended.
+
+        See also, --morph, which provides a more flexible interface to the same
+        notion.
+        """,
+    )
+    parser.add_argument(
+        "--min-size",
+        type=float,
+        help="""
+        A volume in nm³. Starting from the leaf nodes, recursively merge with
+        ancestors until this minimum size has been met.
+
+        This is very helpful for filtering out small, non-relevant compartments
+        by merging them to their parent compartments.
+        """,
+    )
+    parser.add_argument(
+        "--containment-resolution",
+        default=DEFAULT_CONTAINMENT_RESOLUTION,
+        type=float,
+        help="Resolution for the compartment finding routine (nm). (default: %(default)s nm)",
+    )
+    parser.add_argument(
+        "--mask-resolution",
+        default=DEFAULT_MASK_RESOLUTION,
+        type=float,
+        help="Voxel size (resolution) for the exported mask (nm). (default: %(default)s nm)",
+    )
+    parser.add_argument(
+        "--selection",
+        default="not resname W ION",
+        type=str,
+        help="MDAnalysis selection string for the atom group over which to perform the segmentation. (default: '%(default)s')",
+    )
+    labels_group = parser.add_mutually_exclusive_group()
+    labels_group.add_argument(
+        "--labels",
+        type=process_labels,
+        help="Pre-selected compartment labels, comma-separated.",
+    )
+    labels_group.add_argument(
+        "--autofill",
+        action="store_true",
+        help="Automatically select the leaf nodes from the containment graph, which commonly represent the 'insides' of the system.",
+    )
+    parser.add_argument(
+        "-b",
+        "--inspect-labels-path",
+        type=Path,
+        nargs="?",
+        const="labels.gro",
+        help="""Optional output path to a gro file to write labeled voxel positions to.
+        This file can be inspected with molecule viewers, which is very helpful 
+        in determining which labels match the compartments you want to select.
+        (when used, default: %(const)s)""",
+    )
+    parser.add_argument(
+        "--debug-voxels",
+        type=Path,
+        help="""Write the final voxel mask as a gro file for inspection with molecule viewers. 
+        This can be useful when you want to verify the voxel mask that is produced for some selection of labels.""",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="""Do not cache structure files.
+
+        Caching can improve structure load times a lot, because it can load a
+        previously stored cache of a MDA Universe. Since loading structure
+        files with MDA can be very slow and loading the pickled object is
+        relatively quick, this is fantastic for making multiple different
+        masks of the same structure.
+
+        This option allows you to *switch off* the caching, if you want that.
+        """,
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Display verbose output.",
+    )
+    return parser

mask/mask.py

@@ -0,0 +1,308 @@
+import warnings
+import pickle
+from time import time
+from pathlib import Path
+
+import MDAnalysis as mda
+import numpy as np
+from mdvcontainment import Containment
+from mdvcontainment.voxel_logic import voxels_to_universe
+
+from .config import setup_parser
+from .utilities import voxels_to_gro
+
+# Let's ignore the wordy warnings we tend to get from MDAnalysis.
+warnings.filterwarnings("ignore")
+
+log = print
+
+
+def mask(args):
+    # First, we want to verify our arguments.
+    # Down the line, we assume that the containment resolution can be treated
+    # as integer multiple of the mask resolution. Let's check that at the top.
+    if args.containment_resolution % args.mask_resolution > 0.01:
+        log("ERROR: The containment and mask resolutions are not well-formed.")
+        log(
+            f"The containment resolution ({args.containment_resolution})",
+            f"must be a multiple of the mask resolution ({args.mask_resolution}),",
+            "such that `containment_resolution % mask resolution == 0`.",
+        )
+        return 1
+    if args.mask_resolution < 0:
+        log(f"ERROR: The mask resolution ({args.mask_resolution}) cannot be negative.")
+        return 1
+    zoom = int(args.containment_resolution / args.mask_resolution)
+    # Everything must be set correctly in case --no-interactive is used.
+    if not args.interactive:
+        log("Running in non-interactive mode.")
+        if args.output is None:
+            log("WARNING: No mask output path was specified.")
+            log("The computed mask will not be written to disk.")
+            log("Like tears in rain.")
+        if args.labels is None and not args.autofill:
+            log("ERROR: No labels were specified.")
+            log("In non-interactive mode, at least one label must be provided manually (`--label`) or automatically (`--autofill`).")
+            return 1
+
+    # Read in structures from a structure file or from a cache..
+    u = None
+    caching = not args.no_cache  # Whether caching is enabled.
+    structure_path = args.input
+    if caching:
+        cached_path = resolve_cache_path(structure_path)
+
+        # We need to check if the requested structure file actually exists.
+        # We don't want to end up using a cached file for a structure file that
+        # does not exist anymore.
+        structure_exists = structure_path.is_file()
+        # Try to find a cached equivalent to the structure.
+        cache_exists = cached_path.is_file()
+        if structure_exists and cache_exists:
+            log(f"Reading in cached structure from {cached_path}...")
+            log("You can reload a changed structure by removing the cached file.")
+            log("Caching can be disabled with --no-cache.")
+            with open(cached_path, "rb") as cache_file:
+                start = time()
+                u = pickle.load(cache_file)
+                dur = time() - start
+                log(
+                    f"Done reading the cached file. (Read {u.atoms.n_atoms} atoms in {dur:.1f} s.)"
+                )
+
+    # If the file was not cached, we read it from the structure file.
+    if u is None:
+        # Read the structure file.
+        log(f"Reading in structure from {structure_path}... ", end="")
+        start = time()
+        u = mda.Universe(structure_path)
+        dur = time() - start
+        log(f"done. (Read {u.atoms.n_atoms} atoms in {dur:.1f} s.)")
+
+        # Cache the universe if desired and necessary.
+        if caching and not cache_exists:
+            with open(cached_path, "wb") as cache_file:
+                pickle.dump(u, cache_file)
+
+    # Apply the selection before we hand it to mdvcontainment.
+    selection = u.select_atoms(args.selection)
+    log(f"Selected {selection.n_atoms} atoms according to '{args.selection}'.")
+
+    # Closing is just a short-hand for --morph='de'.
+    morph = args.morph
+    if args.closing:
+        morph = "de"
+    # MDVContainment only accepts str, not str | None as of 2.0.0a2.
+    if morph == None:
+        morph = ""
+
+    # Calculate the containments. This is all in the hands of mdvcontainment.
+    log("Calculating containment... ", end="")
+    start = time()
+    containment = Containment(
+        selection,
+        resolution=args.containment_resolution,
+        morph=morph,
+        max_offset=0, # We accept any result of voxelization.
+        verbose=args.verbose,
+        no_mapping=True, # Mapping takes some time and is not used at all in this context.
+    )
+    duration = time() - start
+    log(f"Done in {duration:.3} s.")
+
+    if args.min_size is not None:
+        log(f"Applying a {args.min_size} nm³ minimum size view.")
+        containment = containment.node_view(min_size=args.min_size)
+
+    # Show what we found.
+    log("Found the following node groups:")
+    log(f"        root:\t{npc(containment.voxel_containment.root_nodes)}")
+    log(f"        leaf:\t{npc(containment.voxel_containment.leaf_nodes)}")
+    # And show it as a tree of containments.
+    print(containment.voxel_containment)
+
+    # Get the label array.
+    label_array = containment.voxel_containment.components_grid
+    # Write the labels to a gro file if desired.
+    if args.inspect_labels_path is None and args.interactive:
+        log("Do you want to write a label map as a gro file to view the containments?")
+        log("Provide an output path. To skip this step, leave this field empty.")
+        while True:
+            path = input("(gro) -> ").strip()
+            if len(path) == 0:
+                labels_path = None
+                break
+            labels_path = Path(path)
+            if labels_path.suffix == ".gro":
+                break
+            log(f"Path must have a gro extension. Found '{labels_path.suffix}'.")
+    else:
+        labels_path = args.inspect_labels_path
+    root_nodes = npc(containment.voxel_containment.root_nodes)
+    log(f"Do you want to exclude the 'outside' compartment(s) (labels {root_nodes})?")
+    log("Excluding the root nodes is helpful, because they usually make up a large part of the space.")
+    while True:
+        answer = input("(Y/n) -> ").strip()
+        match answer.lower():
+            case "" | "y":
+                exclude_outside = True
+                break
+            case "n":
+                exclude_outside = False
+                break
+            case _: log(f"Expected 'y' or 'n'. Found '{answer}'.")
+    if labels_path is not None:
+        # voxels_to_gro(labels_path, label_array, scale=args.containment_resolution)
+        if exclude_outside:
+            nodes = set(containment.voxel_containment.nodes) - set(containment.voxel_containment.root_nodes)
+        else:
+            nodes = containment.voxel_containment.nodes
+        labels = containment.voxel_containment.components_grid
+        labels_u = voxels_to_universe(labels, nodes=list(nodes), universe=u)
+        assert labels_u is not None
+        assert labels_u.atoms is not None
+
+        if len(labels_u.atoms) > 0:
+            log(f"Writing labels voxels debug file to {labels_path}... ", end="")
+            labels_u.atoms.write(labels_path)
+            log("done.")
+        else:
+            log(f"Could not write labels to {labels_path}, because there are no voxels to write!")
+
+
+    # Let's select our labels.
+    possible_labels = npc(containment.voxel_containment.nodes)
+    if args.interactive and args.labels is None and args.autofill is False:
+        log(
+            "No compartment labels have been selected, yet.",
+            "Select one or more to continue.\n",
+            f"Options: {possible_labels}.",
+            "Provide them as a space-separated list followed by a return.",
+        )
+        labels = []
+        while len(labels) == 0:
+            try:
+                labels.extend(map(lambda label: int(label), input("-> ").split()))
+            except ValueError:
+                log("Could not parse the labels. Make sure they are well-formed.")
+            for label in labels:
+                if label not in possible_labels:
+                    log(f"'{label}' is not a valid compartment label.")
+                    log("Please try again.")
+                    labels.clear()
+                    break
+    elif args.autofill is True:
+        labels = containment.voxel_containment.leaf_nodes
+        log(f"Automatically choosing leaf components: {npc(labels)}.")
+    else:
+        # Making sure we this is the case, even though we do this check at the top as well.
+        assert (
+            args.labels is not None
+        ), "No labels are specified and the mode is non-interactive so we can't ask."
+        labels = args.labels
+        for label in labels:
+            if label not in possible_labels:
+                log(f"ERROR: '{label}' is not a valid compartment label.")
+                return 1
+    log(f"Selected the following labels: {npc(labels)}.")
+
+    # Get our compartment by masking out all voxels that have our selected labels.
+    compartment = containment.voxel_containment.get_voxel_mask(labels)
+    full = np.count_nonzero(compartment == True)
+    free = np.count_nonzero(compartment == False)
+    full_volume = full * containment.voxel_volume
+    free_volume = free * containment.voxel_volume
+    total_volume = full_volume + free_volume
+    full_frac = full_volume / total_volume
+    free_frac = free_volume / total_volume
+    log("Selected compartment contains:")
+    log(f"    occupied:\t{full} voxels\t({full_frac:.1%}, {full_volume:.1f} nm³)")
+    log(f"   available:\t{free} voxels\t({free_frac:.1%}, {free_volume:.1f} nm³)")
+
+    # Produce our final output mask according to the specified output mask resolution.
+    log(f"Output mask resolution is set to {args.mask_resolution} nm.")
+    log(f"Zoom factor from containment voxels to mask voxels is {zoom}.")
+    zoomed = compartment.repeat(zoom, axis=0).repeat(zoom, axis=1).repeat(zoom, axis=2)
+
+    # Report a summary of the final mask's dimensions.
+    mask_res = args.mask_resolution
+    mask_shape = zoomed.shape
+    mask_size = tuple(npc(np.array(mask_shape) * mask_res))
+    log(f"Size of final voxel mask is {mask_shape} at a {mask_res} nm resolution.")
+    log(f"This corresponds to a final mask size of {mask_size} nm.")
+
+    # Write out a debug voxels gro of the mask if desired.
+    if args.debug_voxels is None and args.interactive:
+        log("Do you want to write the voxel mask as a gro file to inspect it?")
+        log("Warning: This file may be quite large, depending on the mask resolution.")
+        log("Provide an output path. To skip this step, leave this field empty.")
+        while True:
+            path = input("(gro) -> ").strip()
+            if len(path) == 0:
+                voxels_path = None
+                break
+            voxels_path = Path(path)
+            if voxels_path.suffix == ".gro":
+                break
+            log(f"Path must have a gro extension. Found '{voxels_path.suffix}'.")
+    else:
+        voxels_path = args.debug_voxels
+    if voxels_path is not None:
+        log(f"Writing mask voxels debug file to {voxels_path}... ", end="")
+        voxels_to_universe(zoomed, universe=u, nodes=[True])
+        voxels_to_gro(voxels_path, zoomed, scale=args.mask_resolution)
+        log("done.")
+
+    # Determine the voxel mask output path.
+    output_path = args.output
+    if args.output is None and args.interactive:
+        log("Please provide an output path for the final voxel mask.")
+        while True:
+            path = input("(npz) -> ").strip()
+            if len(path) == 0:
+                output_path = None
+                break
+            output_path = Path(path)
+            if output_path.suffix == ".npz":
+                break
+            log(f"Path must have an npz extension. Found '{output_path.suffix}'.")
+
+    # Finally, write out the voxel mask when desired.
+    if output_path is not None:
+        log(f"Writing the voxel mask to {output_path}... ", end="")
+        np.savez(output_path, zoomed)
+        log("done.")
+
+
+def resolve_cache_path(structure_path):
+    """
+    Determine what the cache path for the provided structure path is.
+    """
+    structure_name = structure_path.name
+    cached_name = f"#cached_{structure_name}.pickle"
+    return structure_path.with_name(cached_name)
+
+
+def npc_single(n):
+    match n:
+        case np.float32() | np.float64() | float():
+            return float(n)
+        case np.int32() | np.int64() | int():
+            return int(n)
+        case _:
+            print(f"WARNING: Unknown type for {n}: {type(n)}")
+
+
+def npc(ns):
+    "Canonicalize numpy number types to print them properly."
+    return [npc_single(n) for n in ns]
+
+
+def main():
+    parser = setup_parser()
+    args = parser.parse_args()
+    return mask(args)
+
+
+if __name__ == "__main__":
+    main()