3676917429

Build Type

push

github-actions

Committed by Thomas Gläßle

Commit Message

Add documentation for building on linux+conda

Run Details

1045 of 1117 relevant lines covered (93.55%)

9.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.34

/src/cpymad/types.py

"""
Python type analogues for MAD-X data structures.
"""

from collections import namedtuple

__all__ = [
    'Constraint',
    'Parameter',
    'Range',

    'AlignError',
    'FieldError',
    'PhaseError',

    # constants:
    'PARAM_TYPE_LOGICAL',
    'PARAM_TYPE_INTEGER',
    'PARAM_TYPE_DOUBLE',
    'PARAM_TYPE_STRING',
    'PARAM_TYPE_CONSTRAINT',
    'PARAM_TYPE_LOGICAL_ARRAY',
    'PARAM_TYPE_INTEGER_ARRAY',
    'PARAM_TYPE_DOUBLE_ARRAY',
    'PARAM_TYPE_STRING_ARRAY',
    'VAR_TYPE_CONST',
    'VAR_TYPE_DIRECT',
    'VAR_TYPE_DEFERRED',
    'VAR_TYPE_STRING',
]


PARAM_TYPE_LOGICAL       = 0
PARAM_TYPE_INTEGER       = 1
PARAM_TYPE_DOUBLE        = 2
PARAM_TYPE_STRING        = 3
PARAM_TYPE_CONSTRAINT    = 4
PARAM_TYPE_LOGICAL_ARRAY = 10
PARAM_TYPE_INTEGER_ARRAY = 11
PARAM_TYPE_DOUBLE_ARRAY  = 12
PARAM_TYPE_STRING_ARRAY  = 13

VAR_TYPE_CONST    = 0
VAR_TYPE_DIRECT   = 1
VAR_TYPE_DEFERRED = 2
VAR_TYPE_STRING   = 3

dtype_to_native = {
    PARAM_TYPE_LOGICAL: bool,
    PARAM_TYPE_INTEGER: int,
    PARAM_TYPE_DOUBLE: float,
    PARAM_TYPE_STRING: str,
    PARAM_TYPE_LOGICAL_ARRAY: list,
    PARAM_TYPE_INTEGER_ARRAY: list,
    PARAM_TYPE_DOUBLE_ARRAY: list,
    PARAM_TYPE_STRING_ARRAY: list,
}


Range = namedtuple('Range', ['first', 'last'])

AlignError = namedtuple('AlignError', [
    'dx', 'dy', 'ds',
    'dphi', 'dtheta', 'dpsi',
    'mrex', 'mrey', 'mredx', 'mredy',
    'arex', 'arey', 'mscalx', 'mscaly',
])
FieldError = namedtuple('FieldError', ['dkn', 'dks'])
PhaseError = namedtuple('PhaseError', ['dpn', 'dps'])


class Parameter:

    __slots__ = ('name', 'value', 'expr', 'dtype', 'inform', 'var_type')

    def __init__(self, name, value, expr, dtype, inform, var_type=None):
        self.name = name
        self.value = value
        self.expr = expr
        self.dtype = dtype
        self.inform = inform
        if var_type is None:
            if isinstance(value, str):
                var_type = VAR_TYPE_STRING
            else:
                has_expr = expr and (not isinstance(value, list) or any(expr))
                var_type = VAR_TYPE_DEFERRED if has_expr else VAR_TYPE_DIRECT
        self.var_type = var_type

    def __call__(self):
        return self.definition

    @property
    def definition(self):
        """Return command argument as should be used for MAD-X input to
        create an identical element."""
        if isinstance(self.value, list):
            return [e or v for v, e in zip(self.value, self.expr)]
        else:
            return self.expr or self.value

    def __str__(self):
        return str(self.definition)


class Constraint:

    """Represents a MAD-X constraint, which has either min/max/both/value."""

    def __init__(self, val=None, min=None, max=None):
        """Just store the values"""
        self.val = val
        self.min = min
        self.max = max

