autumn-core 1.0.0__tar.gz

autumn_core-1.0.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.5
+Name: autumn-core
+Version: 1.0.0
+Summary: Autumn - Build CSS and HTML right in your backend
+Author-email: Nerina0Coder <github.py.coder@gmail.com>
+License-Expression: MIT
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: ~=3.12
+Requires-Dist: coloraide~=8.12.1
+Requires-Dist: markupsafe~=3.0.3
+Requires-Dist: werkzeug~=3.1.8
+Description-Content-Type: text/markdown
+
+# Autumn Framework - Build front-end in the back-end
+### What are we?
+Autumn framework, a framework built to make front-end work as close as possible to back-end work.
+Our goal is not to provide a server or back-end, but a tool that makes front-end look like back-end.
+By making an ORM(Object Relational Mapping), we add an object-oriented way to write HTML documents and CSS styles
+directly from Python.
+### Why us?
+You are not limited to us, there are Jinja2 and so many other libraries.
+What makes us unique is making you to look at a Python class rather than a div tag.
+
+Tests proven Autumn's speed is less than one millisecond,
+and removing the prettifier actually makes it even faster(tho
+not visibly faster in some cases).
+### How?
+The process is straight.
+But there are important things to consider:
+- Thread safety:
+    While we try our best to promise thread safety,
+    such as features like before_build, we cannot
+    lock every read/write. Your elements are up to you,
+    So, for reads/writes, it's best to access self._lock.
+- Dynamicity:
+    When elements are dynamic, their dynamic
+    must be set to True. However, if any of the tags owned
+    are dynamic, the parent will be inferred as dynamic,
+    therefore no need to set dynamic to True.
+
+here is an example with HTML, another with CSS.
+#### HTML
+Instead of writing:
+```html
+<div id="hello-world">Hello World!</div>
+```
+You write:
+```python
+from Autumn import new
+
+Base = new()
+
+tag = Base.tag
+
+class MyDiv(tag.Tag):
+    def __init__(self):
+        self.name = "div"
+        self.closable = True
+        self.identifier = "hello-world"
+        self.tags = ["Hello World!"]
+        # How we recommend it.
+        # However, you can place spaces, tabs, and newlines, but be aware that they will be
+        # Replaced with -.
+        
+        super().__init__()
+```
+While this seems like writing too much, it's core benefit will be seen when writing **dynamic** tags or when you don't know about HTML too much.
+Let's see an example for a dynamic tag.
+
+```python
+import time
+from Autumn import new
+
+Base = new()
+
+
+class MyText(Base.tag.Tag):
+    def __init__(self, classes: list[str]):
+        self.name = "p"
+        self.closable = True
+        self.classes = classes
+        self.dynamic = True
+        
+        super().__init__()
+
+    def before_build(self, **_kwargs): # Recommended.
+        self.tags.append(time.time())
+```
+This will produce a well behaving Paragraph with dynamic elements.
+#### CSS
+Well, this is straight forward.
+```css
+div.any-div#my-div-used-for-footer {color: #000000;}
+```
+will simply turn into:
+```python
+from typing import Any
+from Autumn import new
+
+Base = new()
+
+class MyStyle(Base.style.Style):
+    
+    def __init__(self):
+        self.name = Base.name.Name("div", Base.name.Identifier("my-div-used-for-footer"),
+                                   [Base.name.Class("any-div")])
+        self.styles = [
+            "color: #000000;"
+        ]
+        
+        super().__init__()
+
+```
+This will also become valuable when writing **dynamic** CSS or when you simply don't know CSS.
+Let's see an example for that too.
+```python
+from typing import Any
+from Autumn import new
+
+Base = new()
+
+class MyStyle(Base.style.Style):
+    
+    def __init__(self):
+        self.name = Base.name.Name("div", Base.name.Identifier("my-div-used-for-footer"),
+                                   [Base.name.Class("any-div")])
+        self.styles = [
+            "color: #000000;"
+        ]
+        
+        self.dynamic = True
+        
+        super().__init__()
+
+    def before_build(self, **kwargs):
+        if "style" in kwargs:
+            self.styles.append(kwargs["style"])
+    
+```
+
+#### A note on Thread safety
+Thread safety is one of the most important parts to remember,
+every public and private method is thread-safe if it inherits from AbstractBase.
+Well, excluding __getattribute__, __setattr__, every public/private method is thread-safe,
+unless it's a protected method. We do not lock protected methods, as they are (mostly, by convenience)
+used by the public/private methods themselves.
+
+### Our future goals
+Our future goals (currently) can be listed as:
+1. Out of the box experience.
+2. A stable and mature ecosystem.
+3. Complete support for HTML/CSS.
+4. Support for JavaScript, etc...

