1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
# Copyright 2006-2007 Nanorex, Inc. See LICENSE file for details.
"""
basic.py -- define things to be imported by every module in this package (using import *)
$Id$
"""
# Import order issues --
# This module basic gets imported first, and it will be imported at the beginning of most modules.
# But it wants to define things of general interest to all modules.
#
# This can lead to recursive import problems. Here is how we will resolve them:
# - If a high-level def should be included here, import it last.
# Then when it imports basic, it will find what it needs already defined in basic.
# - When we import several high-level defs, they should be lowest-level first; higher ones will find lower ones
# defined in basic when they import it, but not vice versa (but they shouldn't need to find them).
# - When we import symbols like Expr or define symbols like Arg, also do this in order of level, in terms of import dependency.
#
# Note that this means we can't put all our import statements first --
# we have to interleave them with local defs, based on level.
#
# Specific problems:
# - ExprsMeta knows about special cases for some symbols defined in modules which have to import ExprsMeta for its metaclass.
# Solution: ExprsMeta should only import those special-case symbols at runtime.
# (And it should do so using reload_once, so their own modules can support runtime reload.)
#
# Approximate order of imports:
# - Python and debug utilities (especially the ones needed by ExprsMeta), including those defined outside this exprs package
# - ExprsMeta (needed as a metaclass by many classes we'll define)
# - abstract classes like Expr and InstanceOrExpr
# - widget classes, in order of lowest to highest level (most of them don't need to be imported by this module at all)
# == imports from python itself
import sys, os
from Numeric import dot
sys.setrecursionlimit(650) # 5000 is set in startup_funcs.py; this will ease debugging, but REMOVE WHEN DEVEL IS DONE [061121]
# == imports from cad/src
from geometry.VQT import V, A, Q, norm, vlen, cross
from math import sqrt #070225
from math import pi, sin, cos #070130
from foundation.state_utils import transclose, same_vals
## not yet needed: from state_utils import _UNSET_ # warning: not included in "import *"
from utilities.constants import noop # def noop(*args,**kws): pass
from utilities.debug import print_compact_traceback, print_compact_stack, safe_repr
from utilities.debug_prefs import debug_pref, Choice_boolean_False, Choice_boolean_True, Choice #070228
# consider also doing: import env as global_env [070313 suggestion]
# == OpenGL imports -- for now, individual modules import things from submodules of OpenGL as needed; this might be revised
from exprs.reload import reload_once
# == low-level imports from this exprs package
import exprs.py_utils
reload_once(exprs.py_utils)
#from py_utils import * # includes printnim, identity, seen_before
from exprs.intern_ipath import intern_ipath # (it doesn't make sense to try to autoreload this module -- ###e it should say so in some attr)
# == ExprsMeta #e and whatever it requires
#from ExprsMeta import * ###e can this support autoreload?? ###e note -- this imports a few other modules - list those here ##doc
from exprs.__Symbols__ import _self, _my # (__Symbols__ module doesn't support reload) # warning: not included in "import *"
# _this is imported below from somewhere else -- since it's not a Symbol! Maybe __Symbols__ should warn if we ask for it. #e
from exprs.__Symbols__ import _app # not included in import * [070108 in test.py, moved here 070122]
# == fundamental defs
import exprs.Exprs
reload_once(exprs.Exprs) # doesn't support reload, for now, so this is a noop
#from Exprs import * # Expr, lots of predicates and subclasses
import exprs.StatePlace
reload_once(exprs.StatePlace)
from exprs.StatePlace import StatePlace, set_default_attrs # revised 061203, and moved before instance_helpers & If_expr
import exprs.attr_decl_macros
reload_once(exprs.attr_decl_macros)
#from attr_decl_macros import * # Instance, Arg, Option, ArgOrOption, State, etc
import exprs.instance_helpers
reload_once(exprs.instance_helpers)
from exprs.instance_helpers import InstanceOrExpr, DelegatingMixin, DelegatingInstanceOrExpr, InstanceMacro
from exprs.instance_helpers import _this, ModelObject, WithModelType, WithAttributes
import exprs.If_expr # 061128
reload_once(exprs.If_expr)
#from If_expr import *
##import staterefs
##reload_once(staterefs)
##from staterefs import *
import exprs.iterator_exprs # 070302
reload_once(exprs.iterator_exprs)
#from iterator_exprs import *
# === higher-level defs, common enough to import for everything
import widget2d
reload_once(widget2d)
from widget2d import Widget, Widget2D
# == higher-level stubs
# stub types which are also defined as classes in other files
import Set
reload_once(Set)
from Set import Action # import added 070115
###k hmm, is the Set module name a conflict with the proposal for class Set to be imported in this file, basic.py?
import statearray
reload_once(statearray)
from statearray import StateArray, StateArrayRefs
# layout prims and the like (but for the most part, layout prims probably won't be defined in basic.py at all)
# [none at the moment]
# == end
|
