annnet 0.0.1__tar.gz

annnet-0.0.1/.gitignore

@@ -0,0 +1,69 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/
+.vscode/
+.ipynb_checkpoints/
+
+# CMake
+cmake-build-*/
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+# Exclude external libraries
+/demo/lib/
+
+# Exclude all demo output files
+/data/output/
+
+# Exclude all demo input files obtainable via demo script
+/data/input/demo*
+/data/input/custom*
+/data/input/*sh
+
+# Exclude all input files obtainable from GSE, GTEx, TCGS etc
+/data/input/GTEx/
+/data/input/GSE/
+/data/input/KGs/
+/data/input/mouse/
+/data/input/TCGA/
+/data/input/web_Google.txt
+
+# Esclude eventual test plot files
+/tests/*.pdf
+
+# Exclude
+*.pyc
+__pycache__/
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+ENV/
+build/
+dist/
+*.egg-info/
+test_venv/
+*venv*/
+test_venv/

annnet-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Saez Lab
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

annnet-0.0.1/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: annnet
+Version: 0.0.1
+Summary: A Python tool to build, manipulate, and interoperate with flexible graph structures
+Project-URL: Documentation, https://annnet.readthedocs.io/
+Project-URL: Homepage, https://github.com/saezlab/annnet
+Project-URL: Issues, https://github.com/saezlab/annnet/issues
+Project-URL: Repository, https://github.com/saezlab/annnet
+Author-email: Youssef Zerta <youssef.zerta@biomedtech.ueuromed.org>, Bottazzi Daniele <daniele.bottazzi@mail.polimi.it>, Denes Turei <turei.denes@gmail.com>
+Maintainer-email: Bottazzi Daniele <daniele.bottazzi@mail.polimi.it>, Youssef Zerta <youssef.zerta@biomedtech.ueuromed.org>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: polars>=0.20.0
+Requires-Dist: scipy>=1.9.0
+Provides-Extra: all
+Requires-Dist: lxml>=5; extra == 'all'
+Requires-Dist: matplotlib>=3.8; extra == 'all'
+Requires-Dist: networkx>=3.3; extra == 'all'
+Requires-Dist: numcodecs>=0.12; extra == 'all'
+Requires-Dist: openpyxl>=3.1; extra == 'all'
+Requires-Dist: pandas>=2.0.3; extra == 'all'
+Requires-Dist: pyarrow>=14; extra == 'all'
+Requires-Dist: python-igraph>=0.11; extra == 'all'
+Requires-Dist: zarr>=2.18; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-jupyter>=0.25; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.1; extra == 'excel'
+Provides-Extra: igraph
+Requires-Dist: python-igraph>=0.11; extra == 'igraph'
+Provides-Extra: networkx
+Requires-Dist: networkx>=3.3; extra == 'networkx'
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0.3; extra == 'pandas'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=14; extra == 'parquet'
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.8; extra == 'plot'
+Provides-Extra: sbml
+Requires-Dist: lxml>=5; extra == 'sbml'
+Provides-Extra: tests
+Requires-Dist: codecov-cli>=10.2.0; extra == 'tests'
+Requires-Dist: coverage>=6.0; extra == 'tests'
+Requires-Dist: diff-cover; extra == 'tests'
+Requires-Dist: tox-gh>=1.5.0; extra == 'tests'
+Requires-Dist: tox>=4.11; extra == 'tests'
+Provides-Extra: zarr-io
+Requires-Dist: numcodecs>=0.12; extra == 'zarr-io'
+Requires-Dist: zarr>=2.18; extra == 'zarr-io'
+Description-Content-Type: text/markdown
+
+## Description
+
+**annnet** is a lightweight, flexible, minimal-dependencies Python package for creating, manipulating, and interoperating with diverse graph data structures. It aims to be the connective tissue ("glue") between multiple graph ecosystems (NetworkX, igraph, graph-tool, etc.) while maintaining a clean and general-purpose internal representation.
+
+---
+
+## 📌 Description
+
+annnet provides a unified interface for:
+
+- Building general-purpose graphs (simple, directed, hyper, signed, etc.)
+- Managing node/edge annotations
+- Indexing and fast lookups
+- Importing from or exporting to various tools and file formats
+
+Its design supports complex workflows in data science, bioinformatics, and network theory — without locking you into a specific graph backend.
+
+---
+
+## ✅ Features
+
+### General Graph Modeling
+- Simple graphs, directed graphs, multigraphs
+- Hypergraphs (via edge sets or higher-order relationships)
+- Signed and weighted edges
+- Rich node/edge annotations
+- Efficient indexing and lookups
+
+### Import Support
+- CSV, JSON, and flat files
+- Native import from existing objects:
+  - `networkx.Graph`
+  - `igraph.Graph`
+  - `graph_tool.Graph`
+  - `corneto.Graph`
+
+### Export & Interoperability
+- NetworkX (`to_networkx()`)
+- igraph (`to_igraph()`)
+- graph-tool (`to_graphtool()`)
+- [CORNETO](https://corneto.org/)
+- CSV, JSON, and custom serializations
+
+### Backend-specific Integration (if installed)
+
+If `networkx` is installed, you can call any NetworkX algorithm directly using dot notation:
+
+```python
+centrality = G.nx.degree_centrality()
+```
+**How it works:**
+
+1. annnet converts `G` to a NetworkX object on demand, abstracting away all the non-needed attributes.
+2. Runs the algorithm _as-is_.
+3. Returns results directly, syncing any graph changes back to the internal representation of the `gg.Graph`.
+
+This allows you to access the full power of NetworkX algorithms with zero boilerplate.
+
+---
+
+## 🛠️ Installation
+To install annnet, you can use pip:
+
+```bash
+pip install annnet
+```
+
+Optional dependencies for extended functionality:
+
+```bash
+pip install annnet[networkx,igraph]
+pip install annnet[graph-tool]
+pip install annnet[corneto]
+```
+
+---
+
+## 🚀 Quick Start
+
+```python
+import annnet as gg
+
+# Create a new graph
+G = gg.Graph(directed=True, backend="corneto")
+
+# Add nodes and edges
+G.add_node("A", type="gene")
+G.add_node("B", type="protein")
+G.add_edge("A", "B", sign="+", source="literature")
+
+# Run a NetworkX algorithm (if installed)
+path = G.nx.shortest_path(source="A", target="B")
+
+# Export to JSON
+G.to_json("graph.json")
+```
+
+---
+
+## 📦 Refined Package Structure
+The package is organized to separate core functionality, I/O operations, adapters for external libraries, and algorithms. This modular design allows for easy extension and maintenance.
+
+```
+annnet/
+│
+├── __init__.py                # Public API surface, version, re-exports
+├── _version.py                # Single source of truth for __version__
+│
+├── core/                      # Core, always-installed logic
+│   ├── __init__.py
+│   ├── _base.py               # BaseGraph class and common interfaces 
+│   ├── _graph.py              # Graph class and internal state manager
+│   ├── structure.py           # Core data structures (nodes, edges, incidence)
+│   ├── metadata.py            # Node/edge attribute store and access helpers
+│   ├── views.py               # Subgraph views, shallow/deep copies
+│   └── state.py               # Graph history, change tracking, and lazy loading
+│
+├── io/                        # Loaders and writers for files
+│   ├── __init__.py
+│   ├── csv.py                 # CSV format (edge list, node table)
+│   ├── json.py                # JSON or JSONL parsing (streamable)
+│   ├── registry.py            # Entry point registration for loaders/dumpers
+│   └── utils.py               # Format detection, path helpers
+│
+├── adapters/                  # Lazy integration with external libraries
+│   ├── __init__.py
+│   ├── _base.py               # AbstractAdapter, adapter interface
+│   ├── _proxy.py              # Tiny forwarding proxy
+│   ├── manager.py             # Adapter registry and lazy bridge logic
+│   ├── networkx.py            # If available: convert, cache, sync with NetworkX
+│   ├── igraph.py              # If available
+│   ├── graphtool.py           # If available
+│   └── corneto.py             # If available
+│
+├── algorithms/                # Pure-python algorithms using core only
+│   ├── __init__.py
+│   └── traversal.py           # BFS/DFS etc.
+│
+└── utils/                     # Generic helpers not tied to graph structure
+    ├── validation.py
+    ├── typing.py
+    └── config.py              # Global options, logging, toggles
+```
+
+---
+
+## ⚙️ Internal Design
+annnet intelligently adapts its internal representation for performance and compatibility:
+
+- Chooses between edge lists, incidence matrices, and adjacency dicts automatically
+- Keeps metadata (node/edge attributes) separate from core structure
+- Lazy construction of external library representations (e.g., NetworkX) only when needed
+- Copy-on-write design for subgraphs and structural mutations
+
+---
+
+## 🧭  Philosophy
+annnet vis designed with these principles in mind:
+
+- **Simple**, consistent interface for all graph types
+- **Interoperability-first**: integrate, don’t replace
+- **Performance-aware**, not performance-obsessed
+- **Extendable** and modular, not monolithic
+
+---
+
+## 📜 License
+annnet is licensed under the BSD-3 License. See the [LICENSE](LICENSE) file for details.
+

annnet-0.0.1/README.md

@@ -0,0 +1,169 @@
+## Description
+
+**annnet** is a lightweight, flexible, minimal-dependencies Python package for creating, manipulating, and interoperating with diverse graph data structures. It aims to be the connective tissue ("glue") between multiple graph ecosystems (NetworkX, igraph, graph-tool, etc.) while maintaining a clean and general-purpose internal representation.
+
+---
+
+## 📌 Description
+
+annnet provides a unified interface for:
+
+- Building general-purpose graphs (simple, directed, hyper, signed, etc.)
+- Managing node/edge annotations
+- Indexing and fast lookups
+- Importing from or exporting to various tools and file formats
+
+Its design supports complex workflows in data science, bioinformatics, and network theory — without locking you into a specific graph backend.
+
+---
+
+## ✅ Features
+
+### General Graph Modeling
+- Simple graphs, directed graphs, multigraphs
+- Hypergraphs (via edge sets or higher-order relationships)
+- Signed and weighted edges
+- Rich node/edge annotations
+- Efficient indexing and lookups
+
+### Import Support
+- CSV, JSON, and flat files
+- Native import from existing objects:
+  - `networkx.Graph`
+  - `igraph.Graph`
+  - `graph_tool.Graph`
+  - `corneto.Graph`
+
+### Export & Interoperability
+- NetworkX (`to_networkx()`)
+- igraph (`to_igraph()`)
+- graph-tool (`to_graphtool()`)
+- [CORNETO](https://corneto.org/)
+- CSV, JSON, and custom serializations
+
+### Backend-specific Integration (if installed)
+
+If `networkx` is installed, you can call any NetworkX algorithm directly using dot notation:
+
+```python
+centrality = G.nx.degree_centrality()
+```
+**How it works:**
+
+1. annnet converts `G` to a NetworkX object on demand, abstracting away all the non-needed attributes.
+2. Runs the algorithm _as-is_.
+3. Returns results directly, syncing any graph changes back to the internal representation of the `gg.Graph`.
+
+This allows you to access the full power of NetworkX algorithms with zero boilerplate.
+
+---
+
+## 🛠️ Installation
+To install annnet, you can use pip:
+
+```bash
+pip install annnet
+```
+
+Optional dependencies for extended functionality:
+
+```bash
+pip install annnet[networkx,igraph]
+pip install annnet[graph-tool]
+pip install annnet[corneto]
+```
+
+---
+
+## 🚀 Quick Start
+
+```python
+import annnet as gg
+
+# Create a new graph
+G = gg.Graph(directed=True, backend="corneto")
+
+# Add nodes and edges
+G.add_node("A", type="gene")
+G.add_node("B", type="protein")
+G.add_edge("A", "B", sign="+", source="literature")
+
+# Run a NetworkX algorithm (if installed)
+path = G.nx.shortest_path(source="A", target="B")
+
+# Export to JSON
+G.to_json("graph.json")
+```
+
+---
+
+## 📦 Refined Package Structure
+The package is organized to separate core functionality, I/O operations, adapters for external libraries, and algorithms. This modular design allows for easy extension and maintenance.
+
+```
+annnet/
+│
+├── __init__.py                # Public API surface, version, re-exports
+├── _version.py                # Single source of truth for __version__
+│
+├── core/                      # Core, always-installed logic
+│   ├── __init__.py
+│   ├── _base.py               # BaseGraph class and common interfaces 
+│   ├── _graph.py              # Graph class and internal state manager
+│   ├── structure.py           # Core data structures (nodes, edges, incidence)
+│   ├── metadata.py            # Node/edge attribute store and access helpers
+│   ├── views.py               # Subgraph views, shallow/deep copies
+│   └── state.py               # Graph history, change tracking, and lazy loading
+│
+├── io/                        # Loaders and writers for files
+│   ├── __init__.py
+│   ├── csv.py                 # CSV format (edge list, node table)
+│   ├── json.py                # JSON or JSONL parsing (streamable)
+│   ├── registry.py            # Entry point registration for loaders/dumpers
+│   └── utils.py               # Format detection, path helpers
+│
+├── adapters/                  # Lazy integration with external libraries
+│   ├── __init__.py
+│   ├── _base.py               # AbstractAdapter, adapter interface
+│   ├── _proxy.py              # Tiny forwarding proxy
+│   ├── manager.py             # Adapter registry and lazy bridge logic
+│   ├── networkx.py            # If available: convert, cache, sync with NetworkX
+│   ├── igraph.py              # If available
+│   ├── graphtool.py           # If available
+│   └── corneto.py             # If available
+│
+├── algorithms/                # Pure-python algorithms using core only
+│   ├── __init__.py
+│   └── traversal.py           # BFS/DFS etc.
+│
+└── utils/                     # Generic helpers not tied to graph structure
+    ├── validation.py
+    ├── typing.py
+    └── config.py              # Global options, logging, toggles
+```
+
+---
+
+## ⚙️ Internal Design
+annnet intelligently adapts its internal representation for performance and compatibility:
+
+- Chooses between edge lists, incidence matrices, and adjacency dicts automatically
+- Keeps metadata (node/edge attributes) separate from core structure
+- Lazy construction of external library representations (e.g., NetworkX) only when needed
+- Copy-on-write design for subgraphs and structural mutations
+
+---
+
+## 🧭  Philosophy
+annnet vis designed with these principles in mind:
+
+- **Simple**, consistent interface for all graph types
+- **Interoperability-first**: integrate, don’t replace
+- **Performance-aware**, not performance-obsessed
+- **Extendable** and modular, not monolithic
+
+---
+
+## 📜 License
+annnet is licensed under the BSD-3 License. See the [LICENSE](LICENSE) file for details.
+

annnet-0.0.1/annnet/__init__.py

@@ -0,0 +1,89 @@
+# annnet/__init__.py
+"""annnet: single import, full API."""
+
+from __future__ import annotations
+
+from importlib import import_module
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+from typing import Any
+
+# Lazily exposed submodules (imported on first attribute access)
+_lazy_submodules = {
+    # namespaces
+    "adapters": "annnet.adapters",
+    "io": "annnet.io",
+    "core": "annnet.core",
+    "algorithms": "annnet.algorithms",
+    "utils": "annnet.utils",
+    # adapter modules (direct convenience)
+    "graphml": "annnet.adapters.GraphML_adapter",
+    "sif": "annnet.adapters.SIF_adapter",
+    "sbml": "annnet.adapters.sbml_adapter",
+    "parquet": "annnet.adapters.GraphDir_Parquet_adapter",
+    "networkx": "annnet.adapters.networkx_adapter",
+    "igraph": "annnet.adapters.igraph_adapter",
+    "jsonio": "annnet.adapters.json_adapter",
+    "dataframe": "annnet.adapters.dataframe_adapter",
+    # io modules
+    "csvio": "annnet.io.csv",
+    "excelio": "annnet.io.excel",
+    "annnet": "annnet.io.io_annnet",
+}
+
+# Curated top-level symbols (lazy). name -> (module, attribute)
+_lazy_symbols: dict[str, tuple[str, str]] = {
+    # Core
+    "Graph": ("annnet.core.graph", "Graph"),
+    "graph": ("annnet.core.graph", "Graph"),
+    # Stdlib JSON I/O
+    "to_json": ("annnet.adapters.json_adapter", "to_json"),
+    "from_json": ("annnet.adapters.json_adapter", "from_json"),
+    # NetworkX adapter (optional dependency)
+    "to_nx": ("annnet.adapters.networkx_adapter", "to_nx"),
+    "from_nx": ("annnet.adapters.networkx_adapter", "from_nx"),
+    "from_nx_only": ("annnet.adapters.networkx_adapter", "from_nx_only"),
+    # GraphML
+    "to_graphml": ("annnet.adapters.GraphML_adapter", "to_graphml"),
+    "from_graphml": ("annnet.adapters.GraphML_adapter", "from_graphml"),
+    # SIF
+    "to_sif": ("annnet.adapters.SIF_adapter", "to_sif"),
+    "from_sif": ("annnet.adapters.SIF_adapter", "from_sif"),
+    # SBML (common direction)
+    "from_sbml": ("annnet.adapters.sbml_adapter", "from_sbml"),
+    # If you add export later: "to_sbml": ("annnet.adapters.sbml_adapter", "to_sbml"),
+    # Parquet GraphDir
+    "write_parquet_graphdir": (
+        "annnet.adapters.GraphDir_Parquet_adapter",
+        "write_parquet_graphdir",
+    ),
+    "read_parquet_graphdir": (
+        "annnet.adapters.GraphDir_Parquet_adapter",
+        "read_parquet_graphdir",
+    ),
+}
+
+__all__ = sorted(set(list(_lazy_submodules) + list(_lazy_symbols)))
+
+
+def __getattr__(name: str) -> Any:  # PEP 562: lazy attribute resolution
+    if name in _lazy_submodules:
+        return import_module(_lazy_submodules[name])
+    if name in _lazy_symbols:
+        mod, attr = _lazy_symbols[name]
+        return getattr(import_module(mod), attr)
+    raise AttributeError(name)
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + list(__all__))
+
+
+# Version: prefer internal, then fall back to distribution metadata
+try:
+    from ._version import __version__  # type: ignore
+except Exception:
+    try:
+        __version__ = _pkg_version("annnet")
+    except PackageNotFoundError:
+        __version__ = "0.0.0"

annnet-0.0.1/annnet/_metadata.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+
+#
+# This file is part of the `annnet` Python module
+#
+# Copyright 2025
+# Heidelberg University Hospital
+#
+# File author(s): Daniele Bottazzi (daniele.bottazzi@mail.polimi.it)
+#
+# Distributed under the MIT license
+# See the file `LICENSE` or read a copy at
+# https://opensource.org/license/mit
+#
+
+"""Package metadata (version, authors, etc)."""
+
+__all__ = ["get_metadata"]
+
+import importlib.metadata
+import os
+import pathlib
+
+import toml
+
+_VERSION = "0.0.1"
+
+
+def get_metadata() -> dict:
+    """Basic package metadata.
+
+    Retrieves package metadata from the current project directory or from
+    the installed package.
+    """
+
+    here = pathlib.Path(__file__).parent
+    pyproj_toml = "pyproject.toml"
+    meta = {}
+
+    for project_dir in (here, here.parent):
+        toml_path = str(project_dir.joinpath(pyproj_toml).absolute())
+
+        if os.path.exists(toml_path):
+            pyproject = toml.load(toml_path)
+
+            meta = {
+                "name": pyproject["tool"]["poetry"]["name"],
+                "version": pyproject["tool"]["poetry"]["version"],
+                "author": pyproject["tool"]["poetry"]["authors"],
+                "license": pyproject["tool"]["poetry"]["license"],
+                "full_metadata": pyproject,
+            }
+
+            break
+
+    if not meta:
+        try:
+            meta = {k.lower(): v for k, v in importlib.metadata.metadata(here.name).items()}
+
+        except importlib.metadata.PackageNotFoundError:
+            pass
+
+    meta["version"] = meta.get("version", None) or _VERSION
+
+    return meta
+
+
+metadata = get_metadata()
+__version__ = metadata.get("version", None)
+__author__ = metadata.get("author", None)
+__license__ = "MIT"

annnet-0.0.1/annnet/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"