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

Diff of /trunk/LST2008.py

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

trunk/RCS/LST2005.py revision 14 by wilde, Thu Jan 13 12:29:19 2005 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 -*-
2  # --------------------------------------------------------------------  # --------------------------------------------------------------------
3  # LST2005 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2005  # LST2008 -- Python Modul zur Berechnung der Deutschen Lohnsteuer 2008
4  # $Id$  # $Id$
5  # --------------------------------------------------------------------  # --------------------------------------------------------------------
6  #  #
7  # Copyright (c) 2005 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 11  Line 12 
12  # Read the file COPYING coming with this package for details.  # Read the file COPYING coming with this package for details.
13    
14  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan  """Lohnsteuerberechnung nach dem offiziellen Programmablaufplan
15     wie in Programmablaufplan-LSt.pdf dokumentiert."""     wie im offiziellen Programmablaufplan des Bundesfinanzministerium
16       dokumentiert.
17       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 48  VI  = 6 Line 51  VI  = 6
51    
52  class LST:  class LST:
53      def __init__(self,      def __init__(self,
54                   RE4=0,                   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                   SONSTB=0,                   R       =0,
65                   STKL  =1,                   RE4     =0,
66                   VBEZ  =0,                   SONSTB  =0,
67                   VBEZM =0,                   STERBE  =0,
68                   VBEZS =0,                   STKL    =1,
69                   VBS   =0,                   VBEZ    =0,
70                   VMT   =0,                   VBEZM   =0,
71                   WFUNDF=0,                   VBEZS   =0,
72                   ZKF   =0,                   VBS     =0,
73                   ZMVB  =0):                   VJAHR   =0,
74          self.Set_RE4(RE4)                   VKAPA   =0,
75                     VMT     =0,
76                     ZKF     =0,
77                     ZMVB    =0):
78            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)
90          self.Set_SONSTB(SONSTB)          self.Set_SONSTB(SONSTB)
91            self.Set_STERBE(STERBE)
92          self.Set_STKL(STKL)          self.Set_STKL(STKL)
93          self.Set_VBEZ(VBEZ)          self.Set_VBEZ(VBEZ)
94          self.Set_VBEZM(VBEZM)          self.Set_VBEZM(VBEZM)
95          self.Set_VBEZS(VBEZS)          self.Set_VBEZS(VBEZS)
96          self.Set_VBS(VBS)          self.Set_VBS(VBS)
97            self.Set_VJAHR(VJAHR)
98            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 105  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
133            self._HFVBZ = 0.0       # 2 Dezimalstellen
134            self._HFVBZSO = 0.0     # 2 Dezimalstellen
135            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._KENNZ = 0          self._K = 0
141            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
159            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                        0.000) # 2040
196            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                           0)  # 2040
233            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                           0)  # 2040
270            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                           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          # Jetzt wirds richtig toll: X und Y          self._X = 0.0           # 2 Dezimalstellen
322          # kann mal bitte jemand den Verantwortlichen f�r diese          self._Y = 0.0           # 6 Dezimalstellen
323          # Variablen Namen schlagen?          self._ZRE4 = 0.0        # 2 Dezimalstellen
324          self._X = 0.0  # 2 Dezimalstellen          self._ZRE4J = 0.0       # 2 Dezimalstellen
325          self._Y = 0.0  # 6 Dezimalstellen          self._ZRE4OSO = 0.0     # 2 Dezimalstellen
326          self._ZRE4 = 0.0  # 2 Dezimalstellen          self._ZRE4VMT = 0.0     # 2 Dezimalstellen
327          self._ZRE4VP = 0.0  # 2 Dezimalstellen          self._ZRE4VP = 0.0      # 2 Dezimalstellen
328          self._ZRE4VP1 = 0.0  # 2 Dezimalstellen          self._ZTABFB = 0.0      # 2 Dezimalstellen
329          self._ZTABFB = 0          self._ZTABFBOSO = 0.0   # 2 Dezimalstellen
330          self._ZVE = 0          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._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 183  class LST: Line 355  class LST:
355          self._MSOLZ()          self._MSOLZ()
356          self._MSONST()          self._MSONST()
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:
390                    self._J = 1
391                elif self.VJAHR < 2040:
392                    self._J = self.VJAHR - 2004
393                else:
394                    self._J = 36
395              if self.LZZ == 1:              if self.LZZ == 1:
396                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS                  self._VBEZB = self.VBEZM * self.ZMVB + self.VBEZS
397                  self._FVBZ = 75 * self.ZMVB                  self._HFVB = self._TAB2[self._J] / 12 * self.ZMVB
398                    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._FVBZ = 900                  self._HFVB = self._TAB2[self._J]
402              self._FVB = ceil(self._VBEZB * 0.4)                  self._FVBZ = self._TAB3[self._J]
403              if self._FVB > 300000:              self._FVB = self._VBEZB * self._TAB1[self._J] / 100
404                  self._FVB = 300000              if self._FVB > self._HFVB:
405              self._JW = self._FVB                  self._FVB = self._HFVB
406              self._UPANTEIL()              self._VBEZBSO = self.STERBE + self.VKAPA
407              self._FVB = self._ANTEIL2              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          if self.ALTER1 == 0:          if self.ALTER1 == 0:
423              self._ALTE = 0              self._ALTE = 0
424          else:          else:
425              self._BMG = self.RE4 - self.VBEZ              if self.AJAHR < 2006:
426              self._ALTE = ceil(self._BMG * 0.4)                  self._K = 1
427              self._JW = 190000              elif self.AJAHR < 2040:
428              self._UPANTEIL()                  self._K = self.AJAHR - 2004
429              if self._ALTE > self._ANTEIL2:              else:
430                  self._ALTE = self._ANTEIL2                  self._K = 36
431                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    
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)  
         elif self.LZZ == 2:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.67) * 0.12)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 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)  
         else:  
             self._ZRE4 = FixedPointFloor((self._RE4LZZ + 0.56) * 3.6)  
             self._ZRE4VP = FixedPointFloor((self._RE4LZZV + 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:
446                self._ZVBEZ = 0
447    
448      def _MZTABFB(self):      def _MZTABFB(self):
449          self._KZTAB = 1          self._ANP = 0
450          if self.STKL < 6:          if (self._ZVBEZ >= 0) and (self._ZVBEZ < self._FVBZ):
451              if self.VBEZ > 0:              self._FVBZ = self._ZVBEZ
452                  self._ANP = 102          if (self.STKL < 6):
453              if self.RE4 > self.VBEZ:              if (self._ZVBEZ > 0):
454                  self._ANP += 920                  if (self._ZVBEZ - self._FVBZ) < 102:
455                        self._ANP = self._ZVBEZ - self._FVBZ
456                    else:
457                        self._ANP = 102
458          else:          else:
459              self._ANP = 0                          self._FVBZ = 0
460                self._FVBZSO = 0
461            if (self.STKL < 6) and (self._ZRE4 > self._ZVBEZ):
462                if (self._ZRE4 - self._ZVBEZ) < 920:
463                    self._ANP += self._ZRE4 - self._ZVBEZ
464                else:
465                    self._ANP += 920
466            self._KZTAB = 1
467          if self.STKL == 1:          if self.STKL == 1:
468              self._SAP = 36              self._SAP = 36
469              self._KFB = self.ZKF * 5808              self._KFB = self.ZKF * 5808
# Line 254  class LST: Line 481  class LST:
481          else:          else:
482              self._KFB = 0              self._KFB = 0
483          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ          self._ZTABFB = self._EFA + self._ANP + self._SAP + self._FVBZ
         self._KENNZ = 0  
484    
485      def _MLSTJAHR(self):      def _MLSTJAHR(self):
486          if self.STKL < 5:          if self.STKL < 5:
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 = 1.0              self._VSP1 = 0.0
508          else:          else:
509              if self._ZRE4VP > 62400:              if self._ZRE4VP > 63600:
510                  self._ZRE4VP = 62400                  self._ZRE4VP = 63600
511              self._VSP1 = 0.2 * self._ZRE4VP              self._VSP1 = FixedPointFloor(0.32 * self._ZRE4VP)
512              self._VSP1 *= 0.0975              self._VSP1 = FixedPointFloor(self._VSP1 * 0.0995)
513          self._VSP2 = 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:
516              self._VSP2 = self._VHB              self._VSP2 = self._VHB
# Line 298  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 316  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 345  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 388  class LST: Line 620  class LST:
620              self._ANTEIL2 = ceil(self._JW * 7 / 360.0)              self._ANTEIL2 = ceil(self._JW * 7 / 360.0)
621          else:          else:
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 404  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._MRE4()          else:
660              self._MZTABFB()              self._MOSONST()
661              self._MLSTJAHR()              self._ZRE4J = (self.JRE4 + self.SONSTB) / 100
662              self._LST1 = self._ST * 100              self._ZVBEZJ = (self.JVBEZ + self.VBS) / 100
663              self.VBEZ = self.JVBEZ + self.VBS              self._MRE4SONST()
             self.RE4 = self.JRE4 + self.SONSTB  
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
             self._MRE4()  
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              self.SOLZS = self.STS * 5.5 / 100              if self.STS < 0:
668                    self.STS = 0
669                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
674              # ------------------------------          # ------------------------------
675              # Nicht im offiziellen Programm-          # Nicht im offiziellen Programm-
676              # ablaufplan: Attribute          # ablaufplan: Attribute
677              # wiederherstellen          # wiederherstellen
678              self.LZZ = old_lzz          self.LZZ = old_lzz
679              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  
680    
681      def _MVMT(self):      def _MVMT(self):
682          if self.VMT > 0:          if self.VKAPA < 0:
683              # ------------------------------              self.VKAPA = 0
684              # Nicht im offiziellen Programm-          if (self.VMT + self.VKAPA) > 0:
685              # ablaufplan: Attribute sichern              if self._LSTOSO == 0:
686              old_lzz = self.LZZ                  self._MOSONST()
687              old_vbez = self.VBEZ                  self._LSTOSO = self._LST1
688              old_re4 = self.RE4              else:
689              # ------------------------------                    self._LSTSO = self._LST1
690              self.LZZ = 1              self._ZRE4OSO = self._ZRE4
691              self.VBEZ = self.JVBEZ + self.VBS              self._ZTABFBOSO = self._ZTABFB
692              self.RE4 = self.JRE4 + self.SONSTB              self._FVBZOSO = self._FVBZ
693              self._MRE4LZZ()              self._ZRE4J = (self._ZRE4 + self.SONSTB + self.VBS + self.VKAPA) / 100
694              self._MRE4LZZ2()              self._MRE4SONST()
             self._MRE4()  
             self._MZTABFB()  
             self._MLSTJAHR()  
             self._LST1 = self._ST * 100  
             self.RE4 = self.JRE4 + self.SONSTB + self.VMT  
             self._MRE4LZZ()  
             self._MRE4LZZ2()  
             self._MRE4()  
             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.RE4 = self.JRE4 + self.SONSTB              self._ZTABFB = self._ZTABFB - self._FVBZ + self._FVBZOSO
698              self._MRE4LZZ()              self._KENNVMT = 1
699              self.RE4 = self.JRE4 + self.SONSTB + self.VMT / 5              if (self.RE4 + self.SONSTB - self.JFREIB + self.JHINZU) < 0:
700              self._MRE4LZZ2()                  self._KENNVMT = 2
701              self._MRE4()                  self._MLSTJAHR()
702              self._MLSTJAHR()                  self._LST2 = self._ST * 100
703              self._LST2 = self._ST * 100                  self.STV = self._LST2 * 5
704              self.STV = (self._LST2 - self._LST1) * 5              else:
705                    self._ZRE4VMT = (self.VMT / 100 + self.VKAPA / 100
706                                     - self._ZTABFB + self._ZTABFBOSO) / 5
707                    self._MLSTJAHR()
708                    self._LST2 = self._ST * 100
709                    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      def Set_RE4(self, value):  
746          assert value >= 0, "must not be negative"      def Set_AJAHR(self, value):
747          self.RE4 = value          assert type(value) == type(0), "must be integer"
748            assert value >= 1900, "must be greater than 1900"
749            self.AJAHR = value
750    
751      def Set_ALTER1(self, value):      def Set_ALTER1(self, value):
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            
758      def Set_JHINZU(self, value):      def Set_JHINZU(self, value):
759          self.JHINZU = value          self.JHINZU = value
760            
761      def Set_JRE4(self, value):      def Set_JRE4(self, value):
762          self.JRE4 = value          self.JRE4 = value
763            
764      def Set_JVBEZ(self, value):      def Set_JVBEZ(self, value):
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):
772          assert value in (1,2,3,4), \          assert value in (1,2,3,4), \
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)"
785          self.R = value          self.R = value
786            
787        def Set_RE4(self, value):
788            assert value >= 0, "must not be negative"
789            self.RE4 = value
790    
791      def Set_SONSTB(self, value):      def Set_SONSTB(self, value):
792          self.SONSTB = value          self.SONSTB = value
793            
794        def Set_STERBE(self, value):
795            self.STERBE = value
796    
797      def Set_STKL(self, value):      def Set_STKL(self, value):
798          assert value in (1,2,3,4,5,6), \          assert value in (1,2,3,4,5,6), \
799                 "must be in range 1-6 (I II III IV V VI)"                 "must be in range 1-6 (I II III IV V VI)"
800          self.STKL = value          self.STKL = value
801            
802      def Set_VBEZ(self, value):      def Set_VBEZ(self, value):
803          self.VBEZ = value          self.VBEZ = value
804    
# Line 571  class LST: Line 811  class LST:
811      def Set_VBS(self, value):      def Set_VBS(self, value):
812          self.VBS = value          self.VBS = value
813    
814        def Set_VJAHR(self, value):
815            self.VJAHR = value
816    
817        def Set_VKAPA(self, value):
818            self.VKAPA = value
819    
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 \
825                   value >= 0, \
826                   "must be positive, and must not have more than one decimal digit"
827          self.ZKF = value          self.ZKF = value
828    
829      def Set_ZMVB(self, value):      def Set_ZMVB(self, value):
# Line 590  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 LStRechner2005(LST):  class LStRechner2008(LST):
840      def __init__(self):      def __init__(self):
841          LST.__init__(self)          LST.__init__(self)
842        
843        def SetGeb(self, geb):
844            """Setzt das Geburtsjahr"""
845            self.Set_AJAHR(geb + 65)
846            if self.AJAHR <= 2008:
847                self.Set_ALTER1(1)
848            else:
849                self.Set_ALTER1(0)
850    
851      def SetLohn(self, lohn):      def SetLohn(self, lohn):
852          """Setzt Lohn in Euro.Cent"""          """Setzt Lohn in Euro.Cent"""
853          self.Set_RE4(lohn * 100.0)          self.Set_RE4(round (lohn * 100.0))
854    
855        def GetLohn(self):
856            """Liefert Lohn in Euro.Cent"""
857            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)
874    
875        def GetZeitraum(self):
876            """Liefert Berechnungszeitraum (JAHR, MONAT, WOCHE, TAG)"""
877            return self.LZZ
878    
879      def SetSteuerklasse(self, stkl):      def SetSteuerklasse(self, stkl):
880          """Setzt Steuerklasse (I, II, III, IV, V, VI)"""          """Setzt Steuerklasse (I, II, III, IV, V, VI)"""
881          self.Set_STKL(stkl)          self.Set_STKL(stkl)
882    
883      def SetKirchensteuer(self, prozent):      def GetSteuerklasse(self):
884          """Setzt Kirchensteuer in Prozent"""          """Liefert Steuerklasse (I, II, III, IV, V, VI)"""
885            return self.STKL
886    
887        def SetKirchensteuerProzent(self, prozent):
888            """Setzt Kirchensteuer in Prozent,
889            0 wenn keine Kirchensteuer zu zahlen ist."""
890          self.Set_R(prozent)          self.Set_R(prozent)
891    
892        def GetKirchensteuerProzent(self):
893            """Liefert Kirchensteuer in Prozent
894            oder 0 wenn keine Kirchensteuer zu zahlen ist."""
895            return self.R
896    
897        def SetKinderfreibetrag(self, kfb):
898            """Setzt Kinderfreibetrag lt. Lohnsteuerkarte"""
899            self.Set_ZKF(kfb)
900    
901        def GetKinderfreibetrag(self):
902            """Liefert Kinderfreibetrag lt. Lohnsteuerkarte"""
903            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.14  
changed lines
  Added in v.81
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26