### Energy Model Default Set Methods

Source: https://topologicpy.readthedocs.io/en/latest/genindex

Static methods within the topologicpy.EnergyModel.EnergyModel module for retrieving default construction and schedule sets, useful for energy simulation setups.

```APIDOC
topologicpy.EnergyModel.EnergyModel static methods:

DefaultConstructionSets()
  - Returns a collection of default construction sets for energy modeling.

DefaultScheduleSets()
  - Returns a collection of default schedule sets for energy modeling.
```

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

### ANN.HyperparametersBySampleName: Get Suggested Hyperparameters for Sample Datasets

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.ANN

Retrieves a dictionary of suggested initial hyperparameters tailored for specific sample datasets. Useful for quick setup with predefined datasets.

```APIDOC
static HyperparametersBySampleName(name: str)
  - Returns suggested initial hyperparameters to use for the dataset named in the name input parameter.
  - Parameters:
    - name: str
      - The input name of the sample dataset. Must be one of ['breast_cancer', 'california_housing', 'digits', 'iris', 'wine'].
  - Returns: dict
    - A dictionary with the following keys: 'title', 'task_type', 'test_ratio', 'validation_ratio', 'hidden_layers', 'learning_rate', 'epochs', 'batch_size', 'early_stopping', 'patience', 'random_state', 'cross_val_type', 'k_folds', 'interval', 'mantissa'.
```

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

### topologicpy.Helper.Helper Static Methods Reference

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Helper

Detailed API reference for the static methods of the `topologicpy.Helper.Helper` class, including method signatures, parameter descriptions, return values, and usage examples where applicable. These methods are designed for various list and data manipulation tasks.

```APIDOC
topologicpy.Helper.Helper Static Methods:

MergeByThreshold(listA, threshold=0.0001)
  Description: Merges the numbers in the input list so that numbers within the input threshold are averaged into one number.
  Parameters:
    listA (list): The input nested list.
    threshold (float, optional): The desired merge threshold value. The default is 0.0001.
  Returns:
    list: The merged list. The list is sorted in ascending numeric order.

MinimumIndices(listA, silent: bool = False)
  Description: Returns a list of indices of the minimum value in the input list.
  Example: If the input list is [1,3,4,1,5,1] then the returned list is [0,3,5] to indicate the indices of the minimum value (1).
  Parameters:
    listA (list): The input list.
    silent (bool, optional): If set to True, error and warning messages are suppressed. The default is False.
  Returns:
    list: The resulting list.

Normalize(listA, mantissa: int = 6)
  Description: Normalizes the input list so that it is in the range 0 to 1.
  Parameters:
    listA (list): The input nested list.
    mantissa (int, optional): The desired length of the mantissa. The default is 6.
  Returns:
    list: The normalized list.

Position(item, listA)
  Description: Returns the position of the item in the list or the position it would have been inserts. Item is assumed to be numeric. listA is assumed to contain only numeric values and sorted from lowest to highest value.
  Parameters:
    item (int or float): The input number to be positioned.
    listA (list): The input sorted list.
  Returns:
    int: The position of the item within the list.

RemoveEven(listA)
  Description: Removes the even indexed members of the input list.
  Parameters:
    listA (list): The input list.
  Returns:
    list: The resulting list.

RemoveOdd(listA)
  Description: Removes the odd indexed members of the input list.
  Parameters:
    listA (list): The input list.
  Returns:
    list: The resulting list.

Repeat(listA)
  Description: Repeats the input nested list so that each sublist has the same number of members. To fill extra members, the last item in the shorter lists are repeated and appended.
  Example: Repeat([[1,2,3],['m','n','o','p'],['a','b','c','d','e']]) yields [[1, 2, 3, 3, 3], ['m', 'n', 'o', 'p', 'p'], ['a', 'b', 'c', 'd', 'e']]
  Parameters:
    listA (list): The input nested list.
  Returns:
    list: The repeated list.

Sort(listA, *otherLists, reverseFlags=None)
  Description: Sorts the first input list according to the values in the subsequent input lists in order. For example, your first list can be a list of topologies and the next set of lists can be their volume, surface area, and z level. The list of topologies will then be sorted first by volume, then by surface, and lastly by z level. You can choose to reverse the order of sorting by including a list of TRUE/FALSE values in the reverseFlags input parameter. For example, if you wish to sort the volume in reverse order (from large to small), but sort the other parameters normally, you would include the following list for reverseFlag: [True, False, False].
  Parameters:
    listA (list): The first input list to be sorts.
    *otherLists (any number of lists, optional): Any number of lists that are used to sort the listA input parameter. The order of these input parameters determines the order of sorting (from left to right). If no lists are included, the input list will be sorted as is.
    reverseFlags (list, optional): The list of booleans (TRUE/FALSE) to indicated if sorting based on a particular list should be conducted in reverse order.
```

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

