Das deutsche Python-Forum

Code: Alles auswählen

from datetime import datetime

class MyEntry():

    my_entry_list = []
    FILE_PRAEFIX = '.txt'

    def __init__(self, project, pr_date, pr_start, pr_stop = ""):
        self.project = project
        self.pr_date = pr_date
        self.pr_start = pr_start
        self.pr_stop = pr_stop

    def __str__(self):
        return "|".join([self.project, self.pr_date, self.pr_start, self.pr_stop])
    
    @classmethod
    def create_entry(cls, project):
        pr_date = datetime.now().strftime('%Y-%m-%d')
        pr_start = datetime.now().strftime('%H:%M:%S')
        pr_stop = datetime.now().strftime('%H:%M:%S')
        my_entry = cls(project, pr_date, pr_start, pr_stop)
        cls.my_entry_list.append(my_entry)

    @classmethod
    def save_entries(cls, file_name):
        full_file_name = file_name + cls.FILE_PRAEFIX
        with open(full_file_name, "w", encoding="utf-8") as my_file:
            for entry in cls.my_entry_list:
                print(entry)
                my_file.write(str(entry))  # <-- warum ist hier eine Umwandlung nach str nötig?

def main():
    for index in range(5):
        MyEntry.create_entry('P-21-001-' + str(index))

    MyEntry.save_entries('test')
    print('Wrote file...')

if __name__ == '__main__':
    main()

Code: Alles auswählen

my_file.write(str(entry))

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import datetime

FILENAME_SUFFIX = ".txt"


class Entry:
    DELIMITER = "|"

    def __init__(self, project, date=None, start=None, stop=None):
        for illegal_character in [self.DELIMITER, "\n"]:
            if illegal_character in project:
                raise ValueError(
                    f"`project` contains illegal character"
                    f" ({illegal_character!r})"
                )

        if None in [date, start, stop]:
            now = datetime.now()

            if date is None:
                date = format(now, "%Y-%m-%d")

            if start is None:
                start = format(now, "%H:%M:%S")

            if stop is None:
                stop = format(now, "%H:%M:%S")

        if start > stop:
            raise ValueError(f"start ({start!r}) > stop ({stop!r})")

        self.project = project
        self.date = date
        self.start = start
        self.stop = stop

    def __repr__(self):
        return (
            f"{self.__class__.__name__}"
            f"({self.project!r}, {self.date!r}, {self.start!r}, {self.stop!r})"
        )

    def __str__(self):
        return self.DELIMITER.join(
            [self.project, self.date, self.start, self.stop]
        )

    @classmethod
    def parse(cls, text):
        return cls(*text.rstrip().split(cls.DELIMITER))


def save_entries(entries, filename):
    with open(filename + FILENAME_SUFFIX, "w", encoding="utf-8") as file:
        file.writelines(f"{entry}\n" for entry in entries)


def load_entries(filename):
    with open(filename + FILENAME_SUFFIX, "r", encoding="utf-8") as lines:
        return list(map(Entry.parse, lines))


def main():
    entries = [Entry(f"P-21-001-{index}") for index in range(5)]
    save_entries(entries, "test")
    print("Wrote file...")
    print(load_entries("test"))


if __name__ == "__main__":
    main()

Code: Alles auswählen

cur.execute("insert into lang values (?, ?)", ("C", 1972))

Code: Alles auswählen

def adapt_datetime(ts):
    return time.mktime(ts.timetuple())

sqlite3.register_adapter(datetime.datetime, adapt_datetime)

con = sqlite3.connect(":memory:")
cur = con.cursor()

now = datetime.datetime.now()
cur.execute("select ?", (now,))

Code: Alles auswählen

In [29]: def adapt_datetime(ts): 
    ...:     return time.mktime(ts.timetuple()) 
    ...:  
    ...: sqlite3.register_adapter(datetime.datetime, adapt_datetime) 
    ...:  
    ...: con = sqlite3.connect(":memory:") 
    ...: cur = con.cursor() 
    ...:  
    ...: now = datetime.datetime.now() 
    ...: cur.execute("select ?", (now,))                                        
Out[29]: <sqlite3.Cursor at 0x7f8853f0e180>

In [30]: cur.fetchone()                                                         
Out[30]: (1652172420.0,)

Code: Alles auswählen

In [1]: import sqlite3                                                          

In [2]: sqlite3.adapters                                                        
Out[2]: 
{(datetime.date,
  sqlite3.PrepareProtocol): <function sqlite3.dbapi2.register_adapters_and_converters.<locals>.adapt_date(val)>,
 (datetime.datetime,
  sqlite3.PrepareProtocol): <function sqlite3.dbapi2.register_adapters_and_converters.<locals>.adapt_datetime(val)>}
