### Install openmatrix Package

Source: https://context7.com/osplanning/omx-python/llms.txt

Install the openmatrix library using pip. This command is used for setting up the environment.

```bash
pip install openmatrix
```

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

### GET /version

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Returns the OMX file format version.

```APIDOC
## GET /version

### Description
Return the OMX file format of this OMX file, embedded in the OMX_VERSION file attribute.

### Method
GET

### Response
#### Success Response (200)
- **version** (string/null) - The version string or None if not set.
```

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

### Complete Workflow: Create, Read, and Analyze OMX File

Source: https://context7.com/osplanning/omx-python/llms.txt

This example demonstrates the end-to-end workflow of creating an OMX file with multiple trip matrices, setting attributes, creating zone mappings, and then reading and analyzing the data. It covers matrix creation, attribute assignment, zone mapping, summing trips by period, accessing specific OD pairs, and exporting a matrix to a NumPy array.

```python
import openmatrix as omx
import numpy as np

# === CREATE FILE WITH TRIP MATRICES ===
print("Creating trip matrices...")
myfile = omx.open_file('model_output.omx', 'w', shape=(100, 100))

# Generate synthetic trip data
np.random.seed(42)
for period in ['am', 'md', 'pm']:
    for mode in ['auto', 'transit', 'walk']:
        matrix_name = f'{period}_{mode}'
        trips = np.random.exponential(scale=10, size=(100, 100))
        myfile[matrix_name] = trips

        # Set attributes
        myfile[matrix_name].attrs.timeperiod = period
        myfile[matrix_name].attrs.mode = mode
        myfile[matrix_name].attrs.units = 'person_trips'

# Create zone mapping (TAZ 1001-1100)
taz_ids = np.arange(1001, 1101)
myfile.create_mapping('taz', taz_ids)

myfile.close()
print(f"Created file with {len(myfile.list_matrices())} matrices")

# === READ AND ANALYZE ===
print("\nAnalyzing trips...")
myfile = omx.open_file('model_output.omx', 'r')

# Get mapping for zone-based access
taz = myfile.mapping('taz')

# Sum trips by time period
for period in ['am', 'md', 'pm']:
    period_matrices = myfile[{'timeperiod': period}]
    total = sum(np.sum(m) for m in period_matrices)
    print(f'{period.upper()} total trips: {total:,.0f}')

# Get trips between specific zones
origin_taz, dest_taz = 1050, 1075
auto_trips = myfile['am_auto'][taz[origin_taz]][taz[dest_taz]]
print(f'\nAM auto trips from TAZ {origin_taz} to {dest_taz}: {auto_trips:.1f}')

# Export matrix to numpy for further analysis
am_auto_array = np.array(myfile['am_auto'])
print(f'Max AM auto trips in any cell: {am_auto_array.max():.1f}')

myfile.close()
```

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

### Create Matrices with Explicit Parameters

Source: https://context7.com/osplanning/omx-python/llms.txt

Provides examples for creating matrices from existing arrays, defining empty matrices with specific types, and applying compression filters.

```python
import openmatrix as omx
import numpy as np
import tables

myfile = omx.open_file('custom.omx', 'w')

# Create from existing numpy array (recommended)
data = np.random.rand(500, 500).astype(np.float32)
myfile.create_matrix('distances', obj=data, title='Zone-to-zone distances in miles')

# Create empty matrix with specific type and shape
myfile.create_matrix(
    name='counts',
    atom=tables.Int32Atom(),
    shape=(500, 500),
    title='Trip counts',
    attrs={'units': 'trips', 'year': 2024}
)

# Fill the empty matrix
myfile['counts'][:] = np.zeros((500, 500), dtype=np.int32)

# Create with custom compression
custom_filters = tables.Filters(complevel=9, complib='zlib', shuffle=True)
myfile.create_matrix(
    name='compressed',
    obj=np.ones((500, 500)),
    filters=custom_filters
)

myfile.close()
```

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

### GET /list_matrices

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Lists all matrix names stored in the file.

```APIDOC
## GET /list_matrices

### Description
List the matrix names in this File.

### Method
GET

### Response
#### Success Response (200)
- **matrices** (list) - List of all matrix names stored in this OMX file.
```

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

