MLizard 0.0.1__py3-none-any.whl

mlizard/__init__.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+import inspect
+import keyword
+
+from . import interpreter
+
+
+class MertCode:
+    _variables = {}
+    _auto = False
+    _python_globals = None
+
+    @staticmethod
+    def Auto(enabled=True):
+        """Mert Code değişkenlerini Python'a otomatik aktarır."""
+        MertCode._auto = bool(enabled)
+
+        if MertCode._auto:
+            frame = inspect.currentframe().f_back
+            MertCode._python_globals = frame.f_globals
+        else:
+            MertCode._python_globals = None
+
+    @staticmethod
+    def Run(code):
+        """Mert Code kodunu çalıştırır."""
+        MertCode._variables = interpreter.run(code, {})
+
+        if MertCode._auto and MertCode._python_globals is not None:
+            for name, value in MertCode._variables.items():
+                if name.isidentifier() and not keyword.iskeyword(name):
+                    MertCode._python_globals[name] = value
+
+        return MertCode._variables
+
+    @staticmethod
+    def Convert(name=None):
+        """Mert Code değişkenlerini Python değerlerine dönüştürür."""
+        if name is None:
+            return MertCode._variables.copy()
+
+        if name not in MertCode._variables:
+            raise KeyError(f"[{name}] adlı Mert Code değişkeni yok.")
+
+        return MertCode._variables[name]

mlizard/interpreter.py