### Get Start Vertex of an Edge in topologicpy

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Edge

Retrieves the starting vertex of a given edge. This is a fundamental operation for understanding the orientation and connectivity of an edge within a topological structure.

```APIDOC
StartVertex(edge)
  - Returns the start vertex of the input edge.
  - Parameters:
    - edge: topologic_core.Edge - The input edge.
  - Returns: topologic_core.Vertex - The start vertex of the input edge.
```

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

### Importing Topologies from Various Sources (topologicpy.Topology.Topology)

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

This section details the static methods available in `topologicpy.Topology.Topology` for importing or creating topological structures from different file formats and string representations, including BIM (.dotbim), BREP, and DXF. Each method provides specific parameters for handling file paths, content strings, and import options like tolerance and default values.

```APIDOC
topologicpy.Topology.Topology Static Import Methods:

ByBIMString(string, guidKey: str = 'guid', colorKey: str = 'color', typeKey: str = 'type', defaultColor: list = [255, 255, 255, 1], defaultType: str = 'Structure', authorKey: str = 'author', dateKey: str = 'date', mantissa: int = 6, angTolerance: float = 0.001, tolerance: float = 0.0001)
  - Imports topologies from the input BIM file. See https://dotbim.net/
  - Parameters:
    - string (str): The input dotbim string (in JSON format).
    - guidKey (str, optional): The key to use to store the GUID of the topology. Default: "guid".
    - colorKey (str, optional): The key to use to find the color of the topology. Default: "color". If no color is found, the defaultColor parameter is used.
    - typeKey (str, optional): The key to use to find the type of the topology. Default: "type". If no type is found, the defaultType parameter is used.
    - defaultColor (list, optional): The default color to use for the topology. Default: [255,255,255,1] (opaque white).
    - defaultType (str, optional): The default type to use for the topology. Default: "Structure".
    - authorKey (str, optional): The key to use to store the author of the topology. Default: "author".
    - dateKey (str, optional): The key to use to store the creation date of the topology (format: "DD.MM.YYYY"). If no date is found, the date of import is used.
    - mantissa (int, optional): The desired length of the mantissa. Default: 6.
    - angTolerance (float, optional): The angle tolerance in degrees under which no rotation is carried out. Default: 0.001 degrees.
    - tolerance (float, optional): The desired tolerance. Default: 0.0001.
  - Returns: list - The list of imported topologies.

ByBREPFile(file)
  - Imports a topology from a BREP file.
  - Parameters:
    - file (file object): The BREP file.
  - Returns: topologic_core.Topology - The imported topology.

ByBREPPath(path)
  - Imports a topology from a BREP file path.
  - Parameters:
    - path (str): The path to the BREP file.
  - Returns: topologic_core.Topology - The imported topology.

ByBREPString(string)
  - Creates a topology from the input brep string.
  - Parameters:
    - string (str): The input brep string.
  - Returns: topologic_core.Topology - The created topology.

ByDXFFile(file, sides: int = 16, tolerance: float = 0.0001, silent: bool = False)
  - Imports a list of topologies from a DXF file. This is an experimental method with limited capabilities.
  - Parameters:
    - file (a DXF file object): The DXF file object.
    - sides (int, optional): The desired number of sides of splines. Default: 16.
    - tolerance (float, optional): The desired tolerance. Default: 0.0001.
    - silent (bool, optional): If set to True, error and warning messages are suppressed. Default: False.
  - Returns: list - The list of imported topologies.

ByDXFPath(path, sides: int = 16, tolerance: float = 0.0001, silent: bool = False)
  - Imports a list of topologies from a DXF file path. This is an experimental method with limited capabilities.
  - Parameters:
    - path (str): The path to the DXF file.
    - sides (int, optional): The desired number of sides of splines. Default: 16.
    - tolerance (float, optional): The desired tolerance. Default: 0.0001.
    - silent (bool, optional): If set to True, error and warning messages are suppressed. Default: False.
  - Returns: list - The list of imported topologies.
```

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

### Import and Create Topologies using topologicpy.Topology.Topology Static Methods

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

This documentation block details the static methods available in the topologicpy.Topology.Topology class for importing topologies from OBJ files, OBJ strings, and creating them from OCCT shapes. It covers method signatures, parameters, their types, default values, and return types.