### GET /mapping

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Returns a dictionary of key-value pairs for a specified mapping.

```APIDOC
## GET /mapping

### Description
Return dict containing key:value pairs for specified mapping. Keys represent the map item and value represents the array offset.

### Method
GET

### Parameters
#### Query Parameters
- **title** (string) - Required - Name of the mapping to be returned.

### Response
#### Success Response (200)
- **mapping** (dict) - Dictionary where each key is the map item, and the value represents the array offset.

### Errors
- **LookupError** - Thrown if the specified mapping does not exist.
```

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

### GET /shape

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Retrieves the dimensions of the matrices in the file.

```APIDOC
## GET /shape

### Description
Get the one and only shape of all matrices in this File.

### Method
GET

### Response
#### Success Response (200)
- **shape** (tuple) - Tuple of (rows, columns) for this matrix and file.
```

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

### GET /list_mappings

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Lists all mapping names stored in the file.

```APIDOC
## GET /list_mappings

### Description
List all mappings in this file. Mappings are stored internally in the 'lookup' subset of the HDF5 file structure.

### Method
GET

### Response
#### Success Response (200)
- **mappings** (list) - List of the names of all mappings in the OMX file.
```

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

### GET /map_entries

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Returns a list of entries for a specified mapping.

```APIDOC
## GET /map_entries

### Description
Return a list of entries for the specified mapping.

### Method
GET

### Parameters
#### Query Parameters
- **title** (string) - Required - Name of the mapping.

### Response
#### Success Response (200)
- **entries** (list) - List of entries for the specified mapping.

### Errors
- **LookupError** - Thrown if the specified mapping does not exist.
```

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

### Validate an OMX File

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Use the command-line tool 'omx-validate' to check an OMX file against the specification. This tool is added to the system PATH upon installation.

```bash
omx-validate my_file.omx
```

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

### GET /list_all_attributes

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Retrieves a set of all attribute names used across any matrix in the file.

```APIDOC
## GET /list_all_attributes

### Description
Return set of all attributes used for any Matrix in this File.

### Method
GET

### Response
#### Success Response (200)
- **all_attributes** (set) - The combined set of all attribute names that exist on any matrix in this file.
```

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

### Open and Create OMX Files

Source: https://context7.com/osplanning/omx-python/llms.txt

Use `open_file` to create new or open existing OMX files. Specify mode ('w', 'r', 'a') and optionally enforce a consistent shape for all matrices within the file.

```python
import openmatrix as omx
import numpy as np

# Create a new OMX file (overwrites existing)
myfile = omx.open_file('trips.omx', 'w')

# Create with specific shape enforcement (all matrices must match)
myfile = omx.open_file('trips.omx', 'w', shape=(1000, 1000))

# Open existing file for reading only
myfile = omx.open_file('trips.omx', 'r')

# Open existing file for reading and writing (append mode)
myfile = omx.open_file('trips.omx', 'a')

# Always close when done
myfile.close()
```

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

### Create and Write to an OMX File

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Demonstrates creating a new OMX file in write mode ('w') and populating it with NumPy arrays. Use append mode ('a') to edit an existing file.

```python
# Create some data
ones = np.ones((100,100))
twos = 2.0*ones

# Create an OMX file (will overwrite existing file!)
print('Creating myfile.omx')
myfile = omx.open_file('myfile.omx','w')   # use 'a' to append/edit an existing file

# Write to the file.
myfile['m1'] = ones
myfile['m2'] = twos
myfile['m3'] = ones + twos           # numpy array math is fast
myfile.close()
```

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

### Manage Zone Mappings

Source: https://context7.com/osplanning/omx-python/llms.txt

Shows how to create, list, and use zone mappings to translate external identifiers to internal array offsets.

