creyone-model 1.0.0__tar.gz

creyone_model-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 QNiLix
+
+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.

creyone_model-1.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: creyone_model
+Version: 1.0.0
+Summary: PyTorch layer building tools for CREYONE
+Author-email: Linqa Kiriyama <kiriyamalq@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 QNiLix
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/qnilix/creyone_model
+Project-URL: Documentation, https://creyone-model.readthedocs.io/
+Project-URL: Repository, https://github.com/qnilix/creyone_model.git
+Project-URL: Bug Tracker, https://github.com/qnilix/creyone_model/issues
+Project-URL: Changelog, https://github.com/qnilix/creyone_model/blob/main/CHANGELOG.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: einops
+Requires-Dist: creyone_layer
+Dynamic: license-file
+
+# creyone_model
+
+PyTorch layer-building utilities for the CREYONE framework.
+
+## Overview
+
+`creyone_model` provides a config-first API for assembling CNN building blocks.
+All layer hyper-parameters live in a single `CNNBlockCfg` dataclass, making it
+easy to swap layer types (convolution, normalisation, activation, pooling)
+without changing model code.
+
+## Installation
+
+```bash
+pip install creyone_model
+```
+
+Requires Python ≥ 3.10 and PyTorch ≥ 2.0.
+
+## Quick start
+
+```python
+from creyone_model import CNNBlockCfg
+
+cfg = CNNBlockCfg(tensor_dims=2, act_name='silu')
+block = cfg.block_module(in_dim=3, out_dim=64, kernel_size=3)
+
+import torch
+y = block(torch.randn(1, 3, 224, 224))  # (1, 64, 224, 224)
+```
+
+## Documentation
+
+Full documentation (API reference + getting started guide) is hosted at
+<https://creyone-model.readthedocs.io/>.

creyone_model-1.0.0/README.md

@@ -0,0 +1,35 @@
+# creyone_model
+
+PyTorch layer-building utilities for the CREYONE framework.
+
+## Overview
+
+`creyone_model` provides a config-first API for assembling CNN building blocks.
+All layer hyper-parameters live in a single `CNNBlockCfg` dataclass, making it
+easy to swap layer types (convolution, normalisation, activation, pooling)
+without changing model code.
+
+## Installation
+
+```bash
+pip install creyone_model
+```
+
+Requires Python ≥ 3.10 and PyTorch ≥ 2.0.
+
+## Quick start
+
+```python
+from creyone_model import CNNBlockCfg
+
+cfg = CNNBlockCfg(tensor_dims=2, act_name='silu')
+block = cfg.block_module(in_dim=3, out_dim=64, kernel_size=3)
+
+import torch
+y = block(torch.randn(1, 3, 224, 224))  # (1, 64, 224, 224)
+```
+
+## Documentation
+
+Full documentation (API reference + getting started guide) is hosted at
+<https://creyone-model.readthedocs.io/>.

creyone_model-1.0.0/creyone_model/__init__.py

@@ -0,0 +1,2 @@
+from .utils import BaseCfg
+from .cnn.block import CNNBlockCfg, ConvNormAct

creyone_model-1.0.0/creyone_model/cnn/__init__.py

@@ -0,0 +1 @@
+from .block import CNNBlockCfg, ConvNormAct

creyone_model-1.0.0/creyone_model/cnn/block.py

