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

Diff of /trunk/LST2008.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/LST2007.py revision 64 by wilde, Thu Jan 25 08:19:44 2007 UTC trunk/LST2008.py revision 81 by frank, Wed Feb 11 11:04:42 2009 UTC
# Line 1  Line 1 
1  # -*- coding: iso-8859-1 -*-  # -*- coding: iso-8859-1 -*-
2  # --------------------------------------------------------------------  # --------------------------------------------------------------------
3  # LST2006 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2006  # LST2008 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2008
4  # $Id$  # $Id$
5  # --------------------------------------------------------------------  # --------------------------------------------------------------------
6  #  #
7  # Copyright (c) 2005, 2006 by Intevation GmbH  # Copyright (c) 2005, 2006, 2007, 2008 by Intevation GmbH
8  # Authors:  # Authors:
9  # Sascha Wilde <[email protected]>  # Sascha Wilde <[email protected]>
10  #  #
# Line 14  Line 14 
14  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan
15     wie im offiziellen Programmablaufplan des Bundesfinanzministerium     wie im offiziellen Programmablaufplan des Bundesfinanzministerium
16     dokumentiert.     dokumentiert.
17     http://www.bundesfinanzministerium.de/Service/Interaktiver-Steuerrechner-.577.htm"""     https://www.abgabenrechner.de/pruefdaten/pap2008.pdf"""
18    
19  __version__ = "$Revision$"  __version__ = "$Revision$"
20  # $Source$  # $Source:$
21    
22  def _ModulVersion():  def _ModulVersion():
23      return __version__[11:-2]      return __version__[11:-2]
# Line 51  VI  = 6 Line 51  VI  = 6
51    
52  class LST:  class LST:
53      def __init__(self,      def __init__(self,
54                   AJAHR =1964,                   AJAHR   =1964,
55                   ALTER1=0,                   ALTER1  =0,
56                   HINZUR=0,                   JFREIB  =0,
57                   JFREIB=0,                   JHINZU  =0,
58                   JHINZU=0,                   JRE4    =0,
59                   JRE4  =0,                   JVBEZ   =0,
60                   JVBEZ =0,                   KRV     =0,
61                   KRV   =0,                   LZZ     =2,
62                   LZZ   =2,                   LZZFREIB=0,
63                   R     =0,                   LZZHINZU=0,
64                   RE4   =0,                   R       =0,
65                   SONSTB=0,                   RE4     =0,
66                   STERBE=0,                   SONSTB  =0,
67                   STKL  =1,                   STERBE  =0,
68                   VBEZ  =0,                   STKL    =1,
69                   VBEZM =0,                   VBEZ    =0,
70                   VBEZS =0,                   VBEZM   =0,
71                   VBS   =0,                   VBEZS   =0,
72                   VJAHR =0,                   VBS     =0,
73                   VKAPA =0,                   VJAHR   =0,
74                   VMT   =0,                   VKAPA   =0,
75                   WFUNDF=0,                   VMT     =0,
76                   ZKF   =0,                   ZKF     =0,
77                   ZMVB  =0):                   ZMVB    =0):
78          self.Set_AJAHR(AJAHR)          self.Set_AJAHR(AJAHR)
79          self.Set_ALTER1(ALTER1)          self.Set_ALTER1(ALTER1)
         self.Set_HINZUR(HINZUR)  
80          self.Set_JFREIB(JFREIB)          self.Set_JFREIB(JFREIB)
81          self.Set_JHINZU(JHINZU)          self.Set_JHINZU(JHINZU)
82          self.Set_JRE4(JRE4)          self.Set_JRE4(JRE4)
83          self.Set_JVBEZ(JVBEZ)          self.Set_JVBEZ(JVBEZ)
84          self.Set_KRV(KRV)          self.Set_KRV(KRV)
85          self.Set_LZZ(LZZ)          self.Set_LZZ(LZZ)
86            self.Set_LZZFREIB(LZZFREIB)
87            self.Set_LZZHINZU(LZZHINZU)
88          self.Set_R(R)          self.Set_R(R)
89          self.Set_RE4(RE4)          self.Set_RE4(RE4)
90          self.Set_SONSTB(SONSTB)          self.Set_SONSTB(SONSTB)
# Line 96  class LST: Line 97  class LST:
97          self.Set_VJAHR(VJAHR)          self.Set_VJAHR(VJAHR)
98          self.Set_VKAPA(VKAPA)          self.Set_VKAPA(VKAPA)
99          self.Set_VMT(VMT)          self.Set_VMT(VMT)
         self.Set_WFUNDF(WFUNDF)  