```python
import openmatrix as omx
import numpy as np

myfile = omx.open_file('trips.omx', 'a')

# Create zone mapping (TAZ numbers 1-100 map to offsets 0-99)
taz_numbers = np.arange(1, 101)  # [1, 2, 3, ..., 100]
myfile.create_mapping('taz', taz_numbers)

# Create mapping with gaps (zones 100, 200, 300, ..., 10000)
zone_ids = np.arange(100, 10001, 100)  # [100, 200, 300, ..., 10000]
myfile.create_mapping('zone_id', zone_ids)

# List available mappings
print(myfile.list_mappings())  # ['taz', 'zone_id']

# Get mapping dictionary (zone_number -> array_offset)
taz_lookup = myfile.mapping('taz')  # {1: 0, 2: 1, 3: 2, ..., 100: 99}

# Use mapping to access cells by zone number instead of offset
matrix = myfile['am_auto']
origin_zone = 50
dest_zone = 75
trips = matrix[taz_lookup[origin_zone]][taz_lookup[dest_zone]]
print(f'Trips from zone {origin_zone} to {dest_zone}: {trips}')

# Get reverse mapping (offset -> zone_number)
entries = myfile.map_entries('taz')  # [1, 2, 3, ..., 100]
print(f'Zone at offset 0: {entries[0]}')  # 1

# Overwrite existing mapping
new_zones = np.arange(1001, 1101)
myfile.create_mapping('taz', new_zones, overwrite=True)

# Delete a mapping
myfile.delete_mapping('zone_id')

myfile.close()
```

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

### Access File Metadata and Version Information

Source: https://context7.com/osplanning/omx-python/llms.txt

Demonstrates how to retrieve file-level attributes, matrix counts, and iterate through matrix objects.

```python
import openmatrix as omx

myfile = omx.open_file('trips.omx', 'r')

# File version information
print(f'OMX file format version: {myfile.version()}')  # b'0.2'

# Global shape (all matrices share this)
print(f'Matrix shape: {myfile.shape()}')  # (100, 100)

# Number of matrices
print(f'Matrix count: {len(myfile)}')  # 4

# List all matrix names
print(f'Matrices: {myfile.list_matrices()}')  # ['am_auto', 'am_transit', ...]

# List all mappings
print(f'Mappings: {myfile.list_mappings()}')  # ['taz']

# List all attributes across matrices
print(f'Attributes: {myfile.list_all_attributes()}')  # ['mode', 'timeperiod', ...]

# Check if matrix exists
if 'am_auto' in myfile:
    print('Matrix am_auto exists')

# Iterate through all matrices
for matrix in myfile:
    print(f'{matrix.name}: {matrix.shape}, dtype={matrix.dtype}')

myfile.close()
```

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

### Select OMX Matrices Using Attributes

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Demonstrates selecting matrices from an OMX file using dictionaries of attributes. This allows for flexible querying based on metadata.

```python
# Use a DICT to select matrices via attributes:

all_am_trips = myfile[ {'timeperiod':'am'} ]                    # [m1,m3]
all_hwy_trips = myfile[ {'mode':'hwy'} ]                        # [m1]
all_am_trn_trips = myfile[ {'mode':'trn','timeperiod':'am'} ]   # [m3]

print('sum of some tables:', np.sum(all_am_trips))
```

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

### Filter and Aggregate Matrices

Source: https://context7.com/osplanning/omx-python/llms.txt

Demonstrates how to filter matrices by attributes using dictionary-style access and perform aggregation operations.

```python
am_matrices = myfile[{'timeperiod': 'am'}]           # [am_auto, am_transit]
auto_matrices = myfile[{'mode': 'auto'}]             # [am_auto, pm_auto]

# Filter by multiple attributes (AND logic)
am_auto = myfile[{'timeperiod': 'am', 'mode': 'auto'}]  # [am_auto]

# Sum all matching matrices
total_am_trips = np.sum([np.array(m) for m in am_matrices])
print(f'Total AM trips: {total_am_trips}')

# Iterate through filtered results
for matrix in myfile[{'mode': 'transit'}]:
    print(f'Transit matrix sum: {np.sum(matrix)}')

myfile.close()
```

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

### Validate OMX Files via Command Line

Source: https://context7.com/osplanning/omx-python/llms.txt

Demonstrates the use of the omx-validate utility to check file compliance with the OMX specification.

```bash
# Validate an OMX file from command line
omx-validate trips.omx

# Output shows validation checks:
# Check 1: Has OMX_VERSION attribute set to 0.2
# Check 2: Has SHAPE array attribute set to two item integer array
# Check 3: Has data group for matrices
# Check 4: Matrix shape matches file shape
```

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