@@ -0,0 +1,517 @@
+
+# -*- coding: utf-8 -*-
+
+import ast
+import operator
+import re
+
+
+AYARLAR = {
+    "yazi_buyuklugu": 16,
+    "yazi_rengi": "black",
+    "yazi_tipi": "Arial",
+    "yazi_arkaplan": None,
+}
+
+ISLEMLER = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+}
+
+KARSILASTIRMALAR = {
+    ast.Eq: operator.eq,
+    ast.NotEq: operator.ne,
+    ast.Gt: operator.gt,
+    ast.GtE: operator.ge,
+    ast.Lt: operator.lt,
+    ast.LtE: operator.le,
+}
+
+RENKLER = {
+    "kırmızı": "red",
+    "kirmizi": "red",
+    "mavi": "blue",
+    "yeşil": "green",
+    "yesil": "green",
+    "sarı": "yellow",
+    "sari": "yellow",
+    "siyah": "black",
+    "beyaz": "white",
+    "mor": "purple",
+    "turuncu": "orange",
+    "pembe": "pink",
+}
+
+
+def remove_comment(line):
+    """Tırnak içindeki yıldızları yorum olarak algılamaz."""
+    quote = None
+    escaped = False
+    i = 0
+
+    while i < len(line):
+        char = line[i]
+
+        if escaped:
+            escaped = False
+            i += 1
+            continue
+
+        if char == "\\" and quote:
+            escaped = True
+            i += 1
+            continue
+
+        if quote:
+            if char == quote:
+                quote = None
+            i += 1
+            continue
+
+        if char in ("'", '"'):
+            quote = char
+            i += 1
+            continue
+
+        if line.startswith("***", i):
+            return line[:i]
+
+        if line.startswith("**", i):
+            return line[:i]
+
+        i += 1
+
+    return line
+
+
+def safe_eval(node):
+    """Yalnızca izin verilen matematik ve karşılaştırma işlemlerini yapar."""
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, (int, float, str, bool)):
+            return node.value
+        raise ValueError("Desteklenmeyen değer.")
+
+    if isinstance(node, ast.BinOp) and type(node.op) in ISLEMLER:
+        left = safe_eval(node.left)
+        right = safe_eval(node.right)
+
+        if isinstance(node.op, ast.Pow) and abs(right) > 100:
+            raise ValueError("Üs değeri çok büyük.")
+
+        return ISLEMLER[type(node.op)](left, right)
+
+    if isinstance(node, ast.UnaryOp):
+        value = safe_eval(node.operand)
+
+        if isinstance(node.op, ast.USub):
+            return -value
+        if isinstance(node.op, ast.UAdd):
+            return +value
+        if isinstance(node.op, ast.Not):
+            return not value
+
+    if isinstance(node, ast.Compare):
+        left = safe_eval(node.left)
+
+        for op, comparator in zip(
+            node.ops, node.comparators
+        ):
+            right = safe_eval(comparator)
+
+            if type(op) not in KARSILASTIRMALAR:
+                raise ValueError("Desteklenmeyen karşılaştırma.")
+
+            if not KARSILASTIRMALAR[type(op)](left, right):
+                return False
+
+            left = right
+
+        return True
+
+    if isinstance(node, ast.BoolOp):
+        if isinstance(node.op, ast.And):
+            return all(safe_eval(v) for v in node.values)
+
+        if isinstance(node.op, ast.Or):
+            return any(safe_eval(v) for v in node.values)
+
+    raise ValueError("Geçersiz veya desteklenmeyen ifade.")
+
+
+def calculate(expression, variables):
+    expression = expression.strip().replace("mod", "%")
+
+    def replace_variable(match):
+        name = match.group(1).strip()
+
+        if name not in variables:
+            raise KeyError(f"[{name}] değişkeni tanımlı değil.")
+
+        return repr(variables[name])
+
+    expression = re.sub(
+        r"\[([^\]]+)\]", replace_variable, expression
+    )
+
+    tree = ast.parse(expression, mode="eval")
+    return safe_eval(tree.body)
+
+
+
+def get_value(expression, variables):
+    expression = expression.strip()
+
+    # Kullanıcıdan veri al
+    if expression == "Girdi":
+        value = input()
+        return convert_input(value)
+
+    if not expression:
+        return ""
+
+    # Değişken
+    if expression.startswith("[") and expression.endswith("]"):
+        name = expression[1:-1].strip()
+
+        if name not in variables:
+            raise KeyError(f"[{name}] değişkeni tanımlı değil.")
+
+        return variables[name]
+
+    # Sayı, matematik işlemi veya metin
+    try:
+        return calculate(expression, variables)
+    except (SyntaxError, ValueError, TypeError, ZeroDivisionError):
+        import ast
+
+        try:
+            return ast.literal_eval(expression)
+        except (ValueError, SyntaxError):
+            return expression
+
+
+def convert_input(value):
+    """Girdi değerini mümkünse sayıya dönüştürür."""
+    value = value.strip()
+
+    if value == "":
+        return ""
+
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    return value
+
+
+
+def execute_simple(line, variables):
+    line = line.strip()
+
+    if not line:
+        return
+
+    # Eski ve yeni değişken tanımlama biçimleri
+    match = re.fullmatch(
+        r"Ayarla\.Değişken:\s*\[([^\]]+)\]\s*=\s*(.+)",
+        line,
+    )
+
+    if not match:
+        match = re.fullmatch(
+            r"\[([^\]]+)\]\s*=\s*(.+)",
+            line,
+        )
+
+    if match:
+        name = match.group(1).strip()
+        value = get_value(match.group(2), variables)
+        variables[name] = value
+        return
+
+    # Ekrana yazdırma
+    if line.startswith("Yaz:"):
+        content = line[4:].strip()
+
+        try:
+            print(get_value(content, variables))
+        except Exception:
+            # Yan yana yazılan metinleri ve değişkenleri destekle.
+            tokens = re.findall(
+                r'"(?:\\.|[^"\\])*"|'
+                r"'(?:\\.|[^'\\])*'|"
+                r"\[[^\]]+\]|\S+",
+                content,
+            )
+
+            output = []
+
+            for token in tokens:
+                output.append(str(get_value(token, variables)))
+
+            print("".join(output))
+
+        return
+
+
+    if line.startswith("Girdi:"):
+        name = line[6:].strip().strip("[]")
+
+        if not name:
+            raise ValueError("Girdi komutu için değişken adı gerekli.")
+
+        variables[name] = convert_input(input())
+        return
+
+
+    # Yazı ayarları
+    settings = {
+        "Yazı.Büyüklük:": "yazi_buyuklugu",
+        "Yazı.Renk:": "yazi_rengi",
+        "Yazı.Tip:": "yazi_tipi",
+        "Yazı.ArkaPlan:": "yazi_arkaplan",
+    }
+
+    for prefix, setting in settings.items():
+        if line.startswith(prefix):
+            value = get_value(line[len(prefix):], variables)
+
+            if setting == "yazi_rengi":
+                value = RENKLER.get(
+                    str(value).lower(), value
+                )
+
+            AYARLAR[setting] = value
+            return
+
+    raise ValueError(f"Tanınmayan komut: {line}")
+
+def parse_block(lines, index=0, expected_indent=0):
+    """Eğer / Diğer koşul zincirlerini ve girintili blokları ayrıştırır."""
+    nodes = []
+
+    def get_indent(i):
+        return len(lines[i]) - len(lines[i].lstrip())
+
+    def parse_body(i, parent_indent, line_number):
+        while i < len(lines) and not lines[i].strip():
+            i += 1
+
+        if i >= len(lines) or get_indent(i) <= parent_indent:
+            raise SyntaxError(
+                f"{line_number}. satırın altında girintili kod bulunmalı."
+            )
+
+        return parse_block(lines, i, get_indent(i))
+
+    while index < len(lines):
+        raw = lines[index]
+
+        if not raw.strip():
+            index += 1
+            continue
+
+        indent = get_indent(index)
+        line = raw.strip()
+
+        if indent < expected_indent:
+            break
+
+        if indent > expected_indent:
+            raise SyntaxError(
+                f"{index + 1}. satırda beklenmeyen girinti."
+            )
+
+        if line == "Değilse" or line.startswith("Diğer"):
+            break
+
+        if line.startswith("Eğer "):
+            line_number = index + 1
+            condition = line[len("Eğer "):].strip()
+
+            if not condition:
+                raise SyntaxError(
+                    f"{line_number}. satırda koşul eksik."
+                )
+
+            index += 1
+            body, index = parse_body(
+                index, expected_indent, line_number
+            )
+
+            branches = [(condition, body)]
+            else_seen = False
+
+            while index < len(lines):
+                while index < len(lines) and not lines[index].strip():
+                    index += 1
+
+                if index >= len(lines):
+                    break
+
+                if get_indent(index) != expected_indent:
+                    break
+
+                next_line = lines[index].strip()
+
+                if next_line.startswith("Diğer "):
+                    if else_seen:
+                        raise SyntaxError(
+                            "Değilse bloğundan sonra Diğer kullanılamaz."
+                        )
+
+                    other_condition = next_line[len("Diğer "):].strip()
+
+                    if not other_condition:
+                        raise SyntaxError(
+                            f"{index + 1}. satırda Diğer koşulu eksik."
+                        )
+
+                    other_line_number = index + 1
+                    index += 1
+                    other_body, index = parse_body(
+                        index, expected_indent, other_line_number
+                    )
+
+                    branches.append((other_condition, other_body))
+                    continue
+
+                if next_line == "Değilse":
+                    if else_seen:
+                        raise SyntaxError(
+                            "Bir koşul zincirinde yalnızca bir Değilse olabilir."
+                        )
+
+                    else_seen = True
+                    else_line_number = index + 1
+                    index += 1
+                    else_body, index = parse_body(
+                        index, expected_indent, else_line_number
+                    )
+
+                    branches.append((None, else_body))
+                    continue
+
+                if next_line == "Diğer":
+                    raise SyntaxError(
+                        f"{index + 1}. satırda Diğer bir koşul almalı."
+                    )
+
+                break
+
+            nodes.append((
+                "if_chain", branches, line_number
+            ))
+            continue
+
+        if line.startswith("Tekrarla "):
+            line_number = index + 1
+            count = line[len("Tekrarla "):].strip()
+            index += 1
+
+            body, index = parse_body(
+                index, expected_indent, line_number
+            )
+
+            nodes.append(("repeat", count, body, line_number))
+            continue
+
+        if line == "Değilse":
+            raise SyntaxError(
+                f"{index + 1}. satırda Değilse için bir Eğer gerekli."
+            )
+
+        nodes.append(("line", line, index + 1))
+        index += 1
+
+    return nodes, index
+
+
+def execute_nodes(nodes, variables):
+    for node in nodes:
+        kind = node[0]
+
+        try:
+            if kind == "line":
+                execute_simple(node[1], variables)
+
+            elif kind == "if_chain":
+                branches = node[1]
+
+                for condition, body in branches:
+                    if condition is None or calculate(
+                        condition, variables
+                    ):
+                        execute_nodes(body, variables)
+                        break
+
+            elif kind == "repeat":
+                _, count, body, _ = node
+                amount = int(get_value(count, variables))
+
+                if amount < 0:
+                    raise ValueError(
+                        "Tekrar sayısı negatif olamaz."
+                    )
+
+                if amount > 100000:
+                    raise ValueError(
+                        "Tekrar sayısı çok büyük."
+                    )
+
+                for _ in range(amount):
+                    execute_nodes(body, variables)
+
+        except Exception as error:
+            line_number = node[-1]
+
+            raise RuntimeError(
+                f"{line_number}. satır: {error}"
+            ) from error
+
+def run(code, initial_variables=None):
+    variables = dict(initial_variables or {})
+
+    # Her çalıştırmada ayarları başlangıç durumuna getir.
+    AYARLAR.update({
+        "yazi_buyuklugu": 16,
+        "yazi_rengi": "black",
+        "yazi_tipi": "Arial",
+        "yazi_arkaplan": None,
+    })
+
+    lines = []
+    in_multiline_comment = False
+
+    for raw in code.splitlines():
+        stripped = raw.strip()
+
+        if stripped == "***":
+            in_multiline_comment = not in_multiline_comment
+            continue
+
+        if in_multiline_comment:
+            continue
+
+        line = remove_comment(raw)
+
+        if line.strip():
+            lines.append(line)
+        else:
+            lines.append("")
+
+    nodes, _ = parse_block(lines)
+    execute_nodes(nodes, variables)
+
+    return variables

