def __init__(self, args):
self.connect = Connect(args.lphost)
self.show = Format(args.output, self.config.debug)
self.task = args.task
self.data['task'] = args.task
self.data['userinput'] = args.parameter
self.file = args.file
self.lphost = args.lphost
def main():
#Get_Program()
Format()
EM_Waves_in_Geom_Calculus()
xpdf()
return
def main():
Get_Program()
Format()
EM_Waves_in_Geom_Calculus_Complex()
EM_Waves_in_Geom_Calculus_Real()
xpdf()
return
def main():
Get_Program(True)
Format()
basic_multivector_operations_3D()
basic_multivector_operations_2D()
xpdf('simple_test_latex.tex')
return
def main():
Get_Program()
Format()
Maxwells_Equations_in_Geometric_Calculus()
Dirac_Equation_in_Geometric_Calculus()
Lorentz_Tranformation_in_Geometric_Algebra()
xdvi()
return
def main():
Get_Program()
Format()
#Maxwells_Equations_in_Geom_Calculus()
#Dirac_Equation_in_Geom_Calculus()
#Lorentz_Tranformation_in_Geog_Algebra()
Lie_Group()
xpdf()
return
def main():
#Get_Program()
#Eprint()
Format()
derivatives_in_spherical_coordinates()
derivatives_in_paraboloidal_coordinates()
derivatives_in_elliptic_cylindrical_coordinates()
derivatives_in_prolate_spheroidal_coordinates()
#derivatives_in_oblate_spheroidal_coordinates()
#derivatives_in_bipolar_coordinates()
#derivatives_in_toroidal_coordinates()
xpdf()
return
def main():
Format()
a = Matrix(2, 2, (1, 2, 3, 4))
b = Matrix(2, 1, (5, 6))
c = a * b
print a, b, '=', c
x, y = symbols('x, y')
d = Matrix(1, 2, (x**3, y**3))
e = Matrix(2, 2, (x**2, 2 * x * y, 2 * x * y, y**2))
f = d * e
print '%', d, e, '=', f
xpdf()
return
def main():
Get_Program()
Format()
basic_multivector_operations_3D()
basic_multivector_operations_2D()
basic_multivector_operations_2D_orthogonal()
check_generalized_BAC_CAB_formulas()
rounding_numerical_components()
derivatives_in_rectangular_coordinates()
derivatives_in_spherical_coordinates()
noneuclidian_distance_calculation()
conformal_representations_of_circles_lines_spheres_and_planes()
properties_of_geometric_objects()
extracting_vectors_from_conformal_2_blade()
reciprocal_frame_test()
xpdf()
return
def main():
Format()
snr=1
g = '0 0 1 0 ,0 0 0 1 ,1 0 0 0 ,0 1 0 0'
sk4coords = (e1,e2,e3,e4) = symbols('e1 e2 e3 e4')
sk4 = Ga('e_1 e_2 e_3 e_4', g=g, coords=sk4coords)
(e1,e2,e3,e4) = sk4.mv()
print 'g_{ii} =',sk4.g
v = symbols('v', real=True)
x1=(e1+e3)/sqrt(2)
x2=(e2+e4)/sqrt(2)
print 'x_1<x_1==',x1<x1
print 'x_1<x_2==',x1<x2
print 'x_2<x_1==',x2<x1
print 'x_2<x_2==',x2<x2
print r'#$-\infty < v < \infty$'
print '(-v*(x_1^x_2)/2).exp()==',(-v*(x1^x2)/2).exp()
v = symbols('v', real=True, positive=True)
print r'#$0\le v < \infty$'
print '(-v*(x_1^x_2)/2).exp()==',(-v*(x1^x2)/2).exp()
xpdf()
return
def main():
Format()
(ex, ey, ez) = MV.setup('e*x|y|z')
A = MV('A', 'mv')
print(r'\bm{A} =', A)
A.Fmt(2, r'\bm{A}')
A.Fmt(3, r'\bm{A}')
X = (x, y, z) = symbols('x y z')
(ex, ey, ez, grad) = MV.setup('e_x e_y e_z', metric='[1,1,1]', coords=X)
f = MV('f', 'scalar', fct=True)
A = MV('A', 'vector', fct=True)
B = MV('B', 'grade2', fct=True)
print(r'\bm{A} =', A)
print(r'\bm{B} =', B)
print('grad*f =', grad * f)
print(r'grad|\bm{A} =', grad | A)
print(r'grad*\bm{A} =', grad * A)
print(r'-I*(grad^\bm{A}) =', -MV.I * (grad ^ A))
print(r'grad*\bm{B} =', grad * B)
print(r'grad^\bm{B} =', grad ^ B)
print(r'grad|\bm{B} =', grad | B)
(a, b, c, d) = MV.setup('a b c d')
print('g_{ij} =', MV.metric)
print('\\bm{a|(b*c)} =', a | (b * c))
print('\\bm{a|(b^c)} =', a | (b ^ c))
print('\\bm{a|(b^c^d)} =', a | (b ^ c ^ d))
print('\\bm{a|(b^c)+c|(a^b)+b|(c^a)} =',
(a | (b ^ c)) + (c | (a ^ b)) + (b | (c ^ a)))
print('\\bm{a*(b^c)-b*(a^c)+c*(a^b)} =',
a * (b ^ c) - b * (a ^ c) + c * (a ^ b))
print(
'\\bm{a*(b^c^d)-b*(a^c^d)+c*(a^b^d)-d*(a^b^c)} =',
a * (b ^ c ^ d) - b * (a ^ c ^ d) + c * (a ^ b ^ d) - d * (a ^ b ^ c))
print('\\bm{(a^b)|(c^d)} =', (a ^ b) | (c ^ d))
print('\\bm{((a^b)|c)|d} =', ((a ^ b) | c) | d)
print('\\bm{(a^b)\\times (c^d)} =', Com(a ^ b, c ^ d))
metric = '1 # #,'+ \
'# 1 #,'+ \
'# # 1'
(e1, e2, e3) = MV.setup('e1 e2 e3', metric)
E = e1 ^ e2 ^ e3
Esq = (E * E).scalar()
print('E =', E)
print('%E^{2} =', Esq)
Esq_inv = 1 / Esq
E1 = (e2 ^ e3) * E
E2 = (-1) * (e1 ^ e3) * E
E3 = (e1 ^ e2) * E
print('E1 = (e2^e3)*E =', E1)
print('E2 =-(e1^e3)*E =', E2)
print('E3 = (e1^e2)*E =', E3)
print('E1|e2 =', (E1 | e2).expand())
print('E1|e3 =', (E1 | e3).expand())
print('E2|e1 =', (E2 | e1).expand())
print('E2|e3 =', (E2 | e3).expand())
print('E3|e1 =', (E3 | e1).expand())
print('E3|e2 =', (E3 | e2).expand())
w = ((E1 | e1).expand()).scalar()
Esq = expand(Esq)
print('%(E1\\cdot e1)/E^{2} =', simplify(w / Esq))
w = ((E2 | e2).expand()).scalar()
print('%(E2\\cdot e2)/E^{2} =', simplify(w / Esq))
w = ((E3 | e3).expand()).scalar()
print('%(E3\\cdot e3)/E^{2} =', simplify(w / Esq))
X = (r, th, phi) = symbols('r theta phi')
curv = [[r * cos(phi) * sin(th), r * sin(phi) * sin(th), r * cos(th)],
[1, r, r * sin(th)]]
(er, eth, ephi, grad) = MV.setup('e_r e_theta e_phi',
metric='[1,1,1]',
coords=X,
curv=curv)
f = MV('f', 'scalar', fct=True)
A = MV('A', 'vector', fct=True)
B = MV('B', 'grade2', fct=True)
print('A =', A)
print('B =', B)
print('grad*f =', grad * f)
print('grad|A =', grad | A)
print('-I*(grad^A) =', -MV.I * (grad ^ A))
print('grad^B =', grad ^ B)
vars = symbols('t x y z')
(g0, g1, g2, g3, grad) = MV.setup('gamma*t|x|y|z',
metric='[1,-1,-1,-1]',
coords=vars)
I = MV.I
B = MV('B', 'vector', fct=True)
E = MV('E', 'vector', fct=True)
B.set_coef(1, 0, 0)
E.set_coef(1, 0, 0)
B *= g0
E *= g0
J = MV('J', 'vector', fct=True)
F = E + I * B
print('B = \\bm{B\\gamma_{t}} =', B)
print('E = \\bm{E\\gamma_{t}} =', E)
print('F = E+IB =', F)
print('J =', J)
gradF = grad * F
gradF.Fmt(3, 'grad*F')
print('grad*F = J')
(gradF.grade(1) - J).Fmt(3, '%\\grade{\\nabla F}_{1} -J = 0')
(gradF.grade(3)).Fmt(3, '%\\grade{\\nabla F}_{3} = 0')
(alpha, beta, gamma) = symbols('alpha beta gamma')
(x, t, xp, tp) = symbols("x t x' t'")
(g0, g1) = MV.setup('gamma*t|x', metric='[1,-1]')
R = cosh(alpha / 2) + sinh(alpha / 2) * (g0 ^ g1)
X = t * g0 + x * g1
Xp = tp * g0 + xp * g1
print('R =', R)
print(
r"#%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} = t'\bm{\gamma'_{t}}+x'\bm{\gamma'_{x}} = R\lp t'\bm{\gamma_{t}}+x'\bm{\gamma_{x}}\rp R^{\dagger}"
)
Xpp = R * Xp * R.rev()
Xpp = Xpp.collect()
Xpp = Xpp.subs({
2 * sinh(alpha / 2) * cosh(alpha / 2): sinh(alpha),
sinh(alpha / 2)**2 + cosh(alpha / 2)**2: cosh(alpha)
})
print(r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =", Xpp)
Xpp = Xpp.subs({sinh(alpha): gamma * beta, cosh(alpha): gamma})
print(r'%\f{\sinh}{\alpha} = \gamma\beta')
print(r'%\f{\cosh}{\alpha} = \gamma')
print(r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =", Xpp.collect())
vars = symbols('t x y z')
(g0, g1, g2, g3, grad) = MV.setup('gamma*t|x|y|z',
metric='[1,-1,-1,-1]',
coords=vars)
I = MV.I
(m, e) = symbols('m e')
psi = MV('psi', 'spinor', fct=True)
A = MV('A', 'vector', fct=True)
sig_z = g3 * g0
print('\\bm{A} =', A)
print('\\bm{\\psi} =', psi)
dirac_eq = (grad * psi) * I * sig_z - e * A * psi - m * psi * g0
dirac_eq.simplify()
dirac_eq.Fmt(
3,
r'\nabla \bm{\psi} I \sigma_{z}-e\bm{A}\bm{\psi}-m\bm{\psi}\gamma_{t} = 0'
)
xdvi()
return
def main():
Format()
(g3d,ex,ey,ez) = Ga.build('e*x|y|z')
A = g3d.mv('A','mv')
print r'\bm{A} =',A
A.Fmt(2,r'\bm{A}')
A.Fmt(3,r'\bm{A}')
X = (x,y,z) = symbols('x y z',real=True)
o3d = Ga('e_x e_y e_z',g=[1,1,1],coords=X)
(ex,ey,ez) = o3d.mv()
f = o3d.mv('f','scalar',f=True)
A = o3d.mv('A','vector',f=True)
B = o3d.mv('B','bivector',f=True)
print r'\bm{A} =',A
print r'\bm{B} =',B
print 'grad*f =',o3d.grad*f
print r'grad|\bm{A} =',o3d.grad|A
print r'grad*\bm{A} =',o3d.grad*A
print r'-I*(grad^\bm{A}) =',-o3d.i*(o3d.grad^A)
print r'grad*\bm{B} =',o3d.grad*B
print r'grad^\bm{B} =',o3d.grad^B
print r'grad|\bm{B} =',o3d.grad|B
g4d = Ga('a b c d')
(a,b,c,d) = g4d.mv()
print 'g_{ij} =',g4d.g
print '\\bm{a|(b*c)} =',a|(b*c)
print '\\bm{a|(b^c)} =',a|(b^c)
print '\\bm{a|(b^c^d)} =',a|(b^c^d)
print '\\bm{a|(b^c)+c|(a^b)+b|(c^a)} =',(a|(b^c))+(c|(a^b))+(b|(c^a))
print '\\bm{a*(b^c)-b*(a^c)+c*(a^b)} =',a*(b^c)-b*(a^c)+c*(a^b)
print '\\bm{a*(b^c^d)-b*(a^c^d)+c*(a^b^d)-d*(a^b^c)} =',a*(b^c^d)-b*(a^c^d)+c*(a^b^d)-d*(a^b^c)
print '\\bm{(a^b)|(c^d)} =',(a^b)|(c^d)
print '\\bm{((a^b)|c)|d} =',((a^b)|c)|d
print '\\bm{(a^b)\\times (c^d)} =',Com(a^b,c^d)
g = '1 # #,'+ \
'# 1 #,'+ \
'# # 1'
ng3d = Ga('e1 e2 e3',g=g)
(e1,e2,e3) = ng3d.mv()
E = e1^e2^e3
Esq = (E*E).scalar()
print 'E =',E
print '%E^{2} =',Esq
Esq_inv = 1/Esq
E1 = (e2^e3)*E
E2 = (-1)*(e1^e3)*E
E3 = (e1^e2)*E
print 'E1 = (e2^e3)*E =',E1
print 'E2 =-(e1^e3)*E =',E2
print 'E3 = (e1^e2)*E =',E3
print 'E1|e2 =',(E1|e2).expand()
print 'E1|e3 =',(E1|e3).expand()
print 'E2|e1 =',(E2|e1).expand()
print 'E2|e3 =',(E2|e3).expand()
print 'E3|e1 =',(E3|e1).expand()
print 'E3|e2 =',(E3|e2).expand()
w = ((E1|e1).expand()).scalar()
Esq = expand(Esq)
print '%(E1\\cdot e1)/E^{2} =',simplify(w/Esq)
w = ((E2|e2).expand()).scalar()
print '%(E2\\cdot e2)/E^{2} =',simplify(w/Esq)
w = ((E3|e3).expand()).scalar()
print '%(E3\\cdot e3)/E^{2} =',simplify(w/Esq)
X = (r,th,phi) = symbols('r theta phi')
s3d = Ga('e_r e_theta e_phi',g=[1,r**2,r**2*sin(th)**2],coords=X,norm=True)
(er,eth,ephi) = s3d.mv()
f = s3d.mv('f','scalar',f=True)
A = s3d.mv('A','vector',f=True)
B = s3d.mv('B','bivector',f=True)
print 'A =',A
print 'B =',B
print 'grad*f =',s3d.grad*f
print 'grad|A =',s3d.grad|A
print '-I*(grad^A) =',-s3d.i*(s3d.grad^A)
print 'grad^B =',s3d.grad^B
coords = symbols('t x y z')
m4d = Ga('gamma*t|x|y|z',g=[1,-1,-1,-1],coords=coords)
(g0,g1,g2,g3) = m4d.mv()
I = m4d.i
B = m4d.mv('B','vector',f=True)
E = m4d.mv('E','vector',f=True)
B.set_coef(1,0,0)
E.set_coef(1,0,0)
B *= g0
E *= g0
J = m4d.mv('J','vector',f=True)
F = E+I*B
print 'B = \\bm{B\\gamma_{t}} =',B
print 'E = \\bm{E\\gamma_{t}} =',E
print 'F = E+IB =',F
print 'J =',J
gradF = m4d.grad*F
gradF.Fmt(3,'grad*F')
print 'grad*F = J'
(gradF.get_grade(1)-J).Fmt(3,'%\\grade{\\nabla F}_{1} -J = 0')
(gradF.get_grade(3)).Fmt(3,'%\\grade{\\nabla F}_{3} = 0')
(alpha,beta,gamma) = symbols('alpha beta gamma')
(x,t,xp,tp) = symbols("x t x' t'")
m2d = Ga('gamma*t|x',g=[1,-1])
(g0,g1) = m2d.mv()
R = cosh(alpha/2)+sinh(alpha/2)*(g0^g1)
X = t*g0+x*g1
Xp = tp*g0+xp*g1
print 'R =',R
print r"#%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} = t'\bm{\gamma'_{t}}+x'\bm{\gamma'_{x}} = R\lp t'\bm{\gamma_{t}}+x'\bm{\gamma_{x}}\rp R^{\dagger}"
Xpp = R*Xp*R.rev()
Xpp = Xpp.collect()
Xpp = Xpp.trigsimp()
print r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =",Xpp
Xpp = Xpp.subs({sinh(alpha):gamma*beta,cosh(alpha):gamma})
print r'%\f{\sinh}{\alpha} = \gamma\beta'
print r'%\f{\cosh}{\alpha} = \gamma'
print r"%t\bm{\gamma_{t}}+x\bm{\gamma_{x}} =",Xpp.collect()
coords = symbols('t x y z')
m4d = Ga('gamma*t|x|y|z',g=[1,-1,-1,-1],coords=coords)
(g0,g1,g2,g3) = m4d.mv()
I = m4d.i
(m,e) = symbols('m e')
psi = m4d.mv('psi','spinor',f=True)
A = m4d.mv('A','vector',f=True)
sig_z = g3*g0
print '\\bm{A} =',A
print '\\bm{\\psi} =',psi
dirac_eq = (m4d.grad*psi)*I*sig_z-e*A*psi-m*psi*g0
dirac_eq.simplify()
dirac_eq.Fmt(3,r'\nabla \bm{\psi} I \sigma_{z}-e\bm{A}\bm{\psi}-m\bm{\psi}\gamma_{t} = 0')
xpdf()
return
from sympy import expand,simplify
from printer import Format,xpdf
from ga import Ga
g = '1 # #,'+ \
'# 1 #,'+ \
'# # 1'
Format()
ng3d = Ga('e1 e2 e3',g=g)
(e1,e2,e3) = ng3d.mv()
print 'g_{ij} =',ng3d.g
E = e1^e2^e3
Esq = (E*E).scalar()
print 'E =',E
print '%E^{2} =',Esq
Esq_inv = 1/Esq
E1 = (e2^e3)*E
E2 = (-1)*(e1^e3)*E
E3 = (e1^e2)*E
print 'E1 = (e2^e3)*E =',E1
print 'E2 =-(e1^e3)*E =',E2
print 'E3 = (e1^e2)*E =',E3
w = (E1|e2)
w = w.expand()
print 'E1|e2 =',w
w = (E1|e3)
w = w.expand()
print 'E1|e3 =',w
w = (E2|e1)
def main():
Format()
coords = (x,y,z) = symbols('x y z',real=True)
(o3d,ex,ey,ez) = Ga.build('e*x|y|z',g=[1,1,1],coords=coords)
s = o3d.mv('s','scalar')
v = o3d.mv('v','vector')
b = o3d.mv('b','bivector')
print(r'#3D Orthogonal Metric\newline')
print('#Multvectors:')
print('s =',s)
print('v =',v)
print('b =',b)
print('#Products:')
X = ((s,'s'),(v,'v'),(b,'b'))
for xi in X:
print('')
for yi in X:
print(xi[1]+' * '+yi[1]+' =',xi[0]*yi[0])
print(xi[1]+' ^ '+yi[1]+' =',xi[0]^yi[0])
if xi[1] != 's' and yi[1] != 's':
print(xi[1]+' | '+yi[1]+' =',xi[0]|yi[0])
print(xi[1]+' < '+yi[1]+' =',xi[0]<yi[0])
print(xi[1]+' > '+yi[1]+' =',xi[0]>yi[0])
fs = o3d.mv('s','scalar',f=True)
fv = o3d.mv('v','vector',f=True)
fb = o3d.mv('b','bivector',f=True)
print('#Multivector Functions:')
print('s(X) =',fs)
print('v(X) =',fv)
print('b(X) =',fb)
print('#Products:')
fX = ((o3d.grad,'grad'),(fs,'s'),(fv,'v'),(fb,'b'))
for xi in fX:
print('')
for yi in fX:
if xi[1] == 'grad' and yi[1] == 'grad':
pass
else:
print(xi[1]+' * '+yi[1]+' =',xi[0]*yi[0])
print(xi[1]+' ^ '+yi[1]+' =',xi[0]^yi[0])
if xi[1] != 's' and yi[1] != 's':
print(xi[1]+' | '+yi[1]+' =',xi[0]|yi[0])
print(xi[1]+' < '+yi[1]+' =' ,xi[0]<yi[0])
print(xi[1]+' > '+yi[1]+' =' ,xi[0]>yi[0])
(g2d,ex,ey) = Ga.build('e',coords=(x,y))
print(r'#General 2D Metric\newline')
print('#Multivector Functions:')
s = g2d.mv('s','scalar',f=True)
v = g2d.mv('v','vector',f=True)
b = g2d.mv('v','bivector',f=True)
print('s(X) =',s)
print('v(X) =',v)
print('b(X) =',b)
X = ((g2d.grad,'grad'),(s,'s'),(v,'v'))
print('#Products:')
for xi in X:
print('')
for yi in X:
if xi[1] == 'grad' and yi[1] == 'grad':
pass
else:
print(xi[1]+' * '+yi[1]+' =',xi[0]*yi[0])
print(xi[1]+' ^ '+yi[1]+' =',xi[0]^yi[0])
if xi[1] != 's' and yi[1] != 's':
print(xi[1]+' | '+yi[1]+' =',xi[0]|yi[0])
else:
print(xi[1]+' | '+yi[1]+' = Not Allowed')
print(xi[1]+' < '+yi[1]+' =',xi[0]<yi[0])
print(xi[1]+' > '+yi[1]+' =' ,xi[0]>yi[0])
xpdf(paper='letter')
return
class API:
data = {}
devicegroup = DeviceGroups()
config = ApiConfig()
device = Devices()
repo = Repos()
orders = Orders()
processingpolicy = ProcessingPolicy()
normalizationpolicy = NormalizationPolicy()
normalizationpackage = NormalizationPackage()
opendoor = OpenDoor()
systemsettingsntp = SystemSettingsNTP()
syslogcollector = SyslogCollector()
routingpolicy = RoutingPolicy()
def __init__(self, args):
self.connect = Connect(args.lphost)
self.show = Format(args.output, self.config.debug)
self.task = args.task
self.data['task'] = args.task
self.data['userinput'] = args.parameter
self.file = args.file
self.lphost = args.lphost
def syslogcollectors(self):
self.data['option'] = 'SyslogCollector'
self.data['default'] = self.config.default_collector_parameters
self.data['ppapi'] = self.connect.getOption('ProcessingPolicy')
self.data['processingpolicy'] = self.processingpolicy.getNamesOnly(
self.data['ppapi'])
self.data['deviceapi'] = self.connect.getOption('Devices')
self.data['devices'] = self.namesOnly(self.data['deviceapi'], 'name')
if self.task in ['edit', 'delete', 'create']:
if self.file:
tasks = self.readJsonFile()
for taskdata in tasks:
self.data['data'] = taskdata
enriched = self.syslogcollector.update(self.data)
result = self.connect.update(enriched)
self.show.printOrders(result)
else:
self.data = self.syslogcollector.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def repos(self):
self.data['default'] = self.config.default_repo_parameters
if self.task == 'get':
self.data['repoapi'] = self.connect.getOption('Repos')
self.data['repos'] = self.repo.getAll(self.data['repoapi'])
self.show.printformat(self.data['repos'])
if self.task == 'edit':
self.data = self.repo.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
if self.task == 'create':
self.data = self.repo.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
if self.task == 'delete' or self.task == 'trash':
self.data = self.repo.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def devices(self):
self.data['option'] = 'Devices'
self.data['default'] = self.config.default_device_parameters
self.data['groupapi'] = self.connect.getOption('DeviceGroups')
self.data['devicegroups'] = self.devicegroup.getNamesOnly(
self.data['groupapi'])
self.data['ppapi'] = self.connect.getOption('ProcessingPolicy')
self.data['processingpolicy'] = self.processingpolicy.getNamesOnly(
self.data['ppapi'])
if not self.task == 'create':
self.data['deviceapi'] = self.connect.getOption('Devices')
self.data['devices'] = self.namesOnly(self.data['deviceapi'],
'name')
if self.task == 'get':
self.data = self.device.listall(self.data)
self.show.printformat(self.data['devicelist'])
if self.task in ['edit', 'delete', 'create']:
if self.file:
tasks = self.readJsonFile()
for taskdata in tasks:
self.data['data'] = taskdata
enriched = self.device.update(self.data)
result = self.connect.update(enriched)
self.show.printOrders(result)
else:
self.data = self.device.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def distributedLogpoints(self):
if self.task == 'get':
self.data['dlp'] = self.connect.getOption('DistributedLogpoints')
self.show.printformat(self.data['dlp'])
if self.task == 'create':
self.data['option'] = 'DistributedLogpoints'
result = self.connect.update(self.data)
self.show.printOrders(result)
def distributedCollectors(self):
option = 'DistributedCollectors'
if self.task == 'get':
self.data['dcol'] = self.connect.getOption(option)
self.show.printformat(self.data['dcol'])
if self.task == 'create' or self.task == 'activate':
self.data['option'] = option
result = self.connect.update(self.data)
self.show.printOrders(result)
if self.task == 'refresh':
self.refresh(option)
def openDoor(self):
if self.task == 'get':
self.data['opendoorapi'] = self.connect.getOption('OpenDoor')
self.data['opendoor'] = self.opendoor.getAll(
self.data['opendoorapi'])
self.show.printformat(self.data['opendoor'])
if self.task == 'create':
self.data['option'] = 'OpenDoor'
result = self.connect.update(self.data)
self.show.printOrders(result)
def systemSettingsNTP(self):
if self.task == 'get':
self.data['systemsettingsntpapi'] = self.connect.getOption(
'SystemSettingsNTP')
self.data['systemsettingsntp'] = self.systemsettingsntp.getAll(
self.data['systemsettingsntpapi'])
self.show.printformat(self.data['systemsettingsntp'])
if self.task == 'restart':
self.data['option'] = 'SystemSettingsNTP/ntprestart'
result = self.connect.update(self.data)
self.show.printOrders(result)
if self.task == 'create':
self.data['option'] = 'SystemSettingsNTP'
result = self.connect.update(self.data)
self.show.printOrders(result)
def systemSettings(self):
if self.task == 'get':
self.data['systemsettingsapi'] = self.connect.getOption(
'SystemSettingsGeneral')
self.show.rotatePrint(self.data['systemsettingsapi'])
if self.task == 'create' or self.task == 'update':
self.data['option'] = 'SystemSettingsGeneral'
result = self.connect.update(self.data)
self.show.printOrders(result)
def deviceGroups(self):
self.data['option'] = 'DeviceGroups'
if self.task == 'get':
self.data['groupapi'] = self.connect.getOption('DeviceGroups')
self.data['devicegroups'] = self.devicegroup.getAll(
self.data['groupapi'])
self.show.printformat(self.data['devicegroups'])
if self.task == 'create':
result = self.connect.update(self.data)
self.show.printOrders(result)
def processingPolicy(self):
self.data['option'] = 'ProcessingPolicy'
apiresponse = self.connect.getOption('RoutingPolicies')
self.data['routing_policy'] = self.namesOnly(apiresponse,
'policy_name')
apiresponse = self.connect.getOption('EnrichmentPolicy')
self.data['enrich_policy'] = self.namesOnly(apiresponse, 'name')
self.data['ppapi'] = self.connect.getOption('ProcessingPolicy')
if self.task == 'get':
self.data = self.processingpolicy.listAll(self.data)
self.show.printformat(self.data)
if self.task in ['edit', 'delete', 'create']:
self.data = self.processingpolicy.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def normalizationPolicy(self):
self.data['option'] = 'NormalizationPolicy'
self.data['normpolapi'] = self.connect.getOption('NormalizationPolicy')
if self.task == 'get':
self.data['normpackapi'] = self.connect.getOption(
'NormalizationPackage') #get packege names, for translation
self.data[
'normalizationpackage'] = self.normalizationpackage.getNames(
self.data['normpackapi'])
self.data['normalizationpolicy'] = self.normalizationpolicy.getAll(
self.data)
self.show.printformat(self.data['normalizationpolicy'])
if self.task in ['edit', 'delete', 'create']:
self.data = self.normalizationpolicy.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def normalizationPackage(self):
option = 'NormalizationPackage'
if self.task == 'get':
self.data['normpackapi'] = self.connect.getOption(option)
self.show.printformat(self.data['normpackapi'])
if self.task == 'refresh':
self.refresh(option)
def routingPolicy(self):
self.data['option'] = 'RoutingPolicies'
self.data['rpapi'] = self.connect.getOption('RoutingPolicies')
if self.task == 'get':
self.show.printformat(self.data['rpapi'])
if self.task in ['edit', 'delete', 'create']:
self.data = self.routingpolicy.update(self.data)
result = self.connect.update(self.data)
self.show.printOrders(result)
def supportConnection(self):
option = 'SystemSettingsSupportConnection'
if self.task == 'get':
self.data['supcon'] = self.connect.getOption(option)
self.show.printformat(self.data['supcon'])
if self.task == 'refresh':
self.refresh(option)
if self.task == 'create' or self.task == 'save':
self.data['option'] = option
result = self.connect.update(self.data)
self.show.printOrders(result)
def systemSettingsSSH(self):
if self.task == 'get':
self.data['SSSSH'] = self.connect.getOption('SystemSettingsSSH')
self.show.printformat(self.data['SSSSH'])
if self.task == 'create' or self.task == 'save':
self.data['option'] = 'SystemSettingsSSH'
result = self.connect.update(self.data)
self.show.printOrders(result)
def plugins(self):
if self.task == 'get':
self.data['plugins'] = self.connect.getOption('Plugins')
self.show.printformat(self.data['plugins'])
def enrichmentPolicy(self):
if self.task == 'get':
self.data['enrichmentpolicy'] = self.connect.getOption(
'EnrichmentPolicy')
self.show.rotatePrint(self.data['enrichmentpolicy'])
def refresh(self, item):
self.data['option'] = item + '/refreshlist'
self.data['userinput'] = ['data=true']
result = self.connect.update(self.data)
self.show.printOrders(result)
def namesOnly(self, data, item):
returndict = {}
for stuff in data:
returndict[stuff['id']] = stuff[item]
return returndict
def readJsonFile(self):
with open(self.file) as json_data:
return json.load(json_data)
def main():
Get_Program()
Format()
Product_of_Rotors()
xpdf(paper=(8.5, 11), debug=True)
return
def main():
Get_Program()
Format()
derivatives_in_spherical_coordinates()
xdvi()
return
