DanDB 0.0.2__tar.gz

dandb-0.0.2/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

dandb-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Retro2D
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dandb-0.0.2/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: DanDB
+Version: 0.0.2
+Summary:     DanDB     An open-source statistics module created by Daniel Long.      Note: This module isn't ready for any heavy tasks yet.  This is mostly a passion project     built for fun by Danny. 
+Author-email: Daniel Long <dandevthetrue@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# DanDB
+DanDB is a multi-purpose module built for statistics, analyitics, and some other uses (such as a limited selection of machine learning functions).  
+
+Current release is 0.0.1.  It can:
+-Create and manipulate some basic two-dimensional graphs
+-Print out spreadsheets of those graphs
+-Provide an amount of essential formulas for graphing, data science, and machine learning (currently W.I.P with ML formulas)
+
+**IMPORTANT NOTICE:** This project is currently in pre-alpha.  It currently isn't meant for any serious work; it is mostly a fun side project I am building.
+
+# Guide
+Guide to using the module's functions.  Importing the module is what you do for any other module: `import DanDB`.  That's it.
+
+## Creating a table:
+
+To create a basic chart, use the `create_table()` function.   The `create_table()` function has all the essential parameters for creating a basic table.  It requires `name` and `rows` parameters to function; their usage is self explanatory.  
+
+The `name` parameter simply refers to the name you want to give the chart in both JSON and pretty print form, while the `rows` parameter refers to the amount of rows you want to give your chart.  
+
+Likewise, the `columns` parameter refers to the amount of columns you want to give your chart, though it isn't necessary (defaulted to one if not specified).  The `data` parameter can either be a list or string, though only a list will have effect (any string will be IGNORED).   As the name suggests, the `data` parameter will include the data visualized on your chart.  If not inputted, it defaults to 0 for each column and row on your list.  It also should be noted that the length of your list should reflect the size of the table (rows * columns).  If it is less, default values of 0 will be added, and larger values will result in crashes.
+
+The `xcolumn_names` and `ycolumn_names` parameters refer to the names of your columns (xcolumn) and rows (ycolumn).  The default value for these parameters is "Unspecified".  You can either input a list or string for each of them, though inputting a string will cause every row/column of your table to have that exact name.   Lists are expected to be the exact length of either your columns or rows; wrong values can lead to unexpected behavior.  
+
+## Modifying a table:
+Tables have multiple methods and functions you can use to modify them.  Here is a list of them:
+
+### methods:
+
+ 1. `table.addrow(rows, row_name, content)` Adds a row (or multiple rows) to your table.  `rows` parameter specifies how many rows you want to add, while `row_name` parameter specifies what the names for the rows should be.  The value given to this parameter will be used for each row added to the table through this function.  `content` is used to specify the data given to the row.  Unlike other methods/functions, `content` must strictly be a list for it to function.
+ 2. `table.changetitle(newtitle)` Pretty straightforward.  You can change the visual title for your table using this function.  The `newtitle` parameter specifies what your new title should be called.  It must be a string.
+ 3. `table.destroy()` Destroys your entire table, and replaces it with a dummy table.  Pretty straightforward; no parameters.  
+ 4. `table.replace(lines, newval)` Replaces values at `lines` list/int with data from `newval` list.  `lines` can be an int, though it will only replace data from one line.
+
+### functions
+
+ 1. `DanDB.prettyprint(table)` Prints the formatted contents of a `table` onto the terminal in an excel-like style.
+
+# Outro
+This README is a work in progress, and doesn't cover half of the things in this module.  I would advise you to look into the `DanDB.py` file for more info on the functions and attributes of this module.
+
+Good luck!  -Dan.

dandb-0.0.2/README.md