100          self.Set_ZKF(ZKF)          self.Set_ZKF(ZKF)
101          self.Set_ZMVB(ZMVB)          self.Set_ZMVB(ZMVB)
102          # Vorgegebene Ausgangsparameter          # Vorgegebene Ausgangsparameter
# Line 116  class LST: Line 116  class LST:
116          # Interne Felder          # Interne Felder
117          # Laut Dokumentation sollen diese vor der Berechnung gel�scht werden,          # Laut Dokumentation sollen diese vor der Berechnung gel�scht werden,
118          # es ist mir nicht klar, ob das wirklich n�tig ist...          # es ist mir nicht klar, ob das wirklich n�tig ist...
119          self._ALTE = 0          self._ALTE = 0.0        # 2 Dezimalstellen
120          self._ANP = 0          self._ANP = 0
121          self._ANTEIL1 = 0          self._ANTEIL1 = 0
122          self._ANTEIL2 = 0          self._ANTEIL2 = 0
123          self._BMG = 0          self._BMG = 0.0         # 2 Dezimalstellen
124          self._DIFF = 0          self._DIFF = 0
125          self._EFA = 0          self._EFA = 0
126          self._FVB = 0          self._FVB = 0.0         # 2 Dezimalstellen
127            self._FVBSO = 0.0       # 2 Dezimalstellen
128          self._FVBZ = 0          self._FVBZ = 0
129            self._FVBZSO = 0
130            self._FVBZOSO = 0
131            self._HBALTE = 0
132          self._HFVB = 0          self._HFVB = 0
133            self._HFVBZ = 0.0       # 2 Dezimalstellen
134            self._HFVBZSO = 0.0     # 2 Dezimalstellen
135          self._J = 0          self._J = 0
136          self._JBMG = 0          self._JBMG = 0
137            self._JLFREIB = 0.0     # 2 Dezimalstellen
138            self._JLHINZU = 0.0     # 2 Dezimalstellen
139          self._JW = 0          self._JW = 0
140          self._K = 0          self._K = 0
141          self._KENNZ = 0          self._KENNVMT = 0
142          self._KFB = 0          self._KFB = 0
143          self._KZTAB = 1          self._KZTAB = 1
144          self._LSTJAHR = 0          self._LSTJAHR = 0
145          self._LST1 = 0          self._LST1 = 0
146          self._LST2 = 0          self._LST2 = 0
147          self._LST3 = 0          self._LST3 = 0
148            self._LSTOSO = 0
149            self._LSTSO = 0
150          self._MIST = 0          self._MIST = 0
         self._RE4LZZ = 0  
         self._RE4LZZV = 0  
151          self._RW = 0.0          self._RW = 0.0
152          self._SAP = 0          self._SAP = 0
153          self._SOLZFREI = 0          self._SOLZFREI = 0
154          self._SOLZJ = 0.0  # 2 Dezimalstellen          self._SOLZJ = 0.0       # 2 Dezimalstellen
155          self._SOLZMIN = 0.0  # 2 Dezimalstellen          self._SOLZMIN = 0.0     # 2 Dezimalstellen
156          self._ST = 0          self._ST = 0
157          self._ST1 = 0          self._ST1 = 0
158          self._ST2 = 0          self._ST2 = 0
# Line 298  class LST: Line 306  class LST:
306                        38,  # 2039                        38,  # 2039
307                         0)  # 2040                         0)  # 2040
308          self._VBEZB = 0          self._VBEZB = 0
309            self._VBEZBSO = 0
310          self._VHB = 0          self._VHB = 0
311          self._VSP = 0.0  # 2 Dezimalstellen          self._VSP = 0.0         # 2 Dezimalstellen
312          self._VSPN = 0          self._VSPN = 0
313          self._VSP1 = 0.0  # 2 Dezimalstellen          self._VSP1 = 0.0        # 2 Dezimalstellen
314          self._VSP2 = 0.0  # 2 Dezimalstellen          self._VSP2 = 0.0        # 2 Dezimalstellen
315          self._VSPKURZ = 0          self._VSPKURZ = 0
316          self._VSPMAX1 = 0          self._VSPMAX1 = 0
317          self._VSPMAX2 = 0          self._VSPMAX2 = 0
318          self._VSPO = 0.0  # 2 Dezimalstellen          self._VSPO = 0.0        # 2 Dezimalstellen
319          self._VSPREST = 0.0  # 2 Dezimalstellen          self._VSPREST = 0.0     # 2 Dezimalstellen
320          self._VSPVOR = 0.0  # 2 Dezimalstellen          self._VSPVOR = 0.0      # 2 Dezimalstellen
321          self._X = 0.0  # 2 Dezimalstellen          self._X = 0.0           # 2 Dezimalstellen
322          self._Y = 0.0  # 6 Dezimalstellen          self._Y = 0.0           # 6 Dezimalstellen
323          self._ZRE4 = 0.0  # 2 Dezimalstellen          self._ZRE4 = 0.0        # 2 Dezimalstellen
324          self._ZRE4VP = 0.0  # 2 Dezimalstellen          self._ZRE4J = 0.0       # 2 Dezimalstellen
325          self._ZRE4VP1 = 0.0  # 2 Dezimalstellen          self._ZRE4OSO = 0.0     # 2 Dezimalstellen
326          self._ZTABFB = 0          self._ZRE4VMT = 0.0     # 2 Dezimalstellen
327          self._ZVBEZ = 0          self._ZRE4VP = 0.0      # 2 Dezimalstellen
328          self._ZVE = 0          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          self._ZX = 0          self._ZX = 0
334          self._ZZX = 0          self._ZZX = 0
335          self._HOCH = 0          self._HOCH = 0
336          self._VERGL = 0          self._VERGL = 0
337          # ------------------------------------------------------------          # ------------------------------------------------------------
338          # Anfang der Berechnung          # Anfang der Berechnung
339          self._MRE4LZZ()          self._MRE4JL()
         self._KENNZ = 0  
         self._RE4LZZ = self.RE4 - self._FVB \  
                         - self._ALTE - self.WFUNDF \  
                         + self.HINZUR  
         self._RE4LZZV = self.RE4 - self._FVB - self._ALTE  