autumn_core-1.0.0/README.md

@@ -0,0 +1,140 @@
+# Autumn Framework - Build front-end in the back-end
+### What are we?
+Autumn framework, a framework built to make front-end work as close as possible to back-end work.
+Our goal is not to provide a server or back-end, but a tool that makes front-end look like back-end.
+By making an ORM(Object Relational Mapping), we add an object-oriented way to write HTML documents and CSS styles
+directly from Python.
+### Why us?
+You are not limited to us, there are Jinja2 and so many other libraries.
+What makes us unique is making you to look at a Python class rather than a div tag.
+
+Tests proven Autumn's speed is less than one millisecond,
+and removing the prettifier actually makes it even faster(tho
+not visibly faster in some cases).
+### How?
+The process is straight.
+But there are important things to consider:
+- Thread safety:
+    While we try our best to promise thread safety,
+    such as features like before_build, we cannot
+    lock every read/write. Your elements are up to you,
+    So, for reads/writes, it's best to access self._lock.
+- Dynamicity:
+    When elements are dynamic, their dynamic
+    must be set to True. However, if any of the tags owned
+    are dynamic, the parent will be inferred as dynamic,
+    therefore no need to set dynamic to True.
+
+here is an example with HTML, another with CSS.
+#### HTML
+Instead of writing:
+```html
+<div id="hello-world">Hello World!</div>
+```
+You write:
+```python
+from Autumn import new
+
+Base = new()
+
+tag = Base.tag
+
+class MyDiv(tag.Tag):
+    def __init__(self):
+        self.name = "div"
+        self.closable = True
+        self.identifier = "hello-world"
+        self.tags = ["Hello World!"]
+        # How we recommend it.
+        # However, you can place spaces, tabs, and newlines, but be aware that they will be
+        # Replaced with -.
+        
+        super().__init__()
+```
+While this seems like writing too much, it's core benefit will be seen when writing **dynamic** tags or when you don't know about HTML too much.
+Let's see an example for a dynamic tag.
+
+```python
+import time
+from Autumn import new
+
+Base = new()
+
+
+class MyText(Base.tag.Tag):
+    def __init__(self, classes: list[str]):
+        self.name = "p"
+        self.closable = True
+        self.classes = classes
+        self.dynamic = True
+        
+        super().__init__()
+
+    def before_build(self, **_kwargs): # Recommended.
+        self.tags.append(time.time())
+```
+This will produce a well behaving Paragraph with dynamic elements.
+#### CSS
+Well, this is straight forward.
+```css
+div.any-div#my-div-used-for-footer {color: #000000;}
+```
+will simply turn into:
+```python
+from typing import Any
+from Autumn import new
+
+Base = new()
+
+class MyStyle(Base.style.Style):
+    
+    def __init__(self):
+        self.name = Base.name.Name("div", Base.name.Identifier("my-div-used-for-footer"),
+                                   [Base.name.Class("any-div")])
+        self.styles = [
+            "color: #000000;"
+        ]
+        
+        super().__init__()
+
+```
+This will also become valuable when writing **dynamic** CSS or when you simply don't know CSS.
+Let's see an example for that too.
+```python
+from typing import Any
+from Autumn import new
+
+Base = new()
+
+class MyStyle(Base.style.Style):
+    
+    def __init__(self):
+        self.name = Base.name.Name("div", Base.name.Identifier("my-div-used-for-footer"),
+                                   [Base.name.Class("any-div")])
+        self.styles = [
+            "color: #000000;"
+        ]
+        
+        self.dynamic = True
+        
+        super().__init__()
+
+    def before_build(self, **kwargs):
+        if "style" in kwargs:
+            self.styles.append(kwargs["style"])
+    
+```
+
+#### A note on Thread safety
+Thread safety is one of the most important parts to remember,
+every public and private method is thread-safe if it inherits from AbstractBase.
+Well, excluding __getattribute__, __setattr__, every public/private method is thread-safe,
+unless it's a protected method. We do not lock protected methods, as they are (mostly, by convenience)
+used by the public/private methods themselves.
+
+### Our future goals
+Our future goals (currently) can be listed as:
+1. Out of the box experience.
+2. A stable and mature ecosystem.
+3. Complete support for HTML/CSS.
+4. Support for JavaScript, etc...

