Kali pertama

.gitignore

+dist
+*.egg-info

CHANGES.txt

+0.1.1 2019-05-27
+----------------
+- FixLength yang bertipe N tidak di-int() saat get().
+
+0.1 2019-02-04
+--------------
+- Kali pertama.

MANIFEST.in

+include *.txt *.rst *.py
+recursive-include opensipkd *.py

README.rst

+Kumpulan Fungsi
+===============
+
+Kumpulan fungsi non database:
+
+* Rumus menghitung denda pajak.
+* Pengolahan string terkait kolom yang dipisahkan dengan jumlah karakter per
+  kolom (fix length).

opensipkd/hitung.py

+from datetime import (
+    date,
+    datetime,
+    )
+
+
+def round_up(n):
+    i = int(n)
+    if n == i:
+        return i
+    if n > 0:
+        return i + 1
+    return i - 1
+
+
+def bulan_tunggakan(jatuh_tempo, tgl_hitung):
+    x = (tgl_hitung.year - jatuh_tempo.year) * 12
+    y = tgl_hitung.month - jatuh_tempo.month
+    n = x + y + 1
+    if tgl_hitung.day <= jatuh_tempo.day:
+        n -= 1
+    if n < 1:
+        n = 0
+    if n > 24:
+        n = 24
+    return n
+
+
+def hitung_denda(tagihan, jatuh_tempo, persen_denda, tgl_hitung=None):
+    if jatuh_tempo is None:
+        return 0, 0
+    if tgl_hitung is None:
+        tgl_hitung = date.today()
+    if isinstance(jatuh_tempo, datetime):
+        jatuh_tempo = jatuh_tempo.date()
+    if jatuh_tempo >= tgl_hitung or persen_denda <= 0:
+        return 0, 0
+    bulan = bulan_tunggakan(jatuh_tempo, tgl_hitung)
+    denda = bulan * float(persen_denda) / 100 * tagihan
+    return bulan, denda

opensipkd/string/__init__.py

+import sys
+import traceback
+from datetime import (
+    datetime,
+    date,
+    time,
+    )
+from ..waktu import (
+    dmy,
+    dmyhms,
+    )
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+
+def clean(s):
+    r = ''
+    for ch in s:
+        ascii = ord(ch)
+        if ascii > 126 or ascii < 32:
+            ch = ' '
+        r += ch
+    return r
+
+
+def to_str(v):
+    if isinstance(v, date):
+        if isinstance(v, datetime):
+            return dmyhms(v)
+        return dmy(v)
+    if v == 0:
+        return '0'
+    if isinstance(v, bytes):
+        return v.encode('utf-8')
+    if sys.version_info.major == 2 and isinstance(v, unicode):
+        v = str(v)
+    if isinstance(v, str):
+        return v.strip()
+    elif isinstance(v, bool):
+        return v and '1' or '0'
+    return v and str(v) or ''
+
+
+def dict_to_str(d):
+    r = {}
+    for key in d:
+        val = d[key]
+        r[key] = to_str(val)
+    return r
+
+
+def left(s, width):
+    s = to_str(s)
+    return s.ljust(width)[:width]
+
+
+def right(s, width):
+    s = to_str(s)
+    return s.zfill(width)[:width]
+
+
+class FixLength:
+    def __init__(self, struct):
+        self.set_struct(struct)
+
+    def set_struct(self, struct):
+        self.struct = []
+        self.fields = {}
+        for s in struct:
+            name = s[0]
+            size = s[1:] and s[1] or 1
+            typ = s[2:] and s[2] or 'A'  # N: numeric, A: alphanumeric
+            self.fields[name] = {'value': None, 'type': typ, 'size': size}
+            self.struct.append((name, size, typ))
+
+    def set(self, name, value):
+        self.fields[name]['value'] = value
+
+    def get(self, name):
+        return self.fields[name]['value'] or ''
+
+    def __setitem__(self, name, value):
+        self.set(name, value)
+
+    def __getitem__(self, name):
+        return self.get(name)
+
+    def get_raw(self):
+        s = ''
+        for name, size, typ in self.struct:
+            v = self.fields[name]['value']
+            pad_func = typ == 'N' and right or left
+            if v and typ == 'N':
+                i = int(v)
+                if v == i:
+                    v = i
+            s += pad_func(v, size)
+        return s
+
+    def set_raw(self, raw):
+        awal = 0
+        for t in self.struct:
+            name = t[0]
+            size = t[1:] and t[1] or 1
+            akhir = awal + size
+            value = raw[awal:akhir]
+            if not value:
+                return
+            self.set(name, value)
+            awal += size
+        return True
+
+    def from_dict(self, d):
+        for name in d:
+            value = d[name]
+            self.set(name, value)
+
+
+class DateVar(FixLength):
+    def __init__(self):
+        FixLength.__init__(self, [
+            ['month', 2, 'N'],
+            ['day', 2, 'N'],
+            ])
+
+    def get_value(self, year=None):
+        year = year or date.today().year
+        return date(year, self.get('month'), self.get('day'))
+
+
+class DateTimeVar(FixLength):
+    def __init__(self):
+        FixLength.__init__(self, [
+            ['month', 2, 'N'],
+            ['day', 2, 'N'],
+            ['hour', 2, 'N'],
+            ['minute', 2, 'N'],
+            ['second', 2, 'N'],
+            ])
+
+    def get_value(self, year=None):
+        year = year or date.today().year
+        return datetime(year, self.get('month'), self.get('day'),
+                        self.get('hour'), self.get('minute'),
+                        self.get('second'))
+
+
+class TimeVar(FixLength):
+    def __init__(self):
+        FixLength.__init__(self, [
+            ['hour', 2, 'N'],
+            ['minute', 2, 'N'],
+            ['second', 2, 'N'],
+            ])
+
+    def get_value(self):
+        return time(self.get('hour'), self.get('minute'), self.get('second'))
+
+
+def exception_message():
+    f = StringIO()
+    traceback.print_exc(file=f)
+    s = f.getvalue()
+    f.close()
+    return s

