Initial commit.

.gitignore

+*~
+*.pyc
+*.pyo
+
+.idea

example1.kv

+BoxLayout:
+    orientation: 'vertical'
+    BoxLayout:
+        id: fields
+        orientation: 'vertical'
+        size_hint: (1.0, 6.0)
+    BoxLayout:
+        orientation: 'horizontal'
+        Button:
+            text: 'Add Field'
+            font_size: sp(24)
+            on_press: app.add_field()
+        Button:
+            text: 'Remove Field'
+            font_size: sp(24)
+            on_press: app.remove_field()
+    Label:
+        id: result
+        text: 'Smallest Positive: inf'
+        font_size: sp(24)
+
+<Field>:
+    orientation: 'horizontal'
+    Label:
+        text: root.label_text
+        font_size: sp(24)
+    TextInput:
+        id: input
+        multiline: False
+        write_tab: False
+        font_size: sp(24)
+        on_text: app.update()

example1.py

+from math import inf
+
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+from kivy.properties import StringProperty
+
+
+class Field(BoxLayout):
+    label_text = StringProperty()
+
+
+class Example1App(App):
+    def add_field(self):
+        container = self.root.ids.fields
+        container.add_widget(Field(label_text=f'Field #{len(container.children)}: '))
+
+    def remove_field(self):
+        container = self.root.ids.fields
+        if len(container.children) > 0:
+            container.remove_widget(container.children[0])
+
+    def update(self):
+        container = self.root.ids.fields
+        smallest_positive = inf
+        for field in container.children:
+            try:
+                value = float(field.ids.input.text)
+                if 0 < value < smallest_positive:
+                    smallest_positive = value
+            except ValueError:
+                pass
+        self.root.ids.result.text = f'Smallest Positive: {smallest_positive}'
+
+
+if __name__ == '__main__':
+    app = Example1App()
+    app.run()

example2.kv

+BoxLayout:
+    orientation: 'vertical'
+    BoxLayout:
+        id: fields
+        orientation: 'vertical'
+        size_hint: (1.0, 6.0)
+    BoxLayout:
+        orientation: 'horizontal'
+        Button:
+            text: 'Add Field'
+            font_size: sp(24)
+            on_press: app.add_field()
+        Button:
+            text: 'Remove Field'
+            font_size: sp(24)
+            on_press: app.remove_field()
+    Label:
+        id: result
+        text: f'Smallest Positive: {app.smallest_positive}'
+        font_size: sp(24)
+
+<Field>:
+    orientation: 'horizontal'
+    Label:
+        text: root.label_text
+        font_size: sp(24)
+    TextInput:
+        id: input
+        multiline: False
+        write_tab: False
+        font_size: sp(24)
+        on_text: app.update()

example2.py

+from math import inf
+
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+from kivy.properties import NumericProperty, StringProperty
+
+
+class Field(BoxLayout):
+    label_text = StringProperty()
+
+
+class Example2App(App):
+    smallest_positive = NumericProperty(inf)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.values = []
+
+    def add_field(self):
+        container = self.root.ids.fields
+        container.add_widget(Field(label_text=f'Field #{len(container.children)}: '))
+
+    def remove_field(self):
+        container = self.root.ids.fields
+        if len(container.children) > 0:
+            container.remove_widget(container.children[0])
+
+    def _find_smallest_positive(self):
+        result = inf
+        for value in self.values:
+            if 0 < value < result:
+                result = value
+        return result
+
+    def update(self):
+        container = self.root.ids.fields
+        self.values = []
+        for field in container.children:
+            try:
+                self.values.append(float(field.ids.input.text))
+            except ValueError:
+                pass
+        self.smallest_positive = self._find_smallest_positive()
+
+
+if __name__ == '__main__':
+    app = Example2App()
+    app.run()

example3.kv

+BoxLayout:
+    orientation: 'vertical'
+    Label:
+        id: result
+        text: f'Smallest Positive: {app.smallest_positive}'
+        font_size: sp(24)

example3.py

+from sys import stderr
+from math import inf
+
+from sqlalchemy.exc import SQLAlchemyError
+from values import ValueDatabase, Value
+
+from kivy.app import App
+from kivy.properties import NumericProperty
+
+
+class Example3App(App):
+    smallest_positive = NumericProperty(inf)
+
+    @staticmethod
+    def _find_smallest_positive(values):
+        result = inf
+        for value in values:
+            if 0 < value < result:
+                result = value
+        return result
+
+    def on_start(self):
+        url = ValueDatabase.construct_mysql_url('localhost', 3306, 'values', 'root', 'cse1208')
+        value_database = ValueDatabase(url)
+        session = value_database.create_session()
+        values = [record.value for record in session.query(Value).all()]
+        self.smallest_positive = Example3App._find_smallest_positive(values)
+
+
+def main():
+    try:
+        app = Example3App()
+        app.run()
+    except SQLAlchemyError as exception:
+        print('Database connection failed!', file=stderr)
+        print(f'Cause: {exception}', file=stderr)
+        exit(1)
+
+
+if __name__ == '__main__':
+    main()

test_example1.py

+from unittest import TestCase
+
+from example1 import Example1App
+
+
+class TestExample1App(TestCase):
+    def test_update(self):
+        self.fail()

test_example2.py

+from unittest import TestCase
+
+from example2 import Example2App
+
+
+class TestExample2App(TestCase):
+    def test_find_smallest_positive(self):
+        app = Example2App()
+        app.values = [5.0, 2.0, 4.0]
+        actual = app._find_smallest_positive()
+        self.assertEqual(actual, 2.0)

test_example3.py

+from unittest import TestCase
+
+from values import ValueDatabase, Value
+
+from example3 import Example3App
+
+
+class TestExample3App(TestCase):
+    def test_database_access(self):
+        self.fail()

values.py

+from sqlalchemy import create_engine, Column, Integer, Float
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+
+Persisted = declarative_base()
+
+
+class Value(Persisted):
+    __tablename__ = 'values'
+    value_id = Column(Integer, primary_key=True)
+    value = Column(Float)
+
+
+class ValueDatabase(object):
+    @staticmethod
+    def construct_mysql_url(authority, port, database, username, password):
+        return f'mysql+mysqlconnector://{username}:{password}@{authority}:{port}/{database}'
+
+    @staticmethod
+    def construct_in_memory_url():
+        return 'sqlite:///'
+
+    def __init__(self, url):
+        self.engine = create_engine(url)
+        self.Session = sessionmaker()
+        self.Session.configure(bind=self.engine)
+
+    def ensure_tables_exist(self):
+        Persisted.metadata.create_all(self.engine)
+
+    def create_session(self):
+        return self.Session()

values_installer.py

+from sys import stderr
+
+from sqlalchemy.exc import SQLAlchemyError
+
+from values import ValueDatabase, Value
+
+
+def add_starter_data(session):
+    one = Value(value=1.0)
+    two = Value(value=2.0)
+    three = Value(value=3.0)
+    session.add(one)
+    session.add(two)
+    session.add(three)
+
+
+def main():
+    try:
+        url = ValueDatabase.construct_mysql_url('localhost', 3306, 'values', 'root', 'cse1208')
+        value_database = ValueDatabase(url)
+        value_database.ensure_tables_exist()
+        print('Tables created.')
+        session = value_database.create_session()
+        add_starter_data(session)
+        session.commit()
+        print('Records created.')
+    except SQLAlchemyError as exception:
+        print('Database setup failed!', file=stderr)
+        print(f'Cause: {exception}', file=stderr)
+        exit(1)
+
+
+if __name__ == '__main__':
+    main()