Remove 3.10 code for 3.8 code

custom_nodes/WAS_Node_Suite.py

@@ -12,8 +12,8 @@
 # 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.
-
+import image as image
-
+import pilgram
 from PIL import Image, ImageFilter, ImageEnhance, ImageOps, ImageDraw, ImageChops, ImageFont
 from PIL.PngImagePlugin import PngInfo
 from io import BytesIO
@@ -698,9 +698,6 @@ class WAS_Image_Style_Filter:
             subprocess.check_call(
                 [sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
 
-        # Import Pilgram module
-        import pilgram
-
         # Convert image to PIL
         image = tensor2pil(image)
 
@@ -708,62 +705,61 @@ class WAS_Image_Style_Filter:
         WFilter = WAS_Filter_Class()
 
         # Apply blending
-        match style:
+        if style == "1977":
-            case "1977":
             out_image = pilgram._1977(image)
-            case "aden":
+        elif style == "aden":
             out_image = pilgram.aden(image)
-            case "brannan":
+        elif style == "brannan":
             out_image = pilgram.brannan(image)
-            case "brooklyn":
+        elif style == "brooklyn":
             out_image = pilgram.brooklyn(image)
-            case "clarendon":
+        elif style == "clarendon":
             out_image = pilgram.clarendon(image)
-            case "earlybird":
+        elif style == "earlybird":
             out_image = pilgram.earlybird(image)
-            case "fairy tale":
+        elif style == "fairy tale":
             out_image = WFilter.sparkle(image)
-            case "gingham":
+        elif style == "gingham":
             out_image = pilgram.gingham(image)
-            case "hudson":
+        elif style == "hudson":
             out_image = pilgram.hudson(image)
-            case "inkwell":
+        elif style == "inkwell":
             out_image = pilgram.inkwell(image)
-            case "kelvin":
+        elif style == "kelvin":
             out_image = pilgram.kelvin(image)
-            case "lark":
+        elif style == "lark":
             out_image = pilgram.lark(image)
-            case "lofi":
+        elif style == "lofi":
             out_image = pilgram.lofi(image)
-            case "maven":
+        elif style == "maven":
             out_image = pilgram.maven(image)
-            case "mayfair":
+        elif style == "mayfair":
             out_image = pilgram.mayfair(image)
-            case "moon":
+        elif style == "moon":
             out_image = pilgram.moon(image)
-            case "nashville":
+        elif style == "nashville":
             out_image = pilgram.nashville(image)
-            case "perpetua":
+        elif style == "perpetua":
             out_image = pilgram.perpetua(image)
-            case "reyes":
+        elif style == "reyes":
             out_image = pilgram.reyes(image)
-            case "rise":
+        elif style == "rise":
             out_image = pilgram.rise(image)
-            case "slumber":
+        elif style == "slumber":
             out_image = pilgram.slumber(image)
-            case "stinson":
+        elif style == "stinson":
             out_image = pilgram.stinson(image)
-            case "toaster":
+        elif style == "toaster":
             out_image = pilgram.toaster(image)
-            case "valencia":
+        elif style == "valencia":
             out_image = pilgram.valencia(image)
-            case "walden":
+        elif style == "walden":
             out_image = pilgram.walden(image)
-            case "willow":
+        elif style == "willow":
             out_image = pilgram.willow(image)
-            case "xpro2":
+        elif style == "xpro2":
             out_image = pilgram.xpro2(image)
-            case _:
+        else:
             out_image = image
 
         out_image = out_image.convert("RGB")
@@ -771,7 +767,6 @@ class WAS_Image_Style_Filter:
         return (torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0),)
 
 
-
 # COMBINE NODE
 
 class WAS_Image_Blending_Mode:
@@ -825,36 +820,35 @@ class WAS_Image_Blending_Mode:
         img_b = tensor2pil(image_b)
 
         # Apply blending
-        match mode:
+        if mode == "color":
-            case "color":
             out_image = pilgram.css.blending.color(img_a, img_b)
-            case "color_burn":
+        elif mode == "color_burn":
             out_image = pilgram.css.blending.color_burn(img_a, img_b)
-            case "color_dodge":
+        elif mode == "color_dodge":
             out_image = pilgram.css.blending.color_dodge(img_a, img_b)
-            case "darken":
+        elif mode == "darken":
             out_image = pilgram.css.blending.darken(img_a, img_b)
-            case "difference":
+        elif mode == "difference":
             out_image = pilgram.css.blending.difference(img_a, img_b)
-            case "exclusion":
+        elif mode == "exclusion":
             out_image = pilgram.css.blending.exclusion(img_a, img_b)
-            case "hard_light":
+        elif mode == "hard_light":
             out_image = pilgram.css.blending.hard_light(img_a, img_b)
-            case "hue":
+        elif mode == "hue":
             out_image = pilgram.css.blending.hue(img_a, img_b)
-            case "lighten":
+        elif mode == "lighten":
             out_image = pilgram.css.blending.lighten(img_a, img_b)
-            case "multiply":
+        elif mode == "multiply":
             out_image = pilgram.css.blending.multiply(img_a, img_b)
-            case "add":
+        elif mode == "add":
             out_image = pilgram.css.blending.normal(img_a, img_b)
-            case "overlay":
+        elif mode == "overlay":
             out_image = pilgram.css.blending.overlay(img_a, img_b)
-            case "screen":
+        elif mode == "screen":
             out_image = pilgram.css.blending.screen(img_a, img_b)
-            case "soft_light":
+        elif mode == "soft_light":
             out_image = pilgram.css.blending.soft_light(img_a, img_b)
-            case _:
+        else:
             out_image = img_a
 
         out_image = out_image.convert("RGB")
@@ -938,12 +932,11 @@ class WAS_Image_Monitor_Distortion_Filter:
         WFilter = WAS_Filter_Class()
 
         # Apply image effect
-        match mode:
+        if mode == 'Digital Distortion':
-            case 'Digital Distortion':
             image = WFilter.digital_distortion(image, amplitude, offset)
-            case 'Signal Distortion':
+        elif mode == 'Signal Distortion':
             image = WFilter.signal_distortion(image, amplitude)
-            case 'TV Distortion':
+        elif mode == 'TV Distortion':
             image = WFilter.tv_vhs_distortion(image, amplitude)
 
         return (pil2tensor(image), )
@@ -1021,10 +1014,9 @@ class WAS_Image_Analyze:
         WFilter = WAS_Filter_Class()
 
         # Analye Image
-        match mode:
+        if mode == 'Black White Levels':
-            case 'Black White Levels':
             image = WFilter.black_white_levels(image)
-            case 'RGB Levels':
+        elif mode == 'RGB Levels':
             image = WFilter.channel_frequency(image)
 
         return (pil2tensor(image), )
@@ -1995,13 +1987,14 @@ class WAS_Image_Rotate:
             rotation = int((rotation//90)*90)
 
         # Set Sampler
-        match sampler:
+        if sampler == 'nearest':
-            case 'nearest':
             sampler = Image.NEAREST
-            case 'bicubic':
+        elif sampler == 'bicubic':
             sampler = Image.BICUBIC
-            case 'bilinear':
+        elif sampler == 'bilinear':
             sampler = Image.BILINEAR
+        else:
+            sampler = Image.NEAREST  # default to nearest if none of the above
 
         # Rotate Image
         if mode == 'internal':
@@ -2244,13 +2237,12 @@ class WAS_Image_Edge:
         image = tensor2pil(image)
 
         # Detect edges
-        match mode:
+        if mode == "normal":
-            case "normal":
             image = image.filter(ImageFilter.FIND_EDGES)
-            case "laplacian":
+        elif mode == "laplacian":
-                image = image.filter(ImageFilter.Kernel((3, 3), (-1, -1, -1, -1, 8,
+            kernel = (-1, -1, -1, -1, 8, -1, -1, -1, -1)
-                                                                 -1, -1, -1, -1), 1, 0))
+            image = image.filter(ImageFilter.Kernel((3, 3), kernel, scale=1, offset=0))
-            case _:
+        else:
             image = image
 
         return (torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0), )
@@ -3645,14 +3637,13 @@ class WAS_Random_Number:
         random.seed(seed)
 
         # Return random number
-        match number_type:
+        if number_type == 'integer':
-            case 'integer':
             number = random.randint(minimum, maximum)
-            case 'float':
+        elif number_type == 'float':
             number = random.uniform(minimum, maximum)
-            case 'bool':
+        elif number_type == 'bool':
             number = random.random()
-            case _:
+        else:
             return
 
         # Return number
@@ -3682,13 +3673,14 @@ class WAS_Constant_Number:
     def return_constant_number(self, number_type, number):
 
         # Return number
-        match number_type:
+        if number_type == 'integer':
-            case 'integer':
             return (int(number), )
-            case 'integer':
+        elif number_type == 'float':
             return (float(number), )
-            case 'bool':
+        elif number_type == 'bool':
             return ((1 if int(number) > 0 else 0), )
+        else:
+            return
 
 
 # NUMBER TO SEED
@@ -3898,33 +3890,31 @@ class WAS_Number_Operation:
 
     def math_operations(self, number_a, number_b, operation="addition"):
 
-        # Return random number
+        if operation == 'addition':
-        match operation:
-            case 'addition':
             return ((number_a + number_b),)
-            case 'subtraction':
+        elif operation == 'subtraction':
             return ((number_a - number_b),)
-            case 'division':
+        elif operation == 'division':
             return ((number_a / number_b),)
-            case 'floor division':
+        elif operation == 'floor division':
             return ((number_a // number_b),)
-            case 'multiplication':
+        elif operation == 'multiplication':
             return ((number_a * number_b),)
-            case 'exponentiation':
+        elif operation == 'exponentiation':
             return ((number_a ** number_b),)
-            case 'modulus':
+        elif operation == 'modulus':
             return ((number_a % number_b),)
-            case 'greater-than':
+        elif operation == 'greater-than':
             return (+(number_a > number_b),)
-            case 'greater-than or equals':
+        elif operation == 'greater-than or equals':
             return (+(number_a >= number_b),)
-            case 'less-than':
+        elif operation == 'less-than':
             return (+(number_a < number_b),)
-            case 'less-than or equals':
+        elif operation == 'less-than or equals':
             return (+(number_a <= number_b),)
-            case 'equals':
+        elif operation == 'equals':
             return (+(number_a == number_b),)
-            case 'does not equal':
+        elif operation == 'does not equal':
             return (+(number_a != number_b),)