dbis-functional-dependencies 0.0.7__py3-none-any.whl → 1.0.0__py3-none-any.whl

dbis_functional_dependencies/fdcheck.py

@@ -0,0 +1,113 @@
+"""
+Created on 2022-06-11
+@author: wf
+"""
+import time
+from dbis_functional_dependencies.BCNF import FunctionalDependencySet
+from lodstorage.sql import SQLDB
+
+
+class FDCheck:
+    """
+    check functional dependencies for a tabular dataset in list of dicts form
+    """
+
+    def __init__(self, lod: list, debug: bool = False):
+        """
+        construct me with the given list of dicts
+
+        Args:
+            lod(list): the list of dicts (table) to check
+            debug(bool): if true switch on debugging
+        """
+        self.lod = lod
+        self.debug = debug
+        self.entityInfo = None
+
+    def createDatabase(
+        self,
+        entityName,
+        primaryKey=None,
+        executeMany=True,
+        fixNone=False,
+        fixDates=False,
+        debug=False,
+        doClose=True,
+    ):
+        """
+        create a database for my list of Records
+
+        Args:
+           entityName(string): the name of the entity type to be used as a table name
+           primaryKey(string): the name of the key / column to be used as a primary key
+           executeMany(boolean): True if executeMany mode of sqlite3 should be used
+           fixNone(boolean): fix dict entries that are undefined to have a "None" entry
+           debug(boolean): True if debug information e.g. CREATE TABLE and INSERT INTO commands should be shown
+           doClose(boolean): True if the connection should be closed
+
+        """
+        size = len(self.lod)
+        if self.debug:
+            print(
+                "%s size is %d fixNone is %r fixDates is: %r"
+                % (entityName, size, fixNone, fixDates)
+            )
+        self.sqlDB = SQLDB(debug=debug, errorDebug=True)
+        entityInfo = self.sqlDB.createTable(self.lod, entityName, primaryKey)
+        startTime = time.time()
+        self.sqlDB.store(self.lod, entityInfo, executeMany=executeMany, fixNone=fixNone)
+        elapsed = (
+            0.000000000001 if time.time() - startTime == 0 else time.time() - startTime
+        )
+        if self.debug:
+            print(
+                "adding %d %s records took %5.3f s => %5.f records/s"
+                % (size, entityName, elapsed, size / elapsed)
+            )
+        if self.debug:
+            resultList = self.sqlDB.queryAll(entityInfo, fixDates=fixDates)
+            print(
+                "selecting %d %s records took %5.3f s => %5.f records/s"
+                % (len(resultList), entityName, elapsed, len(resultList) / elapsed)
+            )
+        if doClose:
+            self.sqlDB.close()
+        self.entityInfo = entityInfo
+        return entityInfo
+
+    def findFDs(self):
+        """
+        find functional dependencies
+
+        https://github.com/gustavclausen/functional-dependency-finder/blob/master/main.py
+        Return:
+            FunctionalDependencySet: the set of functional dependencies
+        """
+        if self.entityInfo is None:
+            raise Exception("createDataBase needed to supply entityInfo")
+        fields = list(self.entityInfo.typeMap.keys())
+        table_name = self.entityInfo.name
+        fds = FunctionalDependencySet()
+        for i, field in enumerate(fields):
+            attr1_var = chr(ord("A") + i)
+            fds.add_attribute(attr1_var, field)
+        for i, field in enumerate(fields):
+            attr1_var = chr(ord("A") + i)
+            for j in range(0, len(fields)):
+                if i == j:
+                    continue
+
+                field_1 = fields[i]
+                field_2 = fields[j]
+                attr2_var = chr(ord("A") + j)
+                sql = f"SELECT {field_1}, COUNT(DISTINCT {field_2}) c FROM {table_name} GROUP BY {field_1} HAVING c > 1"
+                hits = self.sqlDB.query(sql)
+                if self.debug:
+                    print(f"{sql}\n{hits}")
+
+                if len(hits) == 0:
+                    # Functional dependency found: it's not the case that there's more than one value (field_2)
+                    # associated with field_1
+                    fds.add_dependency(attr1_var, attr2_var)
+        self.fds = fds
+        return fds