340          self._MRE4()          self._MRE4()
341            self._MRE4ABZ()
342          self._MZTABFB()          self._MZTABFB()
343            self._KENNVMT = 0
344          self._MLSTJAHR()          self._MLSTJAHR()
345          self._LSTJAHR = self._ST          self._LSTJAHR = self._ST
346          self._JW = self._LSTJAHR * 100          self._JW = self._LSTJAHR * 100
# Line 347  class LST: Line 357  class LST:
357          self._MVMT()          self._MVMT()
358    
359      # Benutzte Unterprogramme:      # Benutzte Unterprogramme:
360      def _MRE4LZZ(self):      def _MRE4JL(self):
361          if self.VBEZ == 0:          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              self._FVBZ = 0              self._FVBZ = 0
385              self._FVB = 0              self._FVB = 0
386                self._FVBZSO = 0
387                self._FVBSO = 0
388          else:          else:
389              if self.VJAHR < 2006:              if self.VJAHR < 2006:
390                  self._J = 1                  self._J = 1
391              elif self.VJAHR < 2040:              elif self.VJAHR < 2040:
392                  self._J = VJAHR - 2004                  self._J = self.VJAHR - 2004
393              else:              else:
394                  self._J = 36                  self._J = 36
395              if self.LZZ == 1:              if self.LZZ == 1:
396                  if ( self.STERBE + self.VKAPA ) > 0:                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
397                      self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS                  self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB
398                      self._HFVB = self._TAB2[self._J] * 100                  self._FVBZ = ceil(self._TAB3[self._J] / 12 * self.ZMVB)
                     self._FVBZ = self._TAB3[self._J]  
                 else:  
                     self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS  
                     self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB * 100  
                     self._FVBZ = ceil(self._TAB3[self._J] / 12 * self.ZMVB)  
399              else:              else:
400                  self._VBEZB = self.VBEZM * 12 + self.VBEZS                  self._VBEZB = self.VBEZM * 12 + self.VBEZS
401                  self._HFVB = self._TAB2[self._J] * 100                  self._HFVB = self._TAB2[self._J]
402                  self._FVBZ = self._TAB3[self._J]                  self._FVBZ = self._TAB3[self._J]
403              self._FVB = ceil(self._VBEZB * self._TAB1[self._J])              self._FVB = self._VBEZB * self._TAB1[self._J] / 100
404              if self._FVB > self._HFVB:              if self._FVB > self._HFVB:
405                  self._FVB = self._HFVB                  self._FVB = self._HFVB
406              self._JW = self._FVB              self._VBEZBSO = self.STERBE + self.VKAPA
407              self._UPANTEIL()              self._FVBSO = FixedPointCeil(self._FVB + self._VBEZBSO
408              self._FVB = self._ANTEIL2                                           * 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          if self.ALTER1 == 0:          if self.ALTER1 == 0:
423              self._ALTE = 0              self._ALTE = 0
424          else:          else:
# Line 386  class LST: Line 428  class LST:
428                  self._K = self.AJAHR - 2004                  self._K = self.AJAHR - 2004
429              else:              else:
430                  self._K = 36                  self._K = 36
431              self._BMG = self.RE4 - self.VBEZ              self._BMG = self._ZRE4J - self._ZVBEZJ
432              self._ALTE = ceil(self._BMG * self._TAB4[self._K])              self._ALTE = FixedPointCeil(self._BMG * self._TAB4[self._K])
433              self._JW = self._TAB5[self._K] * 100              self._HBALTE = self._TAB5[self._K]
434              self._UPANTEIL()              if self._ALTE > self._HBALTE:
435              if self._ALTE > self._ANTEIL2:                  self._ALTE = self._HBALTE
                 self._ALTE = self._ANTEIL2  
436    
437      def _MRE4(self):      def _MRE4ABZ(self):
438          if self.LZZ == 1:          self._ZRE4 = self._ZRE4J - self._FVB - self._ALTE - self._JLFREIB + self._JLHINZU
             self._ZRE4 = FixedPointFloor(self._RE4LZZ / 100.0)  
             self._ZRE4VP = FixedPointFloor(self._RE4LZZV / 100.0)  
             self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB) / 100.0)  
         elif self.LZZ == 2:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.67) * 0.12)  
             self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.67) * 0.12)  
         elif self.LZZ == 3:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.89) * 3.6 / 7)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.89) * 3.6 / 7)  
             self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.89) * 3.6 / 7)  
         else:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 0.56) * 3.6)  
             self._ZVBEZ = FixedPointFloor((self.VBEZ - self._FVB + 0.56) * 3.6)  