```APIDOC
topologicpy.Topology.Topology Static Methods:

ByOBJPath(objPath: str, defaultColor: list = [255, 255, 255], defaultOpacity: float = 1.0, transposeAxes: bool = True, removeCoplanarFaces: bool = True, selfMerge: bool = False, mantissa: int = 6, tolerance: float = 0.0001)
  - Description: Imports a topology from an OBJ file path and an associated materials file. This method is basic and does not support textures and vertex normals.
  - Parameters:
    - objPath (str): The path to the OBJ file.
    - defaultColor (list, optional, default: [255, 255, 255]): The default color to use if none is specified in the file.
    - defaultOpacity (float, optional, default: 1.0): The default opacity to use if none is specified in the file.
    - transposeAxes (bool, optional, default: True): If set to True the Z and Y axes are transposed. Otherwise, they are not.
    - removeCoplanarFaces (bool, optional, default: True): If set to True, coplanar faces are merged.
    - selfMerge (bool, optional, default: False): If set to True, the faces of the imported topologies will each be self-merged to create higher-dimensional objects. Otherwise, they remain a cluster of faces.
    - mantissa (int, optional, default: 6): The desired length of the mantissa.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
  - Returns: list - The imported topologies.

ByOBJString(objString: str, mtlString: str = None, defaultColor: list = [255, 255, 255], defaultOpacity: float = 1.0, transposeAxes: bool = True, removeCoplanarFaces: bool = True, selfMerge: bool = False, mantissa: int = 6, tolerance: float = 0.0001)
  - Description: Imports a topology from OBJ and MTL strings.
  - Parameters:
    - objString (str): The string of the OBJ file.
    - mtlString (str, optional, default: None): The string of the MTL file.
    - defaultColor (list, optional, default: [255, 255, 255]): The default color to use if none is specified in the string.
    - defaultOpacity (float, optional, default: 1.0): The default opacity to use if none is specified in the string.
    - transposeAxes (bool, optional, default: True): If set to True the Z and Y axes are transposed. Otherwise, they are not.
    - removeCoplanarFaces (bool, optional, default: True): If set to True, coplanar faces are merged.
    - selfMerge (bool, optional, default: False): If set to True, the faces of the imported topologies will each be self-merged to create higher-dimensional objects. Otherwise, they remain a cluster of faces.
    - mantissa (int, optional, default: 6): The desired length of the mantissa.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
  - Returns: list - The imported topologies.

ByOCCTShape(occtShape: topologic_core.TopoDS_Shape)
  - Description: Creates a topology from the input OCCT shape. See https://dev.opencascade.org/doc/overview/html/occt_user_guides__modeling_data.html.
  - Parameters:
    - occtShape (topologic_core.TopoDS_Shape): The input OCCT Shape.
  - Returns: topologic_core.Topology
```

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

### topologicpy.Topology.Topology Static Methods Reference

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

This section provides detailed API documentation for various static methods within the topologicpy.Topology.Topology class. It includes method signatures, descriptions, parameters with their types and explanations, and return values.

