PyReprism 0.0.1__py3-none-any.whl

PyReprism/languages/ruby.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Ruby:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.ruby
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|false|for|if|in|module|new|next|nil|not|or|protected|private|public|raise|redo|require|rescue|retry|return|self|super|then|throw|true|undef|unless|until|when|while|yield|Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|Fixnum|Float|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|=begin[\s\S]*?=end|=begin.*?$|^.*?=end)|(?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(Ruby.keywords()) + r')\b', re.IGNORECASE)
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Ruby.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(Ruby.keywords_regex()), '', source)

PyReprism/languages/rust.py

@@ -0,0 +1,52 @@
+import re
+from PyReprism.utils import extension
+
+
+class Dart:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.dart
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|alignof|as|be|box|break|const|continue|crate|do|else|enum|extern|false|final|fn|for|if|impl|in|let|loop|match|mod|move|mut|offsetof|once|override|priv|pub|pure|ref|return|sizeof|static|self|struct|super|true|trait|type|typeof|unsafe|unsized|use|virtual|where|while|yield'.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(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(\d(?:_?\d)*)?\.?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:[iu](?:8|16|32|64)?|f32|f64))?\b')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'[-+*\/%!^]=?|=[=>]?|@|&[&=]?|\|[|=]?|<<?=?|>>?=?')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Dart.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Dart.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(Dart.keywords_regex()), '', source)

PyReprism/languages/scala.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Scala:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.scala
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|self|super|this|throw|trait|try|type|val|var|while|with|yield|String|Int|Long|Short|Byte|Boolean|Double|Float|Char|Any|AnyRef|AnyVal|Unit|Nothing'.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'\b0x[\da-f]*\.?[\da-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e\d+)?[dfl]?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Scala.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Scala.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(Scala.keywords_regex()), '', source)
+    

PyReprism/languages/scheme.py

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

PyReprism/languages/scss.py

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

PyReprism/languages/smalltalk.py

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

PyReprism/languages/stylus.py

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

PyReprism/languages/swift.py

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

PyReprism/languages/tsx.py

@@ -0,0 +1,52 @@
+import re
+from PyReprism.utils import extension
+
+
+class Tsx:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.tsx
+    
+    @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|module|declare|constructor|namespace|abstract|require|type|string|Function|any|number|boolean|Array|symbol|console'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/|/\*\*[\s\S]*?\*/)|(?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(Tsx.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Tsx.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(Tsx.keywords_regex()), '', source)
+    

PyReprism/languages/typescript.py

@@ -0,0 +1,52 @@
+import re
+from PyReprism.utils import extension
+
+
+class TypeScript:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.typescript
+    
+    @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|module|declare|constructor|namespace|abstract|require|type|string|Function|any|number|boolean|Array|symbol|console'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/|/\*\*[\s\S]*?\*/)|(?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(TypeScript.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in TypeScript.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(TypeScript.keywords_regex()), '', source)
+    

PyReprism/languages/vbnet.py

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

PyReprism/languages/velocity.py

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