Update LEGAR_BENCH.py

LEGAR_BENCH.py

@@ -1,176 +1,96 @@
 import json
-import os
-import glob
-from pathlib import Path
 import datasets
 
-
 _DESCRIPTION = """\
 LEGAR_BENCH is the first large-scale Korean LCR benchmark, covering 411 diverse crime types in queries over 1.2M legal cases.
 """
 
-
 _HOMEPAGE = "https://huggingface.co/datasets/Chaeeun-Kim/LEGAR_BENCH"
 _LICENSE = "Apache 2.0"
 
-class LegarBenchConfig(datasets.BuilderConfig):
-    def __init__(self, **kwargs):
-        super(LegarBenchConfig, self).__init__(**kwargs)
-
+_URLS = {
+    "standard": "data/standard_train.jsonl",
+    "stricter": "data/stricter_train.jsonl", 
+    "stricter_by_difficulty": "data/stricter_by_difficulty_train.jsonl",
+}
 
 class LegarBench(datasets.GeneratorBasedBuilder):
+    VERSION = datasets.Version("1.0.0")
+    
     BUILDER_CONFIGS = [
-        LegarBenchConfig(
+        datasets.BuilderConfig(
             name="standard",
+            version=VERSION,
             description="Standard version of LEGAR BENCH",
         ),
-        LegarBenchConfig(
+        datasets.BuilderConfig(
             name="stricter",
+            version=VERSION, 
             description="Stricter version of LEGAR BENCH",
         ),
-        LegarBenchConfig(
+        datasets.BuilderConfig(
             name="stricter_by_difficulty",
+            version=VERSION,
             description="Stricter version organized by difficulty",
         ),
     ]
-    
+
     DEFAULT_CONFIG_NAME = "standard"
 
     def _info(self):
+        features = datasets.Features({
+            "id": datasets.Value("int64"),
+            "target_category": datasets.Value("string"),
+            "category": datasets.Value("string"),
+            "question": datasets.Value("string"),
+            "question_id": datasets.Value("string"),
+            "answer": datasets.Sequence(datasets.Value("string")),
+            "evidence_id": datasets.Sequence(datasets.Value("string")),
+            "difficulty": datasets.Value("string"),
+        })
+
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
-            features=datasets.Features({
-                "id": datasets.Value("int64"),
-                "target_category": datasets.Value("string"),
-                "category": datasets.Value("string"),
-                "question": datasets.Value("string"),
-                "question_id": datasets.Value("string"),
-                "answer": datasets.Sequence(datasets.Value("string")),
-                "evidence_id": datasets.Sequence(datasets.Value("string")),
-                "difficulty": datasets.Value("string"),
-            }),
+            features=features,
             homepage=_HOMEPAGE,
             license=_LICENSE,
         )
 
     def _split_generators(self, dl_manager):
-        if self.config.name == "standard":
-            file_pattern = "Standard_version/*.json"
-        elif self.config.name == "stricter":
-            file_pattern = "Stricter_version/*.json"
-        elif self.config.name == "stricter_by_difficulty":
-            file_pattern = "Stricter_version_by_difficulty/**/*.json"
-        else:
-            file_pattern = "Standard_version/*.json"
-        
-        # 파일들을 다운로드
-        try:
-            data_files = dl_manager.download_and_extract("")  
-            if isinstance(data_files, str):
-                data_dir = data_files
-            else:
-                data_dir = data_files
-                
-        except Exception as e:
-            if hasattr(dl_manager, 'manual_dir') and dl_manager.manual_dir:
-                data_dir = dl_manager.manual_dir
-            else:
-                raise e
+        url = _URLS[self.config.name]
+        data_file = dl_manager.download(url)
         
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "data_dir": data_dir,
-                    "config_name": self.config.name,
+                    "filepath": data_file,
                 },
             ),
         ]
 
-    def _generate_examples(self, data_dir, config_name):
-        example_id = 0
-        
-        if config_name == "standard":
-            search_path = os.path.join(data_dir, "Standard_version")
-        elif config_name == "stricter":
-            search_path = os.path.join(data_dir, "Stricter_version")
-        elif config_name == "stricter_by_difficulty":
-            search_path = os.path.join(data_dir, "Stricter_version_by_difficulty")
-        else:
-            search_path = os.path.join(data_dir, "Standard_version")
-        
-        if not os.path.exists(search_path):
-            possible_paths = [
-                data_dir,
-                os.path.join(data_dir, "LEGAR_BENCH"),
-                os.path.join(data_dir, "LEGAR-BENCH")
-            ]
-            
-            found = False
-            for possible_path in possible_paths:
-                test_path = os.path.join(possible_path, search_path.split('/')[-1])
-                if os.path.exists(test_path):
-                    search_path = test_path
-                    found = True
-                    break
-            
-            if not found:
-                raise FileNotFoundError(f"Could not find data directory. Tried: {search_path}, data_dir: {data_dir}")
-        
-        if config_name == "stricter_by_difficulty":
-            if os.path.exists(search_path):
-                for difficulty_folder in sorted(os.listdir(search_path)):
-                    folder_path = os.path.join(search_path, difficulty_folder)
-                    if os.path.isdir(folder_path):
-                        for filename in sorted(os.listdir(folder_path)):
-                            if filename.endswith('.json'):
-                                filepath = os.path.join(folder_path, filename)
-                                for item in self._load_json_file(filepath, difficulty=difficulty_folder):
-                                    yield example_id, item
-                                    example_id += 1
-        else:
-            if os.path.exists(search_path):
-                for filename in sorted(os.listdir(search_path)):
-                    if filename.endswith('.json'):
-                        filepath = os.path.join(search_path, filename)
-                        for item in self._load_json_file(filepath, difficulty=""):
-                            yield example_id, item
-                            example_id += 1
-    
-    def _load_json_file(self, filepath, difficulty=""):
-        with open(filepath, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-            
-            if isinstance(data, list):
-                for item in data:
-                    yield self._process_item(item, difficulty)
-            else:
-                yield self._process_item(data, difficulty)
+    def _generate_examples(self, filepath):
+        with open(filepath, encoding="utf-8") as f:
+            for key, line in enumerate(f):
+                data = json.loads(line)
+                
+                yield key, {
+                    "id": int(data.get("id", 0)),
+                    "target_category": str(data.get("target_category", "")),
+                    "category": self._process_category(data.get("category", {})),
+                    "question": str(data.get("question", "")),
+                    "question_id": str(data.get("question_id", "")),
+                    "answer": self._process_list_field(data.get("answer", [])),
+                    "evidence_id": self._process_list_field(data.get("evidence_id", [])),
+                    "difficulty": str(data.get("difficulty", "")),
+                }
     
-    def _process_item(self, item, difficulty=""):
-        category = item.get("category", {})
+    def _process_category(self, category):
         if isinstance(category, dict):
-            category_str = json.dumps(category, ensure_ascii=False)
-        else:
-            category_str = str(category)
-        
-        answer = item.get("answer", [])
-        if answer is None:
-            answer = []
-        answer_clean = [str(a) if a is not None else "" for a in answer]
-        
-        evidence_id = item.get("evidence_id", [])
-        if evidence_id is None:
-            evidence_id = []
-        evidence_id_clean = [str(e) if e is not None else "" for e in evidence_id]
-        
-        return {
-            "id": int(item.get("id", 0)),
-            "target_category": str(item.get("target_category", "")),
-            "category": category_str,
-            "question": str(item.get("question", "")),
-            "question_id": str(item.get("question_id", "")),
-            "answer": answer_clean,
-            "evidence_id": evidence_id_clean,
-            "difficulty": str(difficulty if difficulty else ""),
-        }
+            return json.dumps(category, ensure_ascii=False)
+        return str(category)
+    
+    def _process_list_field(self, field):
+        if field is None:
+            return []
+        return [str(item) if item is not None else "" for item in field]