PyReprism 0.0.1__py3-none-any.whl

PyReprism/languages/clojure.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Clojure:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.clojure
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'def|if|do|let|\.\.|quote|var|->>|->|fn|loop|recur|throw|try|monitor-enter|\.|new|set!|def\-|defn|defn\-|defmacro|defmulti|defmethod|defstruct|defonce|declare|definline|definterface|defprotocol|==|defrecord|>=|deftype|<=|defproject|ns|\*|\+|\-|\/|<|=|>|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|conj|cons|constantly|cond|if-not|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|deref|difference|disj|dissoc|distinct|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|for|fnseq|frest|gensym|get-proxy-class|get|hash-map|hash-set|identical\?|identity|if-let|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|line-seq|list\*|list|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|time|to-array|to-array-2d|tree-seq|true\?|union|up|update-proxy|val|vals|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper|true|false|nil'.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'\b[0-9A-Fa-f]+\b')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r"(?:::|[:|'])\b[a-z][\w*+!?-]*\b")
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Clojure.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Clojure.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(Clojure.keywords_regex()), '', source)
+    

PyReprism/languages/coffeescript.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class CoffeeScript:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.coffeescript
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield'.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|###.*?###|###.*?$|^.*?###)|(?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(CoffeeScript.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in CoffeeScript.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(CoffeeScript.keywords_regex()), '', source)
+    

PyReprism/languages/cpp.py

@@ -0,0 +1,52 @@
+import re
+from PyReprism.utils import extension
+
+
+class CPP:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.cpp
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|class|compl|const|constexpr|const_cast|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|float|for|friend|goto|if|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|mutable|namespace|new|noexcept|nullptr|operator|private|protected|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while|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'(?:\b0x[\da-f]+|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?)[ful]*')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'--?|\+\+?|!=?|<{1,2}=?|>{1,2}=?|->|:{1,2}|={1,2}|\^|~|%|&{1,2}|\|\|?|\?|\*|\/|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(CPP.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in CPP.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(CPP.keywords_regex()), '', source)

PyReprism/languages/crystal.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Crystal:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.crystal
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|alias|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|rescue|return|require|select|self|sizeof|struct|super|then|type|typeof|uninitialized|union|unless|until|when|while|with|yield|__DIR__|__END_LINE__|__FILE__|__LINE__'.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$|=begin[\s\S]*?=end|=begin.*?$|^.*?=end)|(?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'\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(Crystal.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Crystal.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(Crystal.keywords_regex()), '', source)
+    

PyReprism/languages/csharp.py

@@ -0,0 +1,53 @@
+import re
+from PyReprism.utils import extension
+
+
+class CSharp:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.csharp
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|add|alias|as|ascending|async|await|base|bool|break|byte|case|catch|char|checked|class|const|continue|decimal|default|delegate|descending|do|double|dynamic|else|enum|event|explicit|extern|false|finally|fixed|float|for|foreach|from|get|global|goto|group|if|implicit|in|int|interface|internal|into|is|join|let|lock|long|namespace|new|null|object|operator|orderby|out|override|params|partial|private|protected|public|readonly|ref|remove|return|sbyte|sealed|select|set|short|sizeof|stackalloc|static|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|unsafe|ushort|using|value|var|virtual|void|volatile|where|while|yield|warning|define|elif|endif|endregion|error|if|line|pragma|region|undef'.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]+\b|(?:\b\d+\.?\d*|\B\.\d+)f?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'(^|[^.])(?:\+[+=]?|-[-=]?|!=?|<<?=?|>>?>?=?|==?|&[&=]?|\|[|=]?|\*=?|\/=?|%=?|\^=?|[?:~])')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(CSharp.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in CSharp.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(CSharp.keywords_regex()), '', source)
+    

PyReprism/languages/csp.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class CSP:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.csp
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'base-uri|form-action|frame-ancestors|plugin-types|referrer|reflected-xss|report-to|report-uri|require-sri-for|sandbox) |(?:block-all-mixed-content|disown-opener|upgrade-insecure-requests)(?: |;)|(?:child|connect|default|font|frame|img|manifest|media|object|script|style|worker)-src'.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(CSP.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in CSP.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(CSP.keywords_regex()), '', source)
+    

PyReprism/languages/css.py

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

PyReprism/languages/css_extras.py

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

