Windows’ta Python ile Ses Sistemi Analizi: 5.1 mi Kullanıyorsun, Stereo mu? Sıfırdan İleri Seviyeye Tam Rehber

İçindekiler

1. Giriş
2. Python Nedir?
3. Python’u Windows’a Kurmak ve Doğrulamak
4. Neden Ses Sistemimi Python ile Analiz Edeyim?
5. sessistem.py Nedir, Ne İşe Yarar?
6. Python Dışında Ne Kurulmalı? (Gerekli Paketler)
7. Adım Adım Kurulum ve Çalıştırma (CMD Üzerinden)
8. Kodun Fonksiyon Fonksiyon Açıklaması
9. Örnek Çalıştırma ve Çıktının Yorumlanması
10. Üretilen Rapor Dosyaları (.txt / .json) Ne İşe Yarar
11. Sık Karşılaşılan Hatalar ve Çözümleri
12. Güvenlik ve Gizlilik Notu
13. Betiği Geliştirme Fikirleri
14. Sonuç
15. Ek: Tam Kaynak Kod (sessistem.py)

1. Giriş

Bilgisayarınızın ses kartını, sürücülerini ve hoparlör yapılandırmasını hiç merak ettiniz mi? “Şu an gerçekten 5.1 surround mu çalıyorum, yoksa oyun içindeki ayar boşuna mı 5.1 gösteriyor?” sorusuna kafanız takıldı mı? Windows’un Ses Ayarları menüsünde gezinip “Hoparlör Kurulumu” ekranına bakmak bir çözüm, ama bu bilgiyi tek bir ekranda, sürücü sürümüyle, aygıt durumuyla ve ses seviyesiyle birlikte görmek çok daha pratik.

Bu yazıda, tam olarak bunu yapan sessistem.py adında bir Python betiğini (script) baştan sona anlatacağım. Yazının sonunda:

• Python’un ne olduğunu ve nasıl çalıştığını temel örneklerle öğrenmiş olacaksınız,
• Bu betiğin Windows’un içindeki hangi mekanizmaları kullanarak ses donanımı hakkında bilgi topladığını satır satır anlayacaksınız,
• Kendi bilgisayarınızda bu betiği nasıl çalıştıracağınızı, hangi ek paketleri kurmanız gerektiğini ve komut satırında (cmd/PowerShell) hangi komutları yazmanız gerektiğini bileceksiniz,
• Karşılaşabileceğiniz hatalara karşı hazırlıklı olacaksınız.

Yazı, Python’a hiç dokunmamış birinin bile takip edebileceği şekilde en baştan başlıyor. Eğer Python’a zaten aşinaysanız 2. bölümü atlayıp doğrudan 4. bölümden devam edebilirsiniz. Bu, uzun ve kapsamlı bir teknik rehber niteliğinde; rahat bir kahve eşliğinde okuyabileceğiniz uzunlukta hazırlandı.

2. Python Nedir?

2.1 Kısaca Python

Python, 1991 yılında Guido van Rossum tarafından geliştirilmeye başlanan, “okunabilirlik” ilkesini merkezine koyan, yüksek seviyeli, yorumlamalı (interpreted) bir programlama dilidir. Diğer birçok dilde gördüğünüz süslü parantezler {} yerine Python girinti (indentation) kullanır; yani kodun görünümü, kodun mantığıyla doğrudan ilişkilidir. Bu da onu özellikle yeni başlayanlar için daha az göz yorucu, daha “insan diline yakın” hale getirir.

Python bugün:

• Veri bilimi ve yapay zekada (NumPy, Pandas, PyTorch, TensorFlow),
• Web geliştirmede (Django, Flask, FastAPI),
• Otomasyon ve script yazımında (tam da bu yazıda yaptığımız gibi),
• Sistem yönetimi ve DevOps’ta,
• Eğitimde (birçok üniversitenin ilk programlama dili olarak Python’u seçmesi),

yaygın olarak kullanılıyor. TIOBE ve Stack Overflow gibi endeksler yıllardır Python’u en popüler diller arasında ilk sıralarda gösteriyor.

2.2 Python Neden Bu Kadar Sevilir?

Birkaç somut sebep var:

• Basit sözdizimi: Bir işlemi yapmak için yazmanız gereken kod, C veya Java’ya göre çoğu zaman çok daha kısadır.
• “Piller dahil” (batteries included) felsefesi: Python’un standart kütüphanesi zaten dosya işlemleri, tarih/saat işlemleri, ağ işlemleri, JSON ayrıştırma gibi pek çok işi hazır olarak sunar. Az sonra göreceğimiz betikte json, os, re, sys, datetime, subprocess modüllerinin hepsi bu standart kütüphaneden geliyor — hiçbirini ayrıca kurmanıza gerek yok.
• Devasa paket ekosistemi (PyPI): İhtiyacınız olan hemen her şey için (ses, görüntü, ağ, veritabanı…) hazır bir paket zaten yazılmış ve pip ile tek satırda kurulabiliyor durumda.
• Platformlar arası çalışma: Aynı Python kodu (küçük uyarlamalarla) Windows, macOS ve Linux’ta çalışabilir.

2.3 Basit Örneklerle Python

Konuya hiç yabancıysanız, aşağıdaki birkaç örnek Python’un mantığını birkaç dakikada kavramanızı sağlayacak.

Merhaba Dünya:

print("Merhaba Dünya")

Bu tek satır, ekrana “Merhaba Dünya” yazdırır. print() fonksiyonu, parantez içine verdiğiniz her şeyi konsola basar.

Değişkenler:

isim = "Ahmet"
yas = 28
boy = 1.82

print(f"{isim} isimli kişi {yas} yaşında ve {boy} metre boyunda.")

Burada isim, yas ve boy birer değişkendir. Python’da değişken tanımlarken tür belirtmeniz gerekmez (int isim = ... gibi bir şey yazmazsınız); Python değeri görüp türünü kendisi anlar. Metin içine değişken gömmek için kullanılan f"..." yapısına f-string denir ve sessistem.py içinde onlarca kez kullanılmıştır.

Listeler ve döngüler:

aygitlar = ["Realtek Ses Kartı", "AMD HD Audio", "USB Ses Aygıtı"]

for aygit in aygitlar:
    print(f"Bulunan aygıt: {aygit}")

for döngüsü, bir liste (list) içindeki her öğeyi tek tek gezer. sessistem.py da tam olarak bunu yapıyor: WMI’dan gelen aygıt listesini tek tek gezip her biri için bilgi yazdırıyor.

Fonksiyonlar:

def kare_al(sayi):
    return sayi * sayi

sonuc = kare_al(5)
print(sonuc)  # 25 yazar

def anahtar kelimesiyle kendi fonksiyonlarınızı tanımlarsınız. Bir fonksiyon, tekrar tekrar kullanacağınız bir işlemi tek bir isim altında paketler. sessistem.py da ses_aygitlari(), surucu_bilgisi(), kanal_bilgisi_sounddevice() gibi her biri belirli bir işi yapan fonksiyonlardan oluşuyor.

