ducky-python-module 0.1.4__tar.gz → 1.0.0__tar.gz

{ducky_python_module-0.1.4 → ducky_python_module-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducky-python-module
-Version: 0.1.4
+Version: 1.0.0
 Summary: Ducky Python module
 Author: Tom
 License: Creative Commons Attribution-NonCommercial 4.0 International Public
@@ -346,8 +346,15 @@ Dynamic: license-file
 
 # Ducky-Python-Module
 A collection of tools for python  
-Still in progress but it will be releasing fully soon  
+Still in progress and will be releasing fully soon  
 Credit:  
 Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.
 Nltk has been imported but not modified.
-And a few other libraries which I'll mention when this is complete
+Full import list:  
+import random, time, os, tkinter as TK, types, math, inspect, sys, requests, json, numpy, ast, logging
+from os.path import isfile, split, join
+from copy import deepcopy
+from tkinter import simpledialog
+from turtle import Turtle
+from nltk.tokenize import word_tokenize
+from nltk.stem import LancasterStemmer

ducky_python_module-1.0.0/README.md

@@ -0,0 +1,14 @@
+# Ducky-Python-Module
+A collection of tools for python  
+Still in progress and will be releasing fully soon  
+Credit:  
+Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.
+Nltk has been imported but not modified.
+Full import list:  
+import random, time, os, tkinter as TK, types, math, inspect, sys, requests, json, numpy, ast, logging
+from os.path import isfile, split, join
+from copy import deepcopy
+from tkinter import simpledialog
+from turtle import Turtle
+from nltk.tokenize import word_tokenize
+from nltk.stem import LancasterStemmer

{ducky_python_module-0.1.4 → ducky_python_module-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ducky-python-module"
-version = "0.1.4"
+version = "1.0.0"
 description = "Ducky Python module"
 readme = "README.md"
 requires-python = ">=3.8"

{ducky_python_module-0.1.4 → ducky_python_module-1.0.0}/src/ducky/main.py

@@ -102,6 +102,15 @@ def stem(string):
 def array(lst):
     return numpy.array(lst)
 
+def dot_product(mat1,mat2):
+    return numpy.dot(mat1,mat2)
+
+def scale_matrices(mat,val):
+    return mat*val
+
+def average_matrices(mat):
+    return numpy.average(mat)
+
 def calc(param):
     try:
         return ast.literal_eval(param)
@@ -164,6 +173,68 @@ def modify(func,modifier):
 
 #classes
 
+class Tester:
+    _instances = []
+    @classmethod
+    def average(cls):
+        total_success = 0
+        total_errors = 0
+        for instance in cls._instances:
+            total_success += len(instance.success)
+            total_errors += len(instance.errors)
+        total_tests = total_success + total_errors
+        if total_tests == 0:
+            return 0
+        return (total_success / total_tests) * 100
+    def __init__(self):
+        self.errors = []
+        self.success = []
+        Tester._instances.append(self)
+        print("\033[0m")
+    def test(self,code, name="Unnamed"):
+        try:
+            exec(code, globals())
+            self.success.append(name)
+            print(f"\033[32mCode:\n{code}\n({name}) executed successfully\n")
+
+        except Exception as error:
+            print(f"\033[31m{error}\n")
+            self.errors.append(f"Line:  {len(self.errors)+len(self.success)+1}   {error}")
+
+    def results(self):
+        total = len(self.success) + len(self.errors)
+        if total == 0:
+            percent = 0
+        else:
+            percent = (len(self.success) / total) * 100
+
+        if percent == 100:
+            print("\033[92m------------------------------------------------------------")
+            print("\033[92mCompleted 100% successfully:\n")
+
+        elif percent >= 90:
+            print("\033[32m------------------------------------------------------------")
+            print("\033[32mCompleted 90% or more successfully:\n")
+
+        elif percent >= 80:
+            print("\033[33m------------------------------------------------------------")
+            print("\033[33mCompleted 80% or more successfully:\n")
+        elif percent >= 70:
+            print("\033[38;5;208m------------------------------------------------------------")
+            print("\033[38;5;208mCompleted 70% or more successfully:\n")
+        else:
+            print("\033[91m------------------------------------------------------------")
+            print(f"\033[91mCompleted {percent}% successfully:\n")
+        if self.success:
+            print(f"\033[32mSuccessful tests:\n")
+        for s in self.success:
+            print(f"\033[32m{s}")
+        if len(self.errors) > 0:
+            print(f"\n\033[31mFailed tests:\n")
+        for e in self.errors:
+            print(f"\033[31m{e}")
+
+
 class MatrixManager:
     def __init__(self,background,fps,mat=None,wrapping=False,sprite_condition=1):
         self.mat = mat
@@ -361,6 +432,221 @@ class Chatbot:
             return 1
         return None
 
+
+#AI TEMPLATE
+
+import mnist
+import numpy
+import abc
+
+class ActivationFunction:
+    tanh = 0
+    sigmoid = 1
+    softmax = 2
+    @staticmethod
+    def __tanh(x: numpy.ndarray) -> numpy.ndarray:
+        return numpy.tanh(x)
+
+    @staticmethod
+    def __tanh_derivative(x: numpy.ndarray) -> numpy.ndarray:
+        return 1 - numpy.tanh(x) ** 2
+
+    @staticmethod
+    def use_tanh():
+        return ActivationFunction.tanh, ActivationFunction.__tanh, ActivationFunction.__tanh_derivative
+
+    @staticmethod
+    def __sigmoid(x):
+        return 1 / (1 + numpy.exp(-x))
+
+    @staticmethod
+    def __sigmoid_derivative(x):
+        s = 1 / (1 + numpy.exp(-x))
+        return s * (1 - s)
+
+    @staticmethod
+    def use_sigmoid():
+        return ActivationFunction.sigmoid, ActivationFunction.__sigmoid, ActivationFunction.__sigmoid_derivative
+
+    @staticmethod
+    def __softmax(x):
+        x = numpy.array(x)
+        e_x = numpy.exp(x - numpy.max(x))
+        return e_x / e_x.sum(axis=-1, keepdims=True)
+
+    @staticmethod
+    def __softmax_derivative(s):
+        s = s.reshape(-1, 1)
+        return numpy.diagflat(s) - numpy.dot(s, s.T)
+
+    @staticmethod
+    def use_softmax():
+        return ActivationFunction.softmax, ActivationFunction.__softmax, ActivationFunction.__softmax_derivative
+
+
+class CostFunctions:
+    mse = 0
+    cross_entropy = 1
+    @staticmethod
+    def __mean_squared_error(actual: numpy.ndarray, predicted: numpy.ndarray):
+        return numpy.mean(numpy.power((actual - predicted), 2))
+
+    @staticmethod
+    def __mean_squared_error_derivative(actual: numpy.ndarray, predicted: numpy.ndarray) -> numpy.ndarray:
+        return 2 * (predicted - actual)/actual.size
+
+    @staticmethod
+    def use_mean_squared_error():
+        return CostFunctions.mse, CostFunctions.__mean_squared_error, CostFunctions.__mean_squared_error_derivative
+
+    @staticmethod
+    def __categorical_cross_entropy(actual: numpy.ndarray, predicted: numpy.ndarray):
+        epsilon = 1e-12
+        predicted = numpy.clip(predicted, epsilon, 1. - epsilon)
+        return -numpy.mean(numpy.sum(actual * numpy.log(predicted), axis=1))
+
+    @staticmethod
+    def __categorical_cross_entropy_derivative(actual: numpy.ndarray, predicted: numpy.ndarray):
+        return (predicted - actual) / actual.shape[0]
+
+    @staticmethod
+    def use_categorical_cross_entropy():
+        return CostFunctions.cross_entropy, CostFunctions.__categorical_cross_entropy, CostFunctions.__categorical_cross_entropy_derivative
+
+class Layer(abc.ABC):
+    def __init__(self):
+        self.input = None
+        self.output = None
+
+    @abc.abstractmethod
+    def feed_forward(self, inputs: numpy.ndarray) -> numpy.ndarray:
+        pass
+
+    @abc.abstractmethod
+    def back_propagate(self, error: numpy.ndarray, learning_rate: float) -> numpy.ndarray:
+        pass
+
+class FullyConnectedLayer(Layer):
+    def __init__(self, input_size: int, output_size: int):
+        super().__init__()
+        random_bound = 1.0 / numpy.sqrt(input_size)
+        self.weights = numpy.random.uniform(-random_bound, random_bound, (input_size, output_size))
+        self.bias = numpy.zeros((1, output_size))
+
+    def feed_forward(self, inputs: numpy.ndarray) -> numpy.ndarray:
+        self.input = inputs
+        self.output = numpy.dot(inputs, self.weights) + self.bias
+        return self.output
+
+
+    def back_propagate(self, error: numpy.ndarray, learning_rate: float) -> numpy.ndarray:
+        input_error = numpy.dot(error, self.weights.T)
+        weights_error = numpy.dot(self.input.T, error)
+        self.weights -= learning_rate * weights_error
+        self.bias -= learning_rate * numpy.mean(error, axis=0, keepdims=True)
+        return input_error
+
+
+class ActivationLayer(Layer):
+    def __init__(self, ID, activation_function, activation_derivative):
+        super().__init__()
+        self.ID = ID
+        self.activation_function = activation_function
+        self.activation_derivative = activation_derivative
+
+    def feed_forward(self, inputs: numpy.ndarray) -> numpy.ndarray:
+        self.input = inputs
+        self.output = self.activation_function(inputs)
+        return self.output
+
+    def back_propagate(self, error: numpy.ndarray, learning_rate: float) -> numpy.ndarray:
+        if self.ID == ActivationFunction.softmax:
+            return error
+        else:
+            return self.activation_derivative(self.input) * error
+
+class NeuralNetwork:
+    def __init__(self, ID, cost_function, cost_derivative):
+        self.ID = ID
+        self.layers = []
+        self.cost_function = cost_function
+        self.cost_derivative = cost_derivative
+
+    def add_layer(self, layer: Layer):
+        self.layers.append(layer)
+
+    def predict(self, inputs: numpy.ndarray) -> numpy.ndarray:
+        for layer in self.layers:
+            inputs = layer.feed_forward(inputs)
+        return inputs
+
+    def train(self, inputs: numpy.ndarray, outputs: numpy.ndarray, n_epochs: int, batch_size: int, learning_rate: float):
+        for epoch in range(n_epochs):
+            batch_index = 0
+            while batch_index < inputs.shape[0]:
+                if batch_index + batch_size < inputs.shape[0]:
+                    output = inputs[batch_index:batch_index + batch_size, ]
+                    actual = outputs[batch_index:batch_index + batch_size, ]
+                else:
+                    output = inputs[batch_index:, ]
+                    actual = outputs[batch_index:, ]
+                output = self.predict(output)
+                cost = self.cost_function(actual, output)
+                error = self.cost_derivative(actual, output)
+                for layer in reversed(self.layers):
+                    error = layer.back_propagate(error, learning_rate)
+                print(f"Epoch: {epoch+1}/{n_epochs} | Batch: {batch_index}/{inputs.shape[0]} | Cost: {cost}")
+                batch_index += batch_size
+
+    def save(self, path: str):
+        with open(f"{path}.nn", "w") as save_file:
+            save_file.write(f"{self.ID}\n")
+            for index, layer in enumerate(self.layers):
+                if isinstance(layer, FullyConnectedLayer):
+                    save_file.write(f"F|{index}|{layer.weights.shape[0]}|{layer.weights.shape[1]}\n")
+                    numpy.save(f"{path}_{index}_w", layer.weights)
+                    numpy.save(f"{path}_{index}_b", layer.bias)
+                elif isinstance(layer, ActivationLayer):
+                    if layer.ID == ActivationFunction.tanh:
+                        save_file.write(f"A|{index}|{ActivationFunction.tanh}\n")
+                    elif layer.ID == ActivationFunction.sigmoid:
+                        save_file.write(f"A|{index}|{ActivationFunction.sigmoid}\n")
+                    elif layer.ID == ActivationFunction.softmax:
+                        save_file.write(f"A|{index}|{ActivationFunction.softmax}\n")
+                    else:
+                        save_file.write(f"A|{index}|{ActivationFunction.tanh}\n")
+    @staticmethod
+    def load(path: str):
+        with open(f"{path}.nn", "r") as file:
+            lines = file.readlines()
+        cost_function_id = int(lines[0])
+        if cost_function_id == CostFunctions.mse:
+            neural_network = NeuralNetwork(*CostFunctions.use_mean_squared_error())
+        else:
+            neural_network = NeuralNetwork(*CostFunctions.use_mean_squared_error())
+        for line in lines[1:]:
+            if line != "":
+                parts = line.split("|")
+                if parts[0] == "F":
+                    weights = numpy.load(f"{path}_{parts[1]}_w.npy")
+                    bias = numpy.load(f"{path}_{parts[1]}_b.npy")
+                    layer = FullyConnectedLayer(weights.shape[0], weights.shape[1])
+                    layer.weights = weights
+                    layer.bias = bias
+                    neural_network.add_layer(layer)
+                elif parts[0] == "A":
+                    activation_id = int(parts[2])
+                    if activation_id == ActivationFunction.tanh:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunction.use_tanh()))
+                    elif activation_id == ActivationFunction.sigmoid:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunction.use_sigmoid()))
+                    elif activation_id == ActivationFunction.softmax:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunction.use_softmax()))
+                    else:
+                        neural_network.add_layer(ActivationLayer(*ActivationFunction.use_tanh()))
+        return neural_network
+
+
 #turtlel
       
 def dots(turt_name, number, random_colours=True, colours=None, minimum=20, maximum=100):