{functional_dependencies → dbis_functional_dependencies}/fds.py

@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 # SPDX-FileCopyrightText: 2000-2022 Jens Lechtenbörger
 
-u"""Functional dependencies (FDs) are a major tool for database design.
+"""Functional dependencies (FDs) are a major tool for database design.
 
 Introduction
 ============
@@ -416,8 +416,9 @@ class FD(object):
             singleton.add(attr)
             if attr in self.lhs:
                 # FDs of the form XA->A are trivial.
-                logging.debug("rminimize: omitted trivial FD %s",
-                              FD(self.lhs, singleton))
+                logging.debug(
+                    "rminimize: omitted trivial FD %s", FD(self.lhs, singleton)
+                )
                 continue
             result.add(FD(self.lhs.copy(), singleton))
         return result
@@ -490,7 +491,10 @@ class FDSet(set):
             else:
                 logging.debug(
                     "lminimize: removed %s for rhs %s: new lhs: %s",
-                    attr, _set2string(rhs), _set2string(cand))
+                    attr,
+                    _set2string(rhs),
+                    _set2string(cand),
+                )
         return cand
 
     def key(self, attributes=None):
@@ -527,8 +531,8 @@ class FDSet(set):
             if lhs != fdep.lhs:
                 result.remove(fdep)
                 logging.debug(
-                    "basis: replaced lhs in %s with %s",
-                    fdep, _set2string(lhs))
+                    "basis: replaced lhs in %s with %s", fdep, _set2string(lhs)
+                )
                 result.add(FD(lhs, fdep.rhs))
 
         # Third, remove redundant FDs.  (An FD is redundant if it is implied
@@ -559,8 +563,7 @@ class RelSchema(object):
 
     def __str__(self):
         """Return relation schema in usual pair representation."""
-        return "({}, {})".format(_set2string(self.attributes),
-                                 _set2string(self.fds))
+        return "({}, {})".format(_set2string(self.attributes), _set2string(self.fds))
 
     def key(self):
         """Return a key."""
@@ -631,6 +634,7 @@ def extract_by_lhs(basis, fdep):
 
 
 # Run doctests by default.
-if __name__ == '__main__':
+if __name__ == "__main__":
     import doctest
-    print(doctest.testmod())
+
+    print(doctest.testmod())

dbis_functional_dependencies/fdsbase.py