```APIDOC
topologicpy.Topology.Topology Static Methods:

HighestType(topology: topologic_core.Topology) -> int
  Description: Returns the highest topology type found in the input topology.
  Parameters:
    topology: topologic_core.Topology - The input topology.
  Returns:
    int - The highest type found in the input topology.

Impose(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False)
  Description: See Topology.Boolean().

Imprint(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False)
  Description: See Topology.Boolean().

InternalVertex(topology: topologic_core.Topology, timeout: int = 30, tolerance: float = 0.0001, silent: bool = False) -> topologic_core.Vertex
  Description: Returns a vertex guaranteed to be inside the input topology.
  Parameters:
    topology: topologic_core.Topology - The input topology.
    timeout: int, optional - The amount of seconds to wait before timing out. The default is 30 seconds.
    tolerance: float, optional - The desired tolerance. The default is 0.0001.
    silent: bool, optional - If set to True, error and warning messages are suppressed. The default is False.
  Returns:
    topologic_core.Vertex - A vertex guaranteed to be inside the input topology.

Intersect(topologyA, topologyB, tranDict=False, tolerance=0.0001)
  Description: See Topology.Boolean().

IsInstance(topology: topologic_core.Topology, type: str) -> bool
  Description: Returns True if the input topology is an instance of the class specified by the input type string.
  Parameters:
    topology: topologic_core.Topology - The input topology.
    type: string - The topology type. This can be one of:
      "Vertex"
      "Edge"
      "Wire"
      "Face"
      "Shell"
      "Cell"
      "CellComplex"
      "Cluster"
      "Topology"
      "Graph"
      "Aperture"
      "Dictionary"
      "Context"
  Returns:
    bool - True if the input topology is an instance of the class defined by the input type string. False otherwise.

IsPlanar(topology: topologic_core.Topology, mantissa: int = 6, tolerance: float = 0.0001) -> bool
  Description: Returns True if all the vertices of the input topology are co-planar. Returns False otherwise.
  Parameters:
    topology: topologic_core.Topology - The input topology.
    mantissa: int, optional - The desired length of the mantissa. The default is 6.
    tolerance: float, optional - The desired tolerance. The default is 0.0001.
  Returns:
    bool - True if all the vertices of the input topology are co-planar. False otherwise.

IsSame(topologyA: topologic_core.Topology, topologyB: topologic_core.Topology) -> bool
  Description: Returns True if the input topologies are the same topology. Returns False otherwise.
  Parameters:
    topologyA: topologic_core.Topology - The first input topology.
    topologyB: topologic_core.Topology - The second input topology.
  Returns:
    bool - True if the input topologies are the same topology. False otherwise.

IsSimilar(topologyA: topologic_core.Topology, topologyB: topologic_core.Topology, removeCoplanarFaces: bool = False, mantissa: int = 6, epsilon: float = 0.1, tolerance: float = 0.0001, silent: bool = False)
  Description: Calculates if the input topologies are similar. See https://en.wikipedia.org/wiki/Similarity_(geometry).
  Parameters:
    topologyA: topologic_core.Topology - The first input topology.
    topologyB: topologic_core.Topology - The second input topology.
    removeCoplanarFaces: bool, optional - If set to True, coplanar faces are removed. Defaults to False.
    mantissa: int, optional - The desired length of the mantissa. Defaults to 6.
    epsilon: float, optional - The epsilon value for similarity comparison. Defaults to 0.1.
    tolerance: float, optional - The desired tolerance. Defaults to 0.0001.
    silent: bool, optional - If set to True, error and warning messages are suppressed. Defaults to False.
```

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

### Grow a spatially connected group

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Helper

Attempts to grow a spatially connected group of a specified size starting from a given seed index. This method uses a breadth-first search strategy to explore neighboring indices from the seed index, guided by the provided adjacency dictionary. It avoids reusing indices that are globally visited. The growth continues until the desired group size is reached or no further expansion is possible.

```APIDOC
Grow(seed_idx: int, group_size: int, adjacency: dict, visited_global: set) -> list[int] | None
  - Attempts to grow a spatially connected group of a specified size starting from a given seed index.
  - Parameters:
    - seed_idx: The index from which to start growing the group.
    - group_size: The target size of the group to be grown.
    - adjacency: A dictionary mapping each index to a list of adjacent indices. This defines the connectivity.
    - visited_global: A set of indices that have already been used in previously grown groups and should be avoided.
  - Returns: A list of indices representing a connected group of the specified size if successful, otherwise None.
  - Notes: This method is intended for internal use in functions that generate connected subgroups of spatial elements (e.g., cells) based on adjacency. The result may vary between runs due to random shuffling of neighbor order to diversify outputs.
```

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

### API Documentation for topologicpy.Topology.Topology Static Methods

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

This section provides detailed API documentation for various static methods available in the topologicpy.Topology.Topology class. Each method's signature, parameters, return values, and a brief description are included.