@@ -0,0 +1,201 @@
+from dataclasses import dataclass
+
+import torch
+from torch import nn, Tensor
+
+from ..utils import BaseCfg
+from creyone_layer import create_layer
+
+
+@dataclass
+class CNNBlockCfg(BaseCfg):
+    """Configuration dataclass for CNN building blocks.
+
+    Centralises all hyper-parameters needed to construct a
+    :class:`ConvNormAct` block: convolution, normalisation, activation, and
+    pooling layers are each described by a *name* (matched by
+    ``creyone_layer.create_layer``) and a set of scalar options.
+
+    Attributes:
+        tensor_dims: Spatial dimensionality of the input tensor (e.g. ``2``
+            for images, ``1`` for sequences, ``3`` for volumetric data).
+        conv_option: Option string forwarded to the convolution factory
+            (see creyone-layer).
+        conv_name: Registered name of the convolution layer (default
+            ``'base'`` -> standard convolution).
+        conv_bias: Whether the convolution includes a learnable bias term.
+            Typically ``False`` when batch normalisation follows.
+        act_name: Registered name of the activation function
+            (default ``'relu'``).
+        act_inplace: Whether the activation operates in-place.
+        norm_name: Registered name of the normalisation layer
+            (default ``'batch'`` -> BatchNorm).
+        norm_eps: Epsilon added to the denominator for numerical stability.
+        norm_mom: Momentum used to update the running statistics.
+        pool_name: Registered name of the pooling layer (default ``'max'``).
+        pool_option: Option string forwarded to the pooling factory.
+
+    Example::
+
+        cfg = CNNBlockCfg(tensor_dims=2, act_name='silu')
+        block = cfg.block_module(in_dim=32, out_dim=64, kernel_size=3)
+    """
+
+    tensor_dims: int = 2
+    conv_option: str = 'ap'
+
+    conv_name: str = 'base'
+    conv_bias: bool = False
+
+    act_name: str = 'relu'
+    act_inplace: bool = False
+
+    norm_name: str = 'batch'
+    norm_eps: float = 1e-5
+    norm_mom: float = 0.1
+
+    pool_name: str = 'max'
+    pool_option: str = 'ap'
+
+    def block_module(self, in_dim: int, out_dim: int, *args, **kwargs) -> 'ConvNormAct':
+        """Instantiate a :class:`ConvNormAct` block from this config.
+
+        Args:
+            in_dim: Number of input channels / features.
+            out_dim: Number of output channels / features.
+            *args: Positional arguments forwarded to :class:`ConvNormAct`.
+            **kwargs: Keyword arguments forwarded to :class:`ConvNormAct`.
+
+        Returns:
+            A configured :class:`ConvNormAct` module.
+        """
+        return ConvNormAct(self, in_dim, out_dim, *args, **kwargs)
+
+    def act_layer(self, name: str = None, inplace: bool = None, **kwargs) -> nn.Module:
+        """Build and return an activation layer.
+
+        Args:
+            name: Override ``act_name``; uses the config value when ``None``.
+            inplace: Override ``act_inplace``; uses the config value when
+                ``None``.
+            **kwargs: Extra keyword arguments passed to the layer constructor.
+
+        Returns:
+            An instantiated activation ``nn.Module``.
+        """
+        actl = create_layer(name or self.act_name, 'act')
+        return actl(inplace=inplace if inplace is not None else self.act_inplace)(**kwargs)
+
+    def conv_layer(self, *args, name: str = None, bias: bool = None,
+                   c_opt: str = None, **kwargs) -> nn.Module:
+        """Build and return a convolution layer.
+
+        Args:
+            *args: Positional arguments forwarded to the layer constructor
+                (typically ``in_channels`` and ``out_channels``).
+            name: Override ``conv_name``; uses the config value when ``None``.
+            bias: Override ``conv_bias``; uses the config value when ``None``.
+            c_opt: Override ``conv_option``; uses the config value when
+                ``None``.
+            **kwargs: Extra keyword arguments (e.g. ``kernel_size``,
+                ``stride``) forwarded to the layer constructor.
+
+        Returns:
+            An instantiated convolution ``nn.Module``.
+        """
+        conv = create_layer(name or self.conv_name, 'conv')
+        conv = conv(dim = self.tensor_dims, optional = c_opt or self.conv_option)
+        return conv(*args, bias = bias if bias is not None else self.conv_bias, **kwargs)
+
+    def norm_layer(self, dim: int, name: str = None, eps: float = None) -> nn.Module:
+        """Build and return a normalisation layer.
+
+        Args:
+            dim: Number of features / channels to normalise.
+            name: Override ``norm_name``; uses the config value when ``None``.
+            eps: Override ``norm_eps``; uses the config value when ``None``.
+
+        Returns:
+            An instantiated normalisation ``nn.Module``.
+        """
+        norm = create_layer(name or self.norm_name, 'norm')
+        return norm(dim = self.tensor_dims, eps=eps if eps is not None else self.norm_eps, mom=self.norm_mom)(dim)
+
+    def pool_layer(self, *args, name: str = None, p_opt: str = None, **kwargs) -> nn.Module:
+        """Build and return a pooling layer.
+
+        Args:
+            *args: Positional arguments forwarded to the layer constructor
+                (e.g. ``kernel_size``).
+            name: Override ``pool_name``; uses the config value when ``None``.
+            p_opt: Override ``pool_option``; uses the config value when
+                ``None``.
+            **kwargs: Extra keyword arguments forwarded to the layer
+                constructor.
+
+        Returns:
+            An instantiated pooling ``nn.Module``.
+        """
+        pool = create_layer(name or self.pool_name, 'pool')
+        pool = pool(dim = self.tensor_dims, optional = p_opt or self.pool_option)
+        return pool(*args, **kwargs)
+
+
+class ConvNormAct(nn.Module):
+    """Sequential Convolution → Normalisation → Activation block.
+
+    A standard building block used throughout modern CNN architectures.
+    All layer details are driven by a :class:`CNNBlockCfg` instance, which
+    allows swapping convolution type, normalisation, and activation without
+    changing the block's code.
+
+    Attributes:
+        stride: Stride used by the internal convolution (mirrors ``s``).
+        out_dim: Number of output channels / features.
+        conv: The convolution layer.
+        norm: The normalisation layer.
+        act: The activation layer.
+
+    Example::
+
+        cfg = CNNBlockCfg()
+        block = ConvNormAct(cfg, in_dim=3, out_dim=64, kernel_size=3)
+        y = block(x)  # x: (B, 3, H, W) -> y: (B, 64, H, W)
+    """
+
+    def __init__(self, cfg: CNNBlockCfg, in_dim: int, out_dim: int, *args, s=1,
+                 norm_name: str = None, act_name: str = None,
+                 inplace: bool = None, eps: float = None, **kwargs):
+        """Initialise the ConvNormAct block.
+
+        Args:
+            cfg: Configuration object that supplies all layer factories.
+            in_dim: Number of input channels / features.
+            out_dim: Number of output channels / features.
+            *args: Extra positional arguments forwarded to the convolution
+                layer (e.g. ``kernel_size``).
+            s: Stride for the convolution. Defaults to ``1``.
+            norm_name: Override the normalisation layer name from ``cfg``.
+            act_name: Override the activation layer name from ``cfg``.
+            inplace: Override the in-place flag from ``cfg``.
+            eps: Override the normalisation epsilon from ``cfg``.
+            **kwargs: Additional keyword arguments forwarded to the
+                convolution layer.
+        """
+        super().__init__()
+        self.stride = s; self.out_dim = out_dim
+        self.conv = cfg.conv_layer(in_dim, out_dim, *args, s=s, **kwargs)
+        self.norm = cfg.norm_layer(out_dim, name=norm_name, eps=eps)
+        self.act  = cfg.act_layer(name=act_name, inplace=inplace)
+
+    def forward(self, x: Tensor) -> Tensor:
+        """Apply conv -> norm -> act to the input tensor.
+
+        Args:
+            x: Input tensor of shape ``(B, in_dim, *spatial)``.
+
+        Returns:
+            Output tensor of shape ``(B, out_dim, *spatial')``, where
+            ``spatial'`` depends on the convolution stride and padding.
+        """
+        return self.act(self.norm(self.conv(x)))