@@ -0,0 +1,41 @@
+# DanDB
+DanDB is a multi-purpose module built for statistics, analyitics, and some other uses (such as a limited selection of machine learning functions).  
+
+Current release is 0.0.1.  It can:
+-Create and manipulate some basic two-dimensional graphs
+-Print out spreadsheets of those graphs
+-Provide an amount of essential formulas for graphing, data science, and machine learning (currently W.I.P with ML formulas)
+
+**IMPORTANT NOTICE:** This project is currently in pre-alpha.  It currently isn't meant for any serious work; it is mostly a fun side project I am building.
+
+# Guide
+Guide to using the module's functions.  Importing the module is what you do for any other module: `import DanDB`.  That's it.
+
+## Creating a table:
+
+To create a basic chart, use the `create_table()` function.   The `create_table()` function has all the essential parameters for creating a basic table.  It requires `name` and `rows` parameters to function; their usage is self explanatory.  
+
+The `name` parameter simply refers to the name you want to give the chart in both JSON and pretty print form, while the `rows` parameter refers to the amount of rows you want to give your chart.  
+
+Likewise, the `columns` parameter refers to the amount of columns you want to give your chart, though it isn't necessary (defaulted to one if not specified).  The `data` parameter can either be a list or string, though only a list will have effect (any string will be IGNORED).   As the name suggests, the `data` parameter will include the data visualized on your chart.  If not inputted, it defaults to 0 for each column and row on your list.  It also should be noted that the length of your list should reflect the size of the table (rows * columns).  If it is less, default values of 0 will be added, and larger values will result in crashes.
+
+The `xcolumn_names` and `ycolumn_names` parameters refer to the names of your columns (xcolumn) and rows (ycolumn).  The default value for these parameters is "Unspecified".  You can either input a list or string for each of them, though inputting a string will cause every row/column of your table to have that exact name.   Lists are expected to be the exact length of either your columns or rows; wrong values can lead to unexpected behavior.  
+
+## Modifying a table:
+Tables have multiple methods and functions you can use to modify them.  Here is a list of them:
+
+### methods:
+
+ 1. `table.addrow(rows, row_name, content)` Adds a row (or multiple rows) to your table.  `rows` parameter specifies how many rows you want to add, while `row_name` parameter specifies what the names for the rows should be.  The value given to this parameter will be used for each row added to the table through this function.  `content` is used to specify the data given to the row.  Unlike other methods/functions, `content` must strictly be a list for it to function.
+ 2. `table.changetitle(newtitle)` Pretty straightforward.  You can change the visual title for your table using this function.  The `newtitle` parameter specifies what your new title should be called.  It must be a string.
+ 3. `table.destroy()` Destroys your entire table, and replaces it with a dummy table.  Pretty straightforward; no parameters.  
+ 4. `table.replace(lines, newval)` Replaces values at `lines` list/int with data from `newval` list.  `lines` can be an int, though it will only replace data from one line.
+
+### functions
+
+ 1. `DanDB.prettyprint(table)` Prints the formatted contents of a `table` onto the terminal in an excel-like style.
+
+# Outro
+This README is a work in progress, and doesn't cover half of the things in this module.  I would advise you to look into the `DanDB.py` file for more info on the functions and attributes of this module.
+
+Good luck!  -Dan.

dandb-0.0.2/example.json