Modül (kütüphane) içe aktarma — import:

import json

veri = {"ad": "Hoparlör", "kanal": 6}
metin = json.dumps(veri)
print(metin)  # {"ad": "Hoparlör", "kanal": 6}

import json satırı, Python’un standart kütüphanesindeki json modülünü koda dahil eder ve artık json.dumps(), json.loads() gibi fonksiyonları kullanabilirsiniz. Az sonra göreceğiniz gibi, harici bir paket kurmanıza gerek kalmadan JSON verisiyle çalışabiliyoruz — çünkü json Python’un içinde hazır geliyor.

Hata yönetimi — try/except:

try:
    sonuc = 10 / 0
except ZeroDivisionError as hata:
    print(f"Bir hata oluştu: {hata}")

try bloğu içindeki kod çalıştırılmaya çalışılır; bir hata oluşursa program çökmez, except bloğuna düşer ve orada tanımladığınız şekilde hatayı yönetirsiniz. sessistem.py, donanım her bilgisayarda farklı olabileceği için (örneğin bazı bilgisayarlarda mikrofon hiç yoktur) bu yapıyı yoğun şekilde kullanır: bir bilgi okunamazsa program çökmek yerine kullanıcıya nazik bir açıklama gösterir.

2.4 pip Nedir? Paket (Kütüphane) Kavramı

Python’u kurduğunuzda standart kütüphane gelir ama bazen ihtiyacınız olan işlevsellik standart kütüphanede yoktur. Örneğin “bilgisayarın ses kartlarını listele” gibi bir işlev Python’un temelinde bulunmaz, çünkü bu işletim sistemine özgü, oldukça özelleşmiş bir konudur.

İşte tam burada devreye pip girer. pip, Python ile birlikte gelen resmi paket yöneticisidir. PyPI (Python Package Index) adı verilen, dünya çapında geliştiricilerin paylaştığı milyonlarca hazır paketin bulunduğu bir depodan istediğiniz paketi indirip kurmanızı sağlar:

pip install paket_adi

Bu yazıda kuracağımız sounddevice, pycaw ve comtypes paketleri de PyPI üzerinden pip ile kurulacak. Bir paketi kurduktan sonra, kodunuzda import paket_adi diyerek o paketin sunduğu işlevleri kullanmaya başlayabilirsiniz.

3. Python’u Windows’a Kurmak ve Doğrulamak

Eğer bilgisayarınızda Python zaten kuruluysa (bu betiği daha önce çalıştırabildiyseniz muhtemelen kuruludur) bu bölümü atlayabilirsiniz. Yine de eksiksiz olması için kısaca özetleyelim:

1. Tarayıcınızdan python.org/downloads adresine gidip Windows için en güncel Python sürümünü indirin.
2. Kurulum sihirbazını başlattığınızda ekranın altındaki “Add Python to PATH” kutucuğunu mutlaka işaretleyin. Bu adım atlanırsa cmd‘de python yazdığınızda “tanınmayan komut” hatası alırsınız.
3. Kurulumu tamamlayın.
4. Kurulumu doğrulamak için cmd (Komut İstemi) veya PowerShell açıp şu komutları yazın:

python --version
pip --version

Her iki komut da bir sürüm numarası döndürüyorsa (örneğin Python 3.14.6 ve pip 24.x) kurulum başarılı demektir ve devam edebilirsiniz.

Not: Bazı sistemlerde python yerine py komutu kullanılır (Python Launcher). İkisi de aynı işi görür; hangisi sizde çalışıyorsa onu kullanabilirsiniz.

4. Neden Ses Sistemimi Python ile Analiz Edeyim?

Windows’un kendi Ses Ayarları ekranı elbette bazı bilgileri gösterir, ama dağınıktır ve teknik detayları saklar:

• Hangi ses kartının hangi sürücü sürümünü kullandığını görmek için Aygıt Yöneticisi’nde birkaç tık daha gerekir.
• “5.1 Surround” seçili görünse bile, gerçekte Windows’un ses motorunun (audio engine) o anda kaç kanal üzerinden ses gönderdiğini (aktif mix format) tek bakışta göremezsiniz.
• Birden fazla ses kartınız/hoparlörünüz varsa (dahili Realtek, ekran kartı HDMI/DisplayPort sesi, USB kulaklık gibi) hangisinin şu an aktif/varsayılan olduğunu, hangilerinin devre dışı olduğunu bir arada görmek zahmetlidir.
• Sürücü tarihini, üreticisini, INF dosyasını görmek için birden fazla pencere açıp kapatmanız gerekir.

Bir Python betiği yazarak bütün bu bilgiyi tek bir komutla, tek bir ekranda, hatta kalıcı bir dosyada toplayabiliriz. Üstelik bu, ileride “geçen hafta ses kartım böyle değildi, ne değişmiş” diyebileceğiniz zaman damgalı kayıtlar oluşturmamızı da sağlar.

5. sessistem.py Nedir, Ne İşe Yarar?

sessistem.py, Windows üzerinde çalışan, ekstra kurulum dışında hiçbir yapılandırma gerektirmeyen, komut satırından çalıştırılan bir Python betiğidir. Çalıştırıldığında sırasıyla şu 7 bölümü üretir:

1. Ses Aygıtları (WMI) — Windows’un donanım yönetim arayüzü (WMI/CIM) üzerinden sistemdeki ses kartlarının adı, üreticisi ve durumu.
2. Ses Sürücüleri (Driver) — Ses ile ilgili tüm sürücülerin sürüm numarası, tarihi, üreticisi ve INF dosyası.
3. Hoparlör Kanal Sayısı (sounddevice) — Varsayılan çıkış aygıtının donanımsal olarak desteklediği maksimum kanal sayısı (2, 6, 8…).
4. Varsayılan Aygıt Aktif Formatı (pycaw) — Windows ses motorunun şu an gerçekten kaç kanal, kaç Hz ve kaç bit ile çalıştığı.
5. Gerçek Hoparlör Yapılandırması — Windows Ses Ayarları’nda seçtiğiniz gerçek fiziksel düzen (Stereo / 5.1 arka hoparlörlü / 5.1 yan hoparlörlü / 7.1 gibi), doğrudan Windows’un kendi ayar deposundan okunur. Bu, “5.1 mi kullanıyorum” sorusunun en güvenilir cevabıdır.
6. Ses Seviyesi ve Sessize Alma Durumu — Hem varsayılan hoparlörün hem varsayılan mikrofonun ses yüzdesi ve sessiz olup olmadığı.
7. Tüm Ses Aygıtları — Sadece varsayılan aygıt değil, sistemde tanımlı tüm oynatma ve kayıt aygıtlarının aktif/devre dışı/bağlı değil durumları.

Son olarak betik, bütün bu çıktıyı ekrana bastığı gibi, kendi bulunduğu klasöre zaman damgalı bir .txt (insan tarafından okunabilir) ve bir .json (program tarafından işlenebilir, yapılandırılmış) rapor dosyası olarak da kaydeder.

