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

Annotation of /trunk/LST2008.py

Parent Directory Parent Directory | Revision Log Revision Log

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