mlizard-0.0.1.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: mlizard
+Version: 0.0.1
+Summary: A Python library for Mert Code and additional tools
+Author: Pylizard
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# MLizard 🦎
+
+MLizard, çeşitli araçların Python projelerinde çalıştırılmasını sağlamak için geliştirilen bir Python kütüphanesidir.
+
+## Kurulum
+
+```bash
+python -m pip install MLizard
+```
+
+## Kullanım
+
+```python
+from mlizard import LibraryName
+
+
+```
+
+## Geliştirici
+
+Pylizard tarafından geliştirilmektedir.

mlizard-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+mlizard/__init__.py,sha256=tmdmm5J9wCRk-nV7g6UXZfJgPVcJBUh2aJIwaJvbq44,1349
+mlizard/interpreter.py,sha256=k0ERTI-ri9ZfF69u4RG-BHlxPYzqKNnwgjyjammnO4s,13605
+mlizard-0.0.1.dist-info/licenses/LICENSE,sha256=b5f_EKetFbYR1QDEKbU1rD-D1qpb3Lz-VrU6V1L9oEk,1088
+mlizard-0.0.1.dist-info/METADATA,sha256=QcfEAIO6eMkhcjsoo6YrAqTaMbboUJFN54EA9eGtw14,622
+mlizard-0.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mlizard-0.0.1.dist-info/top_level.txt,sha256=BJWUd80fovOwxsqweDFE_10uDoMmaZX7p_HLe3e3lDM,8
+mlizard-0.0.1.dist-info/RECORD,,

mlizard-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mlizard-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2026 PyLizard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mlizard-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mlizard