Özetle: “Şu an ne kullanıyorum, sürücülerim güncel mi, aygıtım hangi ses düzenine ayarlı” sorularının hepsine tek komutla cevap veren bir teşhis (diagnostic) aracı.

6. Python Dışında Ne Kurulmalı? (Gerekli Paketler)

Betiğin bazı bölümleri Python’un standart kütüphanesiyle (ekstra kurulum gerekmeden) çalışır, bazıları ise PyPI’dan kurulması gereken ek paketlere ihtiyaç duyar. Bunları netleştirelim:

6.1 Ekstra kuruluma ihtiyaç duymayanlar (Python ile hazır gelir)

Bunların hiçbirini pip install ile kurmanıza gerek yoktur; Python kurulumunuzla birlikte otomatik olarak gelirler.

6.2 Ayrıca kurmanız gereken paketler

pycaw ve sounddevice kurulduğunda, bunların da ihtiyaç duyduğu birkaç küçük yardımcı paket (cffi, psutil, pycparser) otomatik olarak pip tarafından kurulur; bunlar için ayrıca bir şey yapmanıza gerek yoktur.

6.3 Tek komutla hepsini kurmak

Üç paketi de tek seferde kurmak için:

pip install sounddevice pycaw comtypes

yazmanız yeterlidir. Bu paketler kurulu değilse betik çökmez; ilgili bölüm için “Bu bölüm için X paketi gerekli, kurmak için: pip install X” şeklinde bilgilendirici bir mesaj gösterir ve diğer bölümlere devam eder. Yani betiği paketler kurulu olmadan da çalıştırabilirsiniz — sadece bazı bölümler eksik kalır.

6.4 PowerShell ve WMI için ayrıca bir şey kurmanıza gerek var mı?

Hayır. sessistem.py, ses aygıtları ve sürücü bilgisi için Windows’ta zaten yerleşik olarak bulunan PowerShell ve WMI (Windows Management Instrumentation) altyapısını kullanır. Betik, Python içinden subprocess modülüyle arka planda bir PowerShell komutu çalıştırıp sonucu JSON formatında geri alır. Bu, Windows 10 ve Windows 11’de ekstra kurulum gerektirmeden hazır çalışır.

7. Adım Adım Kurulum ve Çalıştırma (CMD Üzerinden)

Şimdi işin pratiğine geçelim. Aşağıdaki adımları sırasıyla takip ederek betiği kendi bilgisayarınızda çalıştırabilirsiniz.

Adım 1 — Dosyanın nerede olduğunu belirleyin.
sessistem.py dosyasını bir klasöre koyun; örneğin: C:\Users\KullaniciAdi\Desktop\ses sistem\sessistem.py

Adım 2 — Komut istemini (cmd) veya PowerShell’i açın.
Windows’ta Başlat menüsüne “cmd” yazıp Enter’a basmanız yeterli. PowerShell için de aynı şekilde “PowerShell” yazabilirsiniz — bu betik ikisinde de aynı şekilde çalışır.

Adım 3 — İlgili klasöre gidin (cd komutu).

cd "C:\Users\KullaniciAdi\Desktop\ses sistem"

Klasör adında boşluk olduğu için yolu çift tırnak içine almayı unutmayın.

Adım 4 — Python’un kurulu olduğunu doğrulayın.

python --version

Adım 5 — Gerekli paketleri kurun.

pip install sounddevice pycaw comtypes

Bu komut internetten ilgili paketleri indirip kuracak; birkaç saniye ile bir dakika arasında sürebilir. “Successfully installed …” satırını gördüğünüzde kurulum tamamlanmış demektir.

Adım 6 — Betiği çalıştırın.

python sessistem.py

veya dosya yolunu doğrudan belirterek:

python ".\sessistem.py"

Bu kadar. Birkaç saniye içinde ekranda yukarıda anlatılan 7 bölümün çıktısını, en altta da oluşturulan rapor dosyalarının tam yolunu göreceksiniz.

Adım 7 — Oluşan raporları inceleyin.
Betiğin bulunduğu klasörde ses_raporu_20260727_215718.txt ve ses_raporu_20260727_215718.json gibi (tarih/saat sizin çalıştırdığınız ana göre değişir) iki yeni dosya oluşacaktır. .txt dosyasını Not Defteri ile, .json dosyasını ise VS Code gibi bir düzenleyiciyle veya tarayıcıda açarak inceleyebilirsiniz.

Not: Betiği her çalıştırdığınızda yeni bir zaman damgalı çift dosya oluşur; eski raporlar silinmez, üzerine yazılmaz. Zamanla klasörde birikirse istemediklerinizi elle silebilirsiniz.

8. Kodun Fonksiyon Fonksiyon Açıklaması

Betiğin tamamını en sonda bulacaksınız; burada her fonksiyonun ne yaptığını, neden o şekilde yazıldığını açıklıyorum.

8.1 yaz() ve baslik() — Çıktıyı hem ekrana basmak hem saklamak

SATIRLAR = []

def yaz(metin: str = ""):
    print(metin)
    SATIRLAR.append(metin)

Betiğin en can alıcı numaralarından biri burada gizli: Her satırı sadece print() ile ekrana basmak yerine, aynı zamanda SATIRLAR adlı bir listeye de ekliyoruz. Böylece program sonunda bu listeyi birleştirip bir .txt dosyasına yazabiliyoruz — yani ekrana ne basıldıysa dosyaya da birebir aynısı kaydediliyor. baslik() fonksiyonu ise sadece görsel olarak bölüm başlıklarını ==== çizgileriyle çerçeveliyor.

8.2 run_powershell() — Python’dan Windows’a komut göndermek

def run_powershell(command: str):
    encoding_ayari = (
        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
        "$OutputEncoding = [System.Text.Encoding]::UTF8; "
    )
    result = subprocess.run(
        ["powershell", "-NoProfile", "-NonInteractive", "-Command", encoding_ayari + command],
        capture_output=True, encoding="utf-8"
    )
    ...
    return json.loads(result.stdout)

Python’un kendisinde “sistemdeki ses kartlarını listele” gibi bir fonksiyon yoktur; bu bilgi Windows’un WMI altyapısında saklanır ve normalde PowerShell ile sorgulanır. Bu fonksiyon, Python içinden bir PowerShell penceresi açmadan, arka planda bir PowerShell komutu çalıştırır (subprocess.run) ve sonucu yakalar.

