PyReprism 0.0.1__py3-none-any.whl

PyReprism/languages/eiffel.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+
+class Eiffel:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.eiffel
+    
+    @staticmethod
+    def keywords() -> list:
+        keyword = 'across|agent|alias|all|and|attached|as|assign|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor|True|False'.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'\b0[xcb][\da-f](?:_*[\da-f])*\b|(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Eiffel.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Eiffel.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(Eiffel.keywords_regex()), '', source)

PyReprism/languages/elixir.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Elixir:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.elixir
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|"""[\s\S]*?"""|\'\'\'[\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(Elixir.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Elixir.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(Elixir.keywords_regex()), '', source)
+    

PyReprism/languages/erlang.py

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

PyReprism/languages/fortran.py

@@ -0,0 +1,49 @@
+import re
+from PyReprism.utils import extension
+
+
+class ForTran:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.fortran
+    
+    @staticmethod
+    def keywords() -> list:
+        keyword = 'INTEGER|REAL|DOUBLE|PRECISION|COMPLEX|CHARACTER|LOGICAL|/\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE|ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE|ASS'.split('|')
+        return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>!.*?$)|(?P<noncomment>[^!]*[^\n]*)', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV)\.|\.[A-Z]+\.')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(ForTran.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in ForTran.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(ForTran.keywords_regex()), '', source)

PyReprism/languages/fsharp.py

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

PyReprism/languages/go.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Go:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.Go
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var|bool|byte|complex(?:64|128)|error|float32|float64|rune|string|u?int(?:8|16|32|64)?|uintptr|append|cap|close|complex|copy|delete|imag|len|make|new|panic|print|println|real|recover|iota|nil|true|false'.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(Go.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Go.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(Go.keywords_regex()), '', source)
+    

PyReprism/languages/graphql.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class GraphSql:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.graphql
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$)|(?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(GraphSql.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in GraphSql.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(GraphSql.keywords_regex()), '', source)
+    

PyReprism/languages/groovy.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Groovy:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.groovy
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'as|def|in|abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while|setup|given|when|then|and|cleanup|expect|where'.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(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?[\d]+)?)[glidf]?\b')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.{1,2}(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Groovy.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Groovy.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(Groovy.keywords_regex()), '', source)
+    

PyReprism/languages/haml.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Haml:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.haml
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>^-#.*?$|^-#[\s\S]*?(?=\n\S)|^-#[\s\S]*?$)|(?P<noncomment>[^\n]*?(?=\n\S|$))', 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(Haml.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Haml.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(Haml.keywords_regex()), '', source)
+    

PyReprism/languages/haskell.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class Haskell:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.haskell
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where|abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)'.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+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r"\s\.\s|[-!#$%*+=?&@|~.:<>^\\\/]*\.[-!#$%*+=?&@|~.:<>^\\\/]+|[-!#$%*+=?&@|~.:<>^\\\/]+\.[-!#$%*+=?&@|~.:<>^\\\/]*|[-!#$%*+=?&@|~:<>^\\\/]+|`([A-Z][\w']*\.)*[_a-z][\w']*`")
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Haskell.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Haskell.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(Haskell.keywords_regex()), '', source)
+    

PyReprism/languages/html.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class HTML:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.html
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = ''.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'')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.HTMLoin(HTML.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in HTML.comment_regex().finditer(source_code):
+            if match.group('noncomment'):
+                result.append(match.group('noncomment'))
+        if isList:
+            return result
+        return ''.HTMLoin(result)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        return re.sub(re.compile(HTML.keywords_regex()), '', source)
+    

PyReprism/languages/ini.py

@@ -0,0 +1,41 @@
+import re
+from PyReprism.utils import extension
+
+
+class INI:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.ini
+    
+    @staticmethod
+    def keywords() -> list:
+        pass
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'^[ \t]*;.*$', re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pass
+    
+    @staticmethod
+    def operator_regex():
+        pass
+    
+    @staticmethod
+    def keywords_regex():
+        pass
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        return re.sub(re.compile(INI.keywords_regex()), '', source_code)
+
+    @staticmethod
+    def remove_keywords(source: str):
+        pass
+