### Import OpenMatrix Library

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Import the OpenMatrix library as 'omx' in your Python scripts. Do not use 'import omx'.

```python
from __future__ import print_function
import openmatrix as omx
import numpy as np
```

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

### File Object Methods

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Provides methods for managing data within an opened OMX file, including creating mappings and matrices, and deleting mappings.

```APIDOC
## File Object Methods

### create_mapping

#### Description
Create an equivalency index, which maps a raw data dimension to another integer value. Once created, mappings can be referenced by offset or by key.

#### Parameters
- **title** (string) - Required - Name of this mapping
- **entries** (list) - Required - List of n equivalencies for the mapping. n must match one data dimension of the matrix.
- **overwrite** (boolean) - Optional - True to allow overwriting an existing mapping, False will raise a LookupError if the mapping already exists. Default is False.

#### Returns
- **mapping** (tables.array) - Returns the created mapping.

#### Raises
- **LookupError** - if the mapping exists and overwrite=False

### create_matrix

#### Description
Create an OMX Matrix (CArray) at the root level. User must pass in either an existing numpy matrix, or a shape and an atom type.

#### Parameters
- **name** (string) - Required - The name of this matrix. Stored in HDF5 as the leaf name.
- **title** (string) - Optional - Short description of this matrix. Default is ''.
- **obj** (numpy.CArray) - Optional - Existing numpy array from which to create this OMX matrix. If obj is passed in, then shape and atom can be left blank. Default is None.
- **shape** (numpy.array) - Optional - Shape of the matrix. Shape is an int32 numpy array of format (rows,columns). If shape is not specified, an existing numpy CArray must be passed in instead, as the 'obj' parameter. Default is None.
- **atom** (atom_type) - Optional - Atom type of the data. Can be int32, float32, etc. Default is None. If None specified, then obj parameter must be passed in instead.
- **filters** (tables.Filters) - Optional - Set of HDF5 filters (compression, etc) used for creating the matrix. Default is None.
- **attrs** (dict) - Optional - Dictionary of attribute names and values to be attached to this matrix. Default is None.

#### Returns
- **matrix** (tables.carray) - HDF5 CArray matrix

### delete_mapping

#### Description
Remove a mapping.

#### Parameters
- **title** (string) - Required - The title of the mapping to remove.

#### Raises
- **LookupError** - if the specified mapping does not exist.
```

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

### Run OMX Tests with Nose

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Execute the project's tests using the 'nose' test runner. Navigate to the 'openmatrix\test' directory before running the command.

```bash
openmatrix\test> nosetests -v
```

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

### Open File

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Opens an existing OMX file or creates a new one. Supports various modes for reading, writing, and appending, along with options for file title, filters, and shape enforcement.

```APIDOC
## open_file

### Description
Open or create a new OMX file. New files will be created with default zlib compression enabled.

### Parameters
#### Path Parameters
- **filename** (string) - Required - Name or path and name of file
- **mode** (string) - Optional - 'r' for read-only; 'w' to write (erases existing file); 'a' to read/write an existing file (will create it if doesn't exist). Ignored in read-only mode. Default is 'r'.
- **title** (string) - Optional - Short description of this file, used when creating the file. Default is ''. Ignored in read-only mode.
- **filters** (tables.Filters) - Optional - HDF5 default filter options for compression, shuffling, etc. Default for OMX standard file format is: zlib compression level 1, and shuffle=True. 'None' will create enormous uncompressed files.
- **shape** (numpy.array) - Optional - Shape of matrices in this file. Default is None. Specify a valid shape (e.g. (1200,1200)) to enforce shape-checking for all added objects.

### Returns
- **f** (openmatrix.File) - The file object for reading and writing.
```

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

### Retrieve Matrices by Tags

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Look up matrices by passing a tuple of tags to the dictionary-style lookup; returns a list of matching matrices.

```python
list_all_hwy_skims = mybigfile[ ('skims','hwy') ]
```

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

### Read and Inspect an OMX File

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Opens an existing OMX file in read-only mode and displays its shape, number of tables, and table names. Note that OMX objects cannot be modified directly; create a new NumPy array for modifications.

```python
# Open an OMX file for reading only
print('Reading myfile.omx')
myfile = omx.open_file('myfile.omx')

print ('Shape:', myfile.shape())                 # (100,100)
print ('Number of tables:', len(myfile))         # 3
print ('Table names:', myfile.list_matrices())   # ['m1','m2',',m3']

# Work with data. Pass a string to select matrix by name:
# -------------------------------------------------------
m1 = myfile['m1']
m2 = myfile['m2']
m3 = myfile['m3']

# halves = m1 * 0.5  # CRASH!  Don't modify an OMX object directly.
#                    # Create a new numpy array, and then edit it.
halves = np.array(m1) * 0.5

first_row = m2[0]
first_row[:] = 0.5 * first_row[:]

my_very_special_zone_value = m2[10][25]

myfile.close()
```

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

### Create and Use TAZ Mapping in OMX

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Shows how to create a mapping (e.g., for TAZ numbers) in an OMX file to translate zone numbers to matrix indices. This mapping can then be used to access specific cells.

```python
# SUPER FANCY: Create a mapping to use TAZ numbers instead of matrix offsets
# --------------------------------------------------------------------------
# (any mapping would work, such as a mapping with large gaps between zone
#  numbers. For this simple case we'll just assume TAZ numbers are 1-100.)

taz_equivs = np.arange(1,101)                  # 1-100 inclusive

myfile.create_mapping('taz', taz_equivs)
print('mappings:', myfile.list_mappings()) # ['taz']

tazs = myfile.mapping('taz') # Returns a dict:  {1:0, 2:1, 3:2, ..., 100:99}
m3 = myfile['m3']
print('cell value:', m3[tazs[100]][tazs[100]]) # 3.0  (taz (100,100) is cell [99][99])

myfile.close()
```

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

### Write Data to OMX File

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Use dictionary syntax to write a numpy array to an OMX file, which automatically triggers matrix creation.

```python
myfile['matrixname'] = mynumpyobject
```

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

### Perform Matrix Math

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Access matrix objects using dictionary or PyTables path syntax to perform standard numpy operations.

```python
myfile['biketime'][0][0] = 0.60 * myfile['bikedist'][0][0]
total_trips = numpy.sum(myfile.root.trips)
```

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

### Delete Matrices

Source: https://context7.com/osplanning/omx-python/llms.txt

Shows how to remove matrices from an OMX file using standard Python dictionary deletion syntax.

```python
import openmatrix as omx

myfile = omx.open_file('trips.omx', 'a')

# Check existing matrices
print('Before:', myfile.list_matrices())  # ['am_auto', 'am_transit', 'pm_auto', 'pm_transit', 'total']

# Delete single matrix
del myfile['total']

# Delete multiple matrices
for name in ['pm_auto', 'pm_transit']:
    if name in myfile:
        del myfile[name]

print('After:', myfile.list_matrices())  # ['am_auto', 'am_transit']

myfile.close()
```

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

### Write Matrices to OMX File

Source: https://context7.com/osplanning/omx-python/llms.txt

Write numpy arrays as matrices to an OMX file using dictionary-style assignment. Ensure all matrices share the same dimensions. NumPy array math can be used directly before assignment.

```python
import openmatrix as omx
import numpy as np

# Create sample data
auto_trips = np.random.rand(100, 100) * 1000
transit_trips = np.random.rand(100, 100) * 500
walk_trips = np.random.rand(100, 100) * 200

# Create file and write matrices
myfile = omx.open_file('trips.omx', 'w')

# Dictionary-style assignment (recommended)
myfile['auto'] = auto_trips
myfile['transit'] = transit_trips
myfile['walk'] = walk_trips

# NumPy array math works directly
myfile['total'] = auto_trips + transit_trips + walk_trips

myfile.close()

# Expected: File contains 4 matrices, each 100x100
```

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

### Run Validation Checks with Python

Source: https://context7.com/osplanning/omx-python/llms.txt

Use the `run_checks` function from the `openmatrix.validator` module to programmatically validate an OMX file. This function prints detailed check results and an overall status.

```python
from openmatrix.validator import run_checks

# Validate file and print results
run_checks('trips.omx')
```

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

### Read Matrices from OMX File

Source: https://context7.com/osplanning/omx-python/llms.txt

Access matrices from an OMX file using dictionary-style lookup. Returned objects are HDF5 CArrays supporting NumPy indexing. Create a NumPy copy before modifying data to avoid crashes.

```python
import openmatrix as omx
import numpy as np

myfile = omx.open_file('trips.omx', 'r')

# Get file metadata
print('Shape:', myfile.shape())                    # (100, 100)
print('Number of matrices:', len(myfile))          # 4
print('Matrix names:', myfile.list_matrices())     # ['auto', 'transit', 'walk', 'total']

# Access matrix by name
auto = myfile['auto']
transit = myfile['transit']

# Access specific cells and rows
first_row = auto[0]                    # First row (100 elements)
cell_value = auto[10][25]              # Single cell at row 10, col 25
subset = auto[0:10, 0:10]              # 10x10 submatrix

# IMPORTANT: Create numpy copy before modifying
auto_copy = np.array(auto)             # Safe to modify
auto_scaled = auto_copy * 1.5          # Works correctly

# DO NOT modify OMX object directly:
# auto * 1.5  # This will CRASH

myfile.close()
```

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

### Add and Access Matrix Attributes

Source: https://context7.com/osplanning/omx-python/llms.txt

Assign custom key-value attributes to matrices for metadata. Attributes can be used later for filtering. Access attributes using dot notation on the matrix object's `.attrs`.

```python
import openmatrix as omx
import numpy as np

# Create file with matrices
myfile = omx.open_file('trips.omx', 'w')
myfile['am_auto'] = np.ones((100, 100))
myfile['am_transit'] = np.ones((100, 100)) * 2
myfile['pm_auto'] = np.ones((100, 100)) * 3
myfile['pm_transit'] = np.ones((100, 100)) * 4

# Set attributes on matrices
myfile['am_auto'].attrs.timeperiod = 'am'
myfile['am_auto'].attrs.mode = 'auto'
myfile['am_auto'].attrs.purpose = 'work'

myfile['am_transit'].attrs.timeperiod = 'am'
myfile['am_transit'].attrs.mode = 'transit'

myfile['pm_auto'].attrs.timeperiod = 'pm'
myfile['pm_auto'].attrs.mode = 'auto'

myfile['pm_transit'].attrs.timeperiod = 'pm'
myfile['pm_transit'].attrs.mode = 'transit'

# List all attributes used in file
print(myfile.list_all_attributes())  # ['mode', 'purpose', 'timeperiod']

# Access attributes
print(myfile['am_auto'].attrs.timeperiod)  # 'am'
print(myfile['am_auto'].attrs.mode)        # 'auto'

myfile.close()
```

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

### Filter Matrices by Attributes

Source: https://context7.com/osplanning/omx-python/llms.txt

Filter matrices within an OMX file by providing a dictionary of attribute names and values to the `open_file` function in append mode. This returns a list of matching matrix objects.

```python
import openmatrix as omx
import numpy as np

myfile = omx.open_file('trips.omx', 'a')
```

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

### Add Attributes to OMX Matrices

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Opens an OMX file in append mode ('a') to add attributes (like 'timeperiod' and 'mode') to matrices using the '.attrs' property. Attributes can be used to filter matrices.

```python
myfile.close()                            # was opened read-only, so let's reopen.
myfile = omx.open_file('myfile.omx','a')  # append mode: read/write existing file

myfile['m1'].attrs.timeperiod = 'am'
myfile['m1'].attrs.mode = 'hwy'

myfile['m2'].attrs.timeperiod = 'md'

myfile['m3'].attrs.timeperiod = 'am'
myfile['m3'].attrs.mode = 'trn'

print('attributes:', myfile.list_all_attributes())       # ['mode','timeperiod']
```

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

### Access Matrix Attributes

Source: https://github.com/osplanning/omx-python/blob/master/README.md

Retrieve matrix properties using the standard PyTables .attrs field.

```python
print mymatrix.attrs
print mymatrix.attrs.myfield
print mymatrix.attrs['myfield']
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.