rbac2fast-core 0.1.0__tar.gz

rbac2fast_core-0.1.0/LICENSE

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

rbac2fast_core-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE
+recursive-include src/rbac2fast_core *.py
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude .DS_Store

rbac2fast_core-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: rbac2fast-core
+Version: 0.1.0
+Summary: Core design package for RBAC: protocols and pydantic schemas
+Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Angel Daniel Sanchez Castillo
+        
+        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/AngelDanielSanchezCastillo/rbac2fast-core
+Project-URL: Repository, https://github.com/AngelDanielSanchezCastillo/rbac2fast-core
+Project-URL: Issues, https://github.com/AngelDanielSanchezCastillo/rbac2fast-core/issues
+Keywords: permissions,rbac,authorization,access control
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Dynamic: license-file
+
+# rbac2fast-core
+
+🚀 Core abstract package for Role-Based Access Control (RBAC) in Python/FastAPI. Contains Protocols and Pydantic schemas without database logic.
+
+> [!WARNING]
+> **Internal Use Notice**
+> 
+> This package is designed and maintained by the **Solautyc Team** for internal use. While it is publicly available, it may not work as expected in all environments or use cases outside of our specific infrastructure. We do not provide support or guarantees for external usage, and we are not responsible for any issues that may arise from using this package in other contexts.
+> 
+> Use at your own risk. Contributions and feedback are welcome, but compatibility with external environments is not guaranteed.
+
+## Features
+
+- 🧩 **Abstract Interfaces**: Defines standard `Protocols` for RBAC models and services.
+- 📦 **Pydantic Schemas**: Pre-defined base models for validation and serialization of Roles, Permissions, Routes, and Assignments.
+- 🪶 **Lightweight**: Zero database dependencies; relies solely on standard Python abstractions and `pydantic`.
+- 🔌 **Pluggable Architecture**: Allows multiple concrete implementations (e.g., standard global RBAC or multi-tenant RBAC) to share a standardized API contract.
+
+## Installation
+
+```bash
+pip install rbac2fast-core
+```
+
+## Structure
+
+This package exposes abstract definitions that concrete implementations (like `permissions2fast-fastapi`) will fulfill. 
+
+### Protocols (`rbac2fast_core.protocols`)
+
+Defines minimal structural requirements that underlying models must fulfill:
+- `RoleProtocol`, `PermissionProtocol`, `RouteProtocol`
+...
+
+### Schemas (`rbac2fast_core.schemas`)
+
+Provides validation schemas:
+- `RoleBase`, `RoleCreate`, `RoleRead`
+- `PermissionBase`, `PermissionCreate`
+...
+
+## Usage
+
+This package is not meant to be used standalone to handle permissions, but rather to be imported as a dependency by actual implementation packages or application layers that need to adhere to the standard RBAC design.
+
+Example of implementing a protocol in your ORM model:
+
+```python
+from sqlmodel import SQLModel, Field
+from rbac2fast_core.protocols.models import RoleProtocol
+
+class Role(SQLModel, table=True):
+    # This class structurally fulfills RoleProtocol
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(unique=True, index=True)
+    description: str | None = None
+    is_active: bool = True
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Copyright (c) 2026 Angel Daniel Sanchez Castillo

rbac2fast_core-0.1.0/README.md

@@ -0,0 +1,64 @@
+# rbac2fast-core
+
+🚀 Core abstract package for Role-Based Access Control (RBAC) in Python/FastAPI. Contains Protocols and Pydantic schemas without database logic.
+
+> [!WARNING]
+> **Internal Use Notice**
+> 
+> This package is designed and maintained by the **Solautyc Team** for internal use. While it is publicly available, it may not work as expected in all environments or use cases outside of our specific infrastructure. We do not provide support or guarantees for external usage, and we are not responsible for any issues that may arise from using this package in other contexts.
+> 
+> Use at your own risk. Contributions and feedback are welcome, but compatibility with external environments is not guaranteed.
+
+## Features
+
+- 🧩 **Abstract Interfaces**: Defines standard `Protocols` for RBAC models and services.
+- 📦 **Pydantic Schemas**: Pre-defined base models for validation and serialization of Roles, Permissions, Routes, and Assignments.
+- 🪶 **Lightweight**: Zero database dependencies; relies solely on standard Python abstractions and `pydantic`.
+- 🔌 **Pluggable Architecture**: Allows multiple concrete implementations (e.g., standard global RBAC or multi-tenant RBAC) to share a standardized API contract.
+
+## Installation
+
+```bash
+pip install rbac2fast-core
+```
+
+## Structure
+
+This package exposes abstract definitions that concrete implementations (like `permissions2fast-fastapi`) will fulfill. 
+
+### Protocols (`rbac2fast_core.protocols`)
+
+Defines minimal structural requirements that underlying models must fulfill:
+- `RoleProtocol`, `PermissionProtocol`, `RouteProtocol`
+...
+
+### Schemas (`rbac2fast_core.schemas`)
+
+Provides validation schemas:
+- `RoleBase`, `RoleCreate`, `RoleRead`
+- `PermissionBase`, `PermissionCreate`
+...
+
+## Usage
+
+This package is not meant to be used standalone to handle permissions, but rather to be imported as a dependency by actual implementation packages or application layers that need to adhere to the standard RBAC design.
+
+Example of implementing a protocol in your ORM model:
+
+```python
+from sqlmodel import SQLModel, Field
+from rbac2fast_core.protocols.models import RoleProtocol
+
+class Role(SQLModel, table=True):
+    # This class structurally fulfills RoleProtocol
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(unique=True, index=True)
+    description: str | None = None
+    is_active: bool = True
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Copyright (c) 2026 Angel Daniel Sanchez Castillo