439          if self._ZRE4 < 0:          if self._ZRE4 < 0:
440              self._ZRE4 = 0.0              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:          if self._ZVBEZ < 0:
446              self._ZVBEZ = 0.0              self._ZVBEZ = 0
447    
448      def _MZTABFB(self):      def _MZTABFB(self):
449          self._ANP = 0          self._ANP = 0
450          if (self._ZVBEZ > 0) and (self._ZVBEZ < self._FVBZ):          if (self._ZVBEZ >= 0) and (self._ZVBEZ < self._FVBZ):
451              self._FVBZ = self._ZVBEZ              self._FVBZ = self._ZVBEZ
452          if (self.STKL < 6) and (self._ZVBEZ > 0):          if (self.STKL < 6):
453              if (self._ZVBEZ - self._FVBZ) < 102:              if (self._ZVBEZ > 0):
454                  self._ANP = self._ZVBEZ - self._FVBZ                  if (self._ZVBEZ - self._FVBZ) < 102:
455              else:                      self._ANP = self._ZVBEZ - self._FVBZ
456                  self._ANP = 102                  else:
457                        self._ANP = 102
458            else:
459                self._FVBZ = 0
460                self._FVBZSO = 0
461          if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):          if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):
462              if (self._ZRE4 - self._ZVBEZ) < 920:              if (self._ZRE4 - self._ZVBEZ) < 920:
463                  self._ANP = self._ANP + self._ZRE4 - self._ZVBEZ                  self._ANP += self._ZRE4 - self._ZVBEZ
464              else:              else:
465                  self._ANP = self._ANP + 920                  self._ANP += 920
466          self._KZTAB = 1          self._KZTAB = 1
467          if self.STKL == 1:          if self.STKL == 1:
468              self._SAP = 36              self._SAP = 36
# Line 453  class LST: Line 487  class LST:
487              self._UPEVP()              self._UPEVP()
488          else:          else:
489              self._VSP = 0.0              self._VSP = 0.0
490          self._ZVE = self._ZRE4 - self._ZTABFB - self._VSP          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          if self._ZVE < 1:          if self._ZVE < 1:
497              self._ZVE = self._X = 0.0              self._ZVE = self._X = 0.0
498          else:          else:
499              self._X = floor(float(self._ZVE) / self._KZTAB)              self._X = floor(float(self._ZVE) / self._KZTAB)
500          if self.STKL < 5:          if self.STKL < 5:
501              self._UPTAB05()              self._UPTAB07()
502          else:          else:
503              self._MST5_6()              self._MST5_6()
504    
505      def _UPEVP(self):      def _UPEVP(self):
506          if self.KRV == 1:          if self.KRV > 0:
507              self._VSP1 = 0.0              self._VSP1 = 0.0
508          else:          else:
509              if self._ZRE4VP > 63000:              if self._ZRE4VP > 63600:
510                  self._ZRE4VP = 63000                  self._ZRE4VP = 63600
511              self._VSP1 = 0.24 * self._ZRE4VP              self._VSP1 = FixedPointFloor(0.32 * self._ZRE4VP)
512              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0975)              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0995)
513          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)          self._VSP2 = FixedPointFloor(0.11 * self._ZRE4VP)
514          self._VHB = 1500 * self._KZTAB          self._VHB = 1500 * self._KZTAB
515          if self._VSP2 > self._VHB:          if self._VSP2 > self._VHB:
# Line 481  class LST: Line 520  class LST:
520              self._VSP = self._VSPN              self._VSP = self._VSPN
521    
522      def _MVSP(self):      def _MVSP(self):
523          if self._KENNZ == 1:          self._VSPO = self._ZRE4VP * 0.2
             self._VSPO = self._ZRE4VP1 * 0.2  
         else:  
             self._VSPO = self._ZRE4VP * 0.2  