@@ -0,0 +1,207 @@
+"""
+Created on 2022-06-08
+
+@author: wf
+"""
+from enum import Enum
+import copy
+
+
+class Notation(str, Enum):
+    """
+    a notation to be used for stringifcation
+    """
+
+    math = "LaTex math symbols"
+    utf8 = "UTF-8 Symbols"
+    plain = "plaintext ASCII"
+    short = "short notation without delimiters using juxtapositions"
+
+
+class Set(set):
+    """
+    https://docs.python.org/3/tutorial/datastructures.html#sets
+    """
+
+    notation = Notation.plain
+
+    def __init__(self, *args, **kwargs):
+        """
+        constructor
+        """
+        super().__init__(*args, **kwargs)
+
+    def __str__(self):
+        text = Set.stringify_set(self, notation=Set.notation)
+        return text
+
+    @classmethod
+    def stringify_set(cls, pSet, notation: Notation):
+        """
+        return a string representation of the given set using the given delimiter
+
+        Args:
+            pSet(set): the set to stringify
+            delim(str): the delimiter to use
+        """
+        elementTexts = []
+        for elem in pSet:
+            elementTexts.append(str(elem))
+        sortedElements = sorted(elementTexts)
+        if len(sortedElements) == 0:
+            # empty set
+            if notation == Notation.math:
+                text = "\emptyset"
+            else:
+                text = "∅"
+        else:
+            elementDelim = ","
+            if notation == Notation.short:
+                elementDelim = ""  # Thin space would be better
+            if notation == Notation.short:
+                text = ""
+            elif notation == Notation.math:
+                text = "\{"
+            else:
+                text = "{"
+
+            delim = ""
+            for element in sortedElements:
+                text += f"{delim}{element}"
+                delim = elementDelim
+            if notation == Notation.short:
+                pass
+            elif notation == Notation.math:
+                text += "\}"
+            else:
+                text += "}"
+        return text
+
+
+class FD(object):
+    """A functional dependency with left- and right-hand side."""
+
+    notation = Notation.plain
+
+    def __init__(self, left, right):
+        """Create FD with left hand side  and right hand side
+
+        Args:
+            left(object): set of attributes for the left hand side
+            right(object): set of attributes for the right hand side
+
+        """
+        self.left = Set(left)
+        self.right = Set(right)
+
+    def __str__(self):
+        """
+        convert me to a string
+
+        Return:
+            str: a string representation of myself
+        """
+        text = FD.stringify_FD(self, FD.notation)
+        return text
+
+    @classmethod
+    def stringify_FD(cls, fd, notation: Notation):
+        """
+        Return:
+            a string representation of the given Functional Dependency
+        """
+        setNotation = Notation.short
+        leftText = Set.stringify_set(fd.left, notation=setNotation)
+        rightText = Set.stringify_set(fd.right, notation=setNotation)
+        if notation == Notation.utf8:
+            to = "→"
+        elif notation == Notation.math:
+            to = " \to "
+        else:
+            to = "->"
+        text = f"{leftText}{to}{rightText}"
+        return text
+
+
+class Attribute:
+    """
+    an Attribute e.g.
+        Example: Attribute('A', 'Wikidata identifier', 'Wikidata-Schlüssel')
+    """
+
+    def __init__(self, var_name: str, english_name: str, german_name: str):
+        """
+        constructor
+
+        Args:
+            var_name(str): the Variable name
+            english_name(str): the english name
+            german_name(str): the german name
+
+        """
+        self.var_name = var_name
+        self.german_name = german_name
+        self.english_name = english_name
+
+    def __str__(self):
+        text = f"{self.var_name}≡{self.english_name}≡{self.german_name}"
+        return text
+
+
+class RelSchema(object):
+    """A relation schema consists of a set of attributes and a set of FDs.
+
+    Various normal forms exist to describe "good" schemata.  Normalization
+    is the process of creating schemata that satisfy certain normal forms.
+    The class of synthesis algorithms targets 3NF.
+    """
+
+    def __init__(
+        self, attributes: Set, fds, name: str = "R", notation: Notation = None
+    ):
+        """
+        Construct relation schema with attributes and FDs.
+
+        Args:
+            attributes(list): a list of Attributes
+            fds(FunctionalDependencySet): a set of FDs
+            name(string): the name of the RelatonSchema
+            notation(Notation): the notation to use
+        """
+        if notation is None:
+            notation = Notation.utf8
+        self.notation = notation
+        self.attributes = attributes
+        self.fds = fds
+        self.name = name
+
+    def __str__(self):
+        text = RelSchema.stringify(self, self.notation)
+        return text
+
+    @classmethod
+    def stringify(cls, rs, notation):
+        """
+        return a textual representation of the given relational schema in the given notation
+        """
+        attrText = Set.stringify_set(rs.attributes, notation)
+        fds = copy.deepcopy(rs.fds)
+        fds.notation = notation
+        fdsText = str(fds)
+        rsSet = Set([attrText, fdsText])
+        rsSetText = Set.stringify_set(rsSet, notation=notation)
+        rsText = f"{rs.name}={rsSetText}"
+        return rsText
+
+    def findCandidateKeys(self):
+        """
+        find candidate keys
+        """
+        cklist = []
+        for foundKeySet in self.fds.find_candidate_keys():
+            keySet = Set()
+            for foundKey in foundKeySet:
+                attr = self.fds.attribute_map[foundKey]
+                keySet.update([attr])
+            cklist.append(keySet)
+        return cklist