@@ -1087,13 +1373,7 @@ class TurtleScreenBase(object):
         return self.cv.type(item)
 
     def _pointlist(self, item):
-        """returns list of coordinate-pairs of points of item
-        Example (for insiders):
-        >>> from turtle import *
-        >>> getscreen()._pointlist(getturtle().turtle._item)
-        [(0.0, 9.9999999999999982), (0.0, -9.9999999999999982),
-        (9.9999999999999982, 0.0)]
-        >>> """
+        #returns list of coordinate-pairs of points of item
         cl = self.cv.coords(item)
         pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)]
         return  pl
@@ -1383,10 +1663,6 @@ class TurtleScreen(TurtleScreenBase):
           'standard'    to the right (east)       counterclockwise
             'logo'        upward    (north)         clockwise
 
-        Examples:
-        >>> mode('logo')   # resets turtle heading to north
-        >>> mode()
-        'logo'
         """
         if mode is None:
             return self._mode
@@ -1416,11 +1692,6 @@ class TurtleScreen(TurtleScreenBase):
         But ATTENTION: in user-defined coordinatesystems angles may appear
         distorted. (see Screen.mode())
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.setworldcoordinates(-10,-0.5,50,1.5)
-        >>> for _ in range(36):
-        ...     left(10)
-        ...     forward(0.5)
         """
         if self.mode() != "world":
             self.mode("world")