524          self._VSPVOR = 3068 * self._KZTAB          self._VSPVOR = 3068 * self._KZTAB
525          self._VSPMAX1 = 1334 * self._KZTAB          self._VSPMAX1 = 1334 * self._KZTAB
526          self._VSPMAX2 = 667 * self._KZTAB          self._VSPMAX2 = 667 * self._KZTAB
# Line 493  class LST: Line 529  class LST:
529              if self._VSPO > self._VSPKURZ:              if self._VSPO > self._VSPKURZ:
530                  self._VSP = self._VSPKURZ                  self._VSP = self._VSPKURZ
531              else:              else:
532                  self._VSP = ceil(self._VSPO)                  self._VSP = floor(self._VSPO)
533          else:          else:
534              self._UMVSP()              self._UMVSP()
535    
536      def _UMVSP(self):      def _UMVSP(self):
537          if self._KENNZ == 1:          self._VSPVOR -= self._ZRE4VP * 0.16
             self._VSPVOR = self._VSPVOR - self._ZRE4VP1 * 0.16  
         else:  
             self._VSPVOR = self._VSPVOR - self._ZRE4VP * 0.16  
538          if self._VSPVOR < 0:          if self._VSPVOR < 0:
539              self._VSPVOR = 0.0              self._VSPVOR = 0.0
540          if self._VSPO > self._VSPVOR:          if self._VSPO > self._VSPVOR:
# Line 511  class LST: Line 544  class LST:
544                  self._VSP += self._VSPMAX1                  self._VSP += self._VSPMAX1
545                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)                  self._VSPREST = FixedPointCeil((self._VSPREST - self._VSPMAX1) / 2.0)
546                  if self._VSPREST > self._VSPMAX2:                  if self._VSPREST > self._VSPMAX2:
547                      self._VSP = ceil(self._VSP + self._VSPMAX2)                      self._VSP = floor(self._VSP + self._VSPMAX2)
548                  else:                  else:
549                      self._VSP = ceil(self._VSP + self._VSPREST)                      self._VSP = floor(self._VSP + self._VSPREST)
550              else:              else:
551                  self._VSP = ceil(self._VSP + self._VSPREST)                  self._VSP = floor(self._VSP + self._VSPREST)
552          else:          else:
553              self._VSP = ceil(self._VSPO)              self._VSP = floor(self._VSPO)
554    
555      def _MST5_6(self):      def _MST5_6(self):
556          self._ZZX = self._X          self._ZZX = self._X
557          if self._ZZX > 25812:          if self._ZZX > 25812:
558              self._ZX = 25812              self._ZX = 25812
559              self._UP5_6()              self._UP5_6()
560              self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)              if self._ZZX > 200000:
561                    self._ST += (200000 - 25812) * 0.42
562                    self._ST = floor(self._ST + (self._ZZX - 200000) * 0.45)
563                else:
564                    self._ST = floor(self._ST + (self._ZZX - 25812) * 0.42)
565          else:          else:
566              self._ZX = self._ZZX              self._ZX = self._ZZX
567              self._UP5_6()              self._UP5_6()
# Line 540  class LST: Line 577  class LST:
577    
578      def _UP5_6(self):      def _UP5_6(self):
579          self._X = self._ZX * 1.25          self._X = self._ZX * 1.25
580          self._UPTAB05()          self._UPTAB07()
581          self._ST1 = self._ST          self._ST1 = self._ST
582          self._X = self._ZX * 0.75          self._X = self._ZX * 0.75
583          self._UPTAB05()          self._UPTAB07()
584          self._ST2 = self._ST          self._ST2 = self._ST
585          self._DIFF = (self._ST1 - self._ST2) * 2          self._DIFF = (self._ST1 - self._ST2) * 2
586          self._MIST = floor(self._ZX * 0.15)          self._MIST = floor(self._ZX * 0.15)
# Line 585  class LST: Line 622  class LST:
622              self._ANTEIL1 = floor(self._JW / 360.0)              self._ANTEIL1 = floor(self._JW / 360.0)
623              self._ANTEIL2 = ceil(self._JW / 360.0)              self._ANTEIL2 = ceil(self._JW / 360.0)
624    
625      def _UPTAB05(self):      def _UPTAB07(self):
626          if self._X < 7665:          if self._X < 7665:
627              self._ST = 0              self._ST = 0
628          elif self._X < 12740:          elif self._X < 12740:
# Line 599  class LST: Line 636  class LST:
636              self._RW += 2397              self._RW += 2397
637              self._RW *= self._Y              self._RW *= self._Y
638              self._ST = floor(self._RW + 989)              self._ST = floor(self._RW + 989)
639          else:          elif self._X < 250001:
640              self._ST = floor(self._X * 0.42 - 7914)              self._ST = floor(self._X * 0.42 - 7914)
641            else:
642                self._ST = floor(self._X * 0.45 - 15414)
643          self._ST *= self._KZTAB          self._ST *= self._KZTAB
644    
645      def _MSONST(self):      def _MSONST(self):
646          if self.SONSTB > 0:          # ------------------------------
647              # ------------------------------          # Nicht im offiziellen Programm-
648              # Nicht im offiziellen Programm-          # ablaufplan: Attribute sichern
649              # ablaufplan: Attribute sichern          old_lzz = self.LZZ
650              old_lzz = self.LZZ          # ------------------------------
651              old_vbez = self.VBEZ          self.LZZ = 1
652              old_re4 = self.RE4          if self.ZMVB == 0:
653              # ------------------------------              self.ZMVB = 12
654              self.LZZ = 1          if self.SONSTB == 0:
655              self.VBEZ = self.JVBEZ              self._LSTSO = 0
656              self.RE4 = self.JRE4              self.STS = 0
657              self._MRE4LZZ()              self.SOLZS = 0
658              self._MRE4LZZ2()              self.BKS = 0
659              self._MLSTJAHR()          else:
660              self._LST1 = self._ST * 100              self._MOSONST()
661              self.VBEZ = self.JVBEZ + self.VBS              self._ZRE4J = (self.JRE4 + self.SONSTB) / 100
662              self.RE4 = self.JRE4 + self.SONSTB              self._ZVBEZJ = (self.JVBEZ + self.VBS) / 100
663              self.VBEZS = self.VBEZS + self.STERBE              self._MRE4SONST()
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
664              self._MLSTJAHR()              self._MLSTJAHR()
665              self._LST2 = self._ST * 100              self._LSTSO = self._ST * 100
666              self.STS = self._LST2 - self._LST1              self.STS = self._LSTSO - self._LSTOSO
667                if self.STS < 0:
668                    self.STS = 0
669              self.SOLZS = floor(self.STS * 5.5 / 100)              self.SOLZS = floor(self.STS * 5.5 / 100)
670              if self.R > 0:              if self.R > 0:
671                  self.BKS = self.STS                  self.BKS = self.STS
672              else:              else:
673                  self.BKS = 0                  self.BKS = 0
             # ------------------------------  
             # Nicht im offiziellen Programm-  
             # ablaufplan: Attribute  
             # wiederherstellen  
             self.LZZ = old_lzz  
             self.VBEZ = old_vbez  
             self.RE4 = old_re4  
             # ------------------------------  
         else:  
             self.STS = 0  
             self.SOLZS = 0  
             self.BKS = 0  
   
     def _MRE4LZZ2(self):  
         self._RE4LZZ = self.RE4 - self._FVB - self._ALTE \  
                        - self.JFREIB + self.JHINZU  
         self._RE4LZZV = self.RE4 - self._FVB - self._ALTE  
         self._MRE4()  
         self._MZTABFB()  
   
     def _MVMT(self):  
