PyReprism 0.0.1__py3-none-any.whl

PyReprism/languages/j.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class J:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.j
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>NB\..*$)|(?P<noncomment>[^N][^\n]*)', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(J.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in J.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(J.keywords_regex()), '', source)
+    

PyReprism/languages/java.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Java:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.java
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|continue|for|new|switch|assert|default|goto|package|synchronized|boolean|do|if|private|this|break|double|implements|protected|throw|byte|else|import|public|throws|case|enum|instanceof|return|transient|catch|extends|int|short|try|char|final|interface|static|void|class|finally|long|strictfp|volatile|const|float|native|super|while'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*.*?\*/|/\*.*?$|^.*?\*/|[{}]+)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"{}]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b0b[01]+\b|\b0x[\da-f]*\.?[\da-fp-]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?[df]?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Java.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Java.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Java.keywords_regex()), '', source)
+    

PyReprism/languages/javascript.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class JavaScript:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.javascript
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*.*?\*/|/\*.*?$|^.*?\*/|[{}]+)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"{}]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(JavaScript.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in JavaScript.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(JavaScript.keywords_regex()), '', source)
+    

PyReprism/languages/jolie.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Jolie:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.jolie
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/)|(?P<noncomment>[^/\n]*[^\n]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Jolie.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Jolie.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Jolie.keywords_regex()), '', source)
+    

PyReprism/languages/json.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Json:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.json
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/)|(?P<noncomment>[^/\n]*[^\n]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Json.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Json.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Json.keywords_regex()), '', source)
+    

PyReprism/languages/jsx.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Jsx:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.jsx
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|var|void|while|with|yield'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|\{/\*[\s\S]*?\*/\}|/\*.*?$|^.*?\*/|/\*\*[\s\S]*?\*/)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Jsx.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Jsx.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Jsx.keywords_regex()), '', source)
+    

PyReprism/languages/julia.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Julia:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.julia
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|let|local|macro|module|print|println|quote|return|try|type|typealias|using|while|true|false'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|#=[\s\S]*?=#|#=.*?$|^.*?=#)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^#\'"]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+\.?\d*|\.\d+)(?:[efp][+-]?\d+)?j?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'[-+*^%÷&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥]')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Julia.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Julia.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Julia.keywords_regex()), '', source)
+    

PyReprism/languages/kotlin.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Kotlin:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.kotlin
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|else|enum|final|finally|for|fun|get|if|import|in|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|out|override|package|private|protected|public|reified|return|sealed|set|super|tailrec|this|throw|to|try|val|var|when|where|while'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*.*?\*/|/\*.*?$|^.*?\*/|[{}]+)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"{}]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b(?:0[bx][\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?[fFL]?)\b')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Kotlin.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Kotlin.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Kotlin.keywords_regex()), '', source)
+    

PyReprism/languages/latex.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Latex:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.latex
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>%.*?$)|(?P<noncomment>[^%\n]*[^\n]*)', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Latex.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Latex.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Latex.keywords_regex()), '', source)
+    

PyReprism/languages/less.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Less:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.less
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/)|(?P<noncomment>[^/*]*[^\n]*)',re.DOTALL | re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Less.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Less.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Less.keywords_regex()), '', source)
+    

PyReprism/languages/liquid.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+class Liquid:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.liquid
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>\{% comment %\}[\s\S]*?\{% endcomment %\}|{% #.*? %})|(?P<noncomment>[^{%]*)', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Liquid.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Liquid.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(Liquid.keywords_regex()), '', source)
+    

PyReprism/languages/livescript.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+class LiveScript:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.livescript
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/)|(?P<noncomment>[^#/*]*[^\n]*)', re.MULTILINE | re.DOTALL)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(LiveScript.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in LiveScript.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(LiveScript.keywords_regex()), '', source)
+    

PyReprism/languages/makefile.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class MakeFile:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.makefile
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$)|(?P<noncomment>[^#\n]*[^\n]*)', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(MakeFile.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in MakeFile.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.join(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(MakeFile.keywords_regex()), '', source)
+