opensipkd/waktu.py

+import calendar
+from datetime import (
+    date,
+    datetime,
+    )
+import pytz
+
+
+settings = {
+    'timezone': 'Asia/Jakarta',
+    }
+
+
+def get_timezone():
+    return pytz.timezone(settings['timezone'])
+
+
+def create_datetime(
+        year, month, day, hour=0, minute=7, second=0, microsecond=0):
+    tz = get_timezone()
+    return datetime(
+        year, month, day, hour, minute, second, microsecond, tzinfo=tz)
+
+
+def create_date(year, month, day):
+    return create_datetime(year, month, day)
+
+
+def as_timezone(tz_date):
+    localtz = get_timezone()
+    if not tz_date.tzinfo:
+        tz_date = create_datetime(tz_date.year, tz_date.month, tz_date.day,
+                                  tz_date.hour, tz_date.minute, tz_date.second,
+                                  tz_date.microsecond)
+    return tz_date.astimezone(localtz)
+
+
+def create_now():
+    tz = get_timezone()
+    return datetime.now(tz)
+
+
+def date_from_str(value):
+    separator = None
+    value = value.split()[0]  # dd-mm-yyyy HH:MM:SS
+    for s in ['-', '/']:
+        if value.find(s) > -1:
+            separator = s
+            break
+    if separator:
+        t = map(lambda x: int(x), value.split(separator))
+        y, m, d = t[2], t[1], t[0]
+        if d > 999:  # yyyy-mm-dd
+            y, d = d, y
+    else:
+        y, m, d = int(value[:4]), int(value[4:6]), int(value[6:])
+    return date(y, m, d)
+
+
+def split_time(s):
+    t = s.split(':')  # HH:MM:SS
+    hour = int(t[0])
+    minutes = seconds = 0
+    if t[1:]:
+        minutes = int(t[1])
+        if t[2:]:
+            seconds = int(t[2])
+    return hour, minutes, seconds
+
+
+# dd-mm-yyyy
+# yyyy-mm-dd
+# dd/mm/yyyy
+# yyyy/mm/dd
+# yyyymmdd
+
+def split_date(s):
+    separator = None
+    for sep in ['-', '/']:
+        if s.find(sep) > -1:
+            separator = sep
+            break
+    if separator:
+        d, m, y = [int(x) for x in s.split(separator)]
+        if d > 999:  # yyyy-mm-dd
+            y, d = d, y
+    else:
+        y, m, d = int(value[:4]), int(value[4:6]), int(value[6:])
+    return y, m, d
+
+
+def split_datetime(s):
+    t = s.split()  # dd-mm-yyyy HH:MM:SS
+    year, month, day = split_date(t[0])
+    if t[1:]:
+        hours, minutes, seconds = split_time(t[1])
+    else:
+        hours = minutes = seconds = 0
+    return year, month, day, hours, minutes, seconds
+
+
+def date_from_str(s):
+    y, m, d, hh, mm, ss = split_datetime(s)
+    return date(y, m, d)
+
+
+def datetime_from_str(s):
+    y, m, d, hh, mm, ss = split_datetime(s)
+    return create_datetime(y, m, d, hh, mm, ss)
+
+
+def dmy(tgl):
+    return tgl.strftime('%d-%m-%Y')
+
+
+def dmyhms(t):
+    return t.strftime('%d-%m-%Y %H:%M:%S')
+
+
+def next_month(year, month):
+    if month == 12:
+        month = 1
+        year += 1
+    else:
+        month += 1
+    return year, month
+
+
+def best_date(year, month, day):
+    try:
+        return date(year, month, day)
+    except ValueError:
+        last_day = calendar.monthrange(year, month)[1]
+        return date(year, month, last_day)
+
+
+def next_month_day(year, month, day):
+    year, month = next_month(year, month)
+    return best_date(year, month, day)

setup.py

+import os
+from setuptools import setup
+
+
+here = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(here, 'README.rst')) as f:
+    README = f.read()
+with open(os.path.join(here, 'CHANGES.txt')) as f:
+    CHANGES = f.read()
+
+line = CHANGES.splitlines()[0]
+version = line.split()[0]
+
+requires = [
+    'pytz',
+    ]
+
+packages = [
+    'opensipkd',
+    'opensipkd.string',
+    ]
+
+setup(
+    name='opensipkd-hitung',
+    version=version,
+    description='Rumus Pajak',
+    long_description=README + '\n\n' + CHANGES,
+    author='Owo Sugiana',
+    author_email='sugiana@gmail.com',
+    license='PostgreSQL License',
+    packages=packages,
+    install_requires=requires,
+    zip_safe=False,
+    )