674          # ------------------------------          # ------------------------------
675          # Nicht im offiziellen Programm-          # Nicht im offiziellen Programm-
676          # ablaufplan: Attribute sichern          # ablaufplan: Attribute
677          old_lzz = self.LZZ          # wiederherstellen
678          old_vbez = self.VBEZ          self.LZZ = old_lzz
         old_re4 = self.RE4  
679          # ------------------------------          # ------------------------------
680    
681        def _MVMT(self):
682            if self.VKAPA < 0:
683                self.VKAPA = 0
684          if (self.VMT + self.VKAPA) > 0:          if (self.VMT + self.VKAPA) > 0:
685              self.LZZ = 1              if self._LSTOSO == 0:
686              self.VBEZ = self.JVBEZ + self.VBS                  self._MOSONST()
687              self.RE4 = self.JRE4 + self.SONSTB                  self._LSTOSO = self._LST1
688              self._MRE4LZZ()              else:
689              self._MRE4LZZ2()                  self._LSTSO = self._LST1
690              self._MLSTJAHR()              self._ZRE4OSO = self._ZRE4
691              self._LST1 = self._ST * 100              self._ZTABFBOSO = self._ZTABFB
692              self.VMT = self.VMT + self.VKAPA              self._FVBZOSO = self._FVBZ
693              self.VBEZS = self.VBEZS + self.VKAPA              self._ZRE4J = (self._ZRE4 + self.SONSTB + self.VBS + self.VKAPA) / 100
694              self.VBEZ = self.VBEZ + self.VKAPA              self._MRE4SONST()
             self.RE4 = self.JRE4 + self.SONSTB + self.VMT  
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
             self._KENNZ = 1  
             self._ZRE4VP1 = self._ZRE4VP  
