15.12-dars: pathlib

yol = YUKLASH_KATALOGI + "/" + foydalanuvchi_fayl_nomi
if yol.startswith(YUKLASH_KATALOGI):
    saqla(yol)

from pathlib import Path

p = Path("data") / "2026" / "sotuv.csv"      # ⭐ / operatori
Path.cwd(); Path.home()                      # joriy va uy katalogi

Path("/home/aziz/proj/src/app.py").relative_to("/home/aziz/proj")   # src/app.py
Path("/a/b").relative_to("/c")                                     # ValueError
Path("/a/b").is_relative_to("/a")                                  # True

from pathlib import Path

ildiz = Path(__file__).resolve().parent
sozlama = ildiz / "config" / "app.toml"
sozlama.parent.mkdir(parents=True, exist_ok=True)
matn = sozlama.read_text(encoding="utf-8")
sozlama.with_suffix(".bak").write_text(matn, encoding="utf-8")

for f in sorted(ildiz.rglob("*.py")): ...
f.relative_to(ildiz).as_posix()

yol = (YUKLASH / nom).resolve()
if not yol.is_relative_to(YUKLASH.resolve()): raise ValueError("ruxsat yo'q")

yo'l — Path, satr emas
Path / "/absolyut" — oldingi qism yo'qoladi
xavfsizlik: resolve() + is_relative_to(), startswith emas
read_text/write_text — encoding="utf-8"
rglob yashirin kataloglarga ham kiradi
saqlash va almashinuv — as_posix()

"""/ operatori; name, stem, suffix, suffixes, parent, parents, parts; with_* metodlari; absolyut qism va .. ; resolve; Pure yo'llar."""

from pathlib import Path, PurePosixPath, PureWindowsPath


def main() -> None:
    print("=== 1. Qurish va qismlar ===")
    p = PurePosixPath("data") / "2026" / "arxiv.tar.gz"
    print(f"  yo'l:     {p}")
    print(f"  name={p.name!r}, stem={p.stem!r}, suffix={p.suffix!r}, suffixes={p.suffixes}")
    print(f"  parent={p.parent}, parts={p.parts}")
    print(f"  parents: {[str(x) for x in p.parents]}")
    print(f"  ⚠️ '.bashrc': suffix={PurePosixPath('.bashrc').suffix!r}, stem={PurePosixPath('.bashrc').stem!r}")

    print("\n=== 2. with_* metodlari ===")
    fayl = PurePosixPath("hisobot/sotuv.csv")
    print(f"  with_name('x.txt')   → {fayl.with_name('x.txt')}")
    print(f"  with_stem('xarajat') → {fayl.with_stem('xarajat')}")
    print(f"  with_suffix('.json') → {fayl.with_suffix('.json')}")
    print(f"  with_suffix('')      → {fayl.with_suffix('')}")
    try:
        fayl.with_suffix("json")
    except ValueError as xato:
        print(f"  with_suffix('json')  → ValueError: {xato}")

    print("\n=== 3. ⚠️ Birlashtirish tuzoqlari ===")
    print(f"  'yuklash' / 'rasm.png'    → {PurePosixPath('yuklash') / 'rasm.png'}")
    print(f"  'yuklash' / '/etc/passwd' → {PurePosixPath('yuklash') / '/etc/passwd'}  ← oldingi qism yo'qoldi")
    print(f"  'a/./b' → {PurePosixPath('a/./b')},  'a/b/../c' → {PurePosixPath('a/b/../c')}  ← .. saqlanadi")
    print(f"  Path('a/../b') == Path('b'): {PurePosixPath('a/../b') == PurePosixPath('b')}")

    print("\n=== 4. resolve() ===")
    asosiy = Path.cwd()
    chalkash = asosiy / "a" / "b" / ".." / ".." / "c.txt"
    print(f"  resolve() '..' larni hal qildi: {chalkash.resolve() == (asosiy / 'c.txt').resolve()}")
    print(f"  absolute() esa saqlaydi: {'..' in chalkash.absolute().parts}")

    print("\n=== 5. Platforma yo'llari ===")
    print(f"  Windows: 'C:/Users/Aziz' == 'c:/users/aziz' → {PureWindowsPath('C:/Users/Aziz') == PureWindowsPath('c:/users/aziz')}")
    print(f"  POSIX:   '/home/Aziz' == '/home/aziz' → {PurePosixPath('/home/Aziz') == PurePosixPath('/home/aziz')}")
    print(f"  Windows anchor: {PureWindowsPath('C:/x/y').anchor!r}, POSIX anchor: {PurePosixPath('/x/y').anchor!r}")
    print(f"  Windows yo'li as_posix(): {PureWindowsPath('C:\\Loyiha\\src\\app.py').as_posix()}")
    print(f"  Path turi shu tizimda: {type(Path('x')).__name__} (Linux/macOS'da PosixPath)")