1	"""
2	Python type analogues for MAD-X data structures.
3	"""
4
5	from collections import namedtuple	10✔
6
7	__all__ = [	10✔
8	'Constraint',
9	'Parameter',
10	'Range',
11
12	'AlignError',
13	'FieldError',
14	'PhaseError',
15
16	# constants:
17	'PARAM_TYPE_LOGICAL',
18	'PARAM_TYPE_INTEGER',
19	'PARAM_TYPE_DOUBLE',
20	'PARAM_TYPE_STRING',
21	'PARAM_TYPE_CONSTRAINT',
22	'PARAM_TYPE_LOGICAL_ARRAY',
23	'PARAM_TYPE_INTEGER_ARRAY',
24	'PARAM_TYPE_DOUBLE_ARRAY',
25	'PARAM_TYPE_STRING_ARRAY',
26	'VAR_TYPE_CONST',
27	'VAR_TYPE_DIRECT',
28	'VAR_TYPE_DEFERRED',
29	'VAR_TYPE_STRING',
30	]
31
32
33	PARAM_TYPE_LOGICAL = 0	10✔
34	PARAM_TYPE_INTEGER = 1	10✔
35	PARAM_TYPE_DOUBLE = 2	10✔
36	PARAM_TYPE_STRING = 3	10✔
37	PARAM_TYPE_CONSTRAINT = 4	10✔
38	PARAM_TYPE_LOGICAL_ARRAY = 10	10✔
39	PARAM_TYPE_INTEGER_ARRAY = 11	10✔
40	PARAM_TYPE_DOUBLE_ARRAY = 12	10✔
41	PARAM_TYPE_STRING_ARRAY = 13	10✔
42
43	VAR_TYPE_CONST = 0	10✔
44	VAR_TYPE_DIRECT = 1	10✔
45	VAR_TYPE_DEFERRED = 2	10✔
46	VAR_TYPE_STRING = 3	10✔
47
48	dtype_to_native = {	10✔
49	PARAM_TYPE_LOGICAL: bool,
50	PARAM_TYPE_INTEGER: int,
51	PARAM_TYPE_DOUBLE: float,
52	PARAM_TYPE_STRING: str,
53	PARAM_TYPE_LOGICAL_ARRAY: list,
54	PARAM_TYPE_INTEGER_ARRAY: list,
55	PARAM_TYPE_DOUBLE_ARRAY: list,
56	PARAM_TYPE_STRING_ARRAY: list,
57	}
58
59
60	Range = namedtuple('Range', ['first', 'last'])	10✔
61
62	AlignError = namedtuple('AlignError', [	10✔
63	'dx', 'dy', 'ds',
64	'dphi', 'dtheta', 'dpsi',
65	'mrex', 'mrey', 'mredx', 'mredy',
66	'arex', 'arey', 'mscalx', 'mscaly',
67	])
68	FieldError = namedtuple('FieldError', ['dkn', 'dks'])	10✔
69	PhaseError = namedtuple('PhaseError', ['dpn', 'dps'])	10✔
70
71
72	class Parameter:	10✔
73
74	__slots__ = ('name', 'value', 'expr', 'dtype', 'inform', 'var_type')	10✔
75
76	def __init__(self, name, value, expr, dtype, inform, var_type=None):	10✔
77	self.name = name	×
78	self.value = value	×
79	self.expr = expr	×
80	self.dtype = dtype	×
81	self.inform = inform	×
82	if var_type is None:	×
83	if isinstance(value, str):	×
84	var_type = VAR_TYPE_STRING	×
85	else:
86	has_expr = expr and (not isinstance(value, list) or any(expr))	×
87	var_type = VAR_TYPE_DEFERRED if has_expr else VAR_TYPE_DIRECT	×
88	self.var_type = var_type	×
89
90	def __call__(self):	10✔
91	return self.definition	×
92
93	@property	10✔
94	def definition(self):	6✔
95	"""Return command argument as should be used for MAD-X input to
96	create an identical element."""
97	if isinstance(self.value, list):	10✔
98	return [e or v for v, e in zip(self.value, self.expr)]	10✔
99	else:
100	return self.expr or self.value	10✔
101
102	def __str__(self):	10✔
103	return str(self.definition)	×
104
105
106	class Constraint:	10✔
107
108	"""Represents a MAD-X constraint, which has either min/max/both/value."""
109
110	def __init__(self, val=None, min=None, max=None):	10✔
111	"""Just store the values"""
112	self.val = val	10✔
113	self.min = min	10✔
114	self.max = max	10✔

hibtc / cpymad / 3676917429

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous