Restored from older branch

Author: poing

gems/README.md

@@ -0,0 +1,29 @@
+# Gems Directory
+
+Welcome to the "gems" directory! 🚀 Here, you'll find a collection of code snippets that serve as proof-of-concept (PoC) implementations. These snippets, while not directly used in the project, have been valuable in the development process. They've provided insights, solutions, or innovative approaches that have contributed to the overall success of the project.
+
+## Purpose
+
+- **Idea Exploration:** The snippets in this directory were created during the exploration phase, where various ideas and concepts were tested before implementation in the main project codebase.
+
+- **Problem Solving:** These code snippets may contain solutions to specific challenges or problems encountered during development. While they might not be part of the final code, they showcase different approaches to problem-solving.
+
+- **Learning and Experimentation:** The "gems" directory is also a space for experimentation and learning. Developers can refer to these PoCs to understand different techniques and methodologies.
+
+## Organization
+
+The directory is organized with each code snippet placed in a separate file or subdirectory, named descriptively to indicate its purpose or the problem it addresses. Additionally, a brief explanation is provided within each file to give context and insights into the PoC.
+
+## How to Use
+
+While the code in this directory is not directly integrated into the main project, you may find value in reviewing these snippets for reference or inspiration. If a particular PoC aligns with a current or future project requirement, feel free to adapt and incorporate the code into your work.
+
+## Contributing
+
+If you have additional PoCs or innovative code snippets that you believe could benefit the project, consider contributing them to this directory. Follow the contribution guidelines outlined in the project's main README.
+
+## License
+
+All code snippets in this directory are provided under the [project's license](https://github.com/poing/JS2PySecrets/blob/main/LICENSE). Please review the license before using or distributing any code from this directory.
+
+Happy coding! 🎉

gems/dict2json.py

@@ -0,0 +1,36 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# dict2json.py
+
+"""
+This is a basic example of taking a Python dict and returning JSON.  
+
+The goal is passing function names and argument groups in a nested JSON.
+
+It's a work in progress where the assumption is, there will be a set of setup commands (that are likely static), followed by a dynamic command with var based arguments.
+"""
+
+import json
+
+# key: value (the function & arguments)
+setup = [
+    {"function": "setRNG", "args": ["testRandom"]},
+    {"function": "init", "args": [12, 'testRandom']}
+]
+
+# Dynamic Values
+foo = ["1234abc", 6, 3]
+
+# key: value (the function & dynamic arguments)
+main = {"function": "share", "args": foo}
+
+# Combine setup and main
+tasks = [{"setup": setup, "start": main}]
+
+# Convert the Python dictionary to JSON
+json_data = json.dumps(tasks, indent=None)
+
+# Print or use the JSON data as needed
+print(json_data)

gems/example1.py

@@ -0,0 +1,38 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# example1.py
+
+import json
+import js2pysecrets
+
+# // generate a 512-bit key
+# key = js2pysecrets.random(512) // => key is a hex string
+key = js2pysecrets.random(512)
+print(key)
+
+# // split into 10 shares with a threshold of 5
+# shares = js2pysecrets.share(key, 10, 5)
+# // => shares = ['801xxx...xxx','802xxx...xxx','803xxx...xxx','804xxx...xxx','805xxx...xxx']
+shares = js2pysecrets.share(key, 10, 5)
+print(shares)
+
+# // combine 4 shares
+# var comb = secrets.combine(shares.slice(0, 4))
+# console.log(comb === key) // => false
+#
+# // combine 5 shares
+# comb = secrets.combine(shares.slice(4, 9))
+# console.log(comb === key) // => true
+# 
+# // combine ALL shares
+# comb = secrets.combine(shares)
+# console.log(comb === key) // => true
+# 
+# // create another share with id 8
+# var newShare = secrets.newShare(8, shares) // => newShare = '808xxx...xxx'
+# 
+# // reconstruct using 4 original shares and the new share:
+# comb = secrets.combine(shares.slice(1, 5).concat(newShare))
+# console.log(comb === key) // => true

gems/example2.py

@@ -0,0 +1,36 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# example1.py
+
+import json
+import js2pysecrets
+
+# var pw = "<<PassWord123>>"
+pw = "<<PassWord123>>"
+ 
+# // convert the text into a hex string
+# var pwHex = secrets.str2hex(pw) // => hex string
+jsHex = js2pysecrets.str2hex(pw)
+print(jsHex)
+
+pyHex = pw.encode('utf-16-be').hex().lstrip('fe')
+print(pyHex)
+
+# // split into 5 shares, with a threshold of 3
+# var shares = secrets.share(pwHex, 5, 3)
+# 
+# // combine 2 shares:
+# var comb = secrets.combine(shares.slice(1, 3))
+# 
+# //convert back to UTF string:
+# comb = secrets.hex2str(comb)
+# console.log(comb === pw) // => false
+# 
+# // combine 3 shares:
+# comb = secrets.combine([shares[1], shares[3], shares[4]])
+# 
+# //convert back to UTF string:
+# comb = secrets.hex2str(comb)
+# console.log(comb === pw) // => true

gems/func2str.py

@@ -0,0 +1,55 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# func2str.py
+
+from functools import wraps
+import json
+
+
+def function_to_string(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        args_str = ', '.join(repr(arg) for arg in args)
+        kwargs_str = ', '.join(f'{key}={repr(value)}' for key, value in kwargs.items())
+        all_args = ', '.join(filter(None, [args_str, kwargs_str]))
+
+        return f"{func.__name__}({all_args});"
+    
+    return wrapper
+
+# Applying the decorator to functions
+@function_to_string
+def funcA(*args, **kwargs):
+    pass
+
+@function_to_string
+def funcB(*args, **kwargs):
+    pass 
+    
+funcC = function_to_string('blue')
+
+# Testing
+print(funcA("aa", "bb", 123, x=123))  # "funcA('aa', 'bb', 123, x=123)"
+print(funcA('aa', 'bb', 123, x=123))   # "funcA('aa', 'bb', 123, x=123)"
+print(funcA('aa', 'bb', 123, x=123))   # "funcA('aa', 'bb', 123, x=123)"
+
+# Support and pass dict
+print(funcB(["aa", "bb"], 123, x=123)) # 'funcB(["aa", "bb"], 123, x=123)'
+
+foobar = "AAFF"
+
+tasks = [
+	funcA(foobar, 2, "that"),
+	funcA(["some", "more", 2]),
+	funcB("and something", "else", 2, plus=22),
+	blue('hey'),
+]
+
+# Convert the Python dictionary to JSON
+json_data = json.dumps(tasks, indent=None)
+
+# Print or use the JSON data as needed
+print(json_data)
+

gems/func2str2.py

@@ -0,0 +1,60 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# func2str2.py
+
+"""
+This script demonstrates making the JsFunction class work both as a callable and as a decorator. 
+"""
+
+class JsFunction:
+    def __init__(self, func):
+        self.func = func
+
+    def __call__(self, *args, **kwargs):
+        def wrapped_func(*args, **kwargs):
+            args_str = ', '.join(repr(arg) for arg in args)
+            kwargs_str = ', '.join(f'{key}={repr(value)}' 
+            	for key, value in kwargs.items())
+            all_args = ', '.join(filter(None, [args_str, kwargs_str]))
+
+            return f"{self.func.__name__}({all_args})"
+
+        return wrapped_func(*args, **kwargs) if args else self.func(*args, **kwargs)
+
+    def __get__(self, instance, owner):
+        return self if instance is None else types.MethodType(self, instance)
+
+# Applied as a decorator
+# Functional placeholder that uses the JS code, until the Python function is created
+@JsFunction
+def alpha(*args, **kwargs):
+    pass
+
+# Eventually independent python function will be created
+def bravo():
+    return "bravo('aa', 'bb', 123, x=123)"
+
+# Create a alternately named instance of the JsFunction class that's callable
+# Which is important for testing against python functions
+testBravo = JsFunction(bravo)
+
+"""
+WARNING - WARNING - WARNING - WARNING - WARNING - WARNING
+You cannot create an alternate instance using JsFunction it is already used.  Attempting to do so may lead to unexpected behavior.  For example, you cannot use testAlpha = JsFunction(alpha) if alpha() already has the JsFunction decorator applied.
+WARNING - WARNING - WARNING - WARNING - WARNING - WARNING
+"""
+
+print(alpha("aa", "bb", 123, x=123))  # Returns: alpha('aa', 'bb', 123, x=123)
+print(bravo()) # Returns: bravo('aa', 'bb', 123, x=123)
+print(testBravo("aa", "bb", 123, x=123))  # Returns: bravo('aa', 'bb', 123, x=123)
+
+def string_comparison(str1, str2):
+    if str1 == str2:
+        return "Test Passed: Strings are equal"
+    else:
+        return "Test Failed: Strings are not equal"
+
+print(string_comparison(alpha(123,'aaa'), testBravo(123,'aaa')))
+print(string_comparison(bravo(), testBravo('aa', 'bb', 123, x=123)))

gems/func2str3.py

@@ -0,0 +1,68 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# func2str3.py
+
+"""
+This script demonstrates making the JsFunction class work both as a callable and as a decorator. Excluding **kwargs in the output. Added test flag.
+"""
+
+class JsFunction:
+    def __init__(self, func, test=False):
+        self.func = func
+        self.test = test
+
+    def __call__(self, *args, test=False, **kwargs):
+        def wrapped_func(*args, **kwargs):
+            args_str = ', '.join(repr(arg) for arg in args)
+            #kwargs_str = ', '.join(f'{key}={repr(value)}' 
+            #	for key, value in kwargs.items())
+            #all_args = ', '.join(filter(None, [args_str, kwargs_str]))
+
+            return f"{self.func.__name__}({args_str})"
+            
+        data = ["init()"]
+        if test or self.test:
+        	data.append("setRNG('testRandom')")
+
+        data.append(wrapped_func(*args, **kwargs) if args else self.func(*args, **kwargs))
+        return data
+
+    def __get__(self, instance, owner):
+        return self if instance is None else types.MethodType(self, instance)
+
+# Applied as a decorator
+# Functional placeholder that uses the JS code, until the Python function is created
+@JsFunction
+def alpha(*args, **kwargs):
+    pass
+
+# Eventually independent python function will be created
+def bravo():
+    return "bravo('aa', 'bb', 123)"
+
+# Create a alternately named instance of the JsFunction class that's callable
+# Which is important for testing against python functions
+testBravo = JsFunction(bravo, test=True)
+regBravo = JsFunction(bravo)
+
+"""
+WARNING - WARNING - WARNING - WARNING - WARNING - WARNING
+You cannot create an alternate instance using the JsFunction if it is already used.  Attempting to do so may lead to unexpected behavior.  For example, you cannot use testAlpha = JsFunction(alpha) if alpha() already has the JsFunction decorator applied.
+WARNING - WARNING - WARNING - WARNING - WARNING - WARNING
+"""
+
+print(alpha("aa", "bb", 123, x=123))  # Returns: alpha('aa', 'bb', 123, x=123)
+print(bravo()) # Returns: bravo('aa', 'bb', 123, x=123)
+print(testBravo("aa", "bb", 123, x=123))  # Returns: bravo('aa', 'bb', 123, x=123)
+print(regBravo("aa", "bb", 123, x=123))  # Returns: bravo('aa', 'bb', 123, x=123)
+
+def string_comparison(str1, str2):
+    if str1 == str2:
+        return "Test Passed: Strings are equal"
+    else:
+        return "Test Failed: Strings are not equal"
+
+print(string_comparison(alpha(123,'aaa'), testBravo(123,'aaa')))
+print(string_comparison(bravo(), testBravo('aa', 'bb', 123, x=123)))

gems/proc_commV1.py

@@ -0,0 +1,43 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# proc_commV1.py
+
+# Trying to use process.communicate() with Node
+
+import subprocess
+
+#JS_FILE_PATH = "wrapperV7.js"
+#js_command = ["node", "-i", JS_FILE_PATH]
+
+# Start the Node.js process
+node_process = subprocess.Popen(["node", "-i"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+# Send JavaScript commands
+commands = [
+	"const secrets = require('../secrets.js/secrets.js')",
+    "console.log('Hello from Node.js!')",
+    "console.log(2 + 2)",
+    "console.log(Math.random())",
+    "var HHGTTG = 42",
+    "console.log(HHGTTG)",
+    "secrets.share('1234abc', 6, 3)"
+]
+
+
+# Send commands to the Node.js process
+for command in commands:
+    node_process.stdin.write(command + '\n')
+
+# Read output
+output, error = node_process.communicate()
+
+# Close stdin to indicate end of input
+node_process.stdin.close()
+
+print("Output:")
+print(output)
+
+print("Error:")
+print(error)