@@ -0,0 +1,72 @@
+[
+  "test",
+  [
+    [
+      [
+        [
+          0,
+          "row",
+          0,
+          "new value",
+          0,
+          "newer value",
+          0
+        ],
+        [
+          1,
+          "row",
+          "newest value",
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          2,
+          "row",
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          3,
+          "other row",
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          4,
+          "other row",
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          5,
+          "other row",
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    ],
+    [
+      [
+        "column",
+        "column",
+        "column",
+        "column",
+        "column"
+      ]
+    ]
+  ]
+]

dandb-0.0.2/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "DanDB"
+version = "0.0.2"
+description = """
+    DanDB
+    An open-source statistics module created by Daniel Long.
+
+    Note: This module isn't ready for any heavy tasks yet.  This is mostly a passion project
+    built for fun by Danny. 
+"""
+
+authors = [
+    { name = "Daniel Long", email = "dandevthetrue@gmail.com" }
+]
+
+readme = "README.md"
+license = "MIT"
+
+requires-python = ">=3.8"

dandb-0.0.2/src/DanDB/DanDB.py

@@ -0,0 +1,356 @@
+import json
+
+#These are most of the basic functions inside of the DanDB module.  :)
+
+def about():
+    return("Welcome to DanDB! \nThis project was made for the Stardance hackathon, but I plan on using it for \ngeneral purpose.  \nThis project is open-source, and readability friendly.  \nFeel free to use for your own hacks! :D")
+
+### Statistic functions ###
+
+def mean(array):
+    return sum(array)/len(array)
+
+def median(array):
+    array.sort() #Sort our data, pretty self-explanatory.
+    if len(array)%2 == 0: #Checks if value is even
+        return mean([array[len(array)//2], array[len(array)//2-1]]) #Returns mean of middle, middle+1 values since there is no one middle value.
+    
+    elif len(array)%2 == 1: #Checks if value is odd
+        return array[(len(array)-1)//2] #Returns the middle value. Pretty simple to understand.
+
+def mse(act, pred):
+    #Error handling
+    if len(act)-len(pred) != 0:
+        raise ValueError("Actual and predicted values must be the same in length.")
+    
+    #Actual function itself
+    squared_dif = []
+
+    for i, (a, p) in enumerate(zip(act, pred)):
+        squared_dif.append((a-p)**2) #Get difference squared for actual and predicted.
+
+    return mean(squared_dif) #Now we get the mean, which should be the output of the function.
+
+def matrix_combine(*lists):
+    init_lists = [lst for lst in lists if lst]
+
+    if not init_lists:
+        return("Warning: matrix_combine function must have at least one argument")
+    
+    return list(zip(init_lists))
+
+### Database functions ###
+
+#Init database datatypes
+
+class Table:
+
+    #Rate limiting
+
+    max_rows = 100000
+    max_data = 100000000
+    max_string = 1000
+
+    #Bundling function
+    def bundle_data_row(self, row, data):
+        output = []
+        chunk = []
+
+        for i in range(len(row)):
+            chunk = [i]
+            chunk.append(row[i])
+
+            for x in range(len(data)//len(row)):
+                chunk.append(data[i * (len(row)-1) + x])
+
+            output.append(chunk)
+
+        return(output)
+    
+    def __init__(self, name: str, columns: int, rows=1, data=None, xcolumn_names=None, ycolumn_names=None):
+        if data == None:
+            data = []
+
+        if xcolumn_names == None:
+            xcolumn_names ='Unspecified'
+
+        if ycolumn_names == None:
+            ycolumn_names = 'Unspecified'
+
+        #Initialize params
+        self.name = name
+        self.columns = columns
+        self.rows = rows
+        self.dimensions = 3
+        self.data = data
+
+        #Error handling for wrong datatype
+        def column_check(self, column_val: int):
+            if not isinstance(column_val, int):
+                raise ValueError("Column datatype must be of int")
+
+        def dimen_check(self, dimen_val: int):
+            if not isinstance(dimen_val, int):
+                raise ValueError("Dimension datatype must be of int")
+
+
+        #Error handling for maximum thershold
+        def threshold_check(self, columns, rows):
+            if columns * rows > self.max_data:
+                raise ValueError("Total data value exceeds maximum threshold")
+            
+        column_check(self, columns)
+
+        tableinit = []
+        xcolumns_init = []
+        ycolumns_init = []
+        mydata = []
+        tableinit.append(name)
+        fulldatasize = columns * rows
+
+        #Append data to table
+        if len(data) == 0 or isinstance(data, str):
+            if isinstance(data, str):
+                print("Warning: Inputting string values as data will not do anything, and instead call the default values of 0.  If you want this, using [] as the input is \nthe best practice.")
+
+            for i in range(fulldatasize):
+                mydata.append(0)
+
+        elif fulldatasize != len(data) and isinstance(data, str) != True:
+            mydata = data
+            fixeddatasize = fulldatasize - len(data)
+
+            for i in range(fixeddatasize):
+                mydata.append(0)
+
+        else:
+            mydata = data
+
+        self.data = mydata
+
+        for i in range(columns):
+            if isinstance(xcolumn_names, str):
+                xcolumns_init.append(xcolumn_names)
+
+            else:
+                if len(xcolumn_names) == 1:
+                     xcolumns_init.append(xcolumn_names[0])
+
+                else:
+                    if i+1 <= len(xcolumn_names):
+                        xcolumns_init.append(xcolumn_names[i])
+
+                    else:
+                        xcolumns_init.append("Unspecified")
+
+        self.columns = xcolumns_init
+
+        for i in range(rows):
+            if len(ycolumn_names) == 1:
+                 ycolumns_init.append(ycolumn_names[0])
+
+            else:
+                if isinstance(ycolumn_names, str):
+                    ycolumns_init.append(ycolumn_names)
+
+                else:
+                    if i+1 <= len(ycolumn_names):
+                        ycolumns_init.append(ycolumn_names[i])
+
+                    else:
+                        ycolumns_init.append("Unspecified")
+
+        self.ycolumns = ycolumns_init
+
+        bundledrows = self.bundle_data_row(self.ycolumns, mydata)
+
+        tableinit = matrix_combine(bundledrows, xcolumns_init)
+        self.table = [name, tableinit]
+
+    #Methods
+
+    def addrow(self, rows, row_name="undefined", content=None):
+        if content == None:
+            content = []
+
+        if rows <= 0:
+            raise ValueError("Row value must be at least one.")
+
+        if rows+len(self.ycolumns) > self.max_rows:
+            raise ValueError("Total row value exceeds maximum threshold")
+        
+        for i in range(rows):
+            self.ycolumns.append(row_name)
+            for x in range(len(self.columns)):   
+                if i+1 <= len(content):
+                    self.data.append(content[i])
+                else:
+                    self.data.append(0)
+
+        bundledrows = self.bundle_data_row(self.ycolumns, self.data)
+
+        tableinit = matrix_combine(bundledrows, self.columns)
+        self.table = [self.name, tableinit]
+        
+        return self
+    
+    def changetitle(self, newtitle):
+        self.table[0] = newtitle
+
+    def destroy(self):        
+        self.table[0] = "Unnamed"
+        self.name = "Unnamed"
+        for i in range(len(self.data)):
+            self.data[i] = 0
+
+        for i in range(len(self.ycolumns)):
+            self.ycolumns[i] = "Unnamed"
+            
+        for i in range(len(self.columns)):
+            self.columns[i] = "Unnamed"
+
+        bundledrows = self.bundle_data_row(self.ycolumns, self.data)
+
+        tableinit = matrix_combine(bundledrows, self.columns)
+        self.table = [self.name, tableinit]
+
+    def replace(self, lines, new_val):
+        if isinstance(lines, int):
+            self.data[lines] = new_val
+
+        elif isinstance(lines, list):
+            for i, x in enumerate(lines):
+                if isinstance(new_val, str):
+                    self.data[x] = new_val
+                elif isinstance(new_val, list):
+                    self.data[x] = new_val[i]
+
+        else:
+            raise ValueError("lines param must be either int or list datatype")
+
+        bundledrows = self.bundle_data_row(self.ycolumns, self.data)
+
+        tableinit = matrix_combine(bundledrows, self.columns)
+        self.table = [self.name, tableinit]
+    
+        return self
+
+    #length organization methods
+
+    @staticmethod
+    def get_longest_item(inputlist):
+        if isinstance(inputlist, list):
+            longestitem = inputlist[0]
+            for i in inputlist:
+                if len(str(i)) > len(longestitem):
+                    longestitem = str(i)
+            return(longestitem)
+        
+        else:
+            raise ValueError("Input type must be list!")
+        
+    @staticmethod
+    def get_shortest_item(inputlist):
+        if isinstance(inputlist, list):
+            longestitem = inputlist[0]
+            for i in inputlist:
+                if len(i) < len(longestitem):
+                    longestitem = i
+            return(longestitem)
+        
+        else:
+            raise ValueError("Input type must be list!")
+        
+    def getlongestrow(self):
+        return(self.get_longest_item(self.ycolumns))
+    
+    def getlongestcolumn(self):
+        return(self.get_longest_item(self.columns))
+
+    #padding methods
+
+    @staticmethod
+    def getrowpadding(currentrow, toprow):
+        return (f"{' ' * (toprow - len(str(currentrow)))}{currentrow}|")
+
+    def getjson(self):
+        return(json.dumps(self.table, separators=(',', ':')))
+
+    def getformattedjson(self):
+        return(json.dumps(self.table, indent=2))
+
+    #File saving
+    def writejson(self, filename):
+        with open(filename, "w") as f:
+            f.write(json.dumps(self.table, indent=2))
+                    
+
+
+#Now, here are the functions :)
+
+def create_table(name, rows, columns=1, data=None, column_names="Unspecified", row_names="Unspecified"):
+    if data == None:
+        data = []
+
+    new_table = Table(name, rows, columns, data, column_names, row_names)
+    return new_table
+
+def table_addxy(table, y_rep):
+    pass
+
+def return_raw(table_name):
+    return table_name.table
+
+def pretty_print(table_name):
+    printinit = [] #This list defines our content, since we cannot return mroe than once.
+    toprowinit = []
+    longestrow = len(table_name.getlongestrow())
+    toppadding = ""
+    for i in range(round((longestrow-len(table_name.table[0]))/2)):
+        toppadding = toppadding+"="
+    
+    for i in range((round(sum(map(len, table_name.columns))/2))):
+        toppadding = toppadding+"="
+    
+    for i in range(len(table_name.columns)):
+        toppadding = toppadding+"="
+    
+    printinit.append(f"{toppadding}{table_name.table[0]}{toppadding}")
+    spacing = ""
+
+    for i in range(longestrow):
+        spacing = spacing+" "
+    toprowinit.append(f"{spacing}| ")
+
+    for i in table_name.columns:
+        toprowinit.append(f"{i}| ")
+
+    toprowinitcontent = "".join(toprowinit)
+    printinit.append(toprowinitcontent)
+
+    for i, item1 in enumerate(table_name.ycolumns): #For every item in table
+        columninit = (f"{' ' * (longestrow - len(str(item1)))}{item1}|")
+
+        for x, item2 in enumerate(table_name.columns): #For for every column in table
+            dataindex = table_name.data[i * len(table_name.columns) + x] #Gets the current item by getting the current row (represented by i), multiplying it by the amount of columns to find where the row is on the list, and then adds x (the column pointer) to find which column it is located at.  This results in the exact location of the data.
+            xindex = table_name.columns[i%len(table_name.columns)]
+
+            #Length conditions
+
+            if i-1 <=len(table_name.data): 
+                if len(str(dataindex)) == len(xindex)+1:
+                    columninit = columninit + (f"{dataindex}|") #Explain this later
+
+                elif len(str(dataindex)) < len(xindex)+1:
+                    columninit = columninit + (f"{dataindex}{' '* ((len(xindex)+1) - len(str(dataindex)))}|") #Explain this later
+
+                else:
+                    cleaneddata = ""
+                    for y in range((len(xindex))+1):
+                        cleaneddata += str(str(dataindex)[y])
+
+                    columninit = columninit + (f"{(cleaneddata)}|") #Explain this later
+                    
+        printinit.append(columninit)
+
+    print(*printinit, sep="\n", end="") #This is our pretty print!

dandb-0.0.2/src/DanDB/__init__.py

@@ -0,0 +1,12 @@
+from .DanDB import *
+
+"""
+    DanDB
+    An open-source statistics module created by Daniel Long.
+
+    Run DanDB.about() for more info.
+
+    v0.0.1
+"""
+
+__version__ = "0.0.1b"

dandb-0.0.2/src/DanDB/demo.py

@@ -0,0 +1,12 @@
+# A basic demo for DanDB, showing how a table is sucessfully made.
+
+import DanDB
+
+table = DanDB.create_table("test", 5, 3, [], "column", "row") # Creating a basic table with unspecified data, column and row names of "column" and "row" respectively.
+
+table.addrow(3, "other row") # Add three other rows with the names "other row"
+table.replace([1, 3, 5], ['new value', 'newer value', 'newest value']) # Replaces data at list index 1, 3, and five with "ndw value", "newer value", and "newest value" respectively.  (please note that indexes are added by one as per Python's default indexing guidelines.  For example, first item in table is at index zero).
+
+DanDB.pretty_print(table) # Pretty print our table.  Pretty straightforward.
+
+table.writejson("example.json") # Writes json of table to example.json file