695              self._MLSTJAHR()              self._MLSTJAHR()
696              self._LST3 = self._ST * 100              self._LST3 = self._ST * 100
697              self.VBEZ = self.VBEZ - self.VKAPA              self._ZTABFB = self._ZTABFB - self._FVBZ + self._FVBZOSO
698              self.RE4 = self.JRE4 + self.SONSTB              self._KENNVMT = 1
699              self._MRE4LZZ()              if (self.RE4 + self.SONSTB - self.JFREIB + self.JHINZU) < 0:
700              if (self.RE4 - self.JFREIB + self.JHINZU) < 0:                  self._KENNVMT = 2
                 self.RE4 = self.RE4 - self.JFREIB + self.JHINZU  
                 self.JFREIB = 0  
                 self.JHINZU = 0  
                 self.RE4 = (self.RE4 + self.VMT) / 5  
                 self._MRE4LZZ2()  
701                  self._MLSTJAHR()                  self._MLSTJAHR()
702                  self._LST2 = self._ST * 100                  self._LST2 = self._ST * 100
703                  self.STV = self._LST2 * 5                  self.STV = self._LST2 * 5
704              else:              else:
705                  self.RE4 = self.RE4 + self.VMT / 5                  self._ZRE4VMT = (self.VMT / 100 + self.VKAPA / 100
706                  self._MRE4LZZ2()                                   - self._ZTABFB + self._ZTABFBOSO) / 5
707                  self._MLSTJAHR()                  self._MLSTJAHR()
708                  self._LST2 = self._ST * 100                  self._LST2 = self._ST * 100
709                  self.STV = (self._LST2 - self._LST1) * 5                  self.STV = (self._LST2 - self._LST1) * 5
710              self._LST3 -= self._LST1              self._LST3 -= self._LST1
711              if self._LST3 < self.STV:              if self._LST3 < self.STV:
712                  self.STV = self._LST3                  self.STV = self._LST3
713                if self.STV < 0:
714                    self.STV = 0
715              self.SOLZV = floor(self.STV * 5.5 / 100)              self.SOLZV = floor(self.STV * 5.5 / 100)
716              if self.R > 0:              if self.R > 0:
717                  self.BKV = self.STV                  self.BKV = self.STV
718              else:              else:
719                  self.BKV = 0                  self.BKV = 0
             # ------------------------------  
             # Nicht im offiziellen Programm-  
             # ablaufplan: Attribute  
             # wiederherstellen  
             self.LZZ = old_lzz  
             self.VBEZ = old_vbez  
             self.RE4 = old_re4  
             # ------------------------------  
720          else:          else:
721              self.STV = 0              self.STV = 0
722              self.SOLZV = 0              self.SOLZV = 0
723              self.BKV = 0              self.BKV = 0
724    
725        def _MOSONST(self):
726            self._ZRE4J = self.JRE4 / 100
727            self._ZVBEZJ = self.JVBEZ / 100
728            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        def _MRE4SONST(self):
737            self._MRE4()
738            self._FVBSO = self._FVB
739            self._MRE4ABZ()
740            self._FVBZSO = self._FVBZ
741            self._MZTABFB()
742    
743      # Methoden zum gepr�ften setzen der Wert      # Methoden zum gepr�ften setzen der Wert
744      # FIX ME: Pr�fung _sehr_ unvollst�ndig      # FIX ME: Pr�fung _sehr_ unvollst�ndig
745    
# Line 729  class LST: Line 752  class LST:
752          assert value in (0,1), "must be 0 or 1"          assert value in (0,1), "must be 0 or 1"
753          self.ALTER1 = value          self.ALTER1 = value
754    
     def Set_HINZUR(self, value):  
         self.HINZUR = value  
   
755      def Set_JFREIB(self, value):      def Set_JFREIB(self, value):
756          self.JFREIB = value          self.JFREIB = value
757    
# Line 745  class LST: Line 765  class LST:
765          self.JVBEZ = value          self.JVBEZ = value
766    
767      def Set_KRV(self, value):      def Set_KRV(self, value):
768          assert value in (0,1), "must be 0 or 1"          assert value in (0,1,2), "must be 0, 1 or 2"
769          self.KRV = value          self.KRV = value
770    
771      def Set_LZZ(self, value):      def Set_LZZ(self, value):
# Line 753  class LST: Line 773  class LST:
773                 "must be in range 1-4 (JAHR, MONAT, WOCHE, TAG)"                 "must be in range 1-4 (JAHR, MONAT, WOCHE, TAG)"
774          self.LZZ = value          self.LZZ = value
775    
776        def Set_LZZFREIB(self, value):
777            self.LZZFREIB = value
778    
779        def Set_LZZHINZU(self, value):
780            self.LZZHINZU = value
781    
782      def Set_R(self, value):      def Set_R(self, value):
783          assert value >= 0.0 and value <= 100.0, \          assert value >= 0.0 and value <= 100.0, \
784                 "must be in range 0.0-100.0 (Percent)"                 "must be in range 0.0-100.0 (Percent)"
# Line 794  class LST: Line 820  class LST:
820      def Set_VMT(self, value):      def Set_VMT(self, value):
821          self.VMT = value          self.VMT = value
822    
     def Set_WFUNDF(self, value):  
         self.WFUNDF = value  
   