@@ -1458,9 +1729,6 @@ class TurtleScreen(TurtleScreenBase):
         call: register_shape("turtle.gif")
         --or: register_shape("tri", ((0,0), (10,10), (-10,10)))
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3)))
-
         """
         if shape is None:
             # image
@@ -1514,17 +1782,6 @@ class TurtleScreen(TurtleScreenBase):
 
     def colourmode(self, cmode=None):
         """Return the colourmode or set it to 1.0 or 255.
-
-        Optional argument:
-        cmode -- one of the values 1.0 or 255
-
-        r, g, b values of colourtriples have to be in range 0..cmode.
-
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.colourmode()
-        1.0
-        >>> screen.colourmode(255)
-        >>> pencolour(240,160,80)
         """
         if cmode is None:
             return self._colourmode
@@ -1538,8 +1795,6 @@ class TurtleScreen(TurtleScreenBase):
 
         No argument.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.reset()
         """
         for turtle in self._turtles:
             turtle._setmode(self._mode)
@@ -1548,9 +1803,6 @@ class TurtleScreen(TurtleScreenBase):
     def turtles(self):
         """Return the list of turtles on the screen.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.turtles()
-        [<turtle.Turtle object at 0x00E11FB0>]
         """
         return self._turtles
 
@@ -1560,12 +1812,6 @@ class TurtleScreen(TurtleScreenBase):
         Arguments (if given): a colour string or three numbers
         in the range 0..colourmode or a 3-tuple of such numbers.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.bgcolour("orange")