```APIDOC
topologicpy.Topology.Topology Static Methods:

Merge(topologyA, topologyB, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False)
  Description:
    See Topology.Boolean().
  Parameters:
    - topologyA: (type not specified)
    - topologyB: (type not specified)
    - tranDict (bool, optional, default: False): If set to True, error and warning messages are suppressed.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
    - silent (bool, optional, default: False): If set to True, error and warning messages are suppressed.
  Returns:
    - (None)

MergeAll(topologies, tolerance=0.0001)
  Description:
    Merge all the input topologies.
  Parameters:
    - topologies (list): The list of input topologies.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
  Returns:
    - topologic_core.Topology: The resulting merged Topology

MeshData(topology, mode: int = 1, transferDictionaries: bool = False, mantissa: int = 6, silent: bool = False)
  Description:
    Creates a mesh data python dictionary from the input topology.
  Parameters:
    - topology (topologic_core.Topology): The input topology.
    - mode (int, optional, default: 1): The desired mode of conversion: 0: The faces list indexes into the vertices list. 1: The faces list indexes into the edges list.
    - transferDictionaries (bool, optional, default: False): If set to True, the python dictionaries will be transferred to the corresponding topologies.
    - mantissa (int, optional, default: 6): The desired length of the mantissa.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
    - silent (bool, optional, default: False): If set to True, error and warning messages are suppressed.
  Returns:
    - dict: The created mesh data python dictionary of vertices, edges, faces, and cells in the form of: { 'mode' : int (the mode of the face data) 'vertices': list, (list of coordinates) 'edges': list, (list of indices into the list of vertices) 'faces': list, (list of indices into the list of edges or list of vertices based on mode) 'cells': list, (list of indices into the list of faces) 'vertex_dict': list of dicts, 'edge_dicts': list of dicts, 'face_dicts', list of dicts, 'cell_dicts', list of dicts }

Move(topology, x=0, y=0, z=0)
  Description:
    Moves the input topology.
  Parameters:
    - topology (topologic_core.topology): The input topology.
    - x (float, optional, default: 0): The x distance value.
    - y (float, optional, default: 0): The y distance value.
    - z (float, optional, default: 0): The z distance value.
  Returns:
    - topologic_core.Topology: The moved topology.

NonPlanarFaces(topology, tolerance=0.0001)
  Description:
    Returns any nonplanar faces in the input topology.
  Parameters:
    - topology (topologic_core.Topology): The input topology.
    - tolerance (float, optional, default: 0.0001): The desired tolerance.
  Returns:
    - list: The list of nonplanar faces.

OBJString(*topologies, nameKey='name', colorKey='color', opacityKey='opacity', defaultColor=[256, 256, 256], defaultOpacity=0.5, transposeAxes: bool = True, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001)
  Description:
    Exports the input topology to a Wavefront OBJ file. This is very experimental and outputs a simple solid topology.
  Parameters:
    - topologies (list or comma separated topologies): The input list of topologies.
    - nameKey (str, optional, default: 'name'): The topology dictionary key under which to find the name of the topology.
    - colorKey (str, optional, default: 'color'): (Description not provided in source)
    - opacityKey (str, optional, default: 'opacity'): (Description not provided in source)
    - defaultColor (list, optional, default: [256, 256, 256]): (Description not provided in source)
    - defaultOpacity (float, optional, default: 0.5): (Description not provided in source)
    - transposeAxes (bool, optional, default: True): (Description not provided in source)
    - mode (int, optional, default: 0): (Description not provided in source)
    - meshSize (float, optional, default: None): (Description not provided in source)
    - mantissa (int, optional, default: 6): (Description not provided in source)
    - tolerance (float, optional, default: 0.0001): (Description not provided in source)
  Returns:
    - (None)
```

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

### Install topologicpy Python Package

Source: https://topologicpy.readthedocs.io/en/latest/index

This command installs or upgrades the topologicpy library using pip, the standard package installer for Python. It ensures that you have the latest version of the library available for use in your Python development environment.

```Python
pip install topologicpy --upgrade
```

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

### Create Edge by Start and End Vertex

Source: https://topologicpy.readthedocs.io/en/latest/genindex

This static method creates an Edge object defined by its starting and ending vertices. It's a straightforward way to define linear topological elements.

```APIDOC
topologicpy.Edge.Edge.ByStartVertexEndVertex() (static method)
  - Creates an Edge object from a start vertex and an end vertex.
```

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

### topologicpy.Vertex Static Methods API Reference

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Vertex

Comprehensive API documentation for static methods available in the `topologicpy.Vertex` class, including signatures, parameters, return values, and detailed descriptions for each function.

```APIDOC
topologicpy.Vertex Static Methods:

Centroid(vertices: list, mantissa: int = 6) -> topologic_core.Vertex
  Description: Returns the centroid of the input list of vertices.
  Parameters:
    vertices (list): The input list of vertices
    mantissa (int, optional): The desired length of the mantissa. The default is 6.
  Returns:
    topologic_core.Vertex: The computed centroid of the input list of vertices

Clockwise2D(vertices: list) -> list
  Description: Sorts the input list of vertices in a clockwise fashion. This method assumes that the vertices are on the XY plane. The Z coordinate is ignored.
  Parameters:
    vertices (list): The input list of vertices
  Returns:
    list: The input list of vertices sorted in a counter clockwise fashion

Coordinates(vertex: topologic_core.Vertex, outputType: str = 'xyz', mantissa: int = 6) -> list
  Description: Returns the coordinates of the input vertex.
  Parameters:
    vertex (topologic_core.Vertex): The input vertex.
    outputType (string, optional): The desired output type. Could be any permutation or substring of “xyz” or the string “matrix”. The default is “xyz”. The input is case insensitive and the coordinates will be returned in the specified order.
    mantissa (int, optional): The desired length of the mantissa. The default is 6.
  Returns:
    list: The coordinates of the input vertex.

CounterClockwise2D(vertices: list, mantissa: int = 6) -> list
  Description: Sorts the input list of vertices in a counterclockwise fashion. This method assumes that the vertices are on the XY plane. The Z coordinate is ignored.
  Parameters:
    vertices (list): The input list of vertices
    mantissa (int, optional): The desired length of the mantissa. The default is 6.
  Returns:
    list: The input list of vertices sorted in a counter clockwise fashion

Degree(vertex: topologic_core.Vertex, hostTopology: topologic_core.Topology, topologyType: str = 'edge') -> int
  Description: Returns the vertex degree (the number of super topologies connected to it). See https://en.wikipedia.org/wiki/Degree_(graph_theory).
  Parameters:
    vertex (topologic_core.Vertex): The input vertex
```

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

