/[lohnrechner]/trunk/LST2007.py
ViewVC logotype

Annotation of /trunk/LST2007.py

Parent Directory Parent Directory | Revision Log Revision Log

Revision 68 - (hide annotations)
Thu Jan 25 11:20:34 2007 UTC (18 years, 3 months ago) by wilde
File MIME type: text/x-python
File size: 29171 byte(s) 
Minor code cleanup.
1 wilde 20 # -*- coding: iso-8859-1 -*-
2 wilde 2 # --------------------------------------------------------------------
3 wilde 67 # LST2007 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2007
4 wilde 2 # $Id$
5     # --------------------------------------------------------------------
6     #
7 wilde 67 # Copyright (c) 2005, 2006, 2007 by Intevation GmbH
8 wilde 2 # Authors:
9     # Sascha Wilde <[email protected]>
10     #
11     # This program is free software under the GPL (>=v2)
12     # Read the file COPYING coming with this package for details.
13    
14     """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan
15 wilde 28 wie im offiziellen Programmablaufplan des Bundesfinanzministerium
16     dokumentiert.
17     http://www.bundesfinanzministerium.de/Service/Interaktiver-Steuerrechner-.577.htm"""
18 wilde 2
19 wilde 8 __version__ = "$Revision$"
20     # $Source$
21    
22     def _ModulVersion():
23     return __version__[11:-2]
24    
25 wilde 2 # Die Variablen Namen sind hässlich, die Algorithmen nicht
26     # dokumentiert, der Code grausam -- dafür entspricht alles Zeile für
27     # Zeile obigem Dokument. Jedenfalls sollte es so sein...
28    
29     from math import ceil, floor
30    
31     # Wir brauchen eigene Rundungsfunktionen mit definierter Präzision
32     def FixedPointFloor(value, precision=2):
33     i = 10.0 ** precision
34     return floor(value * i) / i
35    
36     def FixedPointCeil(value, precision=2):
37     i = 10.0 ** precision
38     return ceil(value * i) / i
39    
40     # Ein paar Konstanten um das ganze etwas Benutzbarer zu machen:
41     JAHR = 1
42     MONAT = 2
43     WOCHE = 3
44     TAG = 4
45     I = 1
46     II = 2
47     III = 3
48     IV = 4
49     V = 5
50     VI = 6
51    
52     class LST:
53     def __init__(self,
54 wilde 53 AJAHR =1964,
55 wilde 2 ALTER1=0,
56     HINZUR=0,
57     JFREIB=0,
58     JHINZU=0,
59     JRE4 =0,
60     JVBEZ =0,
61     KRV =0,
62     LZZ =2,
63     R =0,
64 wilde 47 RE4 =0,
65 wilde 2 SONSTB=0,
66 wilde 47 STERBE=0,
67 wilde 2 STKL =1,
68     VBEZ =0,
69     VBEZM =0,
70     VBEZS =0,
71     VBS =0,
72 wilde 47 VJAHR =0,
73     VKAPA =0,
74 wilde 2 VMT =0,
75     WFUNDF=0,
76     ZKF =0,
77     ZMVB =0):
78 wilde 47 self.Set_AJAHR(AJAHR)
79 wilde 2 self.Set_ALTER1(ALTER1)
80     self.Set_HINZUR(HINZUR)
81     self.Set_JFREIB(JFREIB)
82     self.Set_JHINZU(JHINZU)
83     self.Set_JRE4(JRE4)
84     self.Set_JVBEZ(JVBEZ)
85     self.Set_KRV(KRV)
86     self.Set_LZZ(LZZ)
87     self.Set_R(R)
88 wilde 47 self.Set_RE4(RE4)
89 wilde 2 self.Set_SONSTB(SONSTB)
90 wilde 47 self.Set_STERBE(STERBE)
91 wilde 2 self.Set_STKL(STKL)
92     self.Set_VBEZ(VBEZ)
93     self.Set_VBEZM(VBEZM)
94     self.Set_VBEZS(VBEZS)
95     self.Set_VBS(VBS)
96 wilde 47 self.Set_VJAHR(VJAHR)
97     self.Set_VKAPA(VKAPA)
98 wilde 2 self.Set_VMT(VMT)
99     self.Set_WFUNDF(WFUNDF)
100     self.Set_ZKF(ZKF)
101     self.Set_ZMVB(ZMVB)
102     # Vorgegebene Ausgangsparameter
103     self.BK = 0
104     self.BKS = 0
105     self.BKV = 0
106     self.LSTLZZ = 0
107     self.SOLZLZZ = 0
108     self.SOLZS = 0
109     self.SOLZV = 0
110     self.STS = 0
111     self.STV = 0
112    
113     def Calc(self):
114     """Berechnet die Lohnsteuer,
115     setzt BK, BKS, BKV, LSTLZZ, SOLZLZZ, SOLZS, SOLZV, STS und STV"""
116     # Interne Felder
117     # Laut Dokumentation sollen diese vor der Berechnung gelöscht werden,
118     # es ist mir nicht klar, ob das wirklich nötig ist...
119     self._ALTE = 0
120     self._ANP = 0
121     self._ANTEIL1 = 0
122     self._ANTEIL2 = 0
123     self._BMG = 0
124     self._DIFF = 0
125     self._EFA = 0
126     self._FVB = 0
127     self._FVBZ = 0
128 wilde 47 self._HFVB = 0
129     self._J = 0
130 wilde 2 self._JBMG = 0
131     self._JW = 0
132 wilde 47 self._K = 0
133 wilde 2 self._KENNZ = 0
134     self._KFB = 0
135     self._KZTAB = 1
136     self._LSTJAHR = 0
137     self._LST1 = 0
138     self._LST2 = 0
139     self._LST3 = 0
140     self._MIST = 0
141     self._RE4LZZ = 0
142     self._RE4LZZV = 0
143     self._RW = 0.0
144     self._SAP = 0
145     self._SOLZFREI = 0
146     self._SOLZJ = 0.0 # 2 Dezimalstellen
147     self._SOLZMIN = 0.0 # 2 Dezimalstellen
148     self._ST = 0
149     self._ST1 = 0
150     self._ST2 = 0
151 wilde 47 self._TAB1=(None, # 1 als erstes Element, wie im PAP
152     0.400, # bis 2005
153     0.384, # 2006
154     0.368, # 2007
155     0.352, # 2008
156     0.336, # 2009
157     0.320, # 2010
158     0.304, # 2011
159     0.288, # 2012
160     0.272, # 2013
161     0.256, # 2014
162     0.240, # 2015
163     0.224, # 2016
164     0.208, # 2017
165     0.192, # 2018
166     0.176, # 2019
167     0.160, # 2020
168     0.152, # 2021
169     0.144, # 2022
170     0.136, # 2023
171     0.128, # 2024
172     0.120, # 2025
173     0.112, # 2026
174     0.104, # 2027
175     0.096, # 2028
176     0.088, # 2029
177     0.080, # 2030
178     0.072, # 2031
179     0.064, # 2032
180     0.056, # 2033
181     0.048, # 2034
182     0.040, # 2035
183     0.032, # 2036
184     0.024, # 2037
185     0.016, # 2038
186     0.008, # 2039
187 wilde 52 0.000) # 2040
188 wilde 47 self._TAB2=(None, # 1 als erstes Element, wie im PAP
189     3000, # bis 2005
190     2880, # 2006
191     2760, # 2007
192     2640, # 2008
193     2520, # 2009
194     2400, # 2010
195     2280, # 2011
196     2160, # 2012
197     2040, # 2013
198     1920, # 2014
199     1800, # 2015
200     1680, # 2016
201     1560, # 2017
202     1440, # 2018
203     1320, # 2019
204     1200, # 2020
205     1140, # 2021
206     1080, # 2022
207     1020, # 2023
208     960, # 2024
209     900, # 2025
210     840, # 2026
211     780, # 2027
212     720, # 2028
213     660, # 2029
214     600, # 2030
215     540, # 2031
216     480, # 2032
217     420, # 2033
218     360, # 2034
219     300, # 2035
220     240, # 2036
221     180, # 2037
222     120, # 2038
223     60, # 2039
224 wilde 52 0) # 2040
225 wilde 47 self._TAB3=(None, # 1 als erstes Element, wie im PAP
226     900, # bis 2005
227     864, # 2006
228     828, # 2007
229     792, # 2008
230     756, # 2009
231     720, # 2010
232     684, # 2011
233     648, # 2012
234     612, # 2013
235     576, # 2014
236     540, # 2015
237     504, # 2016
238     468, # 2017
239     432, # 2018
240     396, # 2019
241     360, # 2020
242     342, # 2021
243     324, # 2022
244     306, # 2023
245     288, # 2024
246     270, # 2025
247     252, # 2026
248     234, # 2027
249     216, # 2028
250     198, # 2029
251     180, # 2030
252     162, # 2031
253     144, # 2032
254     126, # 2033
255     108, # 2034
256     90, # 2035
257     72, # 2036
258     54, # 2037
259     36, # 2038
260     18, # 2039
261 wilde 52 0) # 2040
262 wilde 47 self._TAB4=self._TAB1
263     self._TAB5=(None, # 1 als erstes Element, wie im PAP
264     1900, # bis 2005
265     1824, # 2006
266     1748, # 2007
267     1672, # 2008
268     1596, # 2009
269     1520, # 2010
270     1444, # 2011
271     1368, # 2012
272     1292, # 2013
273     1216, # 2014
274     1140, # 2015
275     1064, # 2016
276     988, # 2017
277     912, # 2018
278     836, # 2019
279     760, # 2020
280     722, # 2021
281     684, # 2022
282     646, # 2023
283     608, # 2024
284     570, # 2025
285     532, # 2026
286     494, # 2027
287     456, # 2028
288     418, # 2029
289     380, # 2030
290     342, # 2031
291     304, # 2032
292     266, # 2033
293     228, # 2034
294     190, # 2035
295     152, # 2036
296     114, # 2037
297     76, # 2038
298     38, # 2039
299 wilde 52 0) # 2040
300 wilde 2 self._VBEZB = 0
301     self._VHB = 0
302     self._VSP = 0.0 # 2 Dezimalstellen
303     self._VSPN = 0
304     self._VSP1 = 0.0 # 2 Dezimalstellen
305     self._VSP2 = 0.0 # 2 Dezimalstellen
306     self._VSPKURZ = 0
307     self._VSPMAX1 = 0
308     self._VSPMAX2 = 0
309     self._VSPO = 0.0 # 2 Dezimalstellen
310     self._VSPREST = 0.0 # 2 Dezimalstellen
311     self._VSPVOR = 0.0 # 2 Dezimalstellen
312     self._X = 0.0 # 2 Dezimalstellen
313     self._Y = 0.0 # 6 Dezimalstellen
314     self._ZRE4 = 0.0 # 2 Dezimalstellen
315     self._ZRE4VP = 0.0 # 2 Dezimalstellen
316     self._ZRE4VP1 = 0.0 # 2 Dezimalstellen
317     self._ZTABFB = 0
318 wilde 47 self._ZVBEZ = 0
319 wilde 2 self._ZVE = 0
320     self._ZX = 0
321     self._ZZX = 0
322     self._HOCH = 0
323     self._VERGL = 0
324     # ------------------------------------------------------------
325     # Anfang der Berechnung
326     self._MRE4LZZ()
327 wilde 52 self._KENNZ = 0
328 wilde 2 self._RE4LZZ = self.RE4 - self._FVB \
329     - self._ALTE - self.WFUNDF \
330     + self.HINZUR
331     self._RE4LZZV = self.RE4 - self._FVB - self._ALTE
332     self._MRE4()
333     self._MZTABFB()
334     self._MLSTJAHR()
335     self._LSTJAHR = self._ST
336     self._JW = self._LSTJAHR * 100
337     self._UPANTEIL()
338     self.LSTLZZ = self._ANTEIL1
339     if self.ZKF > 0:
340     self._ZTABFB += self._KFB
341     self._MLSTJAHR()
342     self._JBMG = self._ST
343     else:
344     self._JBMG = self._LSTJAHR
345     self._MSOLZ()
346 wilde 3 self._MSONST()
347     self._MVMT()
348 wilde 47
349 wilde 2 # Benutzte Unterprogramme:
350     def _MRE4LZZ(self):
351     if self.VBEZ == 0:
352     self._FVBZ = 0
353     self._FVB = 0
354     else:
355 wilde 52 if self.VJAHR < 2006:
356     self._J = 1
357     elif self.VJAHR < 2040:
358     self._J = VJAHR - 2004
359     else:
360     self._J = 36
361 wilde 2 if self.LZZ == 1:
362 wilde 52 if ( self.STERBE + self.VKAPA ) > 0:
363     self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
364     self._HFVB = self._TAB2[self._J] * 100
365     self._FVBZ = self._TAB3[self._J]
366     else:
367     self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
368     self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB * 100
369     self._FVBZ = ceil(self._TAB3[self._J] / 12 * self.ZMVB)
370 wilde 2 else:
371     self._VBEZB = self.VBEZM * 12 + self.VBEZS
372 wilde 52 self._HFVB = self._TAB2[self._J] * 100
373     self._FVBZ = self._TAB3[self._J]
374     self._FVB = ceil(self._VBEZB * self._TAB1[self._J])
375     if self._FVB > self._HFVB:
376     self._FVB = self._HFVB
377 wilde 2 self._JW = self._FVB
378     self._UPANTEIL()
379     self._FVB = self._ANTEIL2
380     if self.ALTER1 == 0:
381     self._ALTE = 0
382     else:
383 wilde 52 if self.AJAHR < 2006:
384     self._K = 1
385     elif self.AJAHR < 2040:
386     self._K = self.AJAHR - 2004
387     else:
388     self._K = 36
389 wilde 2 self._BMG = self.RE4 - self.VBEZ
390 wilde 53 self._ALTE = ceil(self._BMG * self._TAB4[self._K])
391     self._JW = self._TAB5[self._K] * 100
392 wilde 2 self._UPANTEIL()
393     if self._ALTE > self._ANTEIL2:
394     self._ALTE = self._ANTEIL2
395    
396     def _MRE4(self):
397     if self.LZZ == 1:
398     self._ZRE4 = FixedPointFloor(self._RE4LZZ / 100.0)
399     self._ZRE4VP = FixedPointFloor(self._RE4LZZV / 100.0)
400 wilde 52 self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB) / 100.0)
401 wilde 2 elif self.LZZ == 2:
402     self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)
403     self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.67) * 0.12)
404 wilde 52 self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.67) * 0.12)
405 wilde 2 elif self.LZZ == 3:
406     self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.89) * 3.6 / 7)
407     self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.89) * 3.6 / 7)
408 wilde 52 self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.89) * 3.6 / 7)
409 wilde 2 else:
410     self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)
411     self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.56) * 3.6)
412 wilde 52 self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.56) * 3.6)
413 wilde 67 if self._RE4LZZ < 0:
414 wilde 2 self._ZRE4 = 0.0
415 wilde 67 if self._RE4LZZV < 0:
416     self._ZRE4VP = 0.0
417     if (self.VBEZ == 0) and (self._FVB == 0):
418     self._ZVBEZ = 0
419     elif (self.VBEZ - self._FVB) < 0:
420     self._ZVBEZ = 0
421 wilde 2
422     def _MZTABFB(self):
423 wilde 52 self._ANP = 0
424 wilde 67 if (self._ZVBEZ >= 0) and (self._ZVBEZ < self._FVBZ):
425 wilde 52 self._FVBZ = self._ZVBEZ
426     if (self.STKL < 6) and (self._ZVBEZ > 0):
427     if (self._ZVBEZ - self._FVBZ) < 102:
428     self._ANP = self._ZVBEZ - self._FVBZ
429     else:
430     self._ANP = 102
431     if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):
432     if (self._ZRE4 - self._ZVBEZ) < 920:
433 wilde 68 self._ANP += self._ZRE4 - self._ZVBEZ
434 wilde 52 else:
435 wilde 68 self._ANP += 920
436 wilde 2 self._KZTAB = 1
437     if self.STKL == 1:
438     self._SAP = 36
439     self._KFB = self.ZKF * 5808
440     elif self.STKL == 2:
441     self._EFA = 1308
442     self._SAP = 36
443     self._KFB = self.ZKF * 5808
444     elif self.STKL == 3:
445     self._KZTAB = 2
446     self._SAP = 72
447     self._KFB = self.ZKF * 5808
448     elif self.STKL == 4:
449     self._SAP = 36
450     self._KFB = self.ZKF * 2904
451     else:
452     self._KFB = 0
453     self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ
454    
455     def _MLSTJAHR(self):
456     if self.STKL < 5:
457     self._UPEVP()
458     else:
459 wilde 47 self._VSP = 0.0
460 wilde 2 self._ZVE = self._ZRE4 - self._ZTABFB - self._VSP
461     if self._ZVE < 1:
462     self._ZVE = self._X = 0.0
463     else:
464     self._X = floor(float(self._ZVE) / self._KZTAB)
465     if self.STKL < 5:
466 wilde 67 self._UPTAB07()
467 wilde 2 else:
468     self._MST5_6()
469    
470     def _UPEVP(self):
471     if self.KRV == 1:
472 wilde 52 self._VSP1 = 0.0
473 wilde 2 else:
474 wilde 52 if self._ZRE4VP > 63000:
475     self._ZRE4VP = 63000
476 wilde 67 self._VSP1 = 0.28 * self._ZRE4VP
477     self._VSP1 = FixedPointFloor(self._VSP1 * 0.0995)
478 wilde 15 self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)
479 wilde 2 self._VHB = 1500 * self._KZTAB
480     if self._VSP2 > self._VHB:
481     self._VSP2 = self._VHB
482     self._VSPN = ceil(self._VSP1 + self._VSP2)
483     self._MVSP()
484     if self._VSPN > self._VSP:
485     self._VSP = self._VSPN
486    
487     def _MVSP(self):
488 wilde 52 if self._KENNZ == 1:
489     self._VSPO = self._ZRE4VP1 * 0.2
490     else:
491     self._VSPO = self._ZRE4VP * 0.2
492 wilde 2 self._VSPVOR = 3068 * self._KZTAB
493     self._VSPMAX1 = 1334 * self._KZTAB
494     self._VSPMAX2 = 667 * self._KZTAB
495     self._VSPKURZ = 1134 * self._KZTAB
496     if self.KRV == 1:
497     if self._VSPO > self._VSPKURZ:
498     self._VSP = self._VSPKURZ
499     else:
500 wilde 67 self._VSP = floor(self._VSPO)
501 wilde 2 else:
502     self._UMVSP()
503    
504     def _UMVSP(self):
505     if self._KENNZ == 1:
506 wilde 68 self._VSPVOR -= self._ZRE4VP1 * 0.16
507 wilde 2 else:
508 wilde 68 self._VSPVOR -= self._ZRE4VP * 0.16
509 wilde 2 if self._VSPVOR < 0:
510     self._VSPVOR = 0.0
511     if self._VSPO > self._VSPVOR:
512     self._VSP = self._VSPVOR
513     self._VSPREST = self._VSPO - self._VSPVOR
514     if self._VSPREST > self._VSPMAX1:
515     self._VSP += self._VSPMAX1
516     self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)
517     if self._VSPREST > self._VSPMAX2:
518 wilde 67 self._VSP = floor(self._VSP + self._VSPMAX2)
519 wilde 2 else:
520 wilde 67 self._VSP = floor(self._VSP + self._VSPREST)
521 wilde 2 else:
522 wilde 67 self._VSP = floor(self._VSP + self._VSPREST)
523 wilde 2 else:
524 wilde 67 self._VSP = floor(self._VSPO)
525 wilde 2
526     def _MST5_6(self):
527     self._ZZX = self._X
528     if self._ZZX > 25812:
529     self._ZX = 25812
530     self._UP5_6()
531 wilde 67 if self._ZZX > 200000:
532 wilde 68 self._ST += (200000 - 25812) * 0.42
533 wilde 67 self._ST = floor(self._ST + (self._ZZX - 200000) * 0.45)
534     else:
535     self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)
536 wilde 2 else:
537     self._ZX = self._ZZX
538     self._UP5_6()
539     if self._ZZX > 9144:
540     self._VERGL = self._ST
541     self._ZX = 9144
542     self._UP5_6()
543     self._HOCH = floor(self._ST + (self._ZZX - 9144) * 0.42)
544     if self._HOCH < self._VERGL:
545     self._ST = self._HOCH
546     else:
547     self._ST = self._VERGL
548    
549     def _UP5_6(self):
550     self._X = self._ZX * 1.25
551 wilde 67 self._UPTAB07()
552 wilde 2 self._ST1 = self._ST
553     self._X = self._ZX * 0.75
554 wilde 67 self._UPTAB07()
555 wilde 2 self._ST2 = self._ST
556     self._DIFF = (self._ST1 - self._ST2) * 2
557     self._MIST = floor(self._ZX * 0.15)
558     if self._MIST > self._DIFF:
559     self._ST = self._MIST
560     else:
561     self._ST = self._DIFF
562    
563     def _MSOLZ(self):
564     self._SOLZFREI = 972 * self._KZTAB
565     if self._JBMG > self._SOLZFREI:
566     self._SOLZJ = FixedPointFloor(self._JBMG * 5.5 / 100.0)
567     self._SOLZMIN = (self._JBMG - self._SOLZFREI) * 20 / 100.0
568     if self._SOLZMIN < self._SOLZJ:
569     self._SOLZJ = self._SOLZMIN
570     self._JW = self._SOLZJ * 100
571     self._UPANTEIL()
572     self.SOLZLZZ = self._ANTEIL1
573     else:
574     self.SOLZLZZ = 0
575     if self.R > 0:
576     self._JW = self._JBMG * 100
577 wilde 13 self._UPANTEIL()
578 wilde 2 self.BK = self._ANTEIL1
579     else:
580     self.BK = 0
581    
582     def _UPANTEIL(self):
583     if self.LZZ == 1:
584     self._ANTEIL1 = self._JW
585     self._ANTEIL2 = self._JW
586     elif self.LZZ == 2:
587     self._ANTEIL1 = floor(self._JW / 12.0)
588     self._ANTEIL2 = ceil(self._JW / 12.0)
589     elif self.LZZ == 3:
590     self._ANTEIL1 = floor(self._JW * 7 / 360.0)
591     self._ANTEIL2 = ceil(self._JW * 7 / 360.0)
592     else:
593     self._ANTEIL1 = floor(self._JW / 360.0)
594 wilde 47 self._ANTEIL2 = ceil(self._JW / 360.0)
595 wilde 2
596 wilde 67 def _UPTAB07(self):
597 wilde 2 if self._X < 7665:
598     self._ST = 0
599     elif self._X < 12740:
600     self._Y = (self._X - 7664) / 10000.0
601     self._RW = self._Y * 883.74
602     self._RW += 1500
603     self._ST = floor(self._RW * self._Y)
604     elif self._X < 52152:
605     self._Y = (self._X - 12739) / 10000.0
606     self._RW = self._Y * 228.74
607     self._RW += 2397
608     self._RW *= self._Y
609     self._ST = floor(self._RW + 989)
610 wilde 67 elif self._X < 250001:
611     self._ST = floor(self._X * 0.42 - 7914)
612 wilde 2 else:
613 wilde 67 self._ST = floor(self._X * 0.45 - 15414)
614 wilde 2 self._ST *= self._KZTAB
615    
616 wilde 3 def _MSONST(self):
617 wilde 67 if self.SONSTB == 0:
618     self.STS = 0
619     self.SOLZS = 0
620     self.BKS = 0
621     else:
622 wilde 3 # ------------------------------
623     # Nicht im offiziellen Programm-
624     # ablaufplan: Attribute sichern
625     old_lzz = self.LZZ
626     old_vbez = self.VBEZ
627     old_re4 = self.RE4
628     # ------------------------------
629     self.LZZ = 1
630     self.VBEZ = self.JVBEZ
631     self.RE4 = self.JRE4
632     self._MRE4LZZ()
633     self._MRE4LZZ2()
634     self._MLSTJAHR()
635     self._LST1 = self._ST * 100
636     self.VBEZ = self.JVBEZ + self.VBS
637     self.RE4 = self.JRE4 + self.SONSTB
638 wilde 68 self.VBEZS += self.STERBE
639 wilde 3 self._MRE4LZZ()
640     self._MRE4LZZ2()
641     self._MLSTJAHR()
642     self._LST2 = self._ST * 100
643     self.STS = self._LST2 - self._LST1
644 wilde 67 if (self.SONSTB > 0) and (self.STS < 0):
645     self.STS = 0
646 wilde 52 self.SOLZS = floor(self.STS * 5.5 / 100)
647 wilde 3 if self.R > 0:
648     self.BKS = self.STS
649     else:
650     self.BKS = 0
651     # ------------------------------
652     # Nicht im offiziellen Programm-
653     # ablaufplan: Attribute
654     # wiederherstellen
655     self.LZZ = old_lzz
656     self.VBEZ = old_vbez
657     self.RE4 = old_re4
658     # ------------------------------
659    
660     def _MRE4LZZ2(self):
661     self._RE4LZZ = self.RE4 - self._FVB - self._ALTE \
662     - self.JFREIB + self.JHINZU
663     self._RE4LZZV = self.RE4 - self._FVB - self._ALTE
664 wilde 52 self._MRE4()
665     self._MZTABFB()
666 wilde 3
667     def _MVMT(self):
668 wilde 52 # ------------------------------
669     # Nicht im offiziellen Programm-
670     # ablaufplan: Attribute sichern
671     old_lzz = self.LZZ
672     old_vbez = self.VBEZ
673     old_re4 = self.RE4
674     # ------------------------------
675 wilde 67 if self.VKAPA < 0:
676     self.VKAPA = 0
677 wilde 52 if (self.VMT + self.VKAPA) > 0:
678 wilde 3 self.LZZ = 1
679     self.VBEZ = self.JVBEZ + self.VBS
680     self.RE4 = self.JRE4 + self.SONSTB
681     self._MRE4LZZ()
682     self._MRE4LZZ2()
683     self._MLSTJAHR()
684     self._LST1 = self._ST * 100
685 wilde 68 self.VMT += self.VKAPA
686     self.VBEZS += self.VKAPA
687     self.VBEZ += self.VKAPA
688 wilde 3 self.RE4 = self.JRE4 + self.SONSTB + self.VMT
689     self._MRE4LZZ()
690     self._MRE4LZZ2()
691     self._KENNZ = 1
692     self._ZRE4VP1 = self._ZRE4VP
693     self._MLSTJAHR()
694     self._LST3 = self._ST * 100
695 wilde 68 self.VBEZ -= self.VKAPA
696     self.VBEZS -= self.VKAPA
697 wilde 3 self.RE4 = self.JRE4 + self.SONSTB
698     self._MRE4LZZ()
699 wilde 52 if (self.RE4 - self.JFREIB + self.JHINZU) < 0:
700 wilde 68 self.RE4 -= self.JFREIB + self.JHINZU
701 wilde 52 self.JFREIB = 0
702     self.JHINZU = 0
703     self.RE4 = (self.RE4 + self.VMT) / 5
704     self._MRE4LZZ2()
705     self._MLSTJAHR()
706     self._LST2 = self._ST * 100
707     self.STV = self._LST2 * 5
708     else:
709 wilde 68 self.RE4 += self.VMT / 5
710 wilde 52 self._MRE4LZZ2()
711     self._MLSTJAHR()
712     self._LST2 = self._ST * 100
713     self.STV = (self._LST2 - self._LST1) * 5
714 wilde 3 self._LST3 -= self._LST1
715     if self._LST3 < self.STV:
716     self.STV = self._LST3
717     self.SOLZV = floor(self.STV * 5.5 / 100)
718     if self.R > 0:
719     self.BKV = self.STV
720     else:
721     self.BKV = 0
722     # ------------------------------
723     # Nicht im offiziellen Programm-
724     # ablaufplan: Attribute
725     # wiederherstellen
726     self.LZZ = old_lzz
727     self.VBEZ = old_vbez
728     self.RE4 = old_re4
729     # ------------------------------
730     else:
731     self.STV = 0
732     self.SOLZV = 0
733     self.BKV = 0
734    
735 wilde 2 # Methoden zum geprüften setzen der Wert
736     # FIX ME: Prüfung _sehr_ unvollständig
737    
738 wilde 47 def Set_AJAHR(self, value):
739 wilde 53 assert type(value) == type(0), "must be integer"
740     assert value >= 1900, "must be greater than 1900"
741     self.AJAHR = value
742 wilde 47
743 wilde 2 def Set_ALTER1(self, value):
744     assert value in (0,1), "must be 0 or 1"
745     self.ALTER1 = value
746 wilde 47
747 wilde 2 def Set_HINZUR(self, value):
748     self.HINZUR = value
749 wilde 47
750 wilde 2 def Set_JFREIB(self, value):
751     self.JFREIB = value
752 wilde 47
753 wilde 2 def Set_JHINZU(self, value):
754     self.JHINZU = value
755 wilde 47
756 wilde 2 def Set_JRE4(self, value):
757     self.JRE4 = value
758 wilde 47
759 wilde 2 def Set_JVBEZ(self, value):
760     self.JVBEZ = value
761 wilde 47
762 wilde 2 def Set_KRV(self, value):
763 wilde 11 assert value in (0,1), "must be 0 or 1"
764 wilde 2 self.KRV = value
765 wilde 47
766 wilde 2 def Set_LZZ(self, value):
767 wilde 11 assert value in (1,2,3,4), \
768     "must be in range 1-4 (JAHR, MONAT, WOCHE, TAG)"
769 wilde 2 self.LZZ = value
770 wilde 47
771 wilde 2 def Set_R(self, value):
772 wilde 11 assert value >= 0.0 and value <= 100.0, \
773     "must be in range 0.0-100.0 (Percent)"
774 wilde 2 self.R = value
775 wilde 47
776     def Set_RE4(self, value):
777     assert value >= 0, "must not be negative"
778     self.RE4 = value
779    
780 wilde 2 def Set_SONSTB(self, value):
781     self.SONSTB = value
782 wilde 47
783     def Set_STERBE(self, value):
784     self.STERBE = value
785    
786 wilde 2 def Set_STKL(self, value):
787 wilde 11 assert value in (1,2,3,4,5,6), \
788     "must be in range 1-6 (I II III IV V VI)"
789 wilde 2 self.STKL = value
790 wilde 47
791 wilde 2 def Set_VBEZ(self, value):
792     self.VBEZ = value
793    
794     def Set_VBEZM(self, value):
795     self.VBEZM = value
796    
797     def Set_VBEZS(self, value):
798     self.VBEZS = value
799    
800     def Set_VBS(self, value):
801     self.VBS = value
802    
803 wilde 47 def Set_VJAHR(self, value):
804     self.VJAHR = value
805    
806     def Set_VKAPA(self, value):
807     self.VKAPA = value
808    
809 wilde 2 def Set_VMT(self, value):
810     self.VMT = value
811    
812     def Set_WFUNDF(self, value):
813     self.WFUNDF = value
814    
815     def Set_ZKF(self, value):
816 wilde 20 assert float(value) == float("%.1f" % value) and \
817     value >= 0, \
818     "must be positive, and must not have more than one decimal digit"
819 wilde 2 self.ZKF = value
820 wilde 47
821 wilde 2 def Set_ZMVB(self, value):
822     self.ZMVB = value
823    
824 wilde 3 # --------------------------------------------------------------------
825 wilde 4 # Eine etwas schönere API
826 wilde 3 #
827 wilde 4 # FIX ME: Diese API berücksichtigt nicht alle Möglichen Parameter und
828     # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrjährigen
829     # Bezügen und Sonstigen Leistungen.
830 wilde 2
831 wilde 67 class LStRechner2007(LST):
832 wilde 3 def __init__(self):
833     LST.__init__(self)
834 wilde 47
835 wilde 53 def SetGeb(self, geb):
836     """Setzt das Geburtsjahr"""
837     self.Set_AJAHR(geb + 65)
838 wilde 67 if self.AJAHR <= 2007:
839 wilde 53 self.Set_ALTER1(1)
840     else:
841     self.Set_ALTER1(0)
842    
843 wilde 3 def SetLohn(self, lohn):
844 wilde 4 """Setzt Lohn in Euro.Cent"""
845 wilde 26 self.Set_RE4(round (lohn * 100.0))
846 wilde 2
847 wilde 26 def GetLohn(self):
848     """Liefert Lohn in Euro.Cent"""
849     return self.RE4 / 100.0
850    
851 wilde 3 def SetZeitraum(self, lzz):
852 wilde 4 """Setzt Berechnungszeitraum (JAHR, MONAT, WOCHE, TAG)"""
853 wilde 2 self.Set_LZZ(lzz)
854    
855 wilde 26 def GetZeitraum(self):
856     """Liefert Berechnungszeitraum (JAHR, MONAT, WOCHE, TAG)"""
857     return self.LZZ
858    
859 wilde 3 def SetSteuerklasse(self, stkl):
860 wilde 4 """Setzt Steuerklasse (I, II, III, IV, V, VI)"""
861 wilde 2 self.Set_STKL(stkl)
862    
863 wilde 26 def GetSteuerklasse(self):
864     """Liefert Steuerklasse (I, II, III, IV, V, VI)"""
865     return self.STKL
866    
867     def SetKirchensteuerProzent(self, prozent):
868     """Setzt Kirchensteuer in Prozent,
869     0 wenn keine Kirchensteuer zu zahlen ist."""
870 wilde 4 self.Set_R(prozent)
871    
872 wilde 26 def GetKirchensteuerProzent(self):
873     """Liefert Kirchensteuer in Prozent
874     oder 0 wenn keine Kirchensteuer zu zahlen ist."""
875     return self.R
876    
877 wilde 20 def SetKinderfreibetrag(self, kfb):
878     """Setzt Kinderfreibetrag lt. Lohnsteuerkarte"""
879     self.Set_ZKF(kfb)
880    
881 wilde 26 def GetKinderfreibetrag(self):
882     """Liefert Kinderfreibetrag lt. Lohnsteuerkarte"""
883     return self.ZFK
884    
885 wilde 3 def GetLohnsteuer(self):
886 wilde 4 """Liefert Lohnsteuer in Euro.Cent"""
887 wilde 2 return round(self.LSTLZZ / 100, 2)
888 wilde 4
889     def GetSoli(self):
890     """Liefert Solidaritätszuschlag in Euro.Cent"""
891 wilde 13 return FixedPointFloor(self.SOLZLZZ / 100, 2)
892 wilde 4
893     def GetKirchensteuer(self):
894     """Liefert Kirchensteuer in Euro.Cent"""
895     return FixedPointFloor(self.BK * self.R / 10000, 2)

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26