-        >>> screen.bgcolour()
-        'orange'
-        >>> screen.bgcolour(0.5,0,0.5)
-        >>> screen.bgcolour()
         '#800080'
         """
         if args:
@@ -1588,13 +1834,6 @@ class TurtleScreen(TurtleScreenBase):
         (Can be used to accelerate the drawing of complex graphics.)
         Second arguments sets delay value (see RawTurtle.delay())
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.tracer(8, 25)
-        >>> dist = 2
-        >>> for i in range(200):
-        ...     fd(dist)
-        ...     rt(90)
-        ...     dist += 2
         """
         if n is None:
             return self._tracing
@@ -1611,10 +1850,6 @@ class TurtleScreen(TurtleScreenBase):
         Optional argument:
         delay -- positive integer
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.delay(15)
-        >>> screen.delay()
-        15
         """
         if delay is None:
             return self._delayvalue
@@ -1643,8 +1878,6 @@ class TurtleScreen(TurtleScreenBase):
     def window_width(self):
         """ Return the width of the turtle window.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.window_width()
         640
         """
         return self._window_size()[0]
@@ -1652,8 +1885,6 @@ class TurtleScreen(TurtleScreenBase):
     def window_height(self):
         """ Return the height of the turtle window.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.window_height()
         480
         """
         return self._window_size()[1]
@@ -1663,10 +1894,6 @@ class TurtleScreen(TurtleScreenBase):
 
         No argument.
 
-        Example (for a Screen instance named screen):
-        >>> cv = screen.getcanvas()
-        >>> cv
-        <turtle.ScrolledCanvas instance at 0x010742D8>
         """
         return self.cv
 
@@ -1675,9 +1902,6 @@ class TurtleScreen(TurtleScreenBase):
 
         No argument.
 
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.getshapes()
-        ['arrow', 'blank', 'circle', ... , 'turtle']
         """
         return sorted(self._shapes.keys())
 
@@ -2104,10 +2328,6 @@ class TNavigator(object):
          180 - west              180 - south
          270 - south             270 - west
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.setheading(90)
-        >>> turtle.heading()
-        90
         """
         angle = (to_angle - self.heading())*self._angleOrient
         full = self._fullcircle
@@ -2140,9 +2360,7 @@ class TNavigator(object):
         --or: circle(radius, extent, steps)
         --or: circle(radius, steps=6)         # 6-sided polygon
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.circle(50)
-        >>> turtle.circle(120, 180)  # semicircle
+
         """
         if self.undobuffer:
             self.undobuffer.push(["seq"])
@@ -2236,10 +2454,6 @@ class TPen(object):
         If no argument is given, return current resizemode.
         resizemode("user") is called by a call of shapesize with arguments.
 
-
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.resizemode("noresize")
-        >>> turtle.resizemode()
         'noresize'
         """
         if rmode is None:
@@ -2261,10 +2475,6 @@ class TPen(object):
         the same line thickness. If no argument is given, current pensize
         is returned.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.pensize()
-        1
-        >>> turtle.pensize(10)   # from here on lines of width 10 are drawn
         """
         if width is None:
             return self._pensize
@@ -2278,8 +2488,6 @@ class TPen(object):
 
         No argument
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.penup()
         """
         if not self._drawing:
             return
@@ -2292,8 +2500,6 @@ class TPen(object):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.pendown()
         """
         if self._drawing:
             return
@@ -2304,13 +2510,6 @@ class TPen(object):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.penup()
-        >>> turtle.isdown()
-        False
-        >>> turtle.pendown()
-        >>> turtle.isdown()
-        True
         """
         return self._drawing
 
@@ -2338,8 +2537,6 @@ class TPen(object):
         speed = 0 : *no* animation takes place. forward/back makes turtle jump
         and likewise left/right make the turtle turn instantly.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.speed(3)
         """
         speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
         if speed is None:
@@ -2375,14 +2572,6 @@ class TPen(object):
         is drawn with the newly set colours.
         For more info see: pencolour, fillcolour
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.colour('red', 'green')
-        >>> turtle.colour()
-        ('red', 'green')
-        >>> colourmode(255)
-        >>> colour((40, 80, 120), (160, 200, 240))
-        >>> colour()
-        ('#285078', '#a0c8f0')
         """
         if args:
             l = len(args)
@@ -2420,12 +2609,6 @@ class TPen(object):
         If turtleshape is a polygon, the outline of that polygon is drawn
         with the newly set pencolour.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.pencolour('brown')
-        >>> tup = (0.2, 0.8, 0.55)
-        >>> turtle.pencolour(tup)
-        >>> turtle.pencolour()
-        '#33cc8c'
         """
         if args:
             colour = self._colourstr(args)
@@ -2457,11 +2640,6 @@ class TPen(object):
         If turtleshape is a polygon, the interior of that polygon is drawn
         with the newly set fillcolour.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.fillcolour('violet')
-        >>> col = turtle.pencolour()
-        >>> turtle.fillcolour(col)
-        >>> turtle.fillcolour(0, .5, 0)
         """
         if args:
             colour = self._colourstr(args)
@@ -2478,9 +2656,6 @@ class TPen(object):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.hideturtle()
-        >>> turtle.showturtle()
         """
         self.pen(shown=True)
 
@@ -2495,8 +2670,6 @@ class TPen(object):
         middle of a complicated drawing, because hiding
         the turtle speeds up the drawing observably.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.hideturtle()
         """
         self.pen(shown=False)
 
@@ -2537,25 +2710,6 @@ class TPen(object):
         or more of these attributes can be provided as keyword-arguments.
         This can be used to set several pen attributes in one statement.
 
