PyReprism 0.0.1__py3-none-any.whl

PyReprism/languages/markdown.py

@@ -0,0 +1,31 @@
+import re
+from PyReprism.utils import extension
+
+class MarkDown:
+    def __init__():
+        pass
+
+    @staticmethod
+    def comment():
+
+        return re.compile(r'(?P<multilinecomment><!--.*?-->)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"]*)', re.DOTALL | re.MULTILINE)
+        
+    @staticmethod
+    def remove_comments(source: str):
+        return re.sub(MarkDown.comment, '', source)
+    
+    @staticmethod
+    def file_extension():
+        return extension.markdown
+    
+    @staticmethod
+    def keywords() -> list:
+        pass
+
+    @staticmethod
+    def remove_keywords(source: str):
+        keywords = MarkDown.keywords()
+        pattern = r'\b(' + '|'.join(keywords) + r')\b'
+  
+        return re.sub(re.compile(pattern), '', source)
+

PyReprism/languages/markup.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+class MarkUp:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.markup
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<multilinecomment><!--.*?-->)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+    
+    @staticmethod
+    def number_regex():
+        pattern = ''
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = ''
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(MarkUp.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in MarkUp.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(MarkUp.keywords_regex()), '', source)

PyReprism/languages/matlab.py

@@ -0,0 +1,51 @@
+import re
+from PyReprism.utils import extension
+
+class MatLab:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.matlab
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'break|case|catch|continue|else|elseif|end|for|function|if|inf|NaN|otherwise|parfor|pause|pi|return|switch|try|while'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>%\{[\s\S]*?\}%|%.*?$)|(?P<noncomment>[^%]*)', re.MULTILINE
+        )
+        return pattern
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b\d+\.?\d*|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r"\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?")
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(MatLab.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in MatLab.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(MatLab.keywords_regex()), '', source)

PyReprism/languages/n4js.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class N4js:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.n4js
+    
+    @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(N4js.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in N4js.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(N4js.keywords_regex()), '', source)
+    

PyReprism/languages/nginx.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Nginx:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.nginx
+    
+    @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(Nginx.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Nginx.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(Nginx.keywords_regex()), '', source)
+    

PyReprism/languages/objectivec.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+class ObjectiveC:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.objectivec
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'asm|typeof|inline|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while|in|self|super)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/)|(?P<noncomment>[^/]*[^\n]*)',re.MULTILINE)
+        return pattern
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b0x[\da-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?)[ful]*', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(ObjectiveC.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in ObjectiveC.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(ObjectiveC.keywords_regex()), '', source)

PyReprism/languages/ocaml.py

@@ -0,0 +1,51 @@
+import re
+from PyReprism.utils import extension
+
+class Ocaml:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.ocaml
+    
+    @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)
+        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(Ocaml.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Ocaml.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(Ocaml.keywords_regex()), '', source)

PyReprism/languages/pascal.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+class Pascal:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.pascal
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with|dispose|exit|false|new|true|class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try|absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        return re.compile(r'(?P<comment>#.*?$)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^#\'"]*)', re.DOTALL | re.MULTILINE)
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Pascal.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Pascal.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(Pascal.keywords_regex()), '', source)

PyReprism/languages/perl.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+class Perl:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.perl
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|say|state|sub|switch|undef|unless|until|use|when|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(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:\d(?:_?\d)*)?\.?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:lt|gt|le|ge|eq|ne|cmp|not|and|or|xor)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Perl.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Perl.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(Perl.keywords_regex()), '', source)
+
+
+
+

PyReprism/languages/php.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+class PHP:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.php
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'and|or|xor|array|as|break|case|cfunction|class|const|continue|declare|default|die|do|else|elseif|enddeclare|endfor|endforeach|endif|endswitch|endwhile|extends|for|foreach|function|include|include_once|global|if|new|return|static|switch|use|require|require_once|var|while|abstract|interface|public|implements|private|protected|parent|throw|null|echo|print|trait|namespace|final|yield|goto|instanceof|finally|try|catch'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|//.*?$|[{}]+)|(?P<multilinecomment>/\*.*?\*/)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^#/\'"{}]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(PHP.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in PHP.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(PHP.keywords_regex()), '', source)

PyReprism/languages/prolog.py

@@ -0,0 +1,51 @@
+import re
+from PyReprism.utils import extension
+
+class Prolog:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.prolog
+    
+    @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.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(Prolog.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Prolog.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(Prolog.keywords_regex()), '', source)

PyReprism/languages/python.py

@@ -0,0 +1,54 @@
+import re
+from PyReprism.utils import extension
+
+class Python:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.python
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'as|assert|async|await|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|nonlocal|pass|print|raise|return|try|while|with|yield|__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|case|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|match|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip|True|False|None'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        # return re.compile(r'(?P<comment>#.*?$)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^#\'"]*)', re.DOTALL | re.MULTILINE)
+        # pattern = re.compile(r'(?P<comment>#.*?$|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\')|(?P<noncomment>[^\n]*?(?=\n|$))', re.MULTILINE)
+        pattern = re.compile(r'(?P<comment>#.*?$)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|[^#\'"]+)',re.DOTALL | re.MULTILINE)
+        return pattern
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*\.?\d*|\.\d+)(?:e[+-]?\d+)?j?\b', re.IGNORECASE)
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:or|and|not)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Python.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        return Python.comment_regex().sub(lambda match: match.group('noncomment') if match.group('noncomment') else '', source_code).strip()
+        result = []
+        for match in Python.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(Python.keywords_regex()), '', source)
+