anoy 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

anoy-0.2.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: anoy
+Version: 0.2.0
+Summary: This is a library that provides simple type checking for YAML.
+Author-email: masaniki <masaniki.software@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/masaniki/annotation-yaml
+Project-URL: Documentation, https://github.com/masaniki/annotation-yaml/tree/master/docs
+Project-URL: Issues, https://github.com/masaniki/annotation-yaml/issues
+Keywords: text,YAML,CLI,type,check
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Natural Language :: Japanese
+Classifier: Natural Language :: English
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: PyYAML
+Dynamic: license-file
+
+# Index
+
+- **English Document**
+
+  English Document <- Here
+
+- **Japanese Document**
+
+  [Japanese Document](docs/README_JP.md)
+
+- **Annotation YAML(ANOY)**
+
+  A YAML file that allows type checking for Map types.
+
+  More about [ANOY](about_anoy.md)
+
+- **Configuration YAML(Config YAML)**
+
+  A YAML file that defines the data types usable in Annotation YAML.
+
+  More about [Config YAML](about_config.md)
+
+- **ANOY CLI**
+  
+  A CLI application that verifies whether Annotation YAML adheres to the data type defined in Configuration YAML.
+
+  More about [ANOY CLI](about_anoycli.md)
+
+# Introduction
+
+YAML maps often become nested and complex.
+
+And these requests have come up.
+
+- Detecting typos in map keys.
+- Verifying the data type of map values.
+- Ensuring the map's nested structure is appropriate.
+
+This library satisfies these requests.
+
+# Installing
+
+`pip install anoy`
+
+## Package Dependencies
+
+The following packages may not work properly if they are not installed:
+
+- [PyYAML](https://pypi.org/project/PyYAML/): Most popular YAML parser for Python.
+
+# Usage
+
+library_config.yaml
+
+```
+"@Books":
+  "@Summary": List the book titles.
+  "!ChildValue": FreeDict
+"@Author":
+  "@Summary": Author of the book.
+  "!ChildValue": Str
+"@PublishYear":
+  "@Summary": The year of the publishment.
+  "!ChildValue": Int
+"@Country":
+  "@Summary": The author's native language.
+  "!ChildValue": Str
+```
+
+valid_library.yaml:
+
+```
+"@Books":
+  "Alice's Adventures in Wonderland":
+    "@Author": Lewis Carroll
+    "@PublishYear": 1865
+    "@Country": UK
+  "The Little Prince":
+    "@Author": Antonie de Saint-Exupéry
+    "@PublishYear": 1945
+    "@Country": France
+  "Harry Potter":
+    "@Author": J.K.Rowling
+    "@PublishYear": 1997
+    "@Country": UK
+```
+
+Use the `anoy` command to verify data types.
+
+If data type issues are not found, it outputs nothing.
+
+```
+>>> anoy library_config.yaml library.yaml
+>>> 
+```
+
+If you mistyped `@Auther` as `@Auther`.
+
+invalid_library.yaml:
+
+```
+"@Books":
+  "Alice's Adventures in Wonderland":
+    "@Auther": Lewis Carroll
+    "@PublishYear": 1865
+    "@Country": UK
+  "The Little Prince":
+    "@Auther": Antonie de Saint-Exupéry
+    "@PublishYear": 1945
+    "@Country": France
+  "Harry Potter":
+    "@Auther": J.K.Rowling
+    "@PublishYear": 1997
+    "@Country": UK
+```
+
+When there is an issue with the annotation YAML, `anoy` outputs as follows.
+
+```
+>>> anoy library_config.yaml library.yaml
+>>> Traceback (most recent call last):
+    ... (omission) ...
+    src.anoyModule.anoyErrors.ConfigurationYamlError: `@Auther` is not defined.
+```
+# For Developers
+
+## Testing
+
+This project uses `pytest`.
+
+If you want to test, put in following command.
+
+`pytest tests\unit\test_dictTraversal.py`
+
+## Next To Do
+
+- [ ] test caseを全てのdata型に拡大。
+- [ ] `!Float`のtest.
+- [ ] `!AnnoMap`のtest.
+- [ ] `!FreeMap`のtest.
+
+## Ideas
+
+```
+- key01
+- key02
+- key03
+```
+と
+```
+- {key01:value01}
+- {key02:value02}
+- {key03:value03}
+```
+を等価に扱うsystemが欲しい。

anoy-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli.py,sha256=kGdZrdmUrI0dCKrbU_dUjrIGNNueV0B8DwQ29zUwxiM,915
+anoy-0.2.0.dist-info/licenses/LICENSE.txt,sha256=nsHvySI1U7YZgAX4K3rJsWli_GfXy2syPI-MtGPwjlo,1062
+anoyModule/__init__.py,sha256=iWletkxm7jDc7oFqp4yDS_4fUYZBny04q2VxkTpIDHo,111
+anoyModule/anoyErrors.py,sha256=2DST9_IenRIyXsABl6vWhMU0D5wqJ2aSs7zkm0DABm4,646
+anoyModule/dictTraversal.py,sha256=zdBHrrHghnvL_58ateZMpFvEYhi3Qi1absvk2OSbb5U,26048
+anoy-0.2.0.dist-info/METADATA,sha256=i4KpdNglLMltxEsdkfwJk4nB4kt60c4Xc5TjGkXIYdQ,3970
+anoy-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+anoy-0.2.0.dist-info/entry_points.txt,sha256=_lpL6R97giGseZcV0r5QwdX4zRwoZLzRHUxyBZl_iYI,34
+anoy-0.2.0.dist-info/top_level.txt,sha256=QExj2OlPPcJU_7B1gwNcL2iYOcgYJBpDZsUArRCaXJw,15
+anoy-0.2.0.dist-info/RECORD,,

anoy-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+anoyModule
+cli

anoyModule/__init__.py

@@ -0,0 +1,3 @@
+
+from .dictTraversal import DictTraversal
+from .anoyErrors import AnoyError, AnoyTypeError, ConfigYamlError

anoyError.py → anoyModule/anoyErrors.py

@@ -1,5 +1,5 @@
 
-class AnnotationYamlError(Exception):
+class AnoyError(Exception):
   """
   @Summ: annotation yaml上のError。
   """
@@ -7,20 +7,20 @@ class AnnotationYamlError(Exception):
     super().__init__(*args)
 
 
-class AnnotationYamlTypeError(Exception):
+class AnoyTypeError(Exception):
   """
   @Summ: annotation yaml上のdata型のError。
   """
-  def __init__(self,type:str,path:list):
+  def __init__(self,type:str,fileName:str,path:list):
     super().__init__()
     self.type=type
+    self.fileName=fileName
     self.path=path
   
   def __str__(self):
-    return f"required {self.type} type at:\n    {self.path}"
+    return f"{self.type} contradiction:\n    {self.fileName}: {self.path}"
 
-
-class ConfigurationYamlError(Exception):
+class ConfigYamlError(Exception):
   """
   @Summ: annotation yaml上のError。
   """

anoyModule/dictTraversal.py

@@ -0,0 +1,642 @@
+import yaml
+from pathlib import Path
+
+from .anoyErrors import AnoyError,ConfigYamlError,AnoyTypeError
+
+class DictTraversal():
+    """
+    @Summ: 辞書型の中身を探索するclass.
+
+    @InsVars:
+        _configDict:
+            @Summ: config yamlを構文解析した後の値を格納する。
+            @Desc:
+            - !Childの値は{"!Child": {typeString(str):typOption(dict)}}という形式に直す。
+            - typeStringはdata型を表す文字列。
+            - typeOptionはdata型の詳細な設定を表すdict型である。
+            - つまり、str-format data typeもmap-format data typeに直すということ。
+            - map-format data typeが無いBool型は{"!Bool":{}}とする。
+            - annotation keyを使った否かを"isVisit" keyに記録する。
+            @Type: Dict
+        _visitQueue:
+            @Summ: 探索queue
+            @Desc: BFSなのでFIFO。
+            @Type: List
+        _pathQueue:
+            @Summ: 探索する要素の相対pathを格納する。
+            @Desc:
+            - visitQueueと要素番号を共有する。
+            - []でroot要素を表す。
+            @Type: List
+        _curFile:
+            @Summ: 現在探索中のANOY file名。
+            @ComeFrom: current file.
+            @Type: Str
+        _curPath:
+            @Summ: _curFile内での現在地。
+            @ComeFrom: current path/
+            @Type: List
+    """
+
+    def __init__(self,configDict:dict):
+        """
+        @Summ: constructor.
+        """
+        self._configDict=self.checkConfig(configDict)
+        print(self._configDict)
+        self._visitQueue=[]
+        self._pathQueue=[]
+        self._curFile=""
+        self._curPath=[]
+    
+    def checkConfig(self,configDict:dict)->dict:
+        """
+        @Summ: config yamlの中身を構文解析する関数。
+
+        @Desc
+        - config yamlは、annotation keyかconfig keyの記述しか許さない。
+        - configDictに"isVisit" keyを追加し、annotation keyを使用したかを記録する。
+
+        @Args:
+          configDict:
+            @Summ: config yamlの中身。
+            @Type: Dict
+        @Returns:
+          @Summ: 型確認して、余計なものを取り除いたconfigDict。
+          @Type: dict
+        """
+        newConfigDict={}  # 整形されたconfigDict
+        for annoKey in configDict.keys():
+            newAnnoValue={}  #annotation keyに対応する値。
+            if(annoKey[0]!="@"):
+                raise ConfigYamlError(f"{annoKey} is invalid definition.")
+            valueDict=configDict[annoKey]
+            if(type(valueDict)!=dict):
+                raise ConfigYamlError(f"{annoKey} is invalid definition.")
+            for key,value in valueDict.items():
+                if(key[0]=="@"):
+                    continue
+                elif(key=="!Parent"):
+                    validConfParent=self.checkParent(annoKey,value)
+                    newAnnoValue["!Parent"]=validConfParent
+                elif(key=="!Child"):
+                    validConfChild=self.checkChild(annoKey,value)
+                    newAnnoValue["!Child"]=validConfChild
+                else:
+                    raise ConfigYamlError(f"{annoKey} is invalid definition.")
+            # isVisit keyの追加。
+            newAnnoValue["isVisit"]=False
+            newConfigDict[annoKey]=newAnnoValue
+        return newConfigDict
+    
+    @classmethod
+    def checkParent(cls,annoKey,confParent):
+        """
+        @Summ: `!Parent`に対応する値を型確認する関数。
+
+        @Args:
+          annoKey:
+            @Summ: `!Parent`の親となるannotation key.
+            @Type: Str
+          confParent:
+            @Summ: `!Parent`の子。
+            @Type: Any
+        @Returns:
+          @Summ: `!Parent`のvalueとして有効な値。
+          @Type: List
+        """
+        if(type(confParent)!=list):
+            raise ConfigYamlError(f"{annoKey} is invalid definition.")
+        for item in confParent:
+            if(item is None):
+                continue
+            if(item[0]!="@"):
+                raise ConfigYamlError(f"{annoKey} is invalid definition.")
+        return confParent.copy()
+    
+    @classmethod
+    def checkChild(cls,annoKey,confChild):
+        """
+        @Summ: `!Child`に対応する値を型確認する関数。
+
+        @Args:
+          annoKey:
+            @Summ: `!Child`の親となるannotation key.
+            @Type: Str
+          confChild:
+            @Summ: `!Child`の子。
+            @Type: Any
+        @Returns:
+          @Summ: `!Child`のvalueとして有効な値。
+          @Type: Dict
+        """
+        if(type(confChild)==str):
+            match confChild:
+                case "!Str":
+                    return {"!Str":{"length":None,"min":None,"max":None}}
+                case "!Bool":
+                    return {"!Bool":{}}
+                case "!Int":
+                    return {"!Int":{"min":None,"max":None}}
+                case "!Float":
+                    return {"!Float":{"min":None,"max":None}}
+                case "!List":
+                    return {"!List":{"type":None,"length":None}}
+                case "!FreeMap":
+                    return {"!FreeMap":{}}
+                case "!AnnoMap":
+                    return {"!AnnoMap":[]}
+                case _:
+                    raise ConfigYamlError(f"{annoKey} is invalid definition.")
+        elif(type(confChild)==dict):
+            confChildKey=list(confChild.keys())
+            if(len(confChildKey)!=1):
+                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+            typeStr=confChildKey[0]
+            typeOption=confChild[typeStr]
+            match typeStr:
+                case "!Str":
+                    if(type(typeOption)!=dict):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    strLength=None
+                    strMin=None
+                    strMax=None
+                    for strKey,strVal in typeOption.items():
+                        match strKey:
+                            case "length":
+                                if(strMin is None and strMax is None):
+                                    strLength=strVal
+                                else:
+                                    raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                            case "min":
+                                if(strLength is None):
+                                    strMin=strVal
+                                else:
+                                    raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                            case "max":
+                                if(strLength is None):
+                                    strMax=strVal
+                                else:
+                                    raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                            case _:
+                                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    return {"!Str":{"length":strLength,"min":strMin,"max":strMax}}
+                case "!Int":
+                    if(type(typeOption)!=dict):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    intMin=None
+                    intMax=None
+                    for intKey,intVal in typeOption.items():
+                        match intKey:
+                            case "min":
+                                intMin=intVal
+                            case "max":
+                                intMax=intVal
+                            case _:
+                                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    return {"!Int":{"min":intMin,"max":intMax}}
+                case "!Float":
+                    if(type(typeOption)!=dict):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    floatMin=None
+                    floatMax=None
+                    for floatKey,floatVal in typeOption.items():
+                        match floatKey:
+                            case "min":
+                                floatMin=floatVal
+                            case "max":
+                                floatMax=floatVal
+                            case _:
+                                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    return {"!Float":{"min":floatMin,"max":floatMax}}
+                case "!Enum":
+                    if(type(typeOption)!=list):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    enumOption=[]
+                    for item in typeOption:
+                        if(type(item)==list):
+                            raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                        elif(type(item)==dict):
+                            keyList=list(item.keys())
+                            if(len(keyList)!=1):
+                                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                            enumOption.append(keyList[0])
+                        else:
+                            enumOption.append(item)
+                    return {"!Enum":enumOption}
+                case "!List":
+                    if(type(typeOption)!=dict):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    listType=None
+                    listLength=None
+                    for listKey,listVal in typeOption.items():
+                        match listKey:
+                            case "type":
+                                listType=listVal
+                            case "length":
+                                listLength=listVal
+                            case _:
+                                raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    return {"!List":{"type":listType,"length":listLength}}
+                case "!AnnoDict":
+                    if(type(typeOption)!=list):
+                        raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    for i in len(typeOption):
+                        item=typeOption[i]
+                        if(item[0]!="@"):
+                            raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+                    return {"!AnnoDict":typeOption}
+                case _:
+                    raise ConfigYamlError(f"`{annoKey}` has invalid definition.")
+        else:
+            raise ConfigYamlError(f"{annoKey} is invalid definition.")
+
+
+    def dirDFS(self,anoyPath:Path):
+        """
+        @Summ: directory内を深さ優先探索する関数。
+
+        @Desc:
+        - fileならばYAMLかどうかを確認して、内部のdict型を探索する。
+        - directoryならば、子要素を再帰的に探索する。
+
+        @Args:
+          anoyPath:
+            @Summ: 探索するfileやdirectoryのpath名。
+            @Type: Path
+        """
+        if(anoyPath.is_file()):
+            suffix=anoyPath.suffix
+            if(suffix==".yaml" or suffix==".yml" or suffix==".anoy"):
+                with open(anoyPath, mode="r", encoding="utf-8") as f:
+                    anoyDict=yaml.safe_load(f)
+                self._curFile=anoyPath
+                self.dictBFS(anoyDict)
+        else:
+            for childPath in anoyPath.iterdir():
+                self.dirDFS(childPath)
+
+
+    def dictBFS(self,anoyDict:dict):
+        """
+        @Summ: anoyDictの中を幅優先探索を開始する関数。
+
+        @Desc:
+        - list型は単純に探索する。
+        - dict型は型確認しながら探索する。
+        - visitQueueには(key(str),value(any))のtupleを入れる。
+        - list型の時は、(key(int),value(any))になる。
+        @Args:
+            anoyDict:
+                @Summ: annotation yamlのdict型。
+        """
+        self._visitQueue=[(None,anoyDict)]
+        self._pathQueue=[[]]
+        while(True):
+            if(self._visitQueue==[]):
+                break
+            key,value=self._visitQueue.pop(0)
+            self._curPath=self._pathQueue.pop(0)
+            print(key,value)
+            print(self._curPath)
+            self.checkAnoy(key,value)
+
+    def checkAnoy(self,parentKey:str|None,childValue):
+        """
+        "@Summ": anoyの中身を探索する関数。
+
+        "@Desc":
+        - 型確認は"!Parent"と"!Child"の2つだ。
+        - parentKeyの`!Child`がchildValueを制限する。
+        - childValueの`!parent`がparentKeyを制限する。
+        - parentKeyがannotationKeyでない時は、"!Parent"も"!Child"も効力を発揮しないので無視。
+        - !Childが無い時は、childValue=Noneとして考える。
+        - `!Parent`による型確認は、childValueが`!AnnoMap`型の時のみ行われる。
+
+        "@Args":
+            parentKey:
+                "@Summ": 探索するdict型のkey。
+                "@Desc":
+                - nullは親要素が存在しないことを表す(つまりvalueがroot要素である)。
+                "@Type":
+                    Union:
+                    - Str
+                    - null
+            childValue:
+                "@Summ": 探索するdict型のvalue。
+                "@Type": Any
+        "@Error":
+        - AnnotationYamlError
+        - AnnotationYamlTypeError
+        - ConfigurationYamlError
+        """
+        if(parentKey is None):
+            confChild=None    #confChild=Noneの時は型確認をしない。
+        elif(type(parentKey)!=str):
+            confChild=None
+        elif(parentKey[0]=="@"):
+            confDictVal=self._configDict.get(parentKey)
+            if(confDictVal is None):
+                raise AnoyError(f"{parentKey} is not found.")
+            confChild=confDictVal.get("!Child")
+        else:
+            confChild=None
+        # anoyの型確認
+        if(confChild is None): #Noneの処理方法は不明。
+            # nestになるlistとdictだけ対処する。
+            if(type(childValue)==list):
+                for i in len(childValue):
+                    element=childValue[i]
+                    newPath=self._curPath+[i]
+                    self._visitQueue.append((i,element))
+                    self._pathQueue.append(newPath)
+            elif(type(childValue)==dict):
+                for key,value in childValue.items():
+                    newPath=self._curPath+[key]
+                    self._visitQueue.append((key,value))
+                    self._pathQueue.append(newPath)
+            return
+        typeStr=list(confChild.keys())[0]
+        typeOption=confChild[typeStr]
+        match typeStr:
+            case "!Str":
+                self.checkStr(childValue,**typeOption)
+            case "!Bool":
+                self.checkBool(childValue)
+            case "!Int":
+                self.checkInt(childValue,**typeOption)
+            case "!Float":
+                self.checkFloat(childValue,**typeOption)
+            case "!FreeMap":
+                self.checkFreeMap(childValue)
+            case "!AnnoMap":
+                self.checkAnnoMap(parentKey,childValue,typeOption)
+            case "!List":
+                self.checkList(parentKey,childValue,elementType=typeOption["type"],length=typeOption["length"])
+            case "!Enum":
+                self.checkEnum(childValue,typeOption)
+            case _:
+                raise ConfigYamlError(f"{parentKey} is invalid definition.")
+
+    def checkStr(self,anoyValue,length=None,min=None,max=None):
+        """
+        @Summ: !Str型を型確認する関数。
+
+        @Desc:
+        - <length>と<min>、<length>と<max>の両立は不可能であるが、この関数ではその確認を行わない。
+        - 呼び出し時にその確認を行うべきである。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+          length:
+            @Summ: 文字列の長さ。
+            @Desc: min,maxとの両立は不可能。
+          min:
+            @Summ: 文字列の長さの最小値。
+            @Desc:
+            - lengthとの両立は不可能。
+            - min-1からerror.
+          max:
+            @Summ: 文字列の長さの最大値。
+            @Desc:
+            - lengthとの両立は不可能。
+            - max+1からerror.
+        """
+        if(type(anoyValue)==str):
+            if(length is not None):
+                if(len(anoyValue)==length):
+                    return
+                else:
+                    raise AnoyTypeError("!Str",self._curFile,self._curPath)
+            else:
+                if(min is not None):
+                    if(len(anoyValue)<min):
+                        raise AnoyTypeError("!Str",self._curFile,self._curPath)
+                if(max is not None):
+                    if(max<len(anoyValue)):
+                        raise AnoyTypeError("!Str",self._curFile,self._curPath)
+                return
+        else:
+            raise AnoyTypeError("!Str",self._curFile,self._curPath)
+
+    def checkBool(self,anoyValue):
+        """
+        @Summ: !Bool型を型確認する関数。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+        """
+        if(type(anoyValue)!=bool):
+            raise AnoyTypeError("!Bool",self._curFile,self._curPath)
+
+    def checkInt(self,anoyValue,min=None,max=None):
+        """
+        @Summ: !Int型を型確認する関数。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+          min:
+            @Summ: 最小値。
+          max:
+            @Summ: 最大値。
+        """
+        if(type(anoyValue)==int):
+            if(min is not None):
+                if(anoyValue<min):
+                    raise AnoyTypeError("!Int",self._curFile,self._curPath)
+            if(max is not None):
+                if(max<anoyValue):
+                    raise AnoyTypeError("!Int",self._curFile,self._curPath)
+            return
+        else:
+            raise AnoyTypeError("!Int",self._curFile,self._curPath)
+
+    def checkFloat(self,anoyValue,min=None,max=None):
+        """
+        @Summ: !Float型を型確認する関数。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+          min:
+            @Summ: 最小値。
+          max:
+            @Summ: 最大値。
+        """
+        if(type(anoyValue)==float):
+            if(min is not None):
+                if(anoyValue<min):
+                    raise AnoyTypeError("!Float",self._curFile,self._curPath)
+            if(max is not None):
+                if(max<anoyValue):
+                    raise AnoyTypeError("!Float",self._curFile,self._curPath)
+            return
+        else:
+            raise AnoyTypeError("!Float",self._curFile,self._curPath)
+
+    def checkFreeMap(self,anoyValue):
+        """
+        @Summ: !FreeMap型を型確認する関数。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+        """
+        if(type(anoyValue)==dict):
+            for key,value in anoyValue.items():
+                newPath=self._curPath+[key]
+                self._visitQueue.append((key,value))
+                self._pathQueue.append(newPath)
+                if(key[0]=="@"):
+                    raise AnoyTypeError("!FreeMap",self._curFile,newPath)
+        else:
+            raise AnoyTypeError("!FreeMap",self._curFile,self._curPath)
+
+    def checkAnnoMap(self,parentKey,anoyValue,annoKeyList:list=[]):
+        """
+        @Summ: !FreeMap型を型確認する関数。
+
+        @Desc:
+        - <annoKeyList>は最低限必要なannotation keyのlistが入る。
+        - 最低限なので、<annoKeyList>以外のannotation keyも許容される。
+
+        @Args:
+          parentKey:
+            @Summ: 親要素のannotation key。
+            @Type: Str
+          anoyValue:
+            @Summ: 型確認する値。
+          annoKeyList:
+            @Summ: annotation keyのlist。
+            @Type: List
+            @Default: []
+        """
+        if(type(anoyValue)==dict):
+            for key,value in anoyValue.items():
+                newPath=self._curPath+[key]
+                self._visitQueue.append((key,value))
+                self._pathQueue.append(newPath)
+                # !Parentの確認。
+                configValue=self._configDict.get(key)
+                if(configValue is None):
+                    raise AnoyError(f"{parentKey} is not found.")
+                confParent=configValue.get("!Parent")
+                if(confParent is not None):
+                    if(parentKey not in confParent):
+                        raise AnoyTypeError("!Parent",self._curFile,newPath)
+                if(annoKeyList!=[]):
+                    if(key not in annoKeyList):
+                        raise AnoyTypeError("!AnnoMap",self._curFile,self._curPath)
+        else:
+            raise AnoyTypeError("!AnnoMap",self._curFile,self._curPath)
+
+    def checkList(self,parentKey,anoyValue,elementType:str=None,length:int=None):
+        """
+        @Summ: !List型を型確認する関数。
+
+        @Desc:
+        - <typeOption>は最低限必要なannotation keyのlistが入る。
+        - 最低限なので、<typeOption>以外のannotation keyも許容される。
+
+        @Args:
+          parentKey:
+            @Summ: 親のkey。
+            @Type: Str
+          anoyValue:
+            @Summ: 型確認する値。
+          elementType:
+            @Summ: list型の子要素のdata型。
+            @Desc:
+            - [!Bool,!Str,!Int,!Float]を指定できる。
+            - Noneの時はdata型を確認しない。
+            @Type: Str
+          length:
+            @Summ: listの長さ
+            @Type: Int
+        """
+        if(type(anoyValue)==list):
+            if(length is not None):
+                if(length!=len(anoyValue)):
+                    raise AnoyTypeError("!List",self._curFile,self._curPath) 
+            for i in range(len(anoyValue)):
+                element=anoyValue[i]
+                newPath=self._curPath+[i]
+                if(elementType is not None):
+                    match elementType:
+                        case "!Str":
+                            if(type(element)!=str):
+                                raise AnoyTypeError("!List",self._curFile,newPath)
+                        case "!Bool":
+                            if(type(element)!=bool):
+                                raise AnoyTypeError("!List",self._curFile,newPath)
+                        case "!Int":
+                            if(type(element)!=int):
+                                raise AnoyTypeError("!List",self._curFile,newPath)
+                        case "!Float":
+                            if(type(element)!=float):
+                                raise AnoyTypeError("!List",self._curFile,newPath)
+                        case _:
+                            raise ConfigYamlError(f"{parentKey} is invalid definition.")
+                self._visitQueue.append((i,element))
+                self._pathQueue.append(newPath)
+        else:
+            raise AnoyTypeError("!List",self._curFile,self._curPath)
+    
+    def checkEnum(self,anoyValue,optionList:list):
+        """
+        @Summ: !Enum型を型確認する関数。
+
+        @Desc:
+        - 他の言語のUnion型の役割も兼ねている。
+        - 選択できるdata型は、[null,!Bool,!Str,!Int,!Float,!List,!FreeMap]である。
+        - 入れ子の下層までは確認しない(浅いdata型確認)。
+
+        @Args:
+          anoyValue:
+            @Summ: 型確認する値。
+          optionList:
+            @Summ: Enum型の選択肢を格納するlist型。
+            @Type: List
+        """
+        for i in range(len(optionList)):
+            option=optionList[i]
+            if(option is None and anoyValue is None):
+                    return
+            match option:
+                case "!Str":
+                    if(type(anoyValue)==str):
+                        return
+                case "!Bool":
+                    if(type(anoyValue)==bool):
+                        return
+                case "!Int":
+                    if(type(anoyValue)==int):
+                        return
+                case "!Float":
+                    if(type(anoyValue)==float):
+                        return
+                case "!List":
+                    if(type(anoyValue)==list):
+                        return
+                case "!FreeMap":
+                    if(type(anoyValue)==dict):
+                        return
+                case _:
+                    if(anoyValue==option):
+                        return
+        raise AnoyTypeError("!Enum",self._curFile,self._curPath)
+
+
+if(__name__=="__main__"):
+    configPath=r"C:\Users\tomot\Backup\sourcecode\python\projects\annotation_yaml\tests\unit\case01\config01.yaml"
+    anoyPath=r"C:\Users\tomot\Backup\sourcecode\python\projects\annotation_yaml\tests\unit\case01\int_false.yaml"
+    with open(configPath,mode="r",encoding="utf-8") as f:
+        configDict=yaml.safe_load(f)
+    with open(anoyPath,mode="r",encoding="utf-8") as f:
+        anoyDict=yaml.safe_load(f)
+    tree01=DictTraversal(configDict)
+    tree01.dictBFS(anoyDict)
+

cli.py

@@ -3,9 +3,9 @@ from pathlib import Path
 import argparse
 import yaml
 
-from dictTraversal import DictTraversal
+from anoyModule import DictTraversal
 
-VERSION="v0.1.2"
+VERSION="v0.2.0"
 
 def main():
     """
@@ -21,11 +21,9 @@ def main():
     anoyPath=Path(args.anoy)
     with open(configPath,mode="r",encoding="utf-8") as f:
         configDict=yaml.safe_load(f)
-    with open(anoyPath,mode="r",encoding="utf-8") as f:
-        anoyDict=yaml.safe_load(f)
-    print("loadEnd")
     tree01=DictTraversal(configDict)
-    tree01.startBFS(anoyDict)
+    # configのload終了。
+    tree01.dirDFS(anoyPath)
 
 if(__name__=="__main__"):
     main()

anoy-0.1.2.dist-info/METADATA

@@ -1,42 +0,0 @@
-Metadata-Version: 2.4
-Name: anoy
-Version: 0.1.2
-Summary: This is a library that provides simple type checking for YAML.
-Author-email: masaniki <masaniki.software@gmail.com>
-License-Expression: MIT
-Project-URL: Repository, https://github.com/masaniki/annotation-yaml
-Project-URL: Documentation, https://github.com/masaniki/annotation-yaml/tree/master/docs
-Project-URL: Issues, https://github.com/masaniki/annotation-yaml/issues
-Keywords: text,YAML,CLI,type,check
-Classifier: Development Status :: 1 - Planning
-Classifier: Environment :: Console
-Classifier: Natural Language :: Japanese
-Classifier: Natural Language :: English
-Classifier: Topic :: Text Processing
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: PyYAML
-Dynamic: license-file
-
-# fileの説明
-# 原文
-[Original README](docs/README_JP.md)
-
-## /docs
-documentを格納するdirecotry.
-
-## /src
-ここでmoduleを開発する。
-
-## testUnit
-単体testを行うdirectory。
-
-## testSystem
-結合testを行うdirectory。
-
-## sanbox.py
-pythonの挙動を確認する。
-
-
-

anoy-0.1.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-anoyError.py,sha256=4smZo02X8YOv407FRyc12ADXW8foNrFr0pv0pRoQUxo,620
-cli.py,sha256=_eAJeiI8b6JvWhASDbCOuAspmo2qCaDvvVnnZ8SSCxU,1005
-dictTraversal.py,sha256=TaAhUUMUUUvRgZzEpiDUbkQp6WvF42QsTu_2NLGWNos,7793
-anoy-0.1.2.dist-info/licenses/LICENSE.txt,sha256=nsHvySI1U7YZgAX4K3rJsWli_GfXy2syPI-MtGPwjlo,1062
-anoy-0.1.2.dist-info/METADATA,sha256=2r-2BU8yC0MxDT7LXDGre5-fGpmYBP3kM6XU1eY4M_g,1130
-anoy-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-anoy-0.1.2.dist-info/entry_points.txt,sha256=_lpL6R97giGseZcV0r5QwdX4zRwoZLzRHUxyBZl_iYI,34
-anoy-0.1.2.dist-info/top_level.txt,sha256=Ml0_35nDdV_uFyw0sUsvSho29qLH9ppoSOUQKuInsA4,28
-anoy-0.1.2.dist-info/RECORD,,

anoy-0.1.2.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-anoyError
-cli
-dictTraversal

dictTraversal.py

@@ -1,187 +0,0 @@
-import yaml
-
-from anoyError import AnnotationYamlError,ConfigurationYamlError,AnnotationYamlTypeError
-
-class DictTraversal():
-    """
-    @Summ: 辞書型の中身を探索するclass
-
-    @InsVars:
-        _configDict:
-            @Summ: configuration yamlの中身。
-            @Type: Dict
-        _configVisit:
-            @Summ: configuration yaml内のannotationKeyを使った否かを記録する変数。
-            @Desc: {annotationKey(str):訪れた⇒True(bool)}
-            @Type: Dict
-        _visitQueue:
-            @Summ: 探索queue
-            @Desc: BFSなのでFIFO。
-            @Type: List
-        _pathQueue:
-            @Summ: 探索する要素の相対pathを格納する。
-            @Desc:
-            - visitQueueと要素番号を共有する。
-            - []でroot要素を表す。
-            @Type: List
-    """
-    def __init__(self,configDict:dict):
-        """
-        @Summ: constructor.
-        """
-        self._configDict=configDict
-        self._visitQueue=[]
-        self._pathQueue=[]
-        self._configVisit={key:False for key in configDict.keys()}
-
-    def startBFS(self,anoyDict:dict):
-        """
-        @Summ: 幅優先探索を開始する関数。
-
-        @Desc:
-        - list型は単純に探索する。
-        - dict型は型確認しながら探索する。
-        - visitQueueには(key(str),value(any))のtupleを入れる。
-        - list型の時は、(key(int),value(any))になる。
-        @Args:
-            anoyDict:
-                @Summ: annotation yamlのdict型。
-        """
-        self._visitQueue=[(None,anoyDict)]
-        self._pathQueue=[[]]
-        while(True):
-            if(self._visitQueue==[]):
-                break
-            key,value=self._visitQueue.pop(0)
-            pathList=self._pathQueue.pop(0)
-            print(key,value)
-            print(pathList)
-            self.typeCheck(key,value,pathList)
-
-    def typeCheck(self,parentKey:str|None,childValue,path:list):
-        """
-        "@Summ": annoDict内を探索する関数。
-
-        "@Desc":
-        - 型確認は"!ParentKey"と"!ChildValue"の2つだ。
-        - annotationKeyが親でない時は、"!ParentKey"も"!ChildValue"も効力を発揮しないので無視。
-        - ただし、annoKeyがNoneの時は、"!ParentKey"が効力を発揮する場合がある。
-        - !ChildValueが無い時は何もしない。
-        - !ChildValueが無い時は、childValue=nullとして考える。
-        - valueがanoyDict型の時のみ、!ParentKeyの型確認が行われる。
-
-        "@Args":
-            parentKey:
-                "@Summ": 探索するdict型のkey。
-                "@Desc":
-                - nullは親要素が存在しないことを表す(つまりvalueがroot要素である)。
-                "@Type":
-                    Union:
-                    - Str
-                    - null
-            childValue:
-                "@Summ": 探索するdict型のvalue。
-                "@Type": Any
-            path:
-                @Summ: 今まで経由したkeyのlist。
-                @Type: List
-        "@Error":
-        - AnnotationYamlError
-        - AnnotationYamlTypeError
-        - ConfigurationYamlError
-        """
-        if(parentKey is None):
-            confChildVal=None    #confChild=Noneの時は型確認をしない。
-        elif(type(parentKey)!=str):
-            confChildVal=None
-        elif(parentKey[0]=="@"):
-            confChild=self._configDict.get(parentKey)
-            if(confChild is None):
-                raise ConfigurationYamlError(f"`{parentKey}` is not defined.")
-            confChildVal=confChild.get("!ChildValue")
-        else:
-            confChildVal=None
-        if(type(confChildVal)==dict):
-            #Enum型の型確認。
-            # config yaml側の型確認。
-            confKeyList=list(confChildVal.keys())
-            if(len(confKeyList)!=1 or confKeyList[0]!="Enum"):
-                raise ConfigurationYamlError(f"`{parentKey}` has invalid definition.")
-            confValueList=confChildVal["Enum"]
-            if(type(confValueList)!=list):
-                raise ConfigurationYamlError(f"`{parentKey}` has invalid definition.")
-            # annotaion yaml側の型確認。
-            for i in range(len(confValueList)):
-                if(childValue==confValueList[i]):
-                    return
-            raise AnnotationYamlTypeError("Enum",path)
-        elif(type(childValue)==bool):
-            if((confChildVal is None) or confChildVal=="Bool"):
-                return
-            else:
-                raise AnnotationYamlTypeError("Bool",path)
-        elif(type(childValue)==str):
-            if((confChildVal is None or confChildVal=="Str")):
-                return
-            else:
-                raise AnnotationYamlTypeError("Str",path)
-        elif(type(childValue)==int):
-            if((confChildVal is None) or confChildVal=="Int"):
-                return
-            else:
-                raise AnnotationYamlTypeError("Int",path)
-        elif(type(childValue)==float):
-            if((confChildVal is None) or confChildVal=="Float"):
-                return
-            else:
-                raise AnnotationYamlTypeError("Float",path)
-        elif(type(childValue)==list):
-            if((confChildVal is None) or confChildVal=="List"):
-                for i in range(len(childValue)):
-                    newPath=path+[i]
-                    self._visitQueue.append((i,childValue[i]))
-                    self._pathQueue.append(newPath)
-                return
-            else:
-                raise AnnotationYamlTypeError("List",path)
-        elif(type(childValue)==dict):
-            if(confChildVal is None):
-                for key,childValue in childValue.items():
-                    newPath=path+[key]
-                    self._visitQueue.append((key,childValue))
-                    self._pathQueue.append(newPath)
-                return
-            elif(confChildVal=="FreeDict"):
-                for key,childValue in childValue.items():
-                    newPath=path+[key]
-                    self._visitQueue.append((key,childValue))
-                    self._pathQueue.append(newPath)
-                    if(key[0]=="@"):
-                        raise AnnotationYamlTypeError("FreeDict",path)
-                return
-            elif(confChildVal=="AnnoDict"):
-                for key,childValue in childValue.items():
-                    newPath=path+[key]
-                    self._visitQueue.append((key,childValue))
-                    self._pathQueue.append(newPath)
-                    confParent=self._configDict[key].get("!ParentKey")
-                    if(key[0]!="@"):
-                        raise AnnotationYamlTypeError("AnnoDict",path)
-                    if(confParent is None):
-                        pass
-                    elif(parentKey not in confParent):
-                        raise AnnotationYamlTypeError("AnnoDict",path)
-                return
-        else:
-            raise AnnotationYamlError(f" invalid value is found at:\n    `{path}`.")
-
-if(__name__=="__main__"):
-    configPath=r"C:\Users\tomot\Backup\sourcecode\python\projects\annotation_yaml\tests\unit\case01\config01.yaml"
-    anoyPath=r"C:\Users\tomot\Backup\sourcecode\python\projects\annotation_yaml\tests\unit\case01\int_false.yaml"
-    with open(configPath,mode="r",encoding="utf-8") as f:
-        configDict=yaml.safe_load(f)
-    with open(anoyPath,mode="r",encoding="utf-8") as f:
-        anoyDict=yaml.safe_load(f)
-    tree01=DictTraversal(configDict)
-    tree01.startBFS(anoyDict)
-