creyone_model-1.0.0/creyone_model/cynn/tensor.py

@@ -0,0 +1,94 @@
+import copy
+from typing import Self
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from einops import rearrange
+
+
+def _matmul(a, b): return a @ b
+
+
+class CreYonT:
+
+    def __init__(self, *args, torchT: torch.Tensor = None, init_val: float = None, **kwargs):
+        self._t = torchT if torchT is not None else torch.Tensor(*args, **kwargs)
+        if init_val is not None: self._t = self._t * 0 + init_val
+    
+    def __call__(self, func: callable, *args, **kwargs) -> Self:
+        return self.plug(func(self._t, *args, **kwargs))
+    
+    def __add__(self, other) -> Self: return self.calc(other, lambda a, b: a + b)
+
+    def __mul__(self, other) -> Self: return self.calc(other, lambda a, b: a * b)
+
+    def __truediv__(self, other) -> Self: return self.calc(other, lambda a, b: a / b)
+
+    def __matmul__(self, other) -> Self: return self.calc(other, _matmul)
+    
+    @property
+    def shape(self): return self._t.shape
+
+    @property
+    def B(self): return self._t.shape[0]
+    
+    def tensor(self) -> torch.Tensor: return self._t
+    
+    def calc(self, other, func, **kwargs):
+        if isinstance(other, CreYonT): other = other.tensor()
+        return self.plug(func(self._t, other, **kwargs))
+
+    def plug(self, x: torch.Tensor) -> Self:
+        result = copy.copy(self); result._t = x; return result
+
+    def chunk(self, chunks: int, dim: int = 0) -> tuple[Self, ...]:
+        return tuple(CreYonT(torchT=t) for t in self._t.chunk(chunks, dim=dim))
+    
+    def contiguous(self) -> Self: return self.plug(self._t.contiguous())
+
+    def exp(self) -> Self: return self.plug(self._t.exp())
+
+    def flatten(self, *args, **kwargs) -> Self:
+        return self.plug(self._t.flatten(*args, **kwargs))
+    
+    def flip(self, *args, **kwargs) -> Self:
+        return self.plug(self._t.flip(*args, **kwargs))
+    
+    def log(self) -> Self: return self.plug(torch.log(self._t))
+
+    def mean(self, dim = None, keepdim: bool = False, *, dtype: torch.dtype = None) -> Self:
+        return self.plug(self._t.mean(dim, keepdim=keepdim, dtype=dtype))
+
+    def reshape(self, *args, **kwargs) -> Self:
+        return self.plug(self._t.reshape(*args, **kwargs))
+
+    def softmax(self, dim: int, dtype: torch.dtype = None) -> Self:
+        return self.plug(self._t.softmax(dim, dtype=dtype))
+    
+    def init(self, name: str, **kwargs) -> Self:
+        if name == 'trunc_normal': nn.init.trunc_normal_(self._t, **kwargs) 
+        return self
+
+    def transpose(self, dim0: int, dim1: int) -> Self:
+        return self.plug(self._t.transpose(dim0, dim1))
+
+    def bmm(self, other) -> Self: return self.calc(other, torch.bmm)
+
+    def cat(self, other, dim: int = 0) -> Self:
+        if isinstance(other, CreYonT): other = other.tensor()
+        return self.plug(torch.cat((self._t, other), dim=dim))
+    
+    def linear(self, other, bias: torch.Tensor = None) -> Self:
+        return self.calc(other, F.linear, bias=bias)
+    
+    def split(self, split_size_or_sections: int | list[int], dim: int = 0) -> tuple[Self, ...]:
+        a, *b = torch.split(self._t, split_size_or_sections, dim=dim)
+        return tuple([self.plug(a)] + [CreYonT(torchT=t) for t in b])
+
+    def normalize(self, p: float = 2, dim: int = 1, eps: float = 1e-12) -> Self:
+        return self.plug(F.normalize(self._t, p=p, dim=dim, eps=eps))
+
+    def rearrange(self, pattern: str, **axes_lengths: any) -> Self:
+        return self.plug(rearrange(self._t, pattern, **axes_lengths))