In [3]: sqlite3.converters                                                      
Out[3]: 
{'DATE': <function sqlite3.dbapi2.register_adapters_and_converters.<locals>.convert_date(val)>,
 'TIMESTAMP': <function sqlite3.dbapi2.register_adapters_and_converters.<locals>.convert_timestamp(val)>}

Code: Alles auswählen

import sqlite3
import datetime
import time

def adapt_datetime(ts):
    return time.mktime(ts.timetuple())

sqlite3.register_adapter(datetime.datetime, adapt_datetime)

con = sqlite3.connect("testdatabase.db")
cur = con.cursor()
cur.execute('create table datetable(something text, sometime datetime)')

now = datetime.datetime.now()
print(now)

cur.execute("insert into datetable values(?, ?)", ('test', now))
con.commit()

for row in cur.execute('select * from datetable'):
    print(row)

con.close()

Code: Alles auswählen

2022-05-10 11:40:23.840789
('test', 1652175623)

Code: Alles auswählen

import datetime
import sqlite3

con = sqlite3.connect(":memory:", detect_types=True)
cur = con.cursor()
cur.execute("CREATE TABLE datetable (something TEXT, sometime TIMESTAMP)")

now = datetime.datetime.now()
print(now)

cur.execute("INSERT INTO datetable VALUES(?, ?)", ("test", now))
con.commit()

for row in cur.execute('SELECT * FROM datetable'):
    print(row)

con.close()

Code: Alles auswählen

TIMESTAMP

Code: Alles auswählen

datetime

Code: Alles auswählen

detect_types=True

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import datetime as DateTime

from sqlalchemy import INTEGER, TEXT, TIMESTAMP, Column, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Session = sessionmaker()
Base = declarative_base()


class Entry(Base):
    __tablename__ = "entry"

    id = Column(INTEGER, primary_key=True)
    project = Column(TEXT, nullable=False)
    start = Column(TIMESTAMP, nullable=False, default=DateTime.now)
    stop = Column(TIMESTAMP, nullable=False, default=DateTime.now)


def main():
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    session = Session(bind=engine)

    for index in range(5):
        session.add(Entry(project=f"P-21-001-{index}"))
    session.commit()

    for entry in session.query(Entry):
        print(
            f"{entry.project} on {entry.start.date()}"
            f" from {entry.start.time()} to {entry.stop.time()}"
        )


if __name__ == "__main__":
    main()

Code: Alles auswählen

    entry = Entry(project="test project")
    session.add(entry)
    session.commit()
    
    print(type(Entry.project))
    print(type(entry.project), entry.project)
    print(type(Entry.start))
    print(type(entry.start), entry.start)

Code: Alles auswählen

<class 'sqlalchemy.orm.attributes.InstrumentedAttribute'>
<class 'str'> test project
<class 'sqlalchemy.orm.attributes.InstrumentedAttribute'>
<class 'datetime.datetime'> 2022-05-11 11:29:47.777694

Code: Alles auswählen

#!/usr/bin/env python3
from datetime import datetime as DateTime

from sqlalchemy import INTEGER, TEXT, TIMESTAMP, Column, create_engine, select
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# DATABASE_NAME = 'project_database.db'
Base = declarative_base()
Session = sessionmaker()


class Entry(Base):
    __tablename__ = "entry"

    id = Column(INTEGER, primary_key=True)
    project = Column(TEXT, nullable=False)
    start = Column(TIMESTAMP, nullable=False, default=DateTime.now)
    stop = Column(TIMESTAMP, nullable=False, default=DateTime.now)

def connect():
    return create_engine("sqlite:///:memory:")

def make_session(engine):
    return Session(bind=engine)

def generate_tables(engine):
    Base.metadata.create_all(engine)

def main():
    engine = connect()
    generate_tables(engine)
    session = make_session(engine)

    # Some testing
    for index in range(5):
        dt = DateTime(2022, 5, 12, 5 + index, 5, 14)
        dts = DateTime(2022, 5, 12, 6 + index, 5, 14)
        session.add(Entry(project=f"P-21-001", start = dt, stop = dts))
        dtx = DateTime(2022, 5, 13, 5 + index, 5, 14)
        dtsx = DateTime(2022, 5, 13, 6 + index, 5, 14)
        session.add(Entry(project=f"P-22-001", start = dtx, stop = dtsx))
    session.commit()

    sel = select(Entry).where(Entry.project == "P-22-001" and Entry.start.date() == (2022,5,12))
    elapsed_time = 0
    for entry in session.scalars(sel):
        print(
            f"{entry.project} on {entry.start.date()}"
            f" from {entry.start.time()} to {entry.stop.time()}"
        )
        # elapsed_time = elapsed_time + (entry.stop.time() - entry.start.time())
    print(elapsed_time)

if __name__ == '__main__':
    main()