autumn_core-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+
+packages = ["src/Autumn/"]
+
+[tool.hatch.build.targets.sdist]
+
+include = [
+    "src/Autumn/**/*.py",
+    "src/Autumn/**/.pyi",
+    "src/Autumn/py.typed",
+]
+
+[project]
+
+name = "autumn-core"
+version = "1.0.0"
+description = "Autumn - Build CSS and HTML right in your backend"
+requires-python = "~=3.12"
+license = "MIT"
+readme = "README.md"
+authors = [
+    {name = "Nerina0Coder", email = "github.py.coder@gmail.com"},
+]
+dependencies = [
+    "markupsafe ~= 3.0.3",
+    "coloraide ~= 8.12.1",
+    "werkzeug ~= 3.1.8"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Environment :: Web Environment"
+]
+
+[dependency-groups]
+
+docs = [
+    "sphinx>=7.0",
+    "myst-parser>=2.0",
+    "furo>=2.0",
+]

autumn_core-1.0.0/src/Autumn/Naming/__init__.py

@@ -0,0 +1,57 @@
+from .class_ import Class
+from .identifier import Identifier
+from .attribute_selector import AttributeSelector
+from .name import Name
+
+# --- Special Function ---
+
+def MakeSelector(state = None,
+                 identifier = None,
+                 cls = None,
+                 selector = None,):
+    out = []
+
+    if state is not None:
+        if not isinstance(state, list):
+            state = [state]
+    else:
+        state = []
+
+    if identifier is not None:
+        if not isinstance(identifier, list):
+            identifier = [identifier]
+    else:
+        identifier = [identifier]
+
+    if cls is not None:
+        if not isinstance(cls, list):
+            cls = [cls]
+    else:
+        cls = []
+
+    if selector is not None:
+        if not isinstance(selector, list):
+            selector = [selector]
+    else:
+        selector = []
+
+    mixed = [*state, *identifier, *cls, *selector]
+
+    for i in mixed:
+        adding = str(i) if not hasattr(i, "build") else i.build()
+        out.append(f"{adding if len(out) == 1 else f",{adding}"}")
+
+    return "".join(out)
+
+# API
+
+class Naming:
+    """
+    Naming - Contains classes used for naming.
+    """
+
+    MakeSelector = MakeSelector
+    Name = Name
+    Identifier = Identifier
+    Class = Class
+    AttributeSelector = AttributeSelector

autumn_core-1.0.0/src/Autumn/Naming/attribute_selector.py

@@ -0,0 +1,19 @@
+import threading
+
+from markupsafe import escape
+
+from Autumn.abstract_base import AbstractBase
+
+
+class AttributeSelector(AbstractBase):
+
+    def __init__(self, attr, value):
+        self._attr = attr
+        self._value = value
+
+        self._lock = threading.Lock()
+
+    def build(self, **kwargs) -> str:
+        with self._lock:
+            self.before_build(**kwargs)
+            return f'[{escape(self._attr)}="{escape(self._attr)}"]'

autumn_core-1.0.0/src/Autumn/Naming/class_.py

@@ -0,0 +1,21 @@
+import dataclasses
+import threading
+
+from markupsafe import escape
+
+
+@dataclasses.dataclass
+class Class:
+    """
+    The class used to hold CSS/HTML class names.
+    """
+    name: str
+
+    _lock = threading.Lock()
+
+    def __post_init__(self):
+        self.name = escape(self.name)
+
+    def __str__(self):
+        with self._lock:
+            return self.name.replace(" ", "-").replace("\n", "-").replace("\t", "-")

autumn_core-1.0.0/src/Autumn/Naming/identifier.py

@@ -0,0 +1,21 @@
+import dataclasses
+import threading
+
+from markupsafe import escape
+
+
+@dataclasses.dataclass
+class Identifier:
+    """
+    The class used to hold CSS/HTML identifiers.
+    """
+    name: str
+
+    _lock = threading.Lock()
+
+    def __post_init__(self):
+        self.name = escape(self.name)
+
+    def __str__(self):
+        with self._lock:
+            return self.name.replace(" ", "-").replace("\n", "-").replace("\t", "-")

autumn_core-1.0.0/src/Autumn/Naming/name.py