### topologicpy.Topology.Topology Class Methods and XYZ File Format

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

Comprehensive documentation for methods within the `topologicpy.Topology.Topology` class, including static methods for importing topological data from XYZ files (both file objects and paths), and instance methods for computing canonical matrices and extracting cell complexes. Also includes the specification and example of the XYZ file format.

```APIDOC
XYZ File Format Specification:
  - An XYZ file can be made out of one or more frames. Each frame will be stored in a separate topologic cluster.
  - First line: total number of vertices in the frame (integer, no other words/characters).
  - Second line: frame label (free text, stored in dictionary of each frame).
  - All other lines: vertex_label, x, y, and z coordinates, separated by spaces, tabs, or commas. Vertex label must be one word, stored in dictionary of each vertex.
  - Example XYZ File:
    3
    Frame 1
    A 5.67 -3.45 2.61
    B 3.91 -1.91 4
    A 3.2 1.2 -12.3
    4
    Frame 2
    B 5.47 -3.45 2.61
    B 3.91 -1.93 3.1
    A 3.2 1.2 -22.4
    A 3.2 1.2 -12.3
    3
    Frame 3
    A 5.67 -3.45 2.61
    B 3.91 -1.91 4
    C 3.2 1.2 -12.3

topologicpy.Topology.Topology.ByXYZFile(file: file object, frameIdKey: str = 'id', vertexIdKey: str = 'id')
  - Imports the topology from an XYZ file object.
  - Parameters:
    - file (file object): The input XYZ file.
    - frameIdKey (str, optional): The desired id key to use to store the ID of each frame in its dictionary. Defaults to "id".
    - vertexIdKey (str, optional): The desired id key to use to store the ID of each point in its dictionary. Defaults to "id".
  - Returns: list (The list of frames (topologic_core.Cluster)).

topologicpy.Topology.Topology.ByXYZPath(path: str, frameIdKey: str = 'id', vertexIdKey: str = 'id')
  - Imports the topology from an XYZ file path. This is a very experimental method.
  - Parameters:
    - path (str): The input XYZ file path.
    - frameIdKey (str, optional): The desired id key to use to store the ID of each frame in its dictionary. Defaults to "id".
    - vertexIdKey (str, optional): The desired id key to use to store the ID of each point in its dictionary. Defaults to "id".
  - Returns: list (The list of frames (topologic_core.Cluster)).

topologicpy.Topology.Topology.CanonicalMatrix(topology: topologic_core.Topology, n: int = 10, normalize: bool = False, mantissa: int = 6, silent: bool = False)
  - Returns the canonical matrix of the input topology.
  - The canonical matrix refers to a transformation matrix that maps an object’s coordinate system to a canonical coordinate frame, where:
    - The origin of the object aligns with the world origin
    - The principal axes of the object align with the world axes
  - This transformation is computed using Principal Component Analysis (PCA), leveraging the eigenvectors of the covariance matrix of the object’s vertices and thus can give erroneous results. The transformation matrix may not yield an object oriented as expected.
  - Parameters:
    - topology (topologic_core.Topology): The input topology.
    - n (int, optional): The number of segments to use to increase the number of points on each face. Defaults to 10.
    - normalize (bool, optional): If set to True, the longest edge in the input topology is scaled to become of length 1. Defaults to False.
    - mantissa (int, optional): The desired length of the mantissa. Defaults to 6.
    - silent (bool, optional): If set to True, error and warning messages are suppressed. Defaults to False.
  - Returns: list (The 4x4 canonical matrix).

topologicpy.Topology.Topology.CellComplexes(topology: topologic_core.Topology)
  - Returns the cellcomplexes of the input topology.
  - Parameters:
    - topology (topologic_core.Topology): The input topology.
  - Returns: list (The list of cellcomplexes of the input topology).
```

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

