Quantities with structured units

astropy/units/__init__.py

@@ -36,6 +36,7 @@
 from .function.core import *
 from .function.logarithmic import *
 
+from .structured import *
 from .decorators import *
 
 del bases

astropy/units/core.py

@@ -2052,6 +2052,10 @@ def __call__(self, s="", represents=None, format=None, namespace=None,
         elif isinstance(s, (int, float, np.floating, np.integer)):
             return CompositeUnit(s, [], [], _error_check=False)
 
+        elif isinstance(s, tuple):
+            from .structured import StructuredUnit
+            return StructuredUnit(s)
+
         elif s is None:
             raise TypeError("None is not a valid Unit")
 

astropy/units/format/generic.py

@@ -65,6 +65,7 @@ class Generic(Base):
     _show_scale = True
 
     _tokens = (
+        'COMMA',
         'DOUBLE_STAR',
         'STAR',
         'PERIOD',
@@ -107,6 +108,7 @@ def _lexer(cls):
     def _make_lexer(cls):
         tokens = cls._tokens
 
+        t_COMMA = r'\,'
         t_STAR = r'\*'
         t_PERIOD = r'\.'
         t_SOLIDUS = r'/'
@@ -178,7 +180,60 @@ def _make_parser(cls):
 
         def p_main(p):
             '''
-            main : product_of_units
+            main : unit
+                 | structured_unit
+                 | structured_subunit
+            '''
+            if isinstance(p[1], tuple):
+                # Unpack possible StructuredUnit inside a tuple, ie.,
+                # ignore any set of very outer parentheses.
+                p[0] = p[1][0]
+            else:
+                p[0] = p[1]
+
+        def p_structured_subunit(p):
+            '''
+            structured_subunit : OPEN_PAREN structured_unit CLOSE_PAREN
+            '''
+            # We hide a structured unit enclosed by parentheses inside
+            # a tuple, so that we can easily distinguish units like
+            # "(au, au/day), yr" from "au, au/day, yr".
+            p[0] = (p[2],)
+
+        def p_structured_unit(p):
+            '''
+            structured_unit : subunit COMMA
+                            | subunit COMMA subunit
+            '''
+            from ..structured import StructuredUnit
+            inputs = (p[1],) if len(p) == 3 else (p[1], p[3])
+            units = ()
+            for subunit in inputs:
+                if isinstance(subunit, tuple):
+                    # Structured unit that should be its own entry in the
+                    # new StructuredUnit (was enclosed in parentheses).
+                    units += subunit
+                elif isinstance(subunit, StructuredUnit):
+                    # Structured unit whose entries should be
+                    # individiually added to the new StructuredUnit.
+                    units += subunit.values()
+                else:
+                    # Regular unit to be added to the StructuredUnit.
+                    units += (subunit,)
+
+            p[0] = StructuredUnit(units)
+
+        def p_subunit(p):
+            '''
+            subunit : unit
+                    | structured_unit
+                    | structured_subunit
+            '''
+            p[0] = p[1]
+
+        def p_unit(p):
+            '''
+            unit : product_of_units
                  | factor product_of_units
                  | factor product product_of_units
                  | division_product_of_units

astropy/units/format/generic_lextab.py

@@ -11,11 +11,11 @@
 
 # generic_lextab.py. This file automatically created by PLY (version 3.11). Don't edit!
 _tabversion   = '3.10'
-_lextokens    = set(('CARET', 'CLOSE_PAREN', 'DOUBLE_STAR', 'FUNCNAME', 'OPEN_PAREN', 'PERIOD', 'SIGN', 'SOLIDUS', 'STAR', 'UFLOAT', 'UINT', 'UNIT'))
+_lextokens    = set(('CARET', 'CLOSE_PAREN', 'COMMA', 'DOUBLE_STAR', 'FUNCNAME', 'OPEN_PAREN', 'PERIOD', 'SIGN', 'SOLIDUS', 'STAR', 'UFLOAT', 'UINT', 'UNIT'))
 _lexreflags   = 32
 _lexliterals  = ''
 _lexstateinfo = {'INITIAL': 'inclusive'}
-_lexstatere   = {'INITIAL': [("(?P<t_UFLOAT>((\\d+\\.?\\d*)|(\\.\\d+))([eE][+-]?\\d+)?)|(?P<t_UINT>\\d+)|(?P<t_SIGN>[+-](?=\\d))|(?P<t_FUNCNAME>((sqrt)|(ln)|(exp)|(log)|(mag)|(dB)|(dex))(?=\\ *\\())|(?P<t_UNIT>%|([YZEPTGMkhdcmuµnpfazy]?'((?!\\d)\\w)+')|((?!\\d)\\w)+)|(?P<t_DOUBLE_STAR>\\*\\*)|(?P<t_STAR>\\*)|(?P<t_PERIOD>\\.)|(?P<t_CARET>\\^)|(?P<t_OPEN_PAREN>\\()|(?P<t_CLOSE_PAREN>\\))|(?P<t_SOLIDUS>/)", [None, ('t_UFLOAT', 'UFLOAT'), None, None, None, None, ('t_UINT', 'UINT'), ('t_SIGN', 'SIGN'), ('t_FUNCNAME', 'FUNCNAME'), None, None, None, None, None, None, None, None, ('t_UNIT', 'UNIT'), None, None, None, (None, 'DOUBLE_STAR'), (None, 'STAR'), (None, 'PERIOD'), (None, 'CARET'), (None, 'OPEN_PAREN'), (None, 'CLOSE_PAREN'), (None, 'SOLIDUS')])]}
+_lexstatere   = {'INITIAL': [("(?P<t_UFLOAT>((\\d+\\.?\\d*)|(\\.\\d+))([eE][+-]?\\d+)?)|(?P<t_UINT>\\d+)|(?P<t_SIGN>[+-](?=\\d))|(?P<t_FUNCNAME>((sqrt)|(ln)|(exp)|(log)|(mag)|(dB)|(dex))(?=\\ *\\())|(?P<t_UNIT>%|([YZEPTGMkhdcmuµnpfazy]?'((?!\\d)\\w)+')|((?!\\d)\\w)+)|(?P<t_DOUBLE_STAR>\\*\\*)|(?P<t_COMMA>\\,)|(?P<t_STAR>\\*)|(?P<t_PERIOD>\\.)|(?P<t_CARET>\\^)|(?P<t_OPEN_PAREN>\\()|(?P<t_CLOSE_PAREN>\\))|(?P<t_SOLIDUS>/)", [None, ('t_UFLOAT', 'UFLOAT'), None, None, None, None, ('t_UINT', 'UINT'), ('t_SIGN', 'SIGN'), ('t_FUNCNAME', 'FUNCNAME'), None, None, None, None, None, None, None, None, ('t_UNIT', 'UNIT'), None, None, None, (None, 'DOUBLE_STAR'), (None, 'COMMA'), (None, 'STAR'), (None, 'PERIOD'), (None, 'CARET'), (None, 'OPEN_PAREN'), (None, 'CLOSE_PAREN'), (None, 'SOLIDUS')])]}
 _lexstateignore = {'INITIAL': ' '}
 _lexstateerrorf = {'INITIAL': 't_error'}
 _lexstateeoff = {}