@@ -0,0 +1,55 @@
+import copy
+import threading
+
+from markupsafe import escape
+
+from Autumn.abstract_base import AbstractBase
+
+
+class Name(AbstractBase):
+    """
+    Represents a CSS name.
+    """
+
+    def __init__(self,
+                 name,
+                 id_,
+                 classes,
+                 /, *,
+                 attributes = None):
+        """
+        :param attributes: CSS/JS only
+        """
+        self.name = name
+        self.identifier = id_
+        self.classes = classes
+
+        self.attrs = attributes
+
+        self._lock = threading.Lock()
+
+        self._cache = []
+
+    def build(self, cache_if_possible = True, **kwargs):
+
+        with self._lock:
+            out = [self.name]
+
+            self.before_build(**kwargs)
+
+            if self.identifier:
+                out.append(f"#{self.identifier}")
+
+            if self.classes:
+                for cls in self.classes:
+                    out.append(f".{cls}")
+
+            if self.attrs:
+                for k, v in self.attrs.items():
+                    out.append(f'[{escape(k)}="{escape(v)}"]')
+
+        return ''.join(out)
+
+    @staticmethod
+    def from_tag(tag):
+        return Name(tag.name, tag.identifier, copy.deepcopy(tag.classes))

autumn_core-1.0.0/src/Autumn/Page/__init__.py

@@ -0,0 +1,2 @@
+from .page import Page as Page
+from .page_manager import PageManager as PageManager

autumn_core-1.0.0/src/Autumn/Page/page.py

@@ -0,0 +1,84 @@
+import html
+import threading
+from typing import Literal, Any
+
+from Autumn.Tag.Enums import Language
+from Autumn.Tag.Meta import Title
+from Autumn.Tag.abstract_tag import AbstractTag
+from Autumn.Tag.Meta import Cdn
+from Autumn.Tag.Meta import Head
+from Autumn.abstract_base import AbstractBase
+
+
+class Page(AbstractBase):
+    """
+    A page class representing an HTML document.
+    """
+
+    def __init__(self, name: str, /, *, direction: Literal["ltr", "rtl", "auto"] = "auto", language: Language | str = "en"):
+        """
+        Initializes a new page object.
+        :param name: The name of the page.
+        :param direction: The direction of the page.
+        :param language: The language of the page.
+        """
+        self.name = name
+        self.direction = direction
+        self.language = language.value if isinstance(language, Language) else language
+        self._tags: list[AbstractTag] = []
+        self._requirements: list[Cdn] = []
+
+        self._cache: list[str] = []
+
+        self._lock = threading.Lock()
+
+    def require(self, cdn: list[Cdn] | Cdn, /) -> "Page":
+        """
+        Requires CDN URL(s) for this specific page.
+        :param cdn: The CDN URL(s).
+        :return: This instance for chaining operations.
+        """
+        self._requirements.extend(cdn if isinstance(cdn, list) else [cdn])
+        return self
+
+    def tag(self, tag: list[AbstractTag] | AbstractTag, /) -> "Page":
+        """
+        Adds tag(s) to this page, which is often only a head and a body.
+        :param tag: The tag(s) to add.
+        :return: This instance for chaining operations.
+        """
+        self._tags.extend(tag if isinstance(tag, list) else [tag])
+        return self
+
+    def build(self, **build_kwargs: Any) -> str:
+        dynamic = any(tag.dynamic for tag in self._tags)
+
+        if not dynamic and self._cache:
+            return self._cache[-1]
+
+        self.before_build(**build_kwargs)
+
+        head: Head | None = next(filter(lambda tag: isinstance(tag, Head), self._tags), None) # type: ignore
+        if head is None:
+            self._tags.insert(0, Head(Title(self.name), *self._requirements))
+        else:
+            head.tags.extend([Title(self.name), *self._requirements])
+
+        out = ("<!DOCTYPE html>" +
+                f'<html lang="{html.escape(self.language)}" dir="{html.escape(self.direction)}">' +
+                "".join(tag.build(dynamic, **build_kwargs) for tag in self._tags) +
+                "</html>")
+
+        if not dynamic and not self._cache:
+            self._cache.append(out)
+        return out
+
+    @property
+    def dynamic(self) -> bool:
+        return any(tag.dynamic for tag in self._tags)
+    @property
+    def tags(self) -> list[AbstractTag]:
+        return self._tags.copy()
+    @property
+    def requirements(self) -> list[Cdn]:
+        return self._requirements.copy()