### Get Cells from topologicpy.Cluster (Cells)

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Cluster

Retrieves a list of cells contained within the specified topologic_core.Cluster object.

```APIDOC
topologicpy.Cluster.Cells(cluster: topologic_core.Cluster) -> list

Parameters:
  cluster: topologic_core.Cluster
    The input cluster.

Returns:
  list
    The list of cells.
```

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

### Get Software Version (topologicpy.Helper.Helper)

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Helper

This static method returns the current version string of the topologicpy software. It takes no parameters.

```APIDOC
Version()
  - Returns the current version of the software.
  - Parameters: None
  - Returns: str
    - The current version of the software.
```

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

### topologicpy.Topology.Topology Static Methods

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Topology

Comprehensive documentation for static methods within the `topologicpy.Topology.Topology` class, covering type identification, UUID generation, geometric transformations, and visualization.

```APIDOC
topologicpy.Topology.Topology Static Methods:

TypeID(name: str = None) -> int
  - Returns the type id of the input name string.
  - Parameters:
    - name: str, optional
      The input class name string. This could be one of: "vertex", "edge", "wire", "face", "shell", "cell", "cellcomplex", "cluster", "aperture", "context", "dictionary", "graph", "topology". It is case insensitive. The default is None.
  - Returns: int
    The type id of the input topologyType string.

UUID(topology: topologic_core.Topology, namespace: str = 'topologicpy') -> UUID
  - Generate a UUID v5 based on the provided content and a fixed namespace.
  - Parameters:
    - topology: topologic_core.Topology
      The input topology.
    - namespace: str, optional
      The base namespace to use for generating the UUID.
  - Returns: UUID
    The uuid of the input topology.

Unflatten(topology: topologic_core.Topology, origin: topologic_core.Vertex = None, direction: list = [0, 0, 1]) -> topologic_core.Topology
  - Unflattens the input topology such that the world origin is translated to the input origin and the input topology is rotated such that the Up direction (see Vector.Up()) is aligned with the input vector.
  - Parameters:
    - topology: topologic_core.Topology
      The input topology.
    - origin: topologic_core.Vertex, optional
      The input origin. If set to None, The object’s centroid will be used to translate the world origin. The default is None.
    - direction: list, optional
      The input direction vector. The input topology will be rotated such that this vector is pointed in the positive Z axis.
  - Returns: topologic_core.Topology
    The flattened topology.

Union(topologyA: topologic_core.Topology, topologyB: topologic_core.Topology, tranDict: bool = False, tolerance: float = 0.0001, silent: bool = False)
  - See Topology.Boolean()
  - Parameters:
    - topologyA: topologic_core.Topology
      The first input topology.
    - topologyB: topologic_core.Topology
      The second input topology.
    - tranDict: bool, default False
      No description provided.
    - tolerance: float, default 0.0001
      No description provided.
    - silent: bool, default False
      No description provided.
  - Returns: (No return type specified)

Vertices(topology: topologic_core.Topology) -> list
  - Returns the vertices of the input topology.
  - Parameters:
    - topology: topologic_core.Topology
      The input topology.
  - Returns: list
    The list of vertices.

View3D(*topologies: list, uuid: UUID = None, nameKey: str = 'name', colorKey: str = 'color', opacityKey: str = 'opacity', defaultColor: list = [256, 256, 256], defaultOpacity: float = 0.5, transposeAxes: bool = True, mode: int = 0, meshSize: float = None, overwrite: bool = False, mantissa: int = 6, tolerance: float = 0.0001)
  - Sends the input topologies to 3dviewer.net. The topologies must be 3D meshes.
  - Parameters:
    - topologies: list or comma separated topologies
      The input list of topologies.
    - uuid: UUID, optional
      The UUID v5 to use to identify these topologies. The default is a UUID based on the topologies themselves.
    - nameKey: str, optional
      The topology dictionary key under which to find the name of the topology. The default is “name”.
    - colorKey: str, optional
      The topology dictionary key under which to find the color of the topology. The default is “color”.
    - opacityKey: str, optional
      The topology dictionary key under which to find the opacity of the topology. The default is “opacity”.
    - defaultColor: list, optional, default [256, 256, 256]
      The default color to use if no color is stored in the topology dictionary. Note: Signature default is [256, 256, 256], description default is [255,255, 255] (white).
    - defaultOpacity: float, optional, default 0.5
      The default opacity to use if no opacity is stored in the topology dictionary. This must be between 0 and 1. Note: Signature default is 0.5, description default is 1 (fully opaque).
    - transposeAxes: bool, optional
      If set to True the Z and Y coordinates are transposed so that Y points “up”.
    - mode: int, optional
      The desired mode of meshing algorithm (for triangulation). Several options are available: 0: Classic, 1: MeshAdapt, 3: Initial Mesh Only, 5: Delaunay, 6: Frontal-Delaunay, 7: BAMG, 8: Fontal-Delaunay for Quads.
    - meshSize: float, optional
      No description provided.
    - overwrite: bool, optional
      No description provided.
    - mantissa: int, optional
      No description provided.
    - tolerance: float, optional
      No description provided.
  - Returns: (No return type specified)
```

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