PyReprism/languages/d.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class D:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.d
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'abstract|alias|align|asm|assert|auto|body|bool|break|byte|case|cast|catch|cdouble|cent|cfloat|char|class|const|continue|creal|dchar|debug|default|delegate|delete|deprecated|do|double|else|enum|export|extern|false|final|finally|float|for|foreach|foreach_reverse|function|goto|idouble|if|ifloat|immutable|import|inout|int|interface|invariant|ireal|lazy|long|macro|mixin|module|new|nothrow|null|out|override|package|pragma|private|protected|public|pure|real|ref|return|scope|shared|short|static|struct|super|switch|synchronized|template|this|throw|true|try|typedef|typeid|typeof|ubyte|ucent|uint|ulong|union|unittest|ushort|version|void|volatile|wchar|while|with|__(?:(?:FILE|MODULE|LINE|FUNCTION|PRETTY_FUNCTION|DATE|EOF|TIME|TIMESTAMP|VENDOR|VERSION)__|gshared|traits|vector|parameters)|string|wstring|dstring|size_t|ptrdiff_t'.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/|/\+[\s\S]*?\+/|/\+.*?$|^.*?\+/)|(?P<noncomment>[^/]*[^\n]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b0x\.?[a-f\d_]+(?:(?!\.\.)\.[a-f\d_]*)?(?:p[+-]?[a-f\d_]+)?[ulfi]*')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'\|[|=]?|&[&=]?|\+[+=]?|-[-=]?|\.?\.\.|=[>=]?|!(?:i[ns]\b|<>?=?|>=?|=)?|\bi[ns]\b|(?:<[<>]?|>>?>?|\^\^|[*\/%^~])=?')
+        return pattern
+    
+    @staticmethod
+    def keywords_regex():
+        return re.compile(r'\b(' + '|'.join(D.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in D.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(D.keywords_regex()), '', source)
+    

PyReprism/languages/dart.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|assert|async|await|break|case|catch|class|const|continue|default|deferred|do|dynamic|else|enum|export|external|extends|factory|final|finally|for|get|if|implements|import|in|library|new|null|operator|part|rethrow|return|set|static|super|switch|this|throw|try|typedef|var|void|while|with|yield|sync'.split('|')
+        
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = pattern = re.compile(r'(?P<comment>//.*?$|/\*[\s\S]*?\*/|/\*.*?$|^.*?\*/|///.*?$)|(?P<noncomment>\'(\\.|[^\\\'])*\'|"(\\.|[^\\"])*"|.[^/\'"]*)', re.DOTALL | re.MULTILINE)
+        return pattern
+
+    
+    @staticmethod
+    def number_regex():
+        pattern = re.compile(r'\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?')
+        return pattern
+    
+    @staticmethod
+    def operator_regex():
+        pattern = re.compile(r'\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?')
+        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/diff.py

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

PyReprism/languages/django.py

@@ -0,0 +1,55 @@
+import re
+from PyReprism.utils import extension
+
+
+class Django:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.django
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'load|verbatim|widthratio|ssi|firstof|for|url|ifchanged|csrf_token|lorem|ifnotequal|autoescape|now|templatetag|debug|cycle|ifequal|regroup|comment|filter|endfilter|if|spaceless|with|extends|block|include|else|empty|endif|endfor|as|endblock|endautoescape|endverbatim|trans|endtrans|[Tt]rue|[Ff]alse|[Nn]one|in|is|static|macro|endmacro|call|endcall|set|endset|raw|endraw'.split('|')
+         return keyword
+    
+    @staticmethod
+    def functions() -> list:
+        func = 'abs|add|addslashes|attr|batch|callable|capfirst|capitalize|center|count|cut|d|date|default|default_if_none|defined|dictsort|dictsortreversed|divisibleby|e|equalto|escape|escaped|escapejs|even|filesizeformat|first|float|floatformat|force_escape|forceescape|format|get_digit|groupby|indent|int|iriencode|iterable|join|last|length|length_is|linebreaks|linebreaksbr|linenumbers|list|ljust|lower|make_list|map|mapping|number|odd|phone2numeric|pluralize|pprint|random|reject|rejectattr|removetags|replace|reverse|rjust|round|safe|safeseq|sameas|select|selectattr|sequence|slice|slugify|sort|string|stringformat|striptags|sum|time|timesince|timeuntil|title|trim|truncate|truncatechars|truncatechars_html|truncatewords|truncatewords_html|undefined|unordered_list|upper|urlencode|urlize|urlizetrunc|wordcount|wordwrap|xmlattr|yesno'.split('|')
+        return func
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>\{#.*?#\})|(?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(Django.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Django.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(Django.keywords_regex()), '', source)
+    

PyReprism/languages/docker.py

@@ -0,0 +1,50 @@
+import re
+from PyReprism.utils import extension
+
+
+class Docker:
+    def __init__():
+        pass
+
+    @staticmethod
+    def file_extension() -> str:
+        return extension.docker
+    
+    @staticmethod
+    def keywords() -> list:
+         keyword = 'ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR'.split('|')
+         return keyword
+    
+    @staticmethod
+    def comment_regex():
+        pattern = re.compile(r'(?P<comment>#.*?$)|(?P<noncomment>[^#]*)', 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(Docker.keywords()) + r')\b')
+    
+    @staticmethod
+    def remove_comments(source_code: str, isList: bool = False) -> str:
+        result = []
+        for match in Docker.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(Docker.keywords_regex()), '', source)
+