rbac2fast_core-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rbac2fast-core"
+version = "0.1.0"
+description = "Core design package for RBAC: protocols and pydantic schemas"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {file = "LICENSE"}
+authors = [
+    {name = "Angel Daniel Sanchez Castillo", email = "angeldaniel.sanchezcastillo@gmail.com"}
+]
+keywords = ["permissions", "rbac", "authorization", "access control"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Framework :: FastAPI",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "pydantic>=2.0",
+]
+
+[dependency-groups]
+dev = [
+    "black",
+    "ruff",
+    "build",
+    "twine",
+]
+test = [
+    "pytest>=7.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AngelDanielSanchezCastillo/rbac2fast-core"
+Repository = "https://github.com/AngelDanielSanchezCastillo/rbac2fast-core"
+Issues = "https://github.com/AngelDanielSanchezCastillo/rbac2fast-core/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["rbac2fast_core*"]

rbac2fast_core-0.1.0/setup.cfg

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

rbac2fast_core-0.1.0/src/rbac2fast_core/__init__.py

@@ -0,0 +1,11 @@
+"""
+rbac2fast_core
+
+Core contracts (Protocols) and schemas for RBAC.
+"""
+
+from .__version__ import __version__
+
+__all__ = [
+    "__version__",
+]

rbac2fast_core-0.1.0/src/rbac2fast_core/__version__.py

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

rbac2fast_core-0.1.0/src/rbac2fast_core/protocols/__init__.py

@@ -0,0 +1,27 @@
+from .models import (
+    RoleProtocol,
+    PermissionProtocol,
+    PermissionCategoryProtocol,
+    RouteProtocol,
+    UserRoleProtocol,
+    PermissionAssignmentProtocol,
+    PermissionRouteProtocol,
+)
+from .services import (
+    RoleServiceProtocol,
+    PermissionServiceProtocol,
+    AccessServiceProtocol,
+)
+
+__all__ = [
+    "RoleProtocol",
+    "PermissionProtocol",
+    "PermissionCategoryProtocol",
+    "RouteProtocol",
+    "UserRoleProtocol",
+    "PermissionAssignmentProtocol",
+    "PermissionRouteProtocol",
+    "RoleServiceProtocol",
+    "PermissionServiceProtocol",
+    "AccessServiceProtocol",
+]

rbac2fast_core-0.1.0/src/rbac2fast_core/protocols/models.py

@@ -0,0 +1,42 @@
+from typing import Protocol, List, Optional
+from datetime import datetime
+
+class RoleProtocol(Protocol):
+    id: int
+    name: str
+    description: Optional[str]
+    is_active: bool
+    created_at: Optional[datetime]
+    updated_at: Optional[datetime]
+
+class PermissionCategoryProtocol(Protocol):
+    id: int
+    name: str
+
+class PermissionProtocol(Protocol):
+    id: int
+    name: str
+    permission_category_id: int
+    created_at: Optional[datetime]
+    updated_at: Optional[datetime]
+
+class RouteProtocol(Protocol):
+    id: int
+    name: str
+    is_active: bool
+
+class UserRoleProtocol(Protocol):
+    id: int
+    user_id: int
+    role_id: int
+
+class PermissionAssignmentProtocol(Protocol):
+    id: int
+    permission_id: int
+    entity_type: str
+    entity_id: int
+
+class PermissionRouteProtocol(Protocol):
+    id: int
+    permission_id: int
+    route_id: int

rbac2fast_core-0.1.0/src/rbac2fast_core/protocols/services.py

@@ -0,0 +1,31 @@
+from typing import Protocol, Any, List, Optional
+from .models import RoleProtocol, PermissionProtocol, PermissionCategoryProtocol, RouteProtocol, UserRoleProtocol, PermissionAssignmentProtocol, PermissionRouteProtocol
+
+class RoleServiceProtocol(Protocol):
+    async def create_role(self, role_data: Any, session: Any) -> RoleProtocol: ...
+    async def get_role(self, role_id: int, session: Any) -> Optional[RoleProtocol]: ...
+    async def list_roles(self, session: Any, skip: int = 0, limit: int = 100) -> List[RoleProtocol]: ...
+    async def update_role(self, role_id: int, role_data: Any, session: Any) -> Optional[RoleProtocol]: ...
+    async def delete_role(self, role_id: int, session: Any) -> bool: ...
+    async def add_role_permission(self, role_id: int, permission_id: int, session: Any) -> PermissionAssignmentProtocol: ...
+    async def list_role_permissions(self, role_id: int, session: Any) -> List[PermissionProtocol]: ...
+    async def delete_role_permission(self, role_id: int, permission_id: int, session: Any) -> bool: ...
+    async def assign_user_role(self, user_id: int, role_id: int, session: Any) -> UserRoleProtocol: ...
+    async def list_user_roles(self, user_id: int, session: Any) -> List[RoleProtocol]: ...
+    async def remove_user_role(self, user_id: int, role_id: int, session: Any) -> bool: ...
+
+class PermissionServiceProtocol(Protocol):
+    async def create_category(self, category_data: Any, session: Any) -> PermissionCategoryProtocol: ...
+    async def list_categories(self, session: Any, skip: int = 0, limit: int = 100) -> List[PermissionCategoryProtocol]: ...
+    async def create_permission(self, permission_data: Any, session: Any) -> PermissionProtocol: ...
+    async def get_permission(self, permission_id: int, session: Any) -> Optional[PermissionProtocol]: ...
+    async def list_permissions(self, session: Any, skip: int = 0, limit: int = 100) -> List[PermissionProtocol]: ...
+    async def update_permission(self, permission_id: int, permission_data: Any, session: Any) -> Optional[PermissionProtocol]: ...
+    async def delete_permission(self, permission_id: int, session: Any) -> bool: ...
+    async def add_permission_route(self, permission_id: int, route_id: int, session: Any) -> PermissionRouteProtocol: ...
+    async def assign_user_permission(self, user_id: int, permission_id: int, session: Any) -> PermissionAssignmentProtocol: ...
+    async def list_user_permissions(self, user_id: int, session: Any) -> List[PermissionProtocol]: ...
+    async def remove_user_permission(self, user_id: int, permission_id: int, session: Any) -> bool: ...
+
+class AccessServiceProtocol(Protocol):
+    async def check_user_access(self, user_id: int, route_path: str, method: str, session: Any) -> bool: ...

rbac2fast_core-0.1.0/src/rbac2fast_core/schemas/__init__.py

@@ -0,0 +1,53 @@
+"""Schemas for rbac2fast-core"""
+
+from .role_schema import (
+    RoleBase,
+    RoleCreate,
+    RoleUpdate,
+    RoleRead,
+    RolePermissionCreate,
+    UserRoleCreate,
+    UserRoleRead,
+)
+from .permission_schema import (
+    PermissionBase,
+    PermissionCreate,
+    PermissionRead,
+    PermissionUpdate,
+    PermissionRouteCreate,
+    UserPermissionCreate,
+    UserPermissionRead,
+)
+from .permission_category_schema import (
+    PermissionCategoryBase,
+    PermissionCategoryCreate,
+    PermissionCategoryRead,
+)
+from .route_schema import (
+    RouteBase,
+    RouteCreate,
+    RouteRead,
+)
+
+__all__ = [
+    "RoleBase",
+    "RoleCreate",
+    "RoleUpdate",
+    "RoleRead",
+    "RolePermissionCreate",
+    "UserRoleCreate",
+    "UserRoleRead",
+    "PermissionBase",
+    "PermissionCreate",
+    "PermissionRead",
+    "PermissionUpdate",
+    "PermissionRouteCreate",
+    "UserPermissionCreate",
+    "UserPermissionRead",
+    "PermissionCategoryBase",
+    "PermissionCategoryCreate",
+    "PermissionCategoryRead",
+    "RouteBase",
+    "RouteCreate",
+    "RouteRead",
+]

rbac2fast_core-0.1.0/src/rbac2fast_core/schemas/permission_category_schema.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, ConfigDict
+
+class PermissionCategoryBase(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    name: str
+
+class PermissionCategoryCreate(PermissionCategoryBase):
+    pass
+
+class PermissionCategoryRead(PermissionCategoryBase):
+    id: int

rbac2fast_core-0.1.0/src/rbac2fast_core/schemas/permission_schema.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict
+
+
+class PermissionBase(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    name: str
+    permission_category_id: int
+
+
+class PermissionCreate(PermissionBase):
+    pass
+
+
+class PermissionUpdate(BaseModel):
+    name: str | None = None
+    permission_category_id: int | None = None
+
+
+class PermissionRead(PermissionBase):
+    id: int
+
+
+# Assignment Schemas
+
+class PermissionRouteCreate(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    permission_id: int
+    route_id: int
+
+
+class UserPermissionCreate(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    user_id: int
+    permission_id: int
+
+
+class UserPermissionRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    permission_id: int
+    entity_type: str
+    entity_id: int

rbac2fast_core-0.1.0/src/rbac2fast_core/schemas/role_schema.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict
+
+
+class RoleBase(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    name: str
+    description: str | None = None
+    is_active: bool = True
+
+
+class RoleCreate(RoleBase):
+    pass
+
+
+class RoleUpdate(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    is_active: bool | None = None
+
+
+class RoleRead(RoleBase):
+    id: int
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+# Assignment Schemas
+
+class RolePermissionCreate(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    permission_id: int
+
+
+class UserRoleCreate(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    user_id: int
+    role_id: int
+
+
+class UserRoleRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    user_id: int
+    role_id: int

rbac2fast_core-0.1.0/src/rbac2fast_core/schemas/route_schema.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, ConfigDict
+
+class RouteBase(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    name: str
+    is_active: bool = True
+
+class RouteCreate(RouteBase):
+    pass
+
+class RouteRead(RouteBase):
+    id: int

rbac2fast_core-0.1.0/src/rbac2fast_core.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: rbac2fast-core
+Version: 0.1.0
+Summary: Core design package for RBAC: protocols and pydantic schemas
+Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Angel Daniel Sanchez Castillo
+        
+        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/AngelDanielSanchezCastillo/rbac2fast-core
+Project-URL: Repository, https://github.com/AngelDanielSanchezCastillo/rbac2fast-core
+Project-URL: Issues, https://github.com/AngelDanielSanchezCastillo/rbac2fast-core/issues
+Keywords: permissions,rbac,authorization,access control
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Dynamic: license-file
+
+# rbac2fast-core
+
+🚀 Core abstract package for Role-Based Access Control (RBAC) in Python/FastAPI. Contains Protocols and Pydantic schemas without database logic.
+
+> [!WARNING]
+> **Internal Use Notice**
+> 
+> This package is designed and maintained by the **Solautyc Team** for internal use. While it is publicly available, it may not work as expected in all environments or use cases outside of our specific infrastructure. We do not provide support or guarantees for external usage, and we are not responsible for any issues that may arise from using this package in other contexts.
+> 
+> Use at your own risk. Contributions and feedback are welcome, but compatibility with external environments is not guaranteed.
+
+## Features
+
+- 🧩 **Abstract Interfaces**: Defines standard `Protocols` for RBAC models and services.
+- 📦 **Pydantic Schemas**: Pre-defined base models for validation and serialization of Roles, Permissions, Routes, and Assignments.
+- 🪶 **Lightweight**: Zero database dependencies; relies solely on standard Python abstractions and `pydantic`.
+- 🔌 **Pluggable Architecture**: Allows multiple concrete implementations (e.g., standard global RBAC or multi-tenant RBAC) to share a standardized API contract.
+
+## Installation
+
+```bash
+pip install rbac2fast-core
+```
+
+## Structure
+
+This package exposes abstract definitions that concrete implementations (like `permissions2fast-fastapi`) will fulfill. 
+
+### Protocols (`rbac2fast_core.protocols`)
+
+Defines minimal structural requirements that underlying models must fulfill:
+- `RoleProtocol`, `PermissionProtocol`, `RouteProtocol`
+...
+
+### Schemas (`rbac2fast_core.schemas`)
+
+Provides validation schemas:
+- `RoleBase`, `RoleCreate`, `RoleRead`
+- `PermissionBase`, `PermissionCreate`
+...
+
+## Usage
+
+This package is not meant to be used standalone to handle permissions, but rather to be imported as a dependency by actual implementation packages or application layers that need to adhere to the standard RBAC design.
+
+Example of implementing a protocol in your ORM model:
+
+```python
+from sqlmodel import SQLModel, Field
+from rbac2fast_core.protocols.models import RoleProtocol
+
+class Role(SQLModel, table=True):
+    # This class structurally fulfills RoleProtocol
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(unique=True, index=True)
+    description: str | None = None
+    is_active: bool = True
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Copyright (c) 2026 Angel Daniel Sanchez Castillo

rbac2fast_core-0.1.0/src/rbac2fast_core.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/rbac2fast_core/__init__.py
+src/rbac2fast_core/__version__.py
+src/rbac2fast_core.egg-info/PKG-INFO
+src/rbac2fast_core.egg-info/SOURCES.txt
+src/rbac2fast_core.egg-info/dependency_links.txt
+src/rbac2fast_core.egg-info/requires.txt
+src/rbac2fast_core.egg-info/top_level.txt
+src/rbac2fast_core/protocols/__init__.py
+src/rbac2fast_core/protocols/models.py
+src/rbac2fast_core/protocols/services.py
+src/rbac2fast_core/schemas/__init__.py
+src/rbac2fast_core/schemas/permission_category_schema.py
+src/rbac2fast_core/schemas/permission_schema.py
+src/rbac2fast_core/schemas/role_schema.py
+src/rbac2fast_core/schemas/route_schema.py

rbac2fast_core-0.1.0/src/rbac2fast_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rbac2fast_core-0.1.0/src/rbac2fast_core.egg-info/requires.txt

@@ -0,0 +1 @@
+pydantic>=2.0

rbac2fast_core-0.1.0/src/rbac2fast_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+rbac2fast_core