dbis_functional_dependencies-1.0.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.1
+Name: dbis-functional-dependencies
+Version: 1.0.0
+Summary: RWTH Aachen Computer Science i5/dbis assets for Lecture Datenbanken und Informationssysteme
+Author-email: DBIS i5 RWTH Aachen <dbis-vl@dbis.rwth-aachen.de>
+Project-URL: Homepage, https://git.rwth-aachen.de/i5/teaching/dbis/dbis-functional-dependencies
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: graphviz ~=0.20
+Requires-Dist: networkx ~=2.7
+Requires-Dist: numpy ~=1.26
+Requires-Dist: sphinx ~=7.2
+Requires-Dist: sphinxcontrib-apidoc ~=0.4
+Requires-Dist: functional-dependencies ~=1.3
+Requires-Dist: build ~=1.0
+Requires-Dist: pylodstorage ~=0.4.11
+Provides-Extra: build
+Requires-Dist: twine ==4.* ; extra == 'build'
+Requires-Dist: build ==1.* ; extra == 'build'
+Provides-Extra: test
+Requires-Dist: black ==23.12.1 ; extra == 'test'
+
+# DBIS Functional Dependencies
+
+Functional Dependencies and Normal Forms for Relational Databases
+
+[![PyPI Status](https://img.shields.io/pypi/v/dbis-functional-dependencies.svg)](https://pypi.python.org/pypi/dbis-functional-dependencies/)
+[![pypi](https://img.shields.io/pypi/pyversions/dbis-functional-dependencies)](https://pypi.org/project/dbis-functional-dependencies/)
+[![License](https://img.shields.io/pypi/l/dbis-functional-dependencies)](https://www.apache.org/licenses/LICENSE-2.0)
+[![Pipeline Status](https://git.rwth-aachen.de/i5/teaching/dbis/dbis-functional-dependencies/badges/main/pipeline.svg)](https://git.rwth-aachen.de/i5/teaching/dbis/dbis-functional-dependencies/-/packages)
+
+This library provides a Python implementation of the [synthesis algorithm](https://de.wikipedia.org/wiki/Synthesealgorithmus) and decomposition algorithm according to the DBIS lecture. For more background and application of functional dependencies and the algorithms, see [Doku-FunctionalDependencies](https://git.rwth-aachen.de/i5/teaching/dbis-jupyter/dbis-ss-2023-test/-/blob/main/doku/Doku-FunctionalDependencies.ipynb).
+
+# Features
+ - Create sets of Functional dependencies (FDSets).
+ - Calculate candidate keys of an FDSet.
+ - Calculate attribute closure of an attribute or set of attributes.
+ - Test whether an FDSet is in 2NF, 3NF or BCNF.
+ - Execute the synthesis algorithm to transform the FDSet into 3NF.
+ - Execute the decomposition algorithm to transform the FDSet into BCNF.
+ - Generate the closure $F^+$ of an FDSet $F$.
+ - Generate true/false questions w.r.t. synthesis and decomposition algorithm.
+
+# Installation
+Install via pip:
+```bash
+pip install dbis-functional-dependencies
+```
+
+# Usage
+### Creating an FDSet
+Create a new instance of `FunctionalDependencySet`. The set of attributes is passed as parameter. 
+```python
+fdset = FunctionalDependencySet('ABCDE')
+```
+You can add more attributes later by using the `add_attribute` function. 
+```python
+fdset.add_attribute('F')
+```
+Add dependencies with the `add_dependency` function ...
+```python
+fdset.add_dependency("AC", "DE")
+fdset.add_dependency("DEF", "B")
+fdset.add_dependency("B", "D")
+```
+... or remove them with the `remove_dependency` function.
+```python
+fdset.remove_dependency("B", "D")
+```
+
+Printing an FDSet shows the dependencies in a more readable form.
+```python
+print(f"{fdset}")
+```
+
+### Attribute closure and candidate keys
+Calculate the attribute closure of one or multiple attributes.
+```python
+closureA = fdset.get_attr_closure('A')
+closureAC = fdset.get_attr_closure('AC')
+```
+
+Calculate all candidate keys.
+```python
+ckeys = fdset.find_candidate_keys()
+```
+
+### Check for normal forms
+Since we only work with schemas (no actual values for the attributes), we assume that a corresponding database is in 1NF.
+
+Check whether the FDSet is in 2NF, 3NF or BCNF.
+```python
+is2NF = fdset.is2NF()
+is3NF = fdset.is3NF()
+isBCNF = fdset.isBCNF()
+```
+
+### Execute the synthesis algorithm
+Execute the synthesis algorithm on an FDSet to generate a corresponding list of FDSets in 3NF.
+```python
+fdslist = fdset.synthesize()
+```
+The algorithm performs the following steps:
+
+0. Find the candidate keys.
+1. Calculate the canonical cover.
+    - left reduction
+    - right reduction
+    - remove dependencies with empty rhs
+    - combine dependencies with same lhs
+2. Create a new relation for every dependency in the canonical cover.
+3. Create the optional key scheme if no candidate key is included in the attribute set of one of the relations of step 2.
+4. Remove subset relations.
+
+You receive additional information on the steps of the algorithm by toggling the parameter `verbose`.
+```python
+fdslist = fdset.synthesize(vebose=True)
+```
+Alternatively, you can also execute the single steps with the following functions:
+```python
+fdset_step.canonical_cover()
+fdslist_step = fdset_step.create_new_fdsets()
+fdslist_step_with_key = FunctionalDependencySet.create_optional_key_scheme(self, ckeys, fdslist_step)
+reduced_fdslist_step = FunctionalDependencySet.remove_subset_relations(self, fdslist_step_with_key)
+```
+The verbose option exists for all steps.
+
+### Execute the decomposition algorithm
+Execute the decomposition algorithm on an FDSet to generate a corresponding decomposition of FDSets in BCNF.
+```python
+fdslist = fdset.decompose2()
+```
+Before performing the actual algorithm, the the closure of the FDSet is calculated.
+
+### Closure of an FDSet
+Calculate the closure $F^+$ of an FDSet $F$.
+```python
+fdset.completeFDsetToClosure()
+```
+This function just adds dependencies with all subset combinations of the attribute set with their corresponding closures on the rhs of the dependency, so that no implicit dependency is missed by the decomposition algorithm.
+
+### Exercise generator
+Generate true/false statements based on the different steps of the algorithms.
+```python
+fdslist = fdset.synthesize(genEx=True)
+```
+The `genEx` option is available for the following functions:
+* `find_candidate_keys`
+* `synthesize`
+  * `canonical_cover`
+    * `left_reduction`
+    * `right_reduction`
+    * `remove_empty_fds`
+    * `combine_fds`
+  * `create_new_fdsets`
+  * `create_optional_key_scheme`
+  * `remove_subset_relations`
+* `decompose2`
+
+### Checking results against expected
+Checks a given calculated step of an FDSet during the synthesis algorithm (according to the DBIS lecture) for correctness.
+```python
+original = fdset.copy()
+fdset.left_reduction()
+original.isCorrectLeftReduction(fdset)
+```
+For this purpose, the following functions exist:
+* `isCorrectLeftReduction`
+* `isCorrectRightReduction`
+* `isCorrectRemovingEmptyFDs`
+* `isCorrectCombinationOfDependencies`
+* `isCorrectCanonicalCover`
+* `isCorrectCreationOfNewFDS`
+
+These functions are called on the FDSet with all steps before already calculated on it.

dbis_functional_dependencies-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dbis_functional_dependencies/BCNF.py,sha256=7EosTQTPl07W_UIiTp41PoxM9OTWMIzwA5cdQxbrkyM,68688
+dbis_functional_dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbis_functional_dependencies/fdcheck.py,sha256=wNFJb2WZGkvQxN8Prbcd6DhuXYnQ4Zm9HsoLxc7RU7k,4082
+dbis_functional_dependencies/fds.py,sha256=CLssS0L-3NxodSCtEcOMG5lxy0elLEaWkK8cT9IUszo,24021
+dbis_functional_dependencies/fdsbase.py,sha256=wgt1tjM-EyD09v8Yf57UgoZB6ptvijIuE0WfgdKj43M,5767
+dbis_functional_dependencies-1.0.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dbis_functional_dependencies-1.0.0.dist-info/METADATA,sha256=zvpMH7aEjXT0x4umngOYQKEqpln54NgK4YXqCOTiH9w,6774
+dbis_functional_dependencies-1.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dbis_functional_dependencies-1.0.0.dist-info/top_level.txt,sha256=Kxq61kOpu1YSAAigxyqE3_XCyftviQ1TW55Q1oxEP-4,29
+dbis_functional_dependencies-1.0.0.dist-info/RECORD,,

{dbis_functional_dependencies-0.0.7.dist-info → dbis_functional_dependencies-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.36.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dbis_functional_dependencies-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dbis_functional_dependencies

dbis_functional_dependencies-0.0.7.dist-info/METADATA

@@ -1,23 +0,0 @@
-Metadata-Version: 2.1
-Name: dbis-functional-dependencies
-Version: 0.0.7
-Summary: RWTH Aachen Computer Science i5/dbis assets for Lecture Datenbanken und Informationssysteme
-Home-page: https://git.rwth-aachen.de/i5/teaching/dbis-functional-dependencies
-Author: Wolfgang Fahl
-Author-email: fahl@dbis.rwth-aachen.de
-License: Apache
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# dbis-functional-dependencies
-
-Functional Dependencies and Normal Forms for Relational Databases
-
-[![PyPI Status](https://img.shields.io/pypi/v/dbis-functional-dependencies.svg)](https://pypi.python.org/pypi/dbis-functional-dependencies/)
-[![pypi](https://img.shields.io/pypi/pyversions/dbis-functional-dependencies)](https://pypi.org/project/dbis-functional-dependencies/)
-[![License](https://img.shields.io/pypi/l/dbis-functional-dependencies)](https://www.apache.org/licenses/LICENSE-2.0)

dbis_functional_dependencies-0.0.7.dist-info/RECORD

@@ -1,10 +0,0 @@
-functional_dependencies/BCNF.py,sha256=O9mzLeUfOOD9891-DOl7soJmzEGpPEmyXRuJnfOLDhE,22485
-functional_dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-functional_dependencies/fdcheck.py,sha256=z1gk1DY0O6bATFCD0mQsrVRJ9FmcusQ0TmIPu97JMUk,3854
-functional_dependencies/fds.py,sha256=jYVc4Dlo8wZutIq7CUo5znIYoDuooCxu3U6qhVWRGhc,23990
-functional_dependencies/fdsbase.py,sha256=Lx2KO2W9LngGHJHK6bhapWJr7P72xaJ_SUDVyyrCaz8,5683
-dbis_functional_dependencies-0.0.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dbis_functional_dependencies-0.0.7.dist-info/METADATA,sha256=2U_HSE5_NVYgWAYbdgilZerfVil8tu6JG45BgvudbwE,1129
-dbis_functional_dependencies-0.0.7.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
-dbis_functional_dependencies-0.0.7.dist-info/top_level.txt,sha256=gdKnqm_LuTOPR2jukC8CfBSBQTbgvYbKJOSjJtM1woo,24
-dbis_functional_dependencies-0.0.7.dist-info/RECORD,,

dbis_functional_dependencies-0.0.7.dist-info/top_level.txt

@@ -1 +0,0 @@
-functional_dependencies