creyone_model-1.0.0/creyone_model/utils/__init__.py

@@ -0,0 +1 @@
+from .config import BaseCfg

creyone_model-1.0.0/creyone_model/utils/config.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, fields
+from typing import Any
+
+
+def type_subclass(cls: type, classinfo) -> bool:
+    """Call issubclass safely, returning False if cls is not a type (e.g. MISSING)."""
+    try:
+        return issubclass(cls, classinfo)
+    except TypeError:
+        return False
+
+
+@dataclass
+class BaseCfg:
+    """Base class for hierarchical configuration dataclasses.
+
+    Subclasses should be decorated with ``@dataclass`` and may declare fields
+    of primitive types or other ``BaseCfg`` subclasses. Fields whose
+    ``default_factory`` is a ``BaseCfg`` subclass are built recursively by
+    ``instance()``.
+    """
+
+    @classmethod
+    def instance(cls, **kwargs) -> tuple[Any, dict[str, Any]]:
+        """Build an instance from kwargs and return any unconsumed kwargs.
+
+        Iterates over all dataclass fields, popping matching keys from kwargs.
+        For fields whose ``default_factory`` is a ``BaseCfg`` subclass, the
+        method recurses, passing both the field-specific kwargs and all
+        remaining kwargs so that shared parameters propagate down. Each nested
+        call returns its own unconsumed kwargs, which continue up the chain.
+
+        Args:
+            **kwargs: Keyword arguments keyed by field name. Values for nested
+                ``BaseCfg`` fields should be provided as a ``dict`` of
+                sub-kwargs for that config.
+
+        Returns:
+            A ``(instance, remaining_kwargs)`` tuple where ``remaining_kwargs``
+            holds any kwargs not consumed by this class or its nested configs.
+        """
+        kw: dict[str, Any] = {}
+        for f in fields(cls):
+            if f.name in kwargs: kw[f.name] = kwargs.pop(f.name)
+            if not type_subclass(f.default_factory, BaseCfg): continue
+            # Field-specific kwargs take priority over shared remaining kwargs.
+            # Build a new dict so the caller's original dict is never mutated.
+            temp = {**kwargs, **kw.get(f.name, {})}
+            kw[f.name], kwargs = f.default_factory.instance(**temp)
+        return cls(**kw), kwargs
+
+
+
+
+
+
+
+
+
+
+
+
+