-
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.pen(fillcolour="black", pencolour="red", pensize=10)
-        >>> turtle.pen()
-        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
-        'pencolour': 'red', 'pendown': True, 'fillcolour': 'black',
-        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
-        >>> penstate=turtle.pen()
-        >>> turtle.colour("yellow","")
-        >>> turtle.penup()
-        >>> turtle.pen()
-        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
-        'pencolour': 'yellow', 'pendown': False, 'fillcolour': '',
-        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
-        >>> p.pen(penstate, fillcolour="green")
-        >>> p.pen()
-        {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
-        'pencolour': 'red', 'pendown': True, 'fillcolour': 'green',
-        'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}
         """
         _pd =  {"shown"         : self._shown,
                 "pendown"       : self._drawing,
@@ -2741,16 +2895,6 @@ class RawTurtle(TPen, TNavigator):
         Delete the turtle's drawings from the screen, re-center the turtle
         and set variables to the default values.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.position()
-        (0.00,-22.00)
-        >>> turtle.heading()
-        100.0
-        >>> turtle.reset()
-        >>> turtle.position()
-        (0.00,0.00)
-        >>> turtle.heading()
-        0.0
         """
         TNavigator.reset(self)
         TPen._reset(self)
@@ -2769,8 +2913,6 @@ class RawTurtle(TPen, TNavigator):
         by the undo() function.
         If size is None, no undobuffer is present.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.setundobuffer(42)
         """
         if size is None or size <= 0:
             self.undobuffer = None
@@ -2782,9 +2924,6 @@ class RawTurtle(TPen, TNavigator):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> while undobufferentries():
-        ...     undo()
         """
         if self.undobuffer is None:
             return 0
@@ -2813,8 +2952,6 @@ class RawTurtle(TPen, TNavigator):
         State and position of the turtle as well as drawings of other
         turtles are not affected.
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.clear()
         """
         self._clear()
         self._update()
@@ -2856,13 +2993,6 @@ class RawTurtle(TPen, TNavigator):
         (Can be used to accelerate the drawing of complex graphics.)
         Second arguments sets delay value (see RawTurtle.delay())
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.tracer(8, 25)
-        >>> dist = 2
-        >>> for i in range(200):
-        ...     turtle.fd(dist)
-        ...     turtle.rt(90)
-        ...     dist += 2
         """
         return self.screen.tracer(flag, delay)
 
@@ -2940,12 +3070,6 @@ class RawTurtle(TPen, TNavigator):
         'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
         To learn about how to deal with shapes see Screen-method register_shape.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.shape()
-        'arrow'
-        >>> turtle.shape("turtle")
-        >>> turtle.shape()
-        'turtle'
         """
         if name is None:
             return self.turtle.shapeIndex
@@ -2968,12 +3092,8 @@ class RawTurtle(TPen, TNavigator):
         stretched according to its stretchfactors:
         stretch_wid is stretchfactor perpendicular to orientation
         stretch_len is stretchfactor in direction of turtles orientation.
-        outline determines the width of the shapes's outline.
+        outline determines the width of the shapes' outline.
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.resizemode("user")
-        >>> turtle.shapesize(5, 5, 12)
-        >>> turtle.shapesize(outline=8)
         """
         if stretch_wid is stretch_len is outline is None:
             stretch_wid, stretch_len = self._stretchfactor
@@ -3002,16 +3122,10 @@ class RawTurtle(TPen, TNavigator):
         Shear the turtleshape according to the given shearfactor shear,
         which is the tangent of the shear angle. DO NOT change the
         turtle's heading (direction of movement).
-        If shear is not given: return the current shearfactor, i. e. the
+        If shear is not given: return the current shearfactor, i.e. the
         tangent of the shear angle, by which lines parallel to the
         heading of the turtle are sheared.
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("circle")
-        >>> turtle.shapesize(5,2)
-        >>> turtle.shearfactor(0.5)
-        >>> turtle.shearfactor()
-        >>> 0.5
         """
         if shear is None:
             return self._shearfactor
@@ -3026,16 +3140,6 @@ class RawTurtle(TPen, TNavigator):
         regardless of its current tilt-angle. DO NOT change the turtle's
         heading (direction of movement).
 
-
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("circle")
-        >>> turtle.shapesize(5,2)
-        >>> turtle.settiltangle(45)
-        >>> stamp()
-        >>> turtle.fd(50)
-        >>> turtle.settiltangle(-45)
-        >>> stamp()
-        >>> turtle.fd(50)
         """
         tilt = -angle * self._degreesPerAU * self._angleOrient
         tilt = math.radians(tilt) % math.tau
@@ -3056,11 +3160,6 @@ class RawTurtle(TPen, TNavigator):
         (Incorrectly marked as deprecated since Python 3.1, it is really
         settiltangle that is deprecated.)
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("circle")
-        >>> turtle.shapesize(5,2)
-        >>> turtle.tilt(45)
-        >>> turtle.tiltangle()
         """
         if angle is None:
             tilt = -math.degrees(self._tilt) * self._angleOrient
@@ -3077,13 +3176,6 @@ class RawTurtle(TPen, TNavigator):
         Rotate the turtleshape by angle from its current tilt-angle,
         but do NOT change the turtle's heading (direction of movement).
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("circle")
-        >>> turtle.shapesize(5,2)
-        >>> turtle.tilt(30)
-        >>> turtle.fd(50)
-        >>> turtle.tilt(30)
-        >>> turtle.fd(50)
         """
         self.settiltangle(angle + self.tiltangle())
 
@@ -3100,11 +3192,6 @@ class RawTurtle(TPen, TNavigator):
         Modify stretchfactor, shearfactor and tiltangle according to the
         given matrix.
 
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("square")
-        >>> turtle.shapesize(4,2)
-        >>> turtle.shearfactor(-0.5)
-        >>> turtle.shapetransform()
         (4.0, -1.0, -0.0, 2.0)
         """
         if t11 is t12 is t21 is t22 is None:
@@ -3143,13 +3230,6 @@ class RawTurtle(TPen, TNavigator):
         """Return the current shape polygon as tuple of coordinate pairs.
 
         No argument.
-
-        Examples (for a Turtle instance named turtle):
-        >>> turtle.shape("square")
-        >>> turtle.shapetransform(4, -1, 0, 2)
-        >>> turtle.get_shapepoly()
-        ((50, -20), (30, 20), (-50, 20), (-30, -20))
-
         """
         shape = self.screen._shapes[self.turtle.shapeIndex]
         if shape._type == "polygon":
@@ -3218,11 +3298,6 @@ class RawTurtle(TPen, TNavigator):
         turtle position. Return a stamp_id for that stamp, which can be
         used to delete it by calling clearstamp(stamp_id).
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.colour("blue")
-        >>> turtle.stamp()
-        13
-        >>> turtle.fd(50)
         """
         screen = self.screen
         shape = screen._shapes[self.turtle.shapeIndex]
@@ -3282,11 +3357,6 @@ class RawTurtle(TPen, TNavigator):
         Argument:
         stampid - an integer, must be return value of previous stamp() call.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.colour("blue")
-        >>> astamp = turtle.stamp()
-        >>> turtle.fd(50)
-        >>> turtle.clearstamp(astamp)
         """
         self._clearstamp(stampid)
         self._update()
@@ -3301,13 +3371,6 @@ class RawTurtle(TPen, TNavigator):
         else if n > 0 delete first n stamps
         else if n < 0 delete last n stamps.
 
-        Example (for a Turtle instance named turtle):
-        >>> for i in range(8):
-        ...     turtle.stamp(); turtle.fd(30)
-        ...
-        >>> turtle.clearstamps(2)
-        >>> turtle.clearstamps(-2)
-        >>> turtle.clearstamps()
         """
         if n is None:
             toDelete = self.stampItems[:]
@@ -3476,12 +3539,6 @@ class RawTurtle(TPen, TNavigator):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.begin_fill()
-        >>> if turtle.filling():
-        ...     turtle.pensize(5)
-        ... else:
-        ...     turtle.pensize(3)
         """
         return isinstance(self._fillpath, list)
 
@@ -3490,11 +3547,6 @@ class RawTurtle(TPen, TNavigator):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.colour("black", "red")
-        >>> turtle.begin_fill()
-        >>> turtle.circle(60)
-        >>> turtle.end_fill()
         """
         if not self.filling():
             self._fillitem = self.screen._createpoly()
@@ -3511,11 +3563,6 @@ class RawTurtle(TPen, TNavigator):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.colour("black", "red")
-        >>> turtle.begin_fill()
-        >>> turtle.circle(60)
-        >>> turtle.end_fill()
         """
         if self.filling():
             if len(self._fillpath) > 2:
@@ -3536,9 +3583,6 @@ class RawTurtle(TPen, TNavigator):
         Draw a circular dot with diameter size, using colour.
         If size is not given, the maximum of pensize+4 and 2*pensize is used.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.dot()
-        >>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
         """
         if not colour:
             if isinstance(size, (str, tuple)):
@@ -3599,9 +3643,6 @@ class RawTurtle(TPen, TNavigator):
         If move is True, the pen is moved to the bottom-right corner
         of the text. By default, move is False.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.write('Home = ', True, align="center")
-        >>> turtle.write((0,0), True)
         """
         if self.undobuffer:
             self.undobuffer.push(["seq"])
@@ -3621,8 +3662,6 @@ class RawTurtle(TPen, TNavigator):
         Start recording the vertices of a polygon. Current turtle position
         is first point of polygon.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.begin_poly()
         """
         self._poly = [self._position]
         self._creatingPoly = True
@@ -3635,8 +3674,6 @@ class RawTurtle(TPen, TNavigator):
         Stop recording the vertices of a polygon. Current turtle position is
         last point of polygon. This will be connected with the first point.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.end_poly()
         """
         self._creatingPoly = False
 
@@ -3645,9 +3682,6 @@ class RawTurtle(TPen, TNavigator):
 
         No argument.
 
-        Example (for a Turtle instance named turtle):
-        >>> p = turtle.get_poly()
-        >>> turtle.register_shape("myFavouriteShape", p)
         """
         ## check if there is any poly?
         if self._poly is not None:
@@ -3661,11 +3695,6 @@ class RawTurtle(TPen, TNavigator):
         Return the TurtleScreen object, the turtle is drawing  on.
         So TurtleScreen-methods can be called for that object.
 
-        Example (for a Turtle instance named turtle):
-        >>> ts = turtle.getscreen()
-        >>> ts
-        <turtle.TurtleScreen object at 0x0106B770>
-        >>> ts.bgcolour("pink")
         """
         return self.screen
 
@@ -3676,13 +3705,6 @@ class RawTurtle(TPen, TNavigator):
 
         Only reasonable use: as a function to return the 'anonymous turtle':
 
-        Example:
-        >>> pet = getturtle()
-        >>> pet.fd(50)
-        >>> pet
-        <turtle.Turtle object at 0x0187D810>
-        >>> turtles()
-        [<turtle.Turtle object at 0x0187D810>]
         """
         return self
 
@@ -3708,13 +3730,6 @@ class RawTurtle(TPen, TNavigator):
         add --  True or False. If True, new binding will be added, otherwise
                 it will replace a former binding.
 
-        Example for the anonymous turtle, i. e. the procedural way:
-
-        >>> def turn(x, y):
-        ...     left(360)
-        ...
-        >>> onclick(turn)  # Now clicking into the turtle will turn it.
-        >>> onclick(None)  # event-binding will be removed
         """
         self.screen._onclick(self.turtle._item, fun, btn, add)
         self._update()
@@ -3727,17 +3742,6 @@ class RawTurtle(TPen, TNavigator):
                 the coordinates of the clicked point on the canvas.
         btn --  number of the mouse-button defaults to 1 (left mouse button).
 
-        Example (for a MyTurtle instance named joe):
-        >>> class MyTurtle(Turtle):
-        ...     def glow(self,x,y):
-        ...             self.fillcolour("red")
-        ...     def unglow(self,x,y):
-        ...             self.fillcolour("")
-        ...
-        >>> joe = MyTurtle()
-        >>> joe.onclick(joe.glow)
-        >>> joe.onrelease(joe.unglow)
-
         Clicking on joe turns fillcolour red, unclicking turns it to
         transparent.
         """
@@ -3755,9 +3759,6 @@ class RawTurtle(TPen, TNavigator):
         Every sequence of mouse-move-events on a turtle is preceded by a
         mouse-click event on that turtle.
 
-        Example (for a Turtle instance named turtle):
-        >>> turtle.ondrag(turtle.goto)
-
         Subsequently clicking and dragging a Turtle will move it
         across the screen thereby producing handdrawings (if pen is
         down).
@@ -3806,13 +3807,6 @@ class RawTurtle(TPen, TNavigator):
         Number of available undo actions is determined by the size of
         the undobuffer.
 
-        Example (for a Turtle instance named turtle):
-        >>> for i in range(4):
-        ...     turtle.fd(50); turtle.lt(80)
-        ...
-        >>> for i in range(8):
-        ...     turtle.undo()
-        ...
         """
         if self.undobuffer is None:
             return
@@ -3884,14 +3878,6 @@ class _Screen(TurtleScreen):
           edge of the screen, if negative from the bottom edge
           Default, starty=None is to center window vertically.
 
-        Examples (for a Screen instance named screen):
-        >>> screen.setup (width=200, height=200, startx=0, starty=0)
-
-        sets window to 200x200 pixels, in upper left of screen
-
-        >>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
-
-        sets window to 75% of screen by 50% of screen and centers
         """
         if not hasattr(self._root, "set_geometry"):
             return
@@ -3918,8 +3904,6 @@ class _Screen(TurtleScreen):
         This is a method of Screen-class. Not available for TurtleScreen-
         objects.
 
-        Example (for a Screen instance named screen):
-        >>> screen.title("Welcome to the turtle-zoo!")
         """
         if _Screen._root is not None:
             _Screen._root.title(titlestring)
@@ -3936,11 +3920,7 @@ class _Screen(TurtleScreen):
         root.destroy()
 
     def bye(self):
-        """Shut the turtlegraphics window.
-
-        Example (for a TurtleScreen instance named screen):
-        >>> screen.bye()
-        """
+       #Shut the turtlegraphics window.
         self._destroy()
 
     def exitonclick(self):
@@ -3957,10 +3937,6 @@ class _Screen(TurtleScreen):
 
         This is a method of the Screen-class and not available for
         TurtleScreen instances.
-
-        Example (for a Screen instance named screen):
-        >>> screen.exitonclick()
-
         """
         def exitGracefully(x, y):
             """Screen.bye() with two dummy-parameters"""

{ducky_python_module-0.1.4 → ducky_python_module-1.0.0}/src/ducky_python_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducky-python-module
-Version: 0.1.4
+Version: 1.0.0
 Summary: Ducky Python module
 Author: Tom
 License: Creative Commons Attribution-NonCommercial 4.0 International Public
@@ -346,8 +346,15 @@ Dynamic: license-file
 
 # Ducky-Python-Module
 A collection of tools for python  
-Still in progress but it will be releasing fully soon  
+Still in progress and will be releasing fully soon  
 Credit:  
 Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.
 Nltk has been imported but not modified.
-And a few other libraries which I'll mention when this is complete
+Full import list:  
+import random, time, os, tkinter as TK, types, math, inspect, sys, requests, json, numpy, ast, logging
+from os.path import isfile, split, join
+from copy import deepcopy
+from tkinter import simpledialog
+from turtle import Turtle
+from nltk.tokenize import word_tokenize
+from nltk.stem import LancasterStemmer

ducky_python_module-0.1.4/README.md

@@ -1,7 +0,0 @@
-# Ducky-Python-Module
-A collection of tools for python  
-Still in progress but it will be releasing fully soon  
-Credit:  
-Turtle library has been used and modified. I did not make it and I did include the text from the original library explaining rights to the Turtle program which I am not allowed to remove.
-Nltk has been imported but not modified.
-And a few other libraries which I'll mention when this is complete