### Get Cell Complexes from topologicpy.Cluster (CellComplexes)

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Cluster

Retrieves a list of cell complexes contained within the specified topologic_core.Cluster object.

```APIDOC
topologicpy.Cluster.CellComplexes(cluster: topologic_core.Cluster) -> list

Parameters:
  cluster: topologic_core.Cluster
    The input cluster.

Returns:
  list
    The list of cellComplexes.
```

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

### Get External Boundary of Wire in TopologicPy

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.Wire

Identifies and returns the external boundary of the input wire, represented as a cluster of vertices where each vertex has a degree of 1.

```APIDOC
*static* ExternalBoundary(wire)
  Returns the external boundary (cluster of vertices where degree == 1) of the input wire.

  Parameters:
    wire: topologic_core.Wire
      The input wire.

  Returns:
    topologic_core.Cluster
      The external boundary of the input wire. This is a cluster of vertices of degree == 1.
```

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

### topologicpy.EnergyModel Class Static Methods Reference

Source: https://topologicpy.readthedocs.io/en/latest/topologicpy.EnergyModel

This comprehensive API documentation details the static methods available within the `topologicpy.EnergyModel.EnergyModel` class. These methods facilitate various operations on energy models, including creation from OSM files or topology, querying data, exporting to different formats (GBXML, OSM), running simulations, and retrieving specific model components like construction sets, schedules, and space properties.

```APIDOC
topologicpy.EnergyModel.EnergyModel.ByOSMFile(file)
  - Creates an EnergyModel from the input OSM file path.
  - Parameters:
    - file (string): The path to the input .OSM file.
  - Returns:
    - openstudio.openstudiomodelcore.Model: The OSM model.

topologicpy.EnergyModel.EnergyModel.ByOSMPath(path)
  - Creates an EnergyModel from the input OSM file path.

topologicpy.EnergyModel.EnergyModel.ByTopology(building[, shadingSurfaces, ...])
  - Creates an EnergyModel from the input topology and parameters.

topologicpy.EnergyModel.EnergyModel.ColumnNames(model, reportName, tableName)
  - Returns the list of column names given an OSM model, report name, and table name.

topologicpy.EnergyModel.EnergyModel.DefaultConstructionSets(model)
  - Returns the default construction sets in the input OSM model.

topologicpy.EnergyModel.EnergyModel.DefaultScheduleSets(model)
  - Returns the default schedule sets found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.ExportToGBXML(model, path[, overwrite])
  - Exports the input OSM model to a GBXML file.

topologicpy.EnergyModel.EnergyModel.ExportToOSM(model, path[, overwrite])
  - Exports the input OSM model to an OSM file.

topologicpy.EnergyModel.EnergyModel.GBXMLString(model)
  - Returns the GBXML string of the input OSM model.

topologicpy.EnergyModel.EnergyModel.Query(model[, reportName, reportForString, ...])
  - Queries the model for values.

topologicpy.EnergyModel.EnergyModel.ReportNames(model)
  - Returns the report names found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.RowNames(model, reportName, tableName)
  - Returns the list of row names given an OSM model, report name, and table name.

topologicpy.EnergyModel.EnergyModel.Run(model[, weatherFilePath, osBinaryPath, ...])
  - Runs an energy simulation.

topologicpy.EnergyModel.EnergyModel.SpaceColors(model)
  - Return the space colors found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.SpaceDictionaries(model)
  - Return the space dictionaries found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.SpaceTypeNames(model)
  - Return the space type names found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.SpaceTypes(model)
  - Return the space types found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.SqlFile(model)
  - Returns the SQL file found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.TableNames(model, reportName)
  - Returns the table names found in the input OSM model and report name.

topologicpy.EnergyModel.EnergyModel.Topologies(model[, tolerance])
  - Returns the topologies found in the input OSM model.

topologicpy.EnergyModel.EnergyModel.Units(model, reportName, tableName, columnName)
  - Returns the units for a specific column in a report and table within the input OSM model.
```