creyone_model-1.0.0/creyone_model.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: creyone_model
+Version: 1.0.0
+Summary: PyTorch layer building tools for CREYONE
+Author-email: Linqa Kiriyama <kiriyamalq@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 QNiLix
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/qnilix/creyone_model
+Project-URL: Documentation, https://creyone-model.readthedocs.io/
+Project-URL: Repository, https://github.com/qnilix/creyone_model.git
+Project-URL: Bug Tracker, https://github.com/qnilix/creyone_model/issues
+Project-URL: Changelog, https://github.com/qnilix/creyone_model/blob/main/CHANGELOG.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: einops
+Requires-Dist: creyone_layer
+Dynamic: license-file
+
+# creyone_model
+
+PyTorch layer-building utilities for the CREYONE framework.
+
+## Overview
+
+`creyone_model` provides a config-first API for assembling CNN building blocks.
+All layer hyper-parameters live in a single `CNNBlockCfg` dataclass, making it
+easy to swap layer types (convolution, normalisation, activation, pooling)
+without changing model code.
+
+## Installation
+
+```bash
+pip install creyone_model
+```
+
+Requires Python ≥ 3.10 and PyTorch ≥ 2.0.
+
+## Quick start
+
+```python
+from creyone_model import CNNBlockCfg
+
+cfg = CNNBlockCfg(tensor_dims=2, act_name='silu')
+block = cfg.block_module(in_dim=3, out_dim=64, kernel_size=3)
+
+import torch
+y = block(torch.randn(1, 3, 224, 224))  # (1, 64, 224, 224)
+```
+
+## Documentation
+
+Full documentation (API reference + getting started guide) is hosted at
+<https://creyone-model.readthedocs.io/>.

creyone_model-1.0.0/creyone_model.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+creyone_model/__init__.py
+creyone_model.egg-info/PKG-INFO
+creyone_model.egg-info/SOURCES.txt
+creyone_model.egg-info/dependency_links.txt
+creyone_model.egg-info/requires.txt
+creyone_model.egg-info/top_level.txt
+creyone_model/cnn/__init__.py
+creyone_model/cnn/block.py
+creyone_model/cynn/tensor.py
+creyone_model/utils/__init__.py
+creyone_model/utils/config.py

creyone_model-1.0.0/creyone_model.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

creyone_model-1.0.0/creyone_model.egg-info/requires.txt

@@ -0,0 +1,3 @@
+torch>=2.0
+einops
+creyone_layer

creyone_model-1.0.0/creyone_model.egg-info/top_level.txt

@@ -0,0 +1 @@
+creyone_model

creyone_model-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "creyone_model"
+version = "1.0.0"
+dependencies = [
+  "torch>=2.0",
+  "einops",
+  "creyone_layer"
+]
+requires-python = ">=3.10"
+authors = [
+  {name = "Linqa Kiriyama", email = "kiriyamalq@gmail.com"},
+]
+description = "PyTorch layer building tools for CREYONE"
+readme = "README.md"
+license = {file = "LICENSE"}
+keywords = []
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python :: 3 :: Only"
+]
+
+[project.urls]
+Homepage = "https://github.com/qnilix/creyone_model"
+Documentation = "https://creyone-model.readthedocs.io/"
+Repository = "https://github.com/qnilix/creyone_model.git"
+"Bug Tracker" = "https://github.com/qnilix/creyone_model/issues"
+Changelog = "https://github.com/qnilix/creyone_model/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["creyone_model*"]

creyone_model-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+