Burada dikkat edilmesi gereken önemli bir detay var: Türkçe karakterlerin bozulmaması. PowerShell’in konsol çıktısı varsayılan olarak Türkçe Windows’ta UTF-8 olmayabilir; bu da “Üretici” gibi kelimelerin “Ãœretici” gibi bozuk görünmesine yol açar (buna teknik olarak mojibake denir). Bu yüzden komutun başına [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 satırını ekleyerek PowerShell’e çıktısını UTF-8 olarak vermesini açıkça söylüyoruz. Bu satır olmadan raporda “USB Ses Aygıtı” gibi bozuk metinler görürdünüz.

PowerShell’den gelen ham metin JSON formatında istenir (ConvertTo-Json ile), çünkü JSON hem insan hem Python için okunması kolay, yapılandırılmış bir formattır. json.loads() bu metni doğrudan bir Python sözlüğüne (dictionary) veya listeye çevirir.

8.3 ses_aygitlari() — WMI’dan ses kartı listesi

veri = run_powershell(
    "Get-CimInstance Win32_SoundDevice | "
    "Select-Object Name,Manufacturer,Status,DeviceID | ConvertTo-Json"
)

Win32_SoundDevice, Windows’un WMI veritabanında ses donanımlarını temsil eden standart sınıftır. Bu sorgu, sistemdeki her ses kartının adını, üreticisini, çalışma durumunu (OK, Error vb.) ve benzersiz aygıt kimliğini getirir. Fonksiyon bu veriyi hem ekrana basar hem de JSON rapor için RAPOR_VERI sözlüğüne kaydeder.

8.4 surucu_bilgisi() — Sürücü sürümü, tarihi, üreticisi

veri = run_powershell(
    "Get-CimInstance Win32_PnPSignedDriver | "
    "Where-Object { $_.DeviceClass -eq 'MEDIA' } | "
    "Select-Object DeviceName,DriverVersion,DriverDate,Manufacturer,InfName "
    "| ConvertTo-Json"
)

Win32_PnPSignedDriver, sisteme kurulu tüm imzalı (signed) sürücüleri listeler; DeviceClass -eq 'MEDIA' filtresiyle bunlar arasından sadece ses/medya sürücülerini seçiyoruz. Burada ilginç bir detay: WMI’dan gelen tarih bilgisi /Date(1629763200000)/ gibi tuhaf bir formatta gelir (bu, Unix zaman damgasının milisaniye cinsinden, JavaScript tarih formatına gömülmüş halidir). Kod, re.search(r"\d+", tarih) ile bu sayıyı ayıklayıp datetime.datetime.fromtimestamp() ile okunabilir bir tarihe (2021-08-24 gibi) çeviriyor.

8.5 kanal_bilgisi_sounddevice() — Donanımın desteklediği maksimum kanal

import sounddevice as sd
varsayilan_cikis = sd.default.device[1]
aygitlar = sd.query_devices()
cikis_aygiti = aygitlar[varsayilan_cikis]
kanal = cikis_aygiti.get('max_output_channels')

sounddevice paketi, işletim sisteminin ses altyapısıyla (Windows’ta WASAPI/MME/DirectSound) konuşarak her aygıtın teorik olarak kaç kanala kadar ses gönderebileceğini raporlar. max_output_channels değeri 6 ise, bu aygıt fiziksel olarak 5.1 (6 kanal) sesi taşıyabilecek kapasitede demektir. Ama dikkat: Bu, “şu an aktif olarak 5.1 çalıyor” anlamına gelmez, sadece “6 kanala kadar destekler” anlamına gelir. Gerçek aktif format için bir sonraki bölüme bakmak gerekir — kod da bunu kullanıcıya açıkça not olarak belirtiyor.

8.6 mix_format_pycaw() — Windows’un o an gerçekten kullandığı format

from pycaw.pycaw import AudioUtilities, IAudioClient
from comtypes import CLSCTX_ALL

speakers = AudioUtilities.GetSpeakers()
cihaz = getattr(speakers, "_dev", speakers)
interface = cihaz.Activate(IAudioClient._iid_, CLSCTX_ALL, None)
audio_client = interface.QueryInterface(IAudioClient)
mix_format = audio_client.GetMixFormat()
kanal = mix_format.contents.nChannels

Burada işler biraz daha derinleşiyor. Windows’un ses motoru (audio engine), bütün uygulamalardan gelen sesleri karıştırıp (mix) tek bir formatta hoparlöre gönderir; buna mix format denir. IAudioClient.GetMixFormat(), Windows Core Audio API’sinin sunduğu düşük seviyeli bir fonksiyondur ve bu karışım formatının kanal sayısını, örnekleme hızını (Hz) ve bit derinliğini döndürür. pycaw, bu C++ tabanlı Windows arayüzünü Python’dan çağırmamızı sağlayan köprüdür.

Kısacası: sounddevice bölümü “bu aygıt en fazla neye ulaşabilir” sorusunu, bu bölüm ise “Windows şu an fiilen kaç kanal kullanıyor” sorusunu cevaplıyor. İkisinin de 6 çıkması, gerçekten 5.1 formatında ses gönderildiğine dair güçlü bir işarettir.

8.7 fiziksel_hoparlor_yapisi() — En kesin cevap: Windows Ses Ayarları’ndaki gerçek seçim

Bu, betiğin en teknik ve aynı zamanda en güvenilir bölümü. Windows, her ses aygıtı için PKEY_AudioEndpoint_PhysicalSpeakers adında özel bir ayar tutar. Bu ayar, sizin Ses Ayarları > Aygıt Özellikleri > “Hoparlör Kurulumu” penceresinde elle seçtiğiniz düzeni (Stereo, 5.1 Surround, 7.1 Surround, arka hoparlörlü mü yan hoparlörlü mü…) bir bit maskesi (channel mask) olarak saklar.

FIZIKSEL_ANAHTAR = "{1DA5D803-D492-4EDD-8C23-E0C0FFEE7F0E} 3"

speakers = AudioUtilities.GetSpeakers()
ozellikler = speakers.properties
mask = ozellikler.get(FIZIKSEL_ANAHTAR)

{1DA5D803-D492-4EDD-8C23-E0C0FFEE7F0E} Windows’un bu özelliği tanımlamak için kullandığı sabit bir GUID’dir (evrensel benzersiz kimlik); sondaki 3 ise o GUID altındaki “PhysicalSpeakers” alt-özelliğinin sıra numarasıdır. pycaw, bir ses aygıtının tüm özelliklerini .properties adlı bir sözlük olarak sunduğu için bu anahtarla doğrudan değeri okuyabiliyoruz.

Peki bu sayı ne anlama geliyor? Windows, her hoparlör konumuna bir bit atar:

Bu bitler bir araya gelip (OR işlemiyle) tek bir sayı oluşturur. Örneğin 1551 sayısı onaltılık tabanda 0x60F‘tir ve bunu ikili tabanda açtığınızda 0x1 | 0x2 | 0x4 | 0x8 | 0x200 | 0x400 bitlerinin aktif olduğunu görürsünüz — yani Ön Sol, Ön Sağ, Ön Orta, Subwoofer, Yan Sol, Yan Sağ. Bu tam olarak “5.1 Surround (yan hoparlörlü)” düzenine karşılık gelir; Windows’un iç kaynak kodlarında bu sabite KSAUDIO_SPEAKER_5POINT1_SURROUND adı verilir.

Kodda bu mantık iki parçaya ayrılmış durumda:

BILINEN_YAPILAR = {
    0x3: "Stereo (2.0)",
    0x3F: "5.1 Surround (arka hoparlörlü)",
    0x60F: "5.1 Surround (yan hoparlörlü)",
    0x63F: "7.1 Surround (yan + arka hoparlörlü)",
    ...
}

Sık karşılaşılan maskeler için doğrudan hazır, okunabilir bir isim tanımlanmış. Eğer sayı bu tabloda yoksa, kanal_maskesini_yorumla() fonksiyonu bitleri tek tek kontrol edip hangi hoparlör konumlarının aktif olduğunu listeler — yani daha önce hiç görülmemiş, egzotik bir hoparlör düzeni bile anlamlı bir açıklamayla raporlanır.

Bu bölümün önemi şurada: sounddevice ve mix format bölümleri size “kaç kanal” bilgisini verirken, bu bölüm size hangi fiziksel düzenin (arka mı yan mı hoparlörlü 5.1, klasik mi yoksa yeni tip 7.1) seçili olduğunu tam olarak söyler. İki farklı 5.1 kurulumu aynı kanal sayısına (6) sahip olabilir ama fiziksel yerleşimleri farklıdır; bunu ayırt edebilen tek bölüm burasıdır.

8.8 ses_seviyesi_ve_sessiz() — Ses seviyesi yüzdesi ve sessize alma

hoparlor = AudioUtilities.GetSpeakers()
ev = hoparlor.EndpointVolume
yuzde = round(ev.GetMasterVolumeLevelScalar() * 100)
sessiz = bool(ev.GetMute())

IAudioEndpointVolume arayüzü, bir ses aygıtının ana ses seviyesini 0.0 ile 1.0 arasında bir ondalık sayı olarak (GetMasterVolumeLevelScalar) ve sessize alınıp alınmadığını True/False olarak (GetMute) döndürür. Kod bunu yüzdeye çevirip (* 100) okunabilir hale getiriyor. Aynı mantık, varsayılan mikrofon için de tekrarlanıyor; tek fark, pycaw‘ın GetMicrophone() fonksiyonunun ham bir COM nesnesi döndürmesi ve bunu AudioUtilities.CreateDevice(...) ile “sarmalamamız” (wrap etmemiz) gerekmesi — aksi halde EndpointVolume özelliğine erişilemiyor.

8.9 tum_ses_aygitlari_pycaw() — Sadece varsayılan değil, hepsi

aygitlar = AudioUtilities.GetAllDevices()
for aygit in aygitlar:
    durum = str(aygit.state).replace("AudioDeviceState.", "")
    if durum == "NotPresent":
        continue
    yon = AudioUtilities.GetEndpointDataFlow(aygit.id)

GetAllDevices(), sisteme şu ana kadar tanınmış (bir kere bile takılmış) tüm ses uç noktalarını döndürür — Realtek’in dijital çıkışından tutun da hiç kullanmadığınız hat girişine kadar. Bunların çoğu NotPresent (asla fiziksel olarak var olmamış/kayıtlı ama bağlı değil) durumdadır ve raporu gereksiz yere kalabalıklaştırır; bu yüzden kod bunları eliyor ve sadece Active (aktif), Disabled (devre dışı bırakılmış) veya Unplugged (kayıtlı ama şu an takılı değil) olanları gösteriyor. GetEndpointDataFlow() ise her aygıtın oynatma (eRender) mı yoksa kayıt (eCapture) aygıtı mı olduğunu söyleyerek listeyi iki ayrı gruba (hoparlör/kulaklıklar ve mikrofonlar) ayırmamızı sağlıyor.

8.10 rapor_kaydet() — Kalıcı rapor dosyaları oluşturma

zaman = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
txt_yolu = os.path.join(dizin, f"ses_raporu_{zaman}.txt")
with open(txt_yolu, "w", encoding="utf-8") as f:
    f.write("\n".join(SATIRLAR))

json_yolu = os.path.join(dizin, f"ses_raporu_{zaman}.json")
with open(json_yolu, "w", encoding="utf-8") as f:
    json.dump(RAPOR_VERI, f, ensure_ascii=False, indent=2, default=str)

Program çalışırken topladığı tüm ekran çıktısı (SATIRLAR listesi) ve yapılandırılmış veri (RAPOR_VERI sözlüğü), betiğin çalıştığı klasöre, o anki tarih ve saat damgasıyla (20260727_215718 gibi) iki ayrı dosya olarak kaydediliyor. .txt dosyası insan okuması için, .json dosyası ise ileride başka bir programın (örneğin bir Excel raporu, bir web paneli veya farklı bir Python betiği) bu veriyi otomatik işlemesi için tasarlandı. encoding="utf-8" burada da Türkçe karakterlerin bozulmadan diske yazılmasını garanti ediyor.

9. Örnek Çalıştırma ve Çıktının Yorumlanması

Betiği çalıştırdığınızda göreceğiniz çıktı, sisteminize göre değişir; ama örneğin bir USB oyuncu kulaklığı/hoparlörü (SteelSeries Arena 9) varsayılan aygıt olarak ayarlanmış bir sistemde şöyle bir sonuç alınabiliyor:

HOPARLÖR KANAL SAYISI (sounddevice)
Varsayılan çıkış aygıtı  : Hoparlör (SteelSeries Arena 9)
Maksimum çıkış kanalı    : 6
Olası yapılandırma       : 5.1 Surround (6 kanal)

VARSAYILAN AYGIT AKTİF FORMATI (pycaw)
Aktif kanal sayısı : 6
Örnekleme hızı     : 48000 Hz
Sonuç: Şu an 5.1 Surround kullanılıyor

GERÇEK HOPARLÖR YAPILANDIRMASI (Windows Ses Ayarları)
Kanal maskesi      : 1551 (0x60F)
Windows'a göre yapı: 5.1 Surround (yan hoparlörlü)

Bu üç bölümün birbirini doğrulaması önemlidir: Aygıt donanımsal olarak 6 kanalı destekliyor, Windows’un ses motoru fiilen 6 kanal üzerinden ses gönderiyor ve Windows Ses Ayarları’ndaki kayıtlı tercih de “5.1 Surround (yan hoparlörlü)” — yani üç ayrı kaynak da aynı sonuca işaret ediyor: Bu sistemde gerçekten 5.1 surround aktif. Eğer bu üç değer birbiriyle çelişseydi (örneğin donanım 6 kanal destekliyor ama aktif format 2 kanal gösteriyorsa), bu, Windows’un o anda stereo modda çalıştığının, yani 5.1 potansiyelin kullanılmadığının bir işareti olurdu.

10. Üretilen Rapor Dosyaları (.txt / .json) Ne İşe Yarar

Betiğin ürettiği iki dosyanın da kendine özgü kullanım alanları var:

• .txt dosyası: İnsan okuması için hazırlanmıştır. Bir teknik destek talebinde (“ses kartım şu problemi veriyor, işte sistem raporum”) doğrudan e-postaya veya forum mesajına yapıştırılabilir.
• .json dosyası: Programatik işleme için hazırlanmıştır. Örneğin ileride bu raporları zaman içinde karşılaştıran, sürücü güncellemesi sonrası neyin değiştiğini otomatik tespit eden başka bir Python betiği yazmak isterseniz, veriyi tekrar ayrıştırmakla uğraşmadan doğrudan json.load() ile okuyabilirsiniz.

Her çalıştırmada dosya adına eklenen zaman damgası sayesinde eski raporların üzerine yazılmaz; böylece “geçen ayki rapor” ile “bugünkü rapor”u yan yana koyup karşılaştırabilirsiniz.

11. Sık Karşılaşılan Hatalar ve Çözümleri

“‘python’ iç ya da dış komut… olarak tanınmıyor” hatası
Python kurulurken “Add Python to PATH” kutucuğu işaretlenmemiş demektir. Python’u python.org’dan tekrar kurup bu kutucuğu işaretleyin, ya da py komutunu deneyin.

“ModuleNotFoundError: No module named ‘sounddevice'” (veya pycaw/comtypes)
İlgili paket kurulu değil demektir. pip install sounddevice pycaw comtypes komutunu çalıştırın. Not: Betiğin kendisi bu hatayı zaten yakalayıp size kurulum komutunu öneren bir mesaj gösterecek şekilde tasarlandı; program çökmez.

Türkçe karakterlerin bozuk görünmesi (“Ãœretici” gibi)
Betiğin güncel sürümü bu sorunu PowerShell çıktısını UTF-8’e zorlayarak (bkz. Bölüm 8.2) zaten çözüyor. Yine de bozukluk görürseniz, konsolunuzun kod sayfasını chcp 65001 komutuyla UTF-8’e çevirip tekrar deneyebilirsiniz.

“Aktif format okunamadı: ‘AudioDevice’ object has no attribute ‘Activate'”
Bu, pycaw kütüphanesinin farklı sürümlerinde GetSpeakers() fonksiyonunun bazen ham bir COM nesnesi, bazen de sarmalanmış (wrapped) bir nesne döndürmesinden kaynaklanır. Kod bunu getattr(speakers, "_dev", speakers) satırıyla otomatik olarak ele alıyor; yine de çok eski veya çok yeni bir pycaw sürümüyle karşılaşırsanız pip install --upgrade pycaw ile güncellemeyi deneyin.

pip çok yavaş veya paket indirilemiyor
İnternet bağlantınızı kontrol edin; kurumsal ağlarda proxy ayarları pip‘in PyPI’ya erişimini engelleyebilir.

Mikrofon veya hoparlör bölümü boş geliyor
Bilgisayarınızda o an aktif bir varsayılan mikrofon/hoparlör tanımlı değilse (örneğin tüm ses aygıtları devre dışı bırakılmışsa) bu bölümler bir hata mesajıyla atlanır; bu normal bir davranıştır, programın bir hatası değildir.

12. Güvenlik ve Gizlilik Notu

Bu betik tamamen yerel çalışır: Hiçbir veri internete gönderilmez, hiçbir dış sunucuya bağlantı kurulmaz. Kullanılan tüm API’ler (WMI, PowerShell, Windows Core Audio / WASAPI) işletim sisteminizin kendi iç arayüzleridir ve sadece donanım/sürücü/ses ayarı bilgisi okurlar — hiçbir kişisel veya hassas veriye (dosyalarınız, tarayıcı geçmişiniz, şifreleriniz vb.) erişilmez. Ürettiği tek çıktı, kendi bilgisayarınızda oluşturduğu .txt ve .json dosyalarıdır; bunları paylaşıp paylaşmamak tamamen sizin kontrolünüzdedir.

13. Betiği Geliştirme Fikirleri

Bu betik bir başlangıç noktası; isterseniz üzerine şunları ekleyebilirsiniz:

• Sürekli izleme modu: Aygıt takıldığında/çıkarıldığında veya format değiştiğinde otomatik uyarı veren bir arka plan servisi.
• Grafik arayüz (GUI): tkinter veya PyQt ile komut satırı yerine tıklanabilir bir pencere.
• Geçmiş karşılaştırması: Önceki .json raporlarını okuyup “sürücü sürümü değişti mi, hoparlör düzeni değişti mi” gibi farkları otomatik tespit eden bir mod.
• E-posta/Bildirim entegrasyonu: Sürücü tarihi çok eskiyse otomatik hatırlatma göndermek.
• Çoklu dil desteği: Raporu İngilizce/Türkçe seçilebilir hale getirmek.

14. Sonuç

Bu yazıda, Python’un ne olduğundan başlayıp, Windows’un WMI, PowerShell ve Core Audio (WASAPI) altyapılarını Python ile nasıl sorgulayabileceğinizi, hangi ek paketlerin (sounddevice, pycaw, comtypes) gerektiğini ve bunları pip ile nasıl kuracağınızı, betiği cmd/PowerShell üzerinden adım adım nasıl çalıştıracağınızı ve kodun her satırının ne işe yaradığını ayrıntılı olarak ele aldık. Artık kendi bilgisayarınızda “gerçekten 5.1 mü kullanıyorum, stereo mu” sorusuna Windows menülerinde kaybolmadan, tek bir komutla ve teknik olarak sağlam bir cevap verebilirsiniz.

Betiği kendi ihtiyaçlarınıza göre uyarlamaktan çekinmeyin — kaynak kod aşağıda, kopyalayıp doğrudan kullanabilirsiniz.

15. Ek: Tam Kaynak Kod (sessistem.py)

Aşağıdaki kodu kopyalayıp sessistem.py adıyla bir dosyaya kaydedip yukarıdaki adımları izleyerek çalıştırabilirsiniz.

"""Windows ses sistemi, ses sürücüleri, hoparlör yapılandırması ve ses seviyesi raporu."""

import json
import os
import re
import sys
import datetime
import subprocess

SATIRLAR = []          # Konsola basılan her satır, dosyaya kaydetmek için burada da tutulur.
RAPOR_VERI = {}         # JSON çıktısı için yapılandırılmış veriler.


def yaz(metin: str = ""):
    print(metin)
    SATIRLAR.append(metin)


def baslik(metin: str):
    yaz("\n" + "=" * 60)
    yaz(metin)
    yaz("=" * 60)


def run_powershell(command: str):
    encoding_ayari = (
        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
        "$OutputEncoding = [System.Text.Encoding]::UTF8; "
    )
    result = subprocess.run(
        ["powershell", "-NoProfile", "-NonInteractive", "-Command", encoding_ayari + command],
        capture_output=True, encoding="utf-8"
    )
    if result.returncode != 0 or not result.stdout.strip():
        return None
    try:
        return json.loads(result.stdout)
    except json.JSONDecodeError:
        return None


def ses_aygitlari():
    baslik("SES AYGITLARI (Windows / WMI)")
    veri = run_powershell(
        "Get-CimInstance Win32_SoundDevice | "
        "Select-Object Name,Manufacturer,Status,DeviceID | ConvertTo-Json"
    )
    if not veri:
        yaz("Aygıt bilgisi alınamadı.")
        return
    if isinstance(veri, dict):
        veri = [veri]
    RAPOR_VERI["ses_aygitlari"] = veri
    for aygit in veri:
        yaz(f"- Ad       : {aygit.get('Name')}")
        yaz(f"  Üretici  : {aygit.get('Manufacturer')}")
        yaz(f"  Durum    : {aygit.get('Status')}")
        yaz(f"  Aygıt ID : {aygit.get('DeviceID')}")
        yaz()


def surucu_bilgisi():
    baslik("SES SÜRÜCÜLERİ (Driver)")
    veri = run_powershell(
        "Get-CimInstance Win32_PnPSignedDriver | "
        "Where-Object { $_.DeviceClass -eq 'MEDIA' } | "
        "Select-Object DeviceName,DriverVersion,DriverDate,Manufacturer,InfName "
        "| ConvertTo-Json"
    )
    if not veri:
        yaz("Sürücü bilgisi alınamadı.")
        return
    if isinstance(veri, dict):
        veri = [veri]

    for surucu in veri:
        tarih = surucu.get('DriverDate')
        if tarih and tarih.startswith('/Date('):
            eslesme = re.search(r"\d+", tarih)
            if eslesme:
                tarih = datetime.datetime.fromtimestamp(
                    int(eslesme.group()) / 1000
                ).strftime('%Y-%m-%d')
        surucu['DriverDate'] = tarih

        yaz(f"- Aygıt        : {surucu.get('DeviceName')}")
        yaz(f"  Sürücü sürümü: {surucu.get('DriverVersion')}")
        yaz(f"  Sürücü tarihi: {tarih}")
        yaz(f"  Üretici      : {surucu.get('Manufacturer')}")
        yaz(f"  INF dosyası  : {surucu.get('InfName')}")
        yaz()

    RAPOR_VERI["surucu_bilgisi"] = veri


def kanal_bilgisi_sounddevice():
    baslik("HOPARLÖR KANAL SAYISI (sounddevice)")
    try:
        import sounddevice as sd
    except ImportError:
        yaz("Bu bölüm için 'sounddevice' paketi gerekli.")
        yaz("Kurmak için: pip install sounddevice")
        return

    try:
        varsayilan_cikis = sd.default.device[1]
        aygitlar = sd.query_devices()
        if varsayilan_cikis is not None and varsayilan_cikis != -1:
            cikis_aygiti = aygitlar[varsayilan_cikis]
        else:
            cikis_aygiti = sd.query_devices(kind='output')
    except Exception as hata:
        yaz(f"Varsayılan aygıt okunamadı: {hata}")
        return

    kanal = cikis_aygiti.get('max_output_channels')
    ad = cikis_aygiti.get('name')
    ornek_hiz = cikis_aygiti.get('default_samplerate')

    yaz(f"Varsayılan çıkış aygıtı  : {ad}")
    yaz(f"Maksimum çıkış kanalı    : {kanal}")
    yaz(f"Varsayılan örnekleme hızı: {ornek_hiz}")

    yorum = {
        1: "Mono",
        2: "Stereo (2.0)",
        6: "5.1 Surround (6 kanal)",
        8: "7.1 Surround (8 kanal)",
    }.get(kanal, f"{kanal} kanal (standart olmayan bir yapılandırma olabilir)")
    yaz(f"Olası yapılandırma       : {yorum}")
    yaz(
        "\nNot: Bu değer aygıtın DESTEKLEDİĞİ maksimum kanal sayısını gösterir; "
        "gerçek aktif format için aşağıdaki bölümlere bakın."
    )

    RAPOR_VERI["sounddevice_varsayilan_cikis"] = {
        "ad": ad, "maks_kanal": kanal, "ornek_hiz": ornek_hiz
    }


def mix_format_pycaw():
    baslik("VARSAYILAN AYGIT AKTİF FORMATI (pycaw)")
    try:
        from pycaw.pycaw import AudioUtilities, IAudioClient
        from comtypes import CLSCTX_ALL
    except ImportError:
        yaz("Bu bölüm için 'pycaw' ve 'comtypes' paketleri gerekli.")
        yaz("Kurmak için: pip install pycaw comtypes")
        return

    try:
        speakers = AudioUtilities.GetSpeakers()
        cihaz = getattr(speakers, "_dev", speakers)
        interface = cihaz.Activate(IAudioClient._iid_, CLSCTX_ALL, None)
        audio_client = interface.QueryInterface(IAudioClient)
        mix_format = audio_client.GetMixFormat()
        kanal = mix_format.contents.nChannels
        ornek_hiz = mix_format.contents.nSamplesPerSec
        bit_derinligi = mix_format.contents.wBitsPerSample

        yaz(f"Aktif kanal sayısı : {kanal}")
        yaz(f"Örnekleme hızı     : {ornek_hiz} Hz")
        yaz(f"Bit derinliği      : {bit_derinligi} bit")

        yorum = {
            2: "Şu an Stereo (2.0) kullanılıyor",
            6: "Şu an 5.1 Surround kullanılıyor",
            8: "Şu an 7.1 Surround kullanılıyor",
        }.get(kanal, f"Şu an {kanal} kanallı özel bir format kullanılıyor")
        yaz(f"Sonuç: {yorum}")

        RAPOR_VERI["aktif_mix_format"] = {
            "kanal": kanal, "ornek_hiz": ornek_hiz, "bit_derinligi": bit_derinligi
        }
    except Exception as hata:
        yaz(f"Aktif format okunamadı: {hata}")


# PKEY_AudioEndpoint_PhysicalSpeakers -> Windows'un "Hoparlör Kurulumu" dialogunda
# gerçekten seçili olan fiziksel kanal maskesi (KSAUDIO_SPEAKER_* sabitleri).
FIZIKSEL_ANAHTAR = "{1DA5D803-D492-4EDD-8C23-E0C0FFEE7F0E} 3"

KANAL_BITLERI = [
    (0x1, "Ön Sol"), (0x2, "Ön Sağ"), (0x4, "Ön Orta"), (0x8, "Subwoofer (LFE)"),
    (0x10, "Arka Sol"), (0x20, "Arka Sağ"),
    (0x40, "Ön Sol-Orta"), (0x80, "Ön Sağ-Orta"),
    (0x100, "Arka Orta"), (0x200, "Yan Sol"), (0x400, "Yan Sağ"),
    (0x800, "Üst Orta"),
]

BILINEN_YAPILAR = {
    0x1: "Mono",
    0x3: "Stereo (2.0)",
    0x33: "Quadrofonik (4.0, arka hoparlörlü)",
    0x107: "Surround (4.0, arka merkez hoparlörlü)",
    0x3F: "5.1 Surround (arka hoparlörlü)",
    0xFF: "7.1 Surround (klasik, ön yan + arka hoparlörlü)",
    0x60F: "5.1 Surround (yan hoparlörlü)",
    0x63F: "7.1 Surround (yan + arka hoparlörlü)",
}


def kanal_maskesini_yorumla(mask: int) -> str:
    bilinen = BILINEN_YAPILAR.get(mask)
    if bilinen:
        return bilinen
    aktif_pozisyonlar = [ad for bit, ad in KANAL_BITLERI if mask & bit]
    kanal_sayisi = bin(mask).count("1")
    if aktif_pozisyonlar:
        return f"{kanal_sayisi} kanal ({', '.join(aktif_pozisyonlar)})"
    return f"{kanal_sayisi} kanal (bilinmeyen maske: {mask})"


def fiziksel_hoparlor_yapisi():
    baslik("GERÇEK HOPARLÖR YAPILANDIRMASI (Windows Ses Ayarları)")
    try:
        from pycaw.pycaw import AudioUtilities
    except ImportError:
        yaz("Bu bölüm için 'pycaw' paketi gerekli.")
        yaz("Kurmak için: pip install pycaw comtypes")
        return

    try:
        speakers = AudioUtilities.GetSpeakers()
        ozellikler = speakers.properties
        mask = ozellikler.get(FIZIKSEL_ANAHTAR)
        if mask is None:
            yaz("Fiziksel hoparlör bilgisi bu aygıt için bulunamadı.")
            return

        yorum = kanal_maskesini_yorumla(int(mask))
        yaz(f"Varsayılan aygıt   : {speakers.FriendlyName}")
        yaz(f"Kanal maskesi      : {mask} (0x{int(mask):X})")
        yaz(f"Windows'a göre yapı: {yorum}")
        yaz(
            "\nBu bilgi, Ses Ayarları > Aygıt özellikleri > Ek aygıt özellikleri > "
            "Hoparlör Kurulumu penceresinde seçtiğiniz gerçek düzenden gelir."
        )

        RAPOR_VERI["fiziksel_hoparlor_yapisi"] = {
            "aygit": speakers.FriendlyName, "mask": int(mask), "yorum": yorum
        }
    except Exception as hata:
        yaz(f"Fiziksel yapı okunamadı: {hata}")


def ses_seviyesi_ve_sessiz():
    baslik("SES SEVİYESİ VE SESSİZE ALMA DURUMU")
    try:
        from pycaw.pycaw import AudioUtilities
    except ImportError:
        yaz("Bu bölüm için 'pycaw' paketi gerekli.")
        yaz("Kurmak için: pip install pycaw comtypes")
        return

    try:
        hoparlor = AudioUtilities.GetSpeakers()
        ev = hoparlor.EndpointVolume
        yuzde = round(ev.GetMasterVolumeLevelScalar() * 100)
        sessiz = bool(ev.GetMute())
        yaz(f"Hoparlör  : {hoparlor.FriendlyName}")
        yaz(f"Ses seviyesi : %{yuzde}")
        yaz(f"Sessize alındı mı: {'Evet' if sessiz else 'Hayır'}")
        RAPOR_VERI["hoparlor_ses_seviyesi"] = {"yuzde": yuzde, "sessiz": sessiz}
    except Exception as hata:
        yaz(f"Hoparlör ses seviyesi okunamadı: {hata}")

    try:
        mikrofon = AudioUtilities.CreateDevice(AudioUtilities.GetMicrophone())
        ev = mikrofon.EndpointVolume
        yuzde = round(ev.GetMasterVolumeLevelScalar() * 100)
        sessiz = bool(ev.GetMute())
        yaz(f"\nMikrofon  : {mikrofon.FriendlyName}")
        yaz(f"Mikrofon seviyesi: %{yuzde}")
        yaz(f"Sessize alındı mı: {'Evet' if sessiz else 'Hayır'}")
        RAPOR_VERI["mikrofon_ses_seviyesi"] = {"ad": mikrofon.FriendlyName, "yuzde": yuzde, "sessiz": sessiz}
    except Exception as hata:
        yaz(f"Mikrofon ses seviyesi okunamadı: {hata}")


def tum_ses_aygitlari_pycaw():
    baslik("TÜM SES AYGITLARI (Oynatma / Kayıt, aktif ve devre dışı)")
    try:
        from pycaw.pycaw import AudioUtilities
    except ImportError:
        yaz("Bu bölüm için 'pycaw' paketi gerekli.")
        yaz("Kurmak için: pip install pycaw comtypes")
        return

    try:
        aygitlar = AudioUtilities.GetAllDevices()
    except Exception as hata:
        yaz(f"Aygıt listesi alınamadı: {hata}")
        return

    oynatma, kayit = [], []
    for aygit in aygitlar:
        durum = str(aygit.state).replace("AudioDeviceState.", "")
        if durum == "NotPresent":
            continue  # Fiziksel olarak takılı olmayan/geçmiş aygıtları listeden çıkar.
        try:
            yon = AudioUtilities.GetEndpointDataFlow(aygit.id)
        except Exception:
            yon = "?"
        kayit_satiri = {"ad": aygit.FriendlyName, "durum": durum}
        if yon == "eRender":
            oynatma.append(kayit_satiri)
        else:
            kayit.append(kayit_satiri)

    yaz("Oynatma (hoparlör/kulaklık) aygıtları:")
    for a in oynatma:
        yaz(f"  - {a['ad']:<45} [{a['durum']}]")

    yaz("\nKayıt (mikrofon) aygıtları:")
    for a in kayit:
        yaz(f"  - {a['ad']:<45} [{a['durum']}]")

    RAPOR_VERI["tum_aygitlar"] = {"oynatma": oynatma, "kayit": kayit}


def rapor_kaydet(dizin: str):
    zaman = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")

    txt_yolu = os.path.join(dizin, f"ses_raporu_{zaman}.txt")
    with open(txt_yolu, "w", encoding="utf-8") as f:
        f.write("\n".join(SATIRLAR))

    json_yolu = os.path.join(dizin, f"ses_raporu_{zaman}.json")
    with open(json_yolu, "w", encoding="utf-8") as f:
        json.dump(RAPOR_VERI, f, ensure_ascii=False, indent=2, default=str)

    print(f"\nRapor kaydedildi:\n  {txt_yolu}\n  {json_yolu}")


if __name__ == "__main__":
    yaz("SES SİSTEMİ VE SÜRÜCÜ RAPORU")
    yaz(f"Python: {sys.version.split()[0]}  Platform: {sys.platform}")
    yaz(f"Tarih  : {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    ses_aygitlari()
    surucu_bilgisi()
    kanal_bilgisi_sounddevice()
    mix_format_pycaw()
    fiziksel_hoparlor_yapisi()
    ses_seviyesi_ve_sessiz()
    tum_ses_aygitlari_pycaw()

    yaz("\nBitti.")

    betik_dizini = os.path.dirname(os.path.abspath(__file__))
    rapor_kaydet(betik_dizini)

Çalıştırmak için gereken tüm komutlar özetle:

pip install sounddevice pycaw comtypes
python sessistem.py

Bu yazı, kişisel bir teknik defter/blog paylaşımı olarak hazırlanmıştır.