Projects:
{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Networkx\nNetworkx is a library for exploring graph network and plot it. Unfortunately, networkx have its own limitation for plotting. First, it cannot draw a round directed graph, for example a graph that goes from A to B and from B to A, well. Second, it does not support self loop graph, for example a graph that goes from A to A. While it seems trivial, there are few graph exploration that require such feature such as Markov Chain graph. Lastly, the edge labelling feature in plotting does not morph to its actual edges so it stands by its own.\n\nBut for now we will explore key feature of networkx so we can at least grasp what networkx is capable of."},{"metadata":{"trusted":true},"cell_type":"code","source":"import networkx as nx\nimport matplotlib.pyplot as plt","execution_count":9,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"For example, we want to create a network between A, B, C, and D.\n\nFirst we want to specify our edges which consists of A and B, B and C, B and D. This is not a directed graph.\nWe start by initiating a networkx graph."},{"metadata":{"trusted":true},"cell_type":"code","source":"G = nx.Graph()","execution_count":2,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"`G` is our graph now. We can add edges to it."},{"metadata":{"trusted":true},"cell_type":"code","source":"edges = [\n ['A','B'],\n ['B','C'],\n ['B','D']\n]\nG.add_edges_from(edges)","execution_count":3,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We add A and B, B and C, and B to D to our graph. Registering edges also registering the nodes. We can see nodes and edges contained in a graph with method `.edges()` for edges and `.nodes()` for nodes."},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"Edges in Network G\", G.edges())\nprint(\"Nodes in Network G\", G.nodes())","execution_count":6,"outputs":[{"output_type":"stream","text":"Edges in Network G [('A', 'B'), ('B', 'C'), ('B', 'D')]\nNodes in Network G ['A', 'B', 'C', 'D']\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"Before plotting our graph, we want to position all our nodes so that the graph is readable. We can do that by assining position. Luckily, networkx has a function to define nodes postion, we use `.spring_layout()` for now with our graph `G` as the input\n."},{"metadata":{"trusted":true},"cell_type":"code","source":"pos = nx.spring_layout(G)","execution_count":7,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We can configure several things to enhance readibility of our graph. First we prepare our subplots to contain our graph."},{"metadata":{"trusted":true},"cell_type":"code","source":"fig, ax = plt.subplots(nrows=1, ncols=2)\nfig.set_figwidth(14)\nfig.set_figheight(8)\nfor a in ax:\n a.axis('off')","execution_count":62,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1008x576 with 2 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"We giving options to our networkx draw. We assign the drawing to axes `ax[0]`"},{"metadata":{"trusted":true},"cell_type":"code","source":"drawOptions = {\n \"edge_color\": 'black',\n \"width\": 1,\n \"linewidths\": 1,\n \"node_size\": 500,\n \"node_color\": 'pink',\n \"alpha\": 0.9,\n \"labels\": { \n node: node for node in G.nodes()\n },\n \"ax\": ax[0]\n}\nnx.draw(G, pos, **drawOptions)\nfig","execution_count":63,"outputs":[{"output_type":"execute_result","execution_count":63,"data":{"text/plain":"<Figure size 1008x576 with 2 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Now we want to give label for each edges, we can do that by using method `,draw_networkx_edge_labels()`"},{"metadata":{"trusted":true},"cell_type":"code","source":"drawEdgeLabelsOptions = {\n \"edge_labels\": {\n ('A', 'B'): 'Queue:\\nasdasd',\n ('B', 'C'): 'BC',\n ('B', 'D'): 'BD'\n },\n \"font_color\": 'red',\n \"ax\": ax[1],\n \"rotate\": False\n}\ndrawOptions[\"ax\"] = ax[1]\nnx.draw(G, pos, **drawOptions)\nnx.draw_networkx_edge_labels(G, pos, **drawEdgeLabelsOptions)\nfig","execution_count":56,"outputs":[{"output_type":"execute_result","execution_count":56,"data":{"text/plain":"<Figure size 1008x576 with 2 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"As you can see, we print two network, first without label and second with label. In order to place it in subplots, we need to specify axes in both `.draw()` and `.draw_networkx_edge_labels()`\n\nThe closest thing we have in directed mapping with capability mapping from A to B and B to A is by changing connectionstyle. First we set the axes from matplotlib"},{"metadata":{"trusted":true},"cell_type":"code","source":"fig, ax = plt.subplots(nrows=1, ncols=1)\nfig.set_figwidth(14)\nfig.set_figheight(14)\nax.axis('off')","execution_count":74,"outputs":[{"output_type":"execute_result","execution_count":74,"data":{"text/plain":"(0.0, 1.0, 0.0, 1.0)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1008x1008 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{},"cell_type":"markdown","source":"We want to initialize our graph using `.MultiDiGraph()` because we need to accomodate a round trip. Our roud trip is from A to B and B to A. "},{"metadata":{"trusted":true},"cell_type":"code","source":"G_di = nx.MultiDiGraph()\nG_di.add_edges_from([\n ('A', 'B'), \n ('C', 'B'), \n ('B', 'A'), \n ('A', 'C'), \n ('D', 'A'), \n ('B', 'D'), \n ('C', 'D')\n])\npos = nx.spring_layout(G_di)","execution_count":75,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Then we specify our plotting options. The key options is `connectionstyle` which we set to using bar. The references for connection style can be found [here](https://matplotlib.org/3.3.4/gallery/userdemo/connectionstyle_demo.html). The rest of keys is quite self explanatory."},{"metadata":{"trusted":true},"cell_type":"code","source":"drawEdgesOptions = {\n \"edge_color\": 'black',\n \"arrows\": True,\n \"width\": .5,\n 'connectionstyle': 'bar,fraction=.01',\n \"arrowsize\": 20,\n \"ax\": ax\n}\nnx.draw_networkx_edges(G_di, pos, **drawEdgesOptions)\ndrawNodesOptions = {\n \"node_color\": 'white',\n \"node_size\": 4000,\n \"alpha\": .2,\n \"ax\": ax\n}\nnx.draw_networkx_nodes(G_di, pos, **drawNodesOptions)\ndrawLabelOptions = {\n \"font_size\": 22,\n \"font_color\": 'black',\n \"ax\": ax\n}\nnx.draw_networkx_labels(G_di, pos, **drawLabelOptions)\nax.axis(\"off\")","execution_count":72,"outputs":[{"output_type":"execute_result","execution_count":72,"data":{"text/plain":"(-1.0553445855674848,\n 0.7812020703984528,\n -1.2056482785810005,\n 1.164203312685767)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 1008x1008 with 1 Axes>","image/png":"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\n"},"metadata":{}}]}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.9","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":4}
package main
import (
"crypto/aes"
"crypto/cipher"
{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.9","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Introduction\n\nDecorator is a function that takes another function and modify it without actually changing it. It is useful design pattern to comply with Open/Close principle in SOLID.\n\nThere are three general function that comes to mind.\n- Timing and Logging\n- Caching Function\n- Permission\n\nThese three usually does not belong to the business application layer but sometimes needed to ensure system operation. Separating between permission and business logic usually is a good idea since permission sometimes can be replicable e.g. permission as a director should be able to access archive and modify it. We can write the permission logic inside the modify archive but it is not best practice since it violates the Single Responsibility principle. Therefore we want to implement the permission as a decorator for archive modifying logic.\n\nCaching function on the otherhand improve performance espeically when fetching to external source of information such as database and other endpoint such as google map is discouraged because it takes a long time or has charge per request policy. So we want to cache the result. We can store all result in dictionary where the key is the input (usually modidified in such a way that has a reliable hashes) and the value is the result. When there is a same input comes to a function, instead of calling the function, cache checks the cache first. If there is exist the input, then return the value. If there is none then call the function and store the result.\n\nTiming and logging is essential especially when debugging. We want to know what gone wrong with the function. Usually we start from the input, isolate the function and find out what is wrong with the function. If the input is the one which is wrong, then we can traverse the code and find out where it gone wrong. It saves a lot developer time since it helps pinpoint which function gone wrong. Unfortunately, logging every function is cumbersome especially when there is a ton of function that operates all time so generates log all day. We can use decorator to create logging with input that can be toggled so we only activate it when there is a problem instead combing our log.\n\nIn this example we want to create logging in a function each time it called","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true}},{"cell_type":"code","source":"def multByTwo(p: int) -> int:\n return p * 2\nmultByTwo(2)","metadata":{"trusted":true},"execution_count":1,"outputs":[{"execution_count":1,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"If we want to log it, we can do it by modifying the function.","metadata":{}},{"cell_type":"code","source":"def multByTwo(p: int) -> int:\n print('input', p)\n return p*2\nmultByTwo(2)","metadata":{"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"input 2\n","output_type":"stream"},{"execution_count":2,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"In Open/Close principle, a function should be open for extension but not modification. So we are not allowed to put print there.\n\nIn order to create a log withoud modifying the function, we can use decorator","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(p):\n print('input', p)\n return function(p)\n return newFunction\n\ndef multByTwo(p: int) -> int:\n return p * 2\nmultByTwo(2)\n\nmultByTwoDecorated = logDecorator(multByTwo)\n\nmultByTwoDecorated(2)","metadata":{"trusted":true},"execution_count":3,"outputs":[{"name":"stdout","text":"input 2\n","output_type":"stream"},{"execution_count":3,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"If we call the `multByTwo` it still come without print","metadata":{}},{"cell_type":"code","source":"multByTwo(2)","metadata":{"trusted":true},"execution_count":4,"outputs":[{"execution_count":4,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"# Basic Decorator\nDecorator can be added in start or end of a function but not modifying the function itself. Below is the example decorator used as an ouput","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(p):\n print('input', p)\n result = function(p)\n print('output', result)\n return result\n return newFunction\n\ndef multByTwo(p: int) -> int:\n return p * 2\n\nmultByTwo(2)\n\nmultByTwoDecorated = logDecorator(multByTwo)\n\nmultByTwoDecorated(2)","metadata":{"trusted":true},"execution_count":5,"outputs":[{"name":"stdout","text":"input 2\noutput 4\n","output_type":"stream"},{"execution_count":5,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"If you want to modify the function without actually writing more code inside the function, we can use `@` notation","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(p):\n print('input', p)\n result = function(p)\n print('output', result)\n return result\n return newFunction\n\n@logDecorator\ndef multByTwo(p: int) -> int:\n return p * 2\n\nmultByTwo(2)","metadata":{"trusted":true},"execution_count":6,"outputs":[{"name":"stdout","text":"input 2\noutput 4\n","output_type":"stream"},{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"The `@` is the same as","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(p):\n print('input', p)\n result = function(p)\n print('output', result)\n return result\n return newFunction\n\ndef multByTwo(p: int) -> int:\n return p * 2\n\nmultByTwo = logDecorator(multByTwo)\n\nmultByTwo(2)","metadata":{"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"input 2\noutput 4\n","output_type":"stream"},{"execution_count":7,"output_type":"execute_result","data":{"text/plain":"4"},"metadata":{}}]},{"cell_type":"markdown","source":"We can also use decorator inside a class","metadata":{}},{"cell_type":"markdown","source":"# Decorator as a class method","metadata":{}},{"cell_type":"code","source":"class someClass:\n def __init__(self, randomInput):\n self.randomInput = randomInput\n \n def logDecorator(function):\n def newFunction(self, p):\n print('input', p)\n result = function(self, p)\n print('output', result)\n return result\n return newFunction\n \n @logDecorator\n def multByTwo(self, randomNumber):\n return self.randomInput * randomNumber\n \n\nsc = someClass(4)\nsc.multByTwo(4)","metadata":{"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"input 4\noutput 16\n","output_type":"stream"},{"execution_count":8,"output_type":"execute_result","data":{"text/plain":"16"},"metadata":{}}]},{"cell_type":"markdown","source":"We can activate the logging by passing verbose from `self`. This is important when we want to read the log in a certain times such as debugging","metadata":{}},{"cell_type":"code","source":"class someClass:\n def __init__(self, randomInput, isVerbose=False):\n self.randomInput = randomInput\n self.isVerbose = isVerbose\n \n def logDecorator(function):\n def newFunction(self, p):\n if self.isVerbose:\n print('input', p)\n result = function(self, p)\n if self.isVerbose:\n print('output', result)\n return result\n return newFunction\n \n @logDecorator\n def mult(self, randomNumber):\n return self.randomInput * randomNumber\n \n\nsc = someClass(4)\nprint(\"Without Verbose\", sc.mult(4))\n\nprint('=====')\n\nsc = someClass(4, True)\nprint(\"With Verbose\", sc.mult(4))","metadata":{"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"Without Verbose 16\n=====\ninput 4\noutput 16\nWith Verbose 16\n","output_type":"stream"}]},{"cell_type":"markdown","source":"Lastly, we can add decorator in atop of another decorator. Let's say we want to create a counting feature where it tracks how many time a function is called.","metadata":{}},{"cell_type":"code","source":"class someClass:\n def __init__(self, randomInput, isVerbose=False):\n self.randomInput = randomInput\n self.isVerbose = isVerbose\n self.counter = {}\n \n def logDecorator(function):\n def newFunction(self, p):\n if self.isVerbose:\n print('input', p)\n result = function(self, p)\n if self.isVerbose:\n print('output', result)\n return result\n return newFunction\n \n def counter(function):\n def newFunction(self, p):\n try:\n self.counter[function.__name__] += 1\n except KeyError:\n self.counter[function.__name__] = 1\n return function(self, p)\n return newFunction\n \n @logDecorator\n @counter\n def mult(self, randomNumber):\n return self.randomInput * randomNumber\n \n @counter\n def div(self, randomNumber):\n return self.randomInput / randomNumber\n \nsc = someClass(4)\nprint(\"Without Verbose\", sc.mult(4))\n\nprint('=====')\n\nsc = someClass(4, True)\nprint(\"With Verbose\", sc.mult(4))\nsc.mult(2)\nsc.mult(6)\n\nsc.div(2)\nsc.div(1.5)\nprint(sc.counter)","metadata":{"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"Without Verbose 16\n=====\ninput 4\noutput 16\nWith Verbose 16\ninput 2\noutput 8\ninput 6\noutput 24\n{'mult': 3, 'div': 2}\n","output_type":"stream"}]},{"cell_type":"markdown","source":"# General Decorator\n\nIn above class, we add @counter so method `.mult` and `.div` counted every time called. The counting is stored in properties `.counter`. We do the counting and printing withoud interfering with the method itself.\n\nThe first advantage is no modofication of methods. The second one we can resuse the decorator to another function so it comply with dont repeat yourself paradigm. The last one is it makes all function has a single responsibility either logging, counting or doing math operation.\n\nDecorator also can be implemented in function with arbitrary output using `*args`","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(*args):\n print('input', *args)\n result = function(*args)\n print('output', result)\n return result\n return newFunction\n\n@logDecorator\ndef asdf(i1, i2):\n return i1 + i2\n\n@logDecorator\ndef asdf2(i3, i4, i5):\n return i3 / i4 * i5\n\nasdf(1,6)\n\nprint('=====')\n\nasdf2(3,6,7)\n","metadata":{"trusted":true},"execution_count":11,"outputs":[{"name":"stdout","text":"input 1 6\noutput 7\n=====\ninput 3 6 7\noutput 3.5\n","output_type":"stream"},{"execution_count":11,"output_type":"execute_result","data":{"text/plain":"3.5"},"metadata":{}}]},{"cell_type":"markdown","source":"To make decorator works more genrally, we can declare the input as `(*args, **kwargs)`. Logging decorator does not modify the input or the output of the function so it makes more sense if it handle `(*args, **kwargs)`. The `**kwargs` part works for additional input such as `(extraNum=1, addParam=\"asd\")` ","metadata":{}},{"cell_type":"code","source":"def logDecorator(function):\n def newFunction(*args, **kwargs):\n print('input', *args, kwargs)\n result = function(*args, **kwargs)\n print('output', result)\n return result\n return newFunction\n\n@logDecorator\ndef asdf2(i3, i4, i5, skip=False):\n if skip:\n i3 += 10\n return i3 + i4 + i5\nasdf2(30,6,7, skip=True)","metadata":{"trusted":true},"execution_count":22,"outputs":[{"name":"stdout","text":"input 30 6 7 {'skip': True}\n30 True\n40\noutput 53\n","output_type":"stream"},{"execution_count":22,"output_type":"execute_result","data":{"text/plain":"53"},"metadata":{}}]},{"cell_type":"markdown","source":"kwargs means all addiional information is stored under a dictionart with name of `kwargs` in to spread it, use the double star `**` again as in the example.\n\n# Decorator with input\nsometimes we want to control our decorator by plugging a certain input. For example, wa want a logging message that tells us whether an execution is done. So we need a custom logging message and position of logging which is after the input","metadata":{}},{"cell_type":"code","source":"def decoratorInput(logMessage, position):\n def logWithInput(f):\n def newFunction(*args, **kwargs):\n if position == 's':\n print(logMessage)\n result = f(*args, **kwargs)\n if position == 'e':\n print(logMessage)\n return result\n return newFunction\n return logWithInput\n\n@decoratorInput(\"START_LOG\", 's')\n@decoratorInput(\"END_LOG\", 'e')\ndef asdf2(i3, i4, i5, skip=False):\n if skip:\n i3 += 10\n return i3 + i4 + i5\nasdf2(30,6,7, skip=True)","metadata":{"trusted":true},"execution_count":28,"outputs":[{"name":"stdout","text":"START_LOG\nEND_LOG\n","output_type":"stream"},{"execution_count":28,"output_type":"execute_result","data":{"text/plain":"53"},"metadata":{}}]},{"cell_type":"markdown","source":"We add start and end log for function asdf. There are two logging with different placement, first one is in the start and the other one is in the end. We can also generaliza our decorator with `*args` and `**kwargs`. For example","metadata":{}},{"cell_type":"code","source":"def decoratorInput(*deco_args, **deco_kwargs):\n def logWithInput(f):\n def newFunction(*args, **kwargs):\n logMessage = deco_args[0]\n position = deco_args[1]\n print(deco_kwargs)\n if position == 's':\n print(logMessage)\n result = f(*args, **kwargs)\n if position == 'e':\n print(logMessage)\n return result\n return newFunction\n return logWithInput\n\n@decoratorInput(\"START_LOG\", 's', asdf=\"heheh\")\n@decoratorInput(\"END_LOG\", 'e', keywaord=\"lasjdlaks\")\ndef asdf2(i3, i4, i5, skip=False):\n if skip:\n i3 += 10\n return i3 + i4 + i5\nasdf2(30,6,7, skip=True)","metadata":{"trusted":true},"execution_count":47,"outputs":[{"name":"stdout","text":"{'asdf': 'heheh'}\nSTART_LOG\n{'keywaord': 'lasjdlaks'}\nEND_LOG\n","output_type":"stream"},{"execution_count":47,"output_type":"execute_result","data":{"text/plain":"53"},"metadata":{}}]},{"cell_type":"markdown","source":"# Decorator as a another class\n\nsome times the decorator is quite complex and need a whole class to set up. Here we can build a class that decorate a function","metadata":{}},{"cell_type":"code","source":"class Counter:\n def __init__(self, func):\n self.count = 0\n self.func = func\n\n def __call__(self, *args, **kwargs):\n self.count += 1\n return self.func(*args, **kwargs)\n\n def printCount(self):\n print(f\"Current count is {self.count}\")\n\n@Counter\ndef mult(a, b):\n return a * b","metadata":{"trusted":true},"execution_count":88,"outputs":[]},{"cell_type":"code","source":"for i in range(10):\n mult(i, i+1)\nmult.printCount()","metadata":{"trusted":true},"execution_count":89,"outputs":[{"name":"stdout","text":"Current count is 10\n","output_type":"stream"}]},{"cell_type":"markdown","source":"Put it simply, we melt the class to the function. In the second cell, we access the properties of `Counter` class from `mult` function. So any `Counter` method and properties could be accessed from `mult` function. We can also decorate class with it. Maybe because when we decorate a class, we actually decorate the init function. Therefore, it only counts when there is a instantiation of a class. The example is","metadata":{}},{"cell_type":"code","source":"@Counter \nclass Asdf:\n def __init__(self, a1, a2, **kwargs):\n self.a1 = a1\n self.a2 = a2\n def mult(self):\n return self.a1 * self.a2","metadata":{"trusted":true},"execution_count":90,"outputs":[]},{"cell_type":"markdown","source":"But to keep things simple, it is better to create a Class that generate decorator so it has the flexibility and encapsulation that class has to offer but keep things from accessing the class itself. For example","metadata":{}},{"cell_type":"code","source":"import time\nclass DecoratorFactory:\n def __init__(self):\n self.cache = {}\n \n self.cacheOptions = []\n pass\n \n def setCacheOptions(self, options):\n self.cacheOptions = options\n return \n \n def composeCacheHash(self, *args, **kwargs):\n cache = []\n for i in self.cacheOptions:\n if type(i) == int:\n cache.append(args[i])\n if type(i) == str:\n cache.append(kwargs[i])\n return \"\".join([str(i) for i in cache])\n \n def isExist(self, *args, **kwargs):\n cacheHash = self.composeCacheHash(*args, **kwargs)\n try:\n return self.cache[cacheHash]\n except KeyError:\n return None\n \n def extractEntity(self, kwargs):\n try:\n return kwargs['entity']\n except KeyError:\n return None\n \n def loggingDecorator(self, logMessage, position):\n def newDecorator(f):\n def newFunction(*args, **kwargs):\n if position == 's': print(logMessage)\n result = f(*args, **kwargs)\n if position == 'e': print(logMessage)\n return result\n return newFunction\n return newDecorator\n \n def cacheDecorator(self):\n def newDecorator(f):\n def newFunction(*args, **kwargs):\n if self.isExist(*args, **kwargs) is not None:\n return self.cache[self.composeCacheHash(*args, **kwargs)]\n else:\n result = f(*args, **kwargs)\n self.cache[self.composeCacheHash(*args, **kwargs)] = result\n return result\n return newFunction\n return newDecorator\n \n def permissionDecorator(self, entity):\n def newDecorator(f):\n def newFunction(*args, **kwargs):\n if (entity != self.extractEntity(kwargs)):\n raise Exception(\"FORBIDDEN\")\n else:\n return f(*args, **kwargs)\n return newFunction\n return newDecorator\n ","metadata":{"trusted":true},"execution_count":153,"outputs":[]},{"cell_type":"code","source":"df = DecoratorFactory()","metadata":{"trusted":true},"execution_count":154,"outputs":[]},{"cell_type":"markdown","source":"This is the logging example","metadata":{}},{"cell_type":"code","source":"@df.loggingDecorator(\"hehe\", 's')\ndef mult(a, b):\n return a * b\n\nprint(mult(1, 2))","metadata":{"trusted":true},"execution_count":155,"outputs":[{"name":"stdout","text":"hehe\n2\n","output_type":"stream"}]},{"cell_type":"markdown","source":"This is the cache decorator, first time we get to sleep for five second, but next time we dont run the function and straight return the answer. We can set the cache options, so the base class now which input to pick when creating a hash. We can create multiple instance of `DecoratorFactory` if we want to create different caching options.","metadata":{}},{"cell_type":"code","source":"df.setCacheOptions([0,1])\n@df.cacheDecorator()\ndef sleepMult(a, b):\n print(\"sleeping\")\n time.sleep(5)\n return a * b\n\nprint(sleepMult(2, 5))\nprint(sleepMult(2, 5))","metadata":{"trusted":true},"execution_count":156,"outputs":[{"name":"stdout","text":"sleeping\n10\n10\n","output_type":"stream"}]},{"cell_type":"markdown","source":"This is the permission decorator. Here we separate the access from the actual function. If the one who access does not have any entity keyword or does not equal to `officer` then it is raise an error.","metadata":{}},{"cell_type":"code","source":"@df.permissionDecorator('officer')\ndef accessFoo(a, b, entity='cadet'):\n return a + b\n\ntry:\n print(accessFoo(2, 3))\nexcept Exception as e: \n print(e)\n \ntry:\n print(accessFoo(2, 3, entity='sergant'))\nexcept Exception as e: \n print(e)\n \n \ntry:\n print(accessFoo(2, 3, entity='officer'))\nexcept Exception as e: \n print(e)\n ","metadata":{"trusted":true},"execution_count":157,"outputs":[{"name":"stdout","text":"FORBIDDEN\nFORBIDDEN\n5\n","output_type":"stream"}]}]}
const puppeteer = require('puppeteer');
let scrape = async (browser, link, returnLink) => {
try {