823      def Set_ZKF(self, value):      def Set_ZKF(self, value):
824          assert float(value) == float("%.1f" % value) and \          assert float(value) == float("%.1f" % value) and \
825                 value >= 0, \                 value >= 0, \
# Line 813  class LST: Line 836  class LST:
836  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen  # Berechnungen, es fehlen insbesondere die Berechnungen zu Mehrj�hrigen
837  # Bez�gen und Sonstigen Leistungen.  # Bez�gen und Sonstigen Leistungen.
838    
839  class LStRechner2006(LST):  class LStRechner2008(LST):
840      def __init__(self):      def __init__(self):
841          LST.__init__(self)          LST.__init__(self)
842    
843      def SetGeb(self, geb):      def SetGeb(self, geb):
844          """Setzt das Geburtsjahr"""          """Setzt das Geburtsjahr"""
845          self.Set_AJAHR(geb + 65)          self.Set_AJAHR(geb + 65)
846          if self.AJAHR <= 2006:          if self.AJAHR <= 2008:
847              self.Set_ALTER1(1)              self.Set_ALTER1(1)
848          else:          else:
849              self.Set_ALTER1(0)              self.Set_ALTER1(0)
# Line 833  class LStRechner2006(LST): Line 856  class LStRechner2006(LST):
856          """Liefert Lohn in Euro.Cent"""          """Liefert Lohn in Euro.Cent"""
857          return self.RE4 / 100.0          return self.RE4 / 100.0
858    
859        def GetLohnGesamt(self):
860            """Liefert Summe Arbeitslohn und sonstige Bez�ge."""
861            return (self.RE4 + self.SONSTB) / 100.0
862    
863        def SetSonstigeBezuege(self, sonstbez):
864            """Setzt Sonstige Bez�ge in Euro.Cent"""
865            self.Set_SONSTB(round(sonstbez * 100.0))
866    
867        def GetSonstigeBezuege(self):
868            """Setzt Sonstige Bez�ge in Euro.Cent"""
869            return self.SONSTB / 100.0
870    
871      def SetZeitraum(self, lzz):      def SetZeitraum(self, lzz):
872          """Setzt Berechnungszeitraum (JAHR, MONAT, WOCHE, TAG)"""          """Setzt Berechnungszeitraum (JAHR, MONAT, WOCHE, TAG)"""
873          self.Set_LZZ(lzz)          self.Set_LZZ(lzz)
# Line 868  class LStRechner2006(LST): Line 903  class LStRechner2006(LST):
903          return self.ZFK          return self.ZFK
904    
905      def GetLohnsteuer(self):      def GetLohnsteuer(self):
906          """Liefert Lohnsteuer in Euro.Cent"""          """Liefert Lohnsteuer f�r Lohnzahlungszeitraum in Euro.Cent"""
907          return round(self.LSTLZZ / 100, 2)          return round(self.LSTLZZ / 100, 2)
908    
909        def GetLohnsteuerGesamt(self):
910            """Gesamte Lohnsteuer auf Basis des Zahlungszeitraumes in Euro.Cent"""
911            return round((self.LSTLZZ + self.STS + self.STV) / 100, 2)
912    
913      def GetSoli(self):      def GetSoli(self):
914          """Liefert Solidarit�tszuschlag in Euro.Cent"""          """Liefert Solidarit�tszuschlag f�r Lohnzahlungszeitraum in Euro.Cent"""
915          return FixedPointFloor(self.SOLZLZZ / 100, 2)          return FixedPointFloor(self.SOLZLZZ / 100, 2)
916    
917        def GetSoliGesamt(self):
918            """Gesamten Solidarit�tszuschlag auf Basis des ZZ in Euro.Cent"""
919            return FixedPointFloor((self.SOLZLZZ + self.SOLZS + self.SOLZV)/ 100, 2)
920    
921      def GetKirchensteuer(self):      def GetKirchensteuer(self):
922          """Liefert Kirchensteuer in Euro.Cent"""          """Liefert Kirchensteuer f�r Lohnzahlungszeitraum in Euro.Cent"""
923          return FixedPointFloor(self.BK * self.R / 10000, 2)          return FixedPointFloor(self.BK * self.R / 10000, 2)
924    
925        def GetKirchensteuerGesamt(self):
926            """Gesamte Kirchensteuer auf Basis des ZZ in Euro.Cent"""
927            return FixedPointFloor((self.BK + self.BKS + self.BKV) \
928                                        * self.R / 10000, 2)
Legend:
Removed from v.64  
changed lines
  Added in v.81
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26