if __name__ == "__main__":
    main()

=== 1. Qurish va qismlar ===
  yo'l:     data/2026/arxiv.tar.gz
  name='arxiv.tar.gz', stem='arxiv.tar', suffix='.gz', suffixes=['.tar', '.gz']
  parent=data/2026, parts=('data', '2026', 'arxiv.tar.gz')
  parents: ['data/2026', 'data', '.']
  ⚠️ '.bashrc': suffix='', stem='.bashrc'

=== 2. with_* metodlari ===
  with_name('x.txt')   → hisobot/x.txt
  with_stem('xarajat') → hisobot/xarajat.csv
  with_suffix('.json') → hisobot/sotuv.json
  with_suffix('')      → hisobot/sotuv
  with_suffix('json')  → ValueError: Invalid suffix 'json'

=== 3. ⚠️ Birlashtirish tuzoqlari ===
  'yuklash' / 'rasm.png'    → yuklash/rasm.png
  'yuklash' / '/etc/passwd' → /etc/passwd  ← oldingi qism yo'qoldi
  'a/./b' → a/b,  'a/b/../c' → a/b/../c  ← .. saqlanadi
  Path('a/../b') == Path('b'): False

=== 4. resolve() ===
  resolve() '..' larni hal qildi: True
  absolute() esa saqlaydi: True

=== 5. Platforma yo'llari ===
  Windows: 'C:/Users/Aziz' == 'c:/users/aziz' → True
  POSIX:   '/home/Aziz' == '/home/aziz' → False
  Windows anchor: 'C:\\', POSIX anchor: '/'
  Windows yo'li as_posix(): C:/Loyiha/src/app.py
  Path turi shu tizimda: WindowsPath (Linux/macOS'da PosixPath)

"""mkdir, write_text, read_text, touch, unlink, rmdir, rename, replace; 3.14 copy va move; iterdir, glob, rglob, walk; match va full_match; TOCTOU."""

import tempfile
from pathlib import Path


def korinish(yollar, ildiz: Path) -> list[str]:
    return sorted(p.relative_to(ildiz).as_posix() for p in yollar)


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        r = Path(vaqtinchalik)

        print("=== 1. Yaratish va o'qish ===")
        (r / "src" / "pkg").mkdir(parents=True)
        (r / "src" / "pkg" / "yordamchi.py").write_text("def f(): ...\n", encoding="utf-8")
        (r / "src" / "app.py").write_text("print('salom')\n", encoding="utf-8")
        (r / "README.md").write_text("# Loyiha\n", encoding="utf-8")
        (r / ".git" / "objects").mkdir(parents=True)
        (r / ".git" / "objects" / "hook.py").write_text("", encoding="utf-8")
        (r / "rasm.png").write_bytes(b"\x89PNG\r\n")
        print(f"  README: {(r / 'README.md').read_text(encoding='utf-8')!r}, hajm: {(r / 'README.md').stat().st_size} bayt")
        print(f"  rasm boshi: {(r / 'rasm.png').read_bytes()[:4]!r}")
        try:
            (r / "src").mkdir()
        except FileExistsError:
            print("  mkdir mavjud katalogga → FileExistsError; exist_ok=True bilan jim")
        (r / "src").mkdir(exist_ok=True)

        print("\n=== 2. O'chirish va nomlash ===")
        vaqt = r / "vaqtinchalik.txt"
        vaqt.touch()
        vaqt.unlink()
        vaqt.unlink(missing_ok=True)
        print(f"  unlink(missing_ok=True) — xato yo'q, mavjud: {vaqt.exists()}")
        try:
            (r / "src").rmdir()
        except OSError as xato:
            print(f"  bo'sh bo'lmagan katalogni rmdir → {type(xato).__name__}")
        eski = r / "README.md"
        yangi = eski.rename(r / "OQIBCHIQ.md")
        print(f"  rename natijasi: {yangi.name}, eski mavjud: {eski.exists()}")
        (r / "nusxa.md").write_text("eski", encoding="utf-8")
        yangi.replace(r / "nusxa.md")
        print(f"  replace mavjud faylga yozdi: {(r / 'nusxa.md').read_text(encoding='utf-8')!r}")

        print("\n=== 3. 3.14: copy va move ===")
        (r / "src" / "app.py").copy(r / "app_nusxa.py")
        (r / "src").copy(r / "src_zaxira")
        print(f"  fayl nusxasi: {(r / 'app_nusxa.py').read_text(encoding='utf-8')!r}")
        print(f"  katalog nusxasi: {korinish((r / 'src_zaxira').rglob('*'), r)}")
        (r / "arxiv").mkdir()                              # ⚠️ move ota katalogni yaratmaydi
        (r / "src_zaxira").move(r / "arxiv" / "src_2026")
        print(f"  ko'chirildi: {(r / 'arxiv' / 'src_2026' / 'app.py').exists()}, eski yo'q: {not (r / 'src_zaxira').exists()}")

        print("\n=== 4. Qidiruv ===")
        print(f"  iterdir:          {korinish(r.iterdir(), r)}")
        print(f"  glob('*.py'):     {korinish(r.glob('*.py'), r)}")
        print(f"  rglob('*.py'):    {korinish(r.rglob('*.py'), r)}")
        print("  ⚠️ rglob .git ichiga ham kirdi")
        yurish = []
        for katalog, ichki, fayllar in r.walk():
            ichki[:] = sorted(d for d in ichki if not d.startswith("."))
            yurish.extend((katalog / f).relative_to(r).as_posix() for f in fayllar if f.endswith(".py"))
        print(f"  walk + kesish:    {sorted(yurish)}")

        print("\n=== 5. match va full_match ===")
        yol = Path("src/pkg/yordamchi.py")
        for naqsh in ("*.py", "pkg/*.py", "src/*.py", "src/**/*.py"):
            print(f"  {naqsh:14} match={yol.match(naqsh)!s:5}  full_match={yol.full_match(naqsh)}")


if __name__ == "__main__":
    main()

=== 1. Yaratish va o'qish ===
  README: '# Loyiha\n', hajm: 10 bayt
  rasm boshi: b'\x89PNG'
  mkdir mavjud katalogga → FileExistsError; exist_ok=True bilan jim

=== 2. O'chirish va nomlash ===
  unlink(missing_ok=True) — xato yo'q, mavjud: False
  bo'sh bo'lmagan katalogni rmdir → OSError
  rename natijasi: OQIBCHIQ.md, eski mavjud: False
  replace mavjud faylga yozdi: '# Loyiha\n'

=== 3. 3.14: copy va move ===
  fayl nusxasi: "print('salom')\n"
  katalog nusxasi: ['src_zaxira/app.py', 'src_zaxira/pkg', 'src_zaxira/pkg/yordamchi.py']
  ko'chirildi: True, eski yo'q: True

=== 4. Qidiruv ===
  iterdir:          ['.git', 'app_nusxa.py', 'arxiv', 'nusxa.md', 'rasm.png', 'src']
  glob('*.py'):     ['app_nusxa.py']
  rglob('*.py'):    ['.git/objects/hook.py', 'app_nusxa.py', 'arxiv/src_2026/app.py', 'arxiv/src_2026/pkg/yordamchi.py', 'src/app.py', 'src/pkg/yordamchi.py']
  ⚠️ rglob .git ichiga ham kirdi
  walk + kesish:    ['app_nusxa.py', 'arxiv/src_2026/app.py', 'arxiv/src_2026/pkg/yordamchi.py', 'src/app.py', 'src/pkg/yordamchi.py']

=== 5. match va full_match ===
  *.py           match=True   full_match=False
  pkg/*.py       match=True   full_match=False
  src/*.py       match=False  full_match=False
  src/**/*.py    match=True   full_match=True

"""Path traversal hujumi; startswith tuzog'i; resolve + is_relative_to; relative_to xatosi; fayl nomini tozalash."""

import re
import tempfile
from pathlib import Path


def xato_tekshiruv(ildiz: str, nom: str) -> bool:
    yol = ildiz + "/" + nom
    return yol.startswith(ildiz)


def togri_tekshiruv(ildiz: Path, nom: str) -> Path | None:
    yol = (ildiz / nom).resolve()
    return yol if yol.is_relative_to(ildiz.resolve()) else None


def nom_tozala(nom: str) -> str:
    asosiy = Path(nom.replace("\\", "/")).name                  # faqat oxirgi qism
    asosiy = re.sub(r"[^\w.\-]", "_", asosiy)                   # xavfli belgilar
    asosiy = asosiy.lstrip(".") or "fayl"                        # yashirin va bo'sh nomlar
    return asosiy[:100]


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        yuklash = Path(vaqtinchalik) / "yuklash"
        yuklash.mkdir()
        (Path(vaqtinchalik) / "yuklash_eski").mkdir()
        nomlar = ["rasm.png", "hujjat/2026/shartnoma.pdf", "../yuklash_eski/sir.txt",
                  "../../etc/passwd", "/etc/passwd", "pkg/../rasm.png"]

        print("=== 1. ⚠️ Satr bilan tekshiruv ===")
        otdi, rad = "o'tdi", "rad"
        for nom in nomlar:
            print(f"  {nom:28} startswith → {otdi if xato_tekshiruv(str(yuklash), nom) else rad}")

        print("\n=== 2. ✅ resolve + is_relative_to ===")
        for nom in nomlar:
            natija = togri_tekshiruv(yuklash, nom)
            korinish = natija.relative_to(yuklash.resolve()).as_posix() if natija else "❌ rad etildi"
            print(f"  {nom:28} → {korinish}")

        print("\n=== 3. ⚠️ Prefiks bilan bir xil boshlanadigan katalog ===")
        eski = (Path(vaqtinchalik) / "yuklash_eski" / "sir.txt").resolve()
        print(f"  str.startswith: {str(eski).startswith(str(yuklash.resolve()))}")
        print(f"  is_relative_to: {eski.is_relative_to(yuklash.resolve())}")
        try:
            eski.relative_to(yuklash.resolve())
        except ValueError:
            print("  relative_to → ValueError (ichida emas)")

        print("\n=== 4. Fayl nomini tozalash ===")
        for nom in ("../../etc/passwd", "C:\\Windows\\win.ini", ".htaccess", "hisobot 2026 (yakuniy).pdf",
                    "rasm<script>.png", "..", ""):
            print(f"  {nom!r:32} → {nom_tozala(nom)!r}")


if __name__ == "__main__":
    main()

=== 1. ⚠️ Satr bilan tekshiruv ===
  rasm.png                     startswith → o'tdi
  hujjat/2026/shartnoma.pdf    startswith → o'tdi
  ../yuklash_eski/sir.txt      startswith → o'tdi
  ../../etc/passwd             startswith → o'tdi
  /etc/passwd                  startswith → o'tdi
  pkg/../rasm.png              startswith → o'tdi

=== 2. ✅ resolve + is_relative_to ===
  rasm.png                     → rasm.png
  hujjat/2026/shartnoma.pdf    → hujjat/2026/shartnoma.pdf
  ../yuklash_eski/sir.txt      → ❌ rad etildi
  ../../etc/passwd             → ❌ rad etildi
  /etc/passwd                  → ❌ rad etildi
  pkg/../rasm.png              → rasm.png

=== 3. ⚠️ Prefiks bilan bir xil boshlanadigan katalog ===
  str.startswith: True
  is_relative_to: False
  relative_to → ValueError (ichida emas)

=== 4. Fayl nomini tozalash ===
  '../../etc/passwd'               → 'passwd'
  'C:\\Windows\\win.ini'           → 'win.ini'
  '.htaccess'                      → 'htaccess'
  'hisobot 2026 (yakuniy).pdf'     → 'hisobot_2026__yakuniy_.pdf'
  'rasm<script>.png'               → 'rasm_script_.png'
  '..'                             → 'fayl'
  ''                               → 'fayl'

"""rglob bilan qidirish; nomdan sana ajratish; with_stem bilan to'qnashuvsiz nom; xesh bilan takrorlarni aniqlash; quruq ishga tushirish rejasi; move va natijani tekshirish."""

import hashlib
import re
import tempfile
from collections import Counter
from pathlib import Path

KENGAYTMALAR = {".jpg", ".jpeg", ".png", ".heic"}
SANA = re.compile(r"(?<![0-9])(20[0-9]{2})([01][0-9])([0-3][0-9])(?![0-9])")

NAMUNA = {
    "DCIM/Camera/IMG_20260917_101500.jpg": b"toshkent-1",
    "DCIM/Camera/IMG_20260917_101501.jpg": b"toshkent-2",
    "DCIM/Camera/IMG_20260301_090000.JPG": b"navruz",
    "WhatsApp/Images/IMG-20260917-WA0001.jpg": b"toshkent-1",
    "Downloads/IMG_20260917_101500.jpg": b"boshqa-rasm-bir-xil-nom",
    "Downloads/screenshot.png": b"sanasiz",
    "Downloads/hujjat.pdf": b"pdf",
    "DCIM/.thumbnails/t1.jpg": b"kichik",
}


def xesh(yol: Path) -> str:
    return hashlib.sha256(yol.read_bytes()).hexdigest()


def bosh_nom(maqsad: Path, band: set[Path]) -> Path:
    nomzod, i = maqsad, 0
    while nomzod.exists() or nomzod in band:
        i += 1
        nomzod = maqsad.with_stem(f"{maqsad.stem}_{i}")
    return nomzod


def reja_tuz(manba: Path, natija: Path) -> list[tuple[Path, Path, str]]:
    reja, band, korilgan = [], set(), {}
    for fayl in sorted(manba.rglob("*")):
        if not fayl.is_file() or any(q.startswith(".") for q in fayl.relative_to(manba).parts):
            continue
        if fayl.suffix.lower() not in KENGAYTMALAR:
            continue
        mazmun = xesh(fayl)
        if mazmun in korilgan:
            maqsad = bosh_nom(natija / "takrorlar" / fayl.name, band)
            sabab = f"takror: {korilgan[mazmun].relative_to(manba).as_posix()}"
        else:
            korilgan[mazmun] = fayl
            topildi = SANA.search(fayl.name.replace("-", ""))
            katalog = natija / topildi[1] / topildi[2] if topildi else natija / "sanasiz"
            maqsad = bosh_nom(katalog / fayl.name.lower(), band)
            sabab = "sana" if topildi else "sana topilmadi"
        band.add(maqsad)
        reja.append((fayl, maqsad, sabab))
    return reja


def main() -> None:
    with tempfile.TemporaryDirectory() as vaqtinchalik:
        manba, natija = Path(vaqtinchalik) / "telefon", Path(vaqtinchalik) / "Rasmlar"
        for nisbiy, mazmun in NAMUNA.items():
            yol = manba / nisbiy
            yol.parent.mkdir(parents=True, exist_ok=True)
            yol.write_bytes(mazmun)

        print("=== 1. Quruq ishga tushirish (reja) ===")
        reja = reja_tuz(manba, natija)
        for fayl, maqsad, sabab in reja:
            print(f"  {fayl.relative_to(manba).as_posix():42} → {maqsad.relative_to(natija).as_posix():32} [{sabab}]")
        print(f"  hali hech narsa ko'chirilmadi: {not natija.exists()}")

        print("\n=== 2. Bajarish ===")
        for fayl, maqsad, _ in reja:
            maqsad.parent.mkdir(parents=True, exist_ok=True)
            fayl.move(maqsad)
        tuzilma = sorted(p.relative_to(natija).as_posix() for p in natija.rglob("*") if p.is_file())
        for yol in tuzilma:
            print(f"  {yol}")

        print("\n=== 3. Tekshiruvlar ===")
        qolganlar = sorted(p.relative_to(manba).as_posix() for p in manba.rglob("*") if p.is_file())
        print(f"  manbada qolganlar: {qolganlar}")
        print(f"  hech bir fayl yo'qolmadi: {len(tuzilma) + len(qolganlar) == len(NAMUNA)}")
        oylar = Counter(Path(y).parts[0] + "/" + Path(y).parts[1] for y in tuzilma if y[0].isdigit())
        print(f"  oylar bo'yicha: {dict(sorted(oylar.items()))}")
        nomlar = [Path(y).name for y in tuzilma]
        print(f"  to'qnashuv hal qilindi (_1 qo'shimchasi): {any('_1.' in n for n in nomlar)}")


if __name__ == "__main__":
    main()

=== 1. Quruq ishga tushirish (reja) ===
  DCIM/Camera/IMG_20260301_090000.JPG        → 2026/03/img_20260301_090000.jpg  [sana]
  DCIM/Camera/IMG_20260917_101500.jpg        → 2026/09/img_20260917_101500.jpg  [sana]
  DCIM/Camera/IMG_20260917_101501.jpg        → 2026/09/img_20260917_101501.jpg  [sana]
  Downloads/IMG_20260917_101500.jpg          → 2026/09/img_20260917_101500_1.jpg [sana]
  Downloads/screenshot.png                   → sanasiz/screenshot.png           [sana topilmadi]
  WhatsApp/Images/IMG-20260917-WA0001.jpg    → takrorlar/IMG-20260917-WA0001.jpg [takror: DCIM/Camera/IMG_20260917_101500.jpg]
  hali hech narsa ko'chirilmadi: True

=== 2. Bajarish ===
  2026/03/img_20260301_090000.jpg
  2026/09/img_20260917_101500.jpg
  2026/09/img_20260917_101500_1.jpg
  2026/09/img_20260917_101501.jpg
  sanasiz/screenshot.png
  takrorlar/IMG-20260917-WA0001.jpg

=== 3. Tekshiruvlar ===
  manbada qolganlar: ['DCIM/.thumbnails/t1.jpg', 'Downloads/hujjat.pdf']
  hech bir fayl yo'qolmadi: True
  oylar bo'yicha: {'2026/03': 1, '2026/09': 3}
  to'qnashuv hal qilindi (_1 qo'shimchasi): True

yol = katalog + "/" + nom                   # ❌
yol = Path(katalog) / nom                   # ✅

(YUKLASH / nom).write_bytes(malumot)        # ❌ path traversal
yol = (YUKLASH / nom).resolve()
if not yol.is_relative_to(YUKLASH.resolve()): raise PermissionError   # ✅

Path("izoh.txt").read_text()                # ⚠️ Windows'da cp1251
Path("izoh.txt").read_text(encoding="utf-8")   # ✅

nom.split(".")[0]                           # ❌ "arxiv.tar.gz", ".bashrc"
Path(nom).stem                              # ✅

open("config.toml")                         # ❌ joriy katalogga bog'liq
Path(__file__).resolve().parent / "config.toml"   # ✅

if not yol.exists(): yol.mkdir()            # ⚠️ TOCTOU
yol.mkdir(exist_ok=True)                    # ✅

baza.saqla(str(yol))                        # ⚠️ Windows'da "\"
baza.saqla(yol.relative_to(ildiz).as_posix())   # ✅

for f in ildiz.rglob("*"): ...              # ⚠️ .git, node_modules
for katalog, ichki, fayllar in ildiz.walk(): ichki[:] = [...]   # ✅

from pathlib import PurePosixPath as P
1.  print(P("a/b/c.txt").name)
2.  print(P("a/b/c.tar.gz").suffix)
3.  print(P("a/b/c.tar.gz").stem)
4.  print(P("a") / "/b")
5.  print(P("a/b").parent.parent)
6.  print(P("x.csv").with_suffix(".json"))
7.  print(P("/a/b/c").relative_to("/a"))
8.  print(P("/ab").is_relative_to("/a"))
9.  print(P(".env").suffix == "")
10. print(P("a/../b") == P("b"))
11. print(P("src/app.py").match("*.py"))
12. print(P("a/b/c").parts)

1.  def saqla(nom, malumot):
        yol = "/srv/yuklash/" + nom
        if yol.startswith("/srv/yuklash"):
            open(yol, "wb").write(malumot)

2.  def yangi_nom(fayl):
        return fayl.split(".")[0] + ".json"

3.  def sozlama():
        return open("config.toml").read()

4.  def barcha_py(ildiz):
        return list(Path(ildiz).rglob("*.py"))       # .venv ichidagilar kerak emas

5.  def zaxira(fayl):
        Path(fayl).rename(fayl + ".bak")            # .bak mavjud bo'lishi mumkin