shikake 0.0.1__tar.gz

shikake-0.0.1/CHANGELOG.md

@@ -0,0 +1,41 @@
+# shikake changelog
+
+This changelog summarizes user-facing changes by release. Design decisions and development history remain in Japanese canonical sources: [pre-release history](devdocs/canonical_sources/development_history/pre_release.py) and [performance refactoring history](devdocs/canonical_sources/development_history/performance.py).
+
+## 0.0.1 - 2026-10-23
+
+**Initial Alpha release.** The public API may change incompatibly in subsequent versions.
+
+### Added
+
+- **AST-based modeling:** Kinds, Structures, Features, and role-based Models. Strict `parse_source()` / `parse_package()` and diagnostic Partial `inspect_source()` / `inspect_package()` APIs, plus bounded `format_model_tree()` output.
+- **Input selection:** `extensions` and the `include` callback select files and directories for package analysis. Custom suffixes are permitted; their contents must still be parseable as Python AST. Regular `.py` files are the default.
+- **Syntax validation:** Non-executing CPython compilation checks by default; `syntax_validation="ast"` skips the additional compilation check.
+- **External definitions:** Trusted Shikumi declarations or `ExternalDefinitionsBuilder` can define external Kinds, Structures, and call mappings.
+- **Import permissions:** Three `import_policy` modes and arbitrary absolute module names in `allowed_modules`, without runtime import resolution or sandbox guarantees.
+- **Static information:** Base-class reference and override candidates, scoped `name_bindings`, and three binding dimensions. Neither definite assignment nor runtime name resolution is guaranteed.
+
+### Python syntax support
+
+- Models Python 3.12 `type` statements and generics, Python 3.13 type-parameter defaults, Python 3.14 t-strings and multiple-exception syntax, and Python 3.15 PEP 798 unpacking comprehensions.
+- Dictionary-unpacking comprehensions use `model.value.comprehension.dict.unpacking`.
+- Explicit Python 3.15 `lazy import` and `lazy from ... import` use the ordinary import Kinds and Structures with a `lazy` Feature on the import statement. Binding dimensions and static reference rules are unchanged; runtime lazy loading is not modeled.
+- Python 3.13-and-earlier baseline rules and 3.14+ overlays are internal. No public model-version selection API is provided.
+
+### Performance improvements
+
+- **Structural Model hashes:** Model instances lazily cache their structural hashes. Hashing a parent also caches computed hashes for its descendants, reducing repeated traversal when those Models are subsequently reused. Structural equality, hash computation rules, and iterative traversal are preserved.
+- **Relationship lookups:** `PackageModel.bindings_for()`, `bases_for()`, and `overrides_for()` use internal identity-based indexes rather than scanning every relationship on each call. Result contents, order, and the public API are unchanged.
+- These internal optimizations trade some Model initialization, indexing, and hash-caching time and memory for faster repeated operations.
+
+### Diagnostics and developer tooling
+
+- **PackageModel diagnostics:** `repr(package)` provides a bounded summary of the composition Model, selected analyses, and counts of bindings, base references, and override candidates, without expanding each relationship fact. Use attributes and lookup methods for full information.
+- **SourceInspection diagnostics:** `repr(inspection)` summarizes the Model and displays a name-binding count rather than expanding every binding. Both inspection result types keep complete `issues` content in their representations.
+- **Documentation generator tests:** Expected argparse errors are captured and asserted in invalid-input tests, keeping test output clean. CLI error messages are unchanged.
+
+### Publication and compatibility notes
+
+- The distribution and public import name is **`shikake`**. No compatibility import under the former development name `kangen` is provided.
+- The Japanese canonical sources are authoritative. See the [API Reference](docs/api_reference/INDEX.md) and [Status](docs/STATUS.md) for the current contracts, limitations, and separately recorded interpreter test evidence.
+- Consult the actual PyPI distribution or GitHub release for downloadable artifacts and publication status.

shikake-0.0.1/LICENSE

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

shikake-0.0.1/MANIFEST.in

@@ -0,0 +1,18 @@
+# Keep the source distribution self-contained for tests and canonical source editing.
+include Makefile
+include README.md
+include CHANGELOG.md
+graft docs
+graft tests
+graft devdocs
+prune devdocs/canonical_documents
+
+# Exclude generated caches and temporary files from the source archive.
+prune .pytest_cache
+prune .ruff_cache
+prune .basedpyright
+prune .pyright
+prune build
+prune dist
+global-exclude *.py[cod]
+global-exclude .DS_Store CACHEDIR.TAG

shikake-0.0.1/Makefile

@@ -0,0 +1,15 @@
+.PHONY: test lint format-check typecheck check
+
+test:
+	python -m unittest discover -s tests -v
+
+lint:
+	ruff check .
+
+format-check:
+	ruff format --check .
+
+typecheck:
+	basedpyright
+
+check: test lint format-check typecheck

shikake-0.0.1/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: shikake
+Version: 0.0.1
+Summary: Experimental AST-based Python source modeling library
+Author: minoru-jp
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/minoru-jp/shikake
+Project-URL: Repository, https://github.com/minoru-jp/shikake
+Project-URL: Documentation, https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md
+Keywords: python-ast,static-analysis,source-modeling,transpilation,restricted-python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: shikumi<2.0.0,>=0.2.4
+Provides-Extra: dev
+Requires-Dist: shikumi-devdoc==0.3.5; extra == "dev"
+Requires-Dist: ruff==0.16.10; extra == "dev"
+Requires-Dist: basedpyright==1.40.1; extra == "dev"
+Dynamic: license-file
+
+# shikake
+
+**shikake** is an AST-based library that models the static structures and relationships of Python source code according to consumer-defined, domain-specific structural conventions.
+
+It provides building blocks for working with Python code under your own rules, including transpilation and the design or validation of restricted Python dialects. You can also define custom structures and have designated Python constructs modeled using those structures.
+
+Python syntax validation defaults to CPython's non-executing compilation level (`syntax_validation="compile"`). Use `syntax_validation="ast"` to skip compilation checks when modeling AST-parseable restricted dialects; unsupported shikake syntax remains unsupported. This does not execute input code or guarantee runtime correctness.
+
+## Development status (Alpha)
+
+shikake is currently in **Alpha**. Public APIs, specifications, and data structures may change incompatibly without prior notice. See [STATUS](https://github.com/minoru-jp/shikake/blob/HEAD/docs/STATUS.md) for current progress.
+
+## Core concepts
+
+Rather than preserving Python syntax verbatim, shikake represents selected syntactic information in a form that consumers can interpret for their own purposes.
+
+### Model structure
+
+- **Kind** classifies a syntactic element.
+- **Structure** specifies the roles and shapes of its constituent parts.
+- **Feature** captures orthogonal characteristics, such as `async` or an explicitly written `lazy` import modifier.
+- **Model** holds a concrete element according to these definitions.
+
+Trusted external Shikumi declarations or an `ExternalDefinitionsBuilder` using Python data can add Kinds and Structures, and registered calls are represented by dedicated Models during parsing. External Feature declarations are not currently supported.
+
+### Three dimensions of name binding
+
+shikake represents three independent properties of a name's binding:
+
+- `introduction`: whether the introduction is structurally stable (`stable` or `unstable`).
+- `may_rebind`: whether a name may be rebound by a later or repeatable write, or by an augmented assignment.
+- `may_delete`: whether the syntax indicates possible deletion.
+
+For example, `x = 1` alone has `may_rebind=False`; adding `x = 2` makes it `True`. A lone `n += 1` does not establish a stable introduction. These are **syntactic facts**, not predictions of execution, definite assignment, or judgments about code quality.
+
+### Static relationship candidates
+
+shikake can report candidate targets of base-class references and same-name method override candidates. These are candidates supported by the AST, not guarantees about runtime targets or method resolution order. See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for the available results and links to their specifications.
+
+## Installation
+
+Python 3.11 or later is required. CI targets Python 3.11–3.15; Python 3.14 t-strings are modeled as distinct Kinds.
+
+```bash
+python -m pip install shikake
+```
+
+## Quick start
+
+```python
+import shikake
+
+source = '''
+class Counter:
+    def __init__(self, start=0):
+        self.value = start
+
+    def increase(self, amount):
+        if amount > 0:
+            self.value += amount
+        return self.value
+
+def calculate(values):
+    counter = Counter()
+    for value in values:
+        counter.increase(value)
+    return counter.value
+'''
+
+root = shikake.parse_source(source)
+
+for model in root.walk():
+    print(model.kind.id)
+    print([part.role for part in model.parts()])
+```
+
+`parse_source()` builds a Model from one Python source string, and `walk()` traverses its composition tree. Kind, Structure, and Feature let consumers classify elements without depending directly on their original AST nodes.
+
+### Strict and Partial analysis
+
+- **Strict:** `parse_source()` and `parse_package()` require a complete result and raise on unsupported syntax or invalid structures.
+- **Partial:** `inspect_source()` and `inspect_package()` return available results together with diagnostics when full analysis is not possible.
+
+Use Strict analysis when completeness is required, and Partial analysis to inspect unsupported or incomplete inputs. **An incomplete Partial result must not be treated as a fully analyzed input.** Consult the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for details.
+
+For package analysis, pass an `include(path, is_directory)` callback to `parse_package()` or `inspect_package()` to choose subdirectories and matching source files. Returning `False` for a directory prunes that entire subtree. The `extensions=(".py",)` parameter selects source suffixes: `(".dot",)` chooses only `.dot` and `(".py", ".dot")` chooses both. These files must contain Python syntax. By default **all** regular `.py` files are included, including those under `.venv`; shikake does not impose exclusion patterns. See [Package input selection](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/public.md#package-input-extensions-extensions-and-selection-include).
+
+### Optional import permissions
+
+Each parsing/inspection API supports `import_policy="unrestricted"` (default), `"registered_interfaces"` (only explicitly imported registered interfaces), and `"registered_modules"` (registered external modules plus caller-specified `allowed_modules=("math", "custom_tools")`). `registered_modules` also permits every explicit registered-interface import. Both restricted modes admit the single directive `from __future__ import annotations`. Relative imports, including within the analyzed package, remain forbidden: change them to absolute imports and explicitly allow the written module names as needed. `allowed_modules` names must be NFKC-normalized. These checks compare written absolute module names without importing them and do not provide a security sandbox. See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/public.md#caller-selected-import-restrictions-import_policy-allowed_modules).
+
+## External structures
+
+Consumers can define custom Kinds and Structures with trusted Shikumi declarations or `shikake.external.ExternalDefinitionsBuilder` and provide them to the parser. For example, a transpiler may map a Python-facing memory or I/O interface to special operations in its target language.
+
+When their documented conditions are met, explicitly imported calls registered as external operations produce dedicated Models instead of ordinary Python call Models. This is not general-purpose resolution of arbitrary libraries: explicit-import and reserved-name rules constrain recognition. See the [External Definitions API](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/external.md).
+
+## Using analysis results
+
+Transpilation and restricted-Python validation share a basic pattern: inspect Kind, Structure, and Feature information, optionally consult binding facts and static relationship candidates, and then **apply the consumer's own rules** to translate or accept/reject the input.
+
+shikake does not define those downstream rules. Models are intended to be obtained from the official parsing APIs; constructing your own Models is unsupported.
+
+## Limitations
+
+shikake does not execute source code, evaluate values, infer types, or resolve dynamic names. Models do not aim to reproduce the original Python code perfectly or to establish its runtime semantics. Syntactic inspection alone does not provide a secure execution sandbox.
+
+See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for individual contracts and the [Documentation Policy](https://github.com/minoru-jp/shikake/blob/HEAD/docs/DOCUMENTATION_POLICY.md) for how the sources are managed.
+
+## Documentation
+
+[API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) | [Status](https://github.com/minoru-jp/shikake/blob/HEAD/docs/STATUS.md) | [Changelog](https://github.com/minoru-jp/shikake/blob/HEAD/CHANGELOG.md) | [Documentation Policy](https://github.com/minoru-jp/shikake/blob/HEAD/docs/DOCUMENTATION_POLICY.md)
+
+## License
+
+shikake is distributed under the [MIT License](https://github.com/minoru-jp/shikake/blob/HEAD/LICENSE).

shikake-0.0.1/README.md

@@ -0,0 +1,116 @@
+# shikake
+
+**shikake** is an AST-based library that models the static structures and relationships of Python source code according to consumer-defined, domain-specific structural conventions.
+
+It provides building blocks for working with Python code under your own rules, including transpilation and the design or validation of restricted Python dialects. You can also define custom structures and have designated Python constructs modeled using those structures.
+
+Python syntax validation defaults to CPython's non-executing compilation level (`syntax_validation="compile"`). Use `syntax_validation="ast"` to skip compilation checks when modeling AST-parseable restricted dialects; unsupported shikake syntax remains unsupported. This does not execute input code or guarantee runtime correctness.
+
+## Development status (Alpha)
+
+shikake is currently in **Alpha**. Public APIs, specifications, and data structures may change incompatibly without prior notice. See [STATUS](https://github.com/minoru-jp/shikake/blob/HEAD/docs/STATUS.md) for current progress.
+
+## Core concepts
+
+Rather than preserving Python syntax verbatim, shikake represents selected syntactic information in a form that consumers can interpret for their own purposes.
+
+### Model structure
+
+- **Kind** classifies a syntactic element.
+- **Structure** specifies the roles and shapes of its constituent parts.
+- **Feature** captures orthogonal characteristics, such as `async` or an explicitly written `lazy` import modifier.
+- **Model** holds a concrete element according to these definitions.
+
+Trusted external Shikumi declarations or an `ExternalDefinitionsBuilder` using Python data can add Kinds and Structures, and registered calls are represented by dedicated Models during parsing. External Feature declarations are not currently supported.
+
+### Three dimensions of name binding
+
+shikake represents three independent properties of a name's binding:
+
+- `introduction`: whether the introduction is structurally stable (`stable` or `unstable`).
+- `may_rebind`: whether a name may be rebound by a later or repeatable write, or by an augmented assignment.
+- `may_delete`: whether the syntax indicates possible deletion.
+
+For example, `x = 1` alone has `may_rebind=False`; adding `x = 2` makes it `True`. A lone `n += 1` does not establish a stable introduction. These are **syntactic facts**, not predictions of execution, definite assignment, or judgments about code quality.
+
+### Static relationship candidates
+
+shikake can report candidate targets of base-class references and same-name method override candidates. These are candidates supported by the AST, not guarantees about runtime targets or method resolution order. See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for the available results and links to their specifications.
+
+## Installation
+
+Python 3.11 or later is required. CI targets Python 3.11–3.15; Python 3.14 t-strings are modeled as distinct Kinds.
+
+```bash
+python -m pip install shikake
+```
+
+## Quick start
+
+```python
+import shikake
+
+source = '''
+class Counter:
+    def __init__(self, start=0):
+        self.value = start
+
+    def increase(self, amount):
+        if amount > 0:
+            self.value += amount
+        return self.value
+
+def calculate(values):
+    counter = Counter()
+    for value in values:
+        counter.increase(value)
+    return counter.value
+'''
+
+root = shikake.parse_source(source)
+
+for model in root.walk():
+    print(model.kind.id)
+    print([part.role for part in model.parts()])
+```
+
+`parse_source()` builds a Model from one Python source string, and `walk()` traverses its composition tree. Kind, Structure, and Feature let consumers classify elements without depending directly on their original AST nodes.
+
+### Strict and Partial analysis
+
+- **Strict:** `parse_source()` and `parse_package()` require a complete result and raise on unsupported syntax or invalid structures.
+- **Partial:** `inspect_source()` and `inspect_package()` return available results together with diagnostics when full analysis is not possible.
+
+Use Strict analysis when completeness is required, and Partial analysis to inspect unsupported or incomplete inputs. **An incomplete Partial result must not be treated as a fully analyzed input.** Consult the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for details.
+
+For package analysis, pass an `include(path, is_directory)` callback to `parse_package()` or `inspect_package()` to choose subdirectories and matching source files. Returning `False` for a directory prunes that entire subtree. The `extensions=(".py",)` parameter selects source suffixes: `(".dot",)` chooses only `.dot` and `(".py", ".dot")` chooses both. These files must contain Python syntax. By default **all** regular `.py` files are included, including those under `.venv`; shikake does not impose exclusion patterns. See [Package input selection](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/public.md#package-input-extensions-extensions-and-selection-include).
+
+### Optional import permissions
+
+Each parsing/inspection API supports `import_policy="unrestricted"` (default), `"registered_interfaces"` (only explicitly imported registered interfaces), and `"registered_modules"` (registered external modules plus caller-specified `allowed_modules=("math", "custom_tools")`). `registered_modules` also permits every explicit registered-interface import. Both restricted modes admit the single directive `from __future__ import annotations`. Relative imports, including within the analyzed package, remain forbidden: change them to absolute imports and explicitly allow the written module names as needed. `allowed_modules` names must be NFKC-normalized. These checks compare written absolute module names without importing them and do not provide a security sandbox. See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/public.md#caller-selected-import-restrictions-import_policy-allowed_modules).
+
+## External structures
+
+Consumers can define custom Kinds and Structures with trusted Shikumi declarations or `shikake.external.ExternalDefinitionsBuilder` and provide them to the parser. For example, a transpiler may map a Python-facing memory or I/O interface to special operations in its target language.
+
+When their documented conditions are met, explicitly imported calls registered as external operations produce dedicated Models instead of ordinary Python call Models. This is not general-purpose resolution of arbitrary libraries: explicit-import and reserved-name rules constrain recognition. See the [External Definitions API](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/external.md).
+
+## Using analysis results
+
+Transpilation and restricted-Python validation share a basic pattern: inspect Kind, Structure, and Feature information, optionally consult binding facts and static relationship candidates, and then **apply the consumer's own rules** to translate or accept/reject the input.
+
+shikake does not define those downstream rules. Models are intended to be obtained from the official parsing APIs; constructing your own Models is unsupported.
+
+## Limitations
+
+shikake does not execute source code, evaluate values, infer types, or resolve dynamic names. Models do not aim to reproduce the original Python code perfectly or to establish its runtime semantics. Syntactic inspection alone does not provide a secure execution sandbox.
+
+See the [API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) for individual contracts and the [Documentation Policy](https://github.com/minoru-jp/shikake/blob/HEAD/docs/DOCUMENTATION_POLICY.md) for how the sources are managed.
+
+## Documentation
+
+[API Reference](https://github.com/minoru-jp/shikake/blob/HEAD/docs/api_reference/INDEX.md) | [Status](https://github.com/minoru-jp/shikake/blob/HEAD/docs/STATUS.md) | [Changelog](https://github.com/minoru-jp/shikake/blob/HEAD/CHANGELOG.md) | [Documentation Policy](https://github.com/minoru-jp/shikake/blob/HEAD/docs/DOCUMENTATION_POLICY.md)
+
+## License
+
+shikake is distributed under the [MIT License](https://github.com/minoru-jp/shikake/blob/HEAD/LICENSE).

shikake-0.0.1/devdocs/build_api_index.py

@@ -0,0 +1,76 @@
+"""Derive the English API index from the two published API translations.
+
+The index is navigation, not a separate canonical document. To change an API
+contract, edit its Japanese canonical source and republish its translation first.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+API_DOCS = ROOT / "docs" / "api_reference"
+API_HEADING = re.compile(r"^## (API_\d{3}): `([^`]+)`$", re.MULTILINE)
+
+
+def render_index(directory: Path = API_DOCS) -> str:
+    sections = [
+        "# API Reference",
+        "",
+        (
+            "Public API documentation translated from Japanese canonical sources. "
+            "Specification links in these pages lead directly to the Japanese Python source modules."
+        ),
+        "",
+        (
+            "See the [README](../../README.md), [STATUS](../STATUS.md), and "
+            "[Documentation Policy](../DOCUMENTATION_POLICY.md)."
+        ),
+        "",
+        (
+            "Usage topics: [Relationship analysis selection]"
+            "(public.md#relationship-analysis-selection-analyses) and "
+            "[minimal external definition example]"
+            "(external.md#minimal-working-example)."
+        ),
+        "",
+    ]
+    for filename, heading in (
+        ("public.md", "Core Python API"),
+        ("external.md", "External Definitions API"),
+    ):
+        content = (directory / filename).read_text(encoding="utf-8")
+        names = API_HEADING.findall(content)
+        if not names:
+            raise ValueError(f"no API entries in {filename}")
+        sections.extend((f"## {heading}", ""))
+        for identifier, name in names:
+            suffix = re.sub(r"[^a-z0-9_-]", "", name.lower())
+            anchor = identifier.lower() + "-" + suffix
+            sections.append(f"- [{identifier}: `{name}`]({filename}#{anchor})")
+        sections.append("")
+    return "\n".join(sections)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--check", action="store_true", help="verify the current index without writing"
+    )
+    args = parser.parse_args()
+    expected = render_index()
+    path = API_DOCS / "INDEX.md"
+    if args.check:
+        if not path.exists() or path.read_text(encoding="utf-8") != expected:
+            parser.error(
+                "API index is outdated: regenerate from the published API pages"
+            )
+    else:
+        path.write_text(expected, encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

shikake-0.0.1/devdocs/canonical_sources/api_reference/__init__.py

@@ -0,0 +1 @@
+"""shikakeの公開Python APIの正本参照。"""