artinforge 0.1.0__tar.gz

artinforge-0.1.0/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.1.0
+- First draft of ArtinForge.
+- Text, file, JSON, HTTP, local server, system information and CLI helpers.
+- No mandatory third-party runtime dependencies.

artinforge-0.1.0/LICENSE

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

artinforge-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+include SECURITY.md
+recursive-include src/artinforge/assets *

artinforge-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: artinforge
+Version: 0.1.0
+Summary: A lightweight, modular Python toolkit for developer utilities.
+Author: Artin Karimian
+License-Expression: MIT
+Keywords: python,developer-tools,automation,files,json,networking
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ArtinForge
+
+**A lightweight, modular Python toolkit for everyday developer tasks.**
+
+ArtinForge starts with useful, real features and avoids mandatory third-party runtime dependencies.
+
+## Features
+
+- **Text utilities:** normalize whitespace, count words, truncate text, create slugs.
+- **File utilities:** UTF-8 read/write, directory creation, file listing and size.
+- **JSON storage:** read and save JSON, including Persian/Unicode text.
+- **HTTP helpers:** GET text/JSON and POST JSON using Python's standard library.
+- **Local development server:** serve a folder for local testing.
+- **System information:** Python version, platform, executable and current directory.
+- **Command line:** inspect runtime details and launch the local server.
+
+> ArtinForge is a developer toolkit, not a bundled AI model. AI features require a model or service to be connected separately.
+
+## Install
+
+```bash
+python -m pip install artinforge
+```
+
+If a package mirror is stale, check the official PyPI index:
+
+```bash
+python -m pip install --index-url https://pypi.org/simple artinforge
+```
+
+The name must be available on PyPI before the first release. Check the project page before publishing.
+
+## Quick example
+
+```python
+from artinforge import text, files, jsonstore
+
+print(text.slugify("Hello ArtinForge!"))
+files.write_text("demo/hello.txt", "سلام آرتین")
+jsonstore.save("demo/settings.json", {"language": "fa", "theme": "dark"})
+print(jsonstore.load("demo/settings.json", default={}))
+```
+
+## Start a local test server
+
+```bash
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+Then open `http://127.0.0.1:8765` in your browser. This is for local development; do not expose it to the public internet without a security review and appropriate protections.
+
+## Commands
+
+```bash
+artinforge --help
+artinforge info
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+## Package the project
+
+From the folder containing `pyproject.toml`:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Only after checks pass, upload with your PyPI token:
+
+```bash
+python -m twine upload dist/*
+```
+
+**Release rule:** every upload to PyPI needs a version that has not been published before. If you need to fix a release, increment `version` in `pyproject.toml`, rebuild from a clean `dist/` directory, and upload the new version. A mirror may take time to sync, so verify against the official PyPI index.
+
+
+## License
+
+MIT. See `LICENSE`.

artinforge-0.1.0/README.md

@@ -0,0 +1,81 @@
+# ArtinForge
+
+**A lightweight, modular Python toolkit for everyday developer tasks.**
+
+ArtinForge starts with useful, real features and avoids mandatory third-party runtime dependencies.
+
+## Features
+
+- **Text utilities:** normalize whitespace, count words, truncate text, create slugs.
+- **File utilities:** UTF-8 read/write, directory creation, file listing and size.
+- **JSON storage:** read and save JSON, including Persian/Unicode text.
+- **HTTP helpers:** GET text/JSON and POST JSON using Python's standard library.
+- **Local development server:** serve a folder for local testing.
+- **System information:** Python version, platform, executable and current directory.
+- **Command line:** inspect runtime details and launch the local server.
+
+> ArtinForge is a developer toolkit, not a bundled AI model. AI features require a model or service to be connected separately.
+
+## Install
+
+```bash
+python -m pip install artinforge
+```
+
+If a package mirror is stale, check the official PyPI index:
+
+```bash
+python -m pip install --index-url https://pypi.org/simple artinforge
+```
+
+The name must be available on PyPI before the first release. Check the project page before publishing.
+
+## Quick example
+
+```python
+from artinforge import text, files, jsonstore
+
+print(text.slugify("Hello ArtinForge!"))
+files.write_text("demo/hello.txt", "سلام آرتین")
+jsonstore.save("demo/settings.json", {"language": "fa", "theme": "dark"})
+print(jsonstore.load("demo/settings.json", default={}))
+```
+
+## Start a local test server
+
+```bash
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+Then open `http://127.0.0.1:8765` in your browser. This is for local development; do not expose it to the public internet without a security review and appropriate protections.
+
+## Commands
+
+```bash
+artinforge --help
+artinforge info
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+## Package the project
+
+From the folder containing `pyproject.toml`:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Only after checks pass, upload with your PyPI token:
+
+```bash
+python -m twine upload dist/*
+```
+
+**Release rule:** every upload to PyPI needs a version that has not been published before. If you need to fix a release, increment `version` in `pyproject.toml`, rebuild from a clean `dist/` directory, and upload the new version. A mirror may take time to sync, so verify against the official PyPI index.
+
+
+## License
+
+MIT. See `LICENSE`.

artinforge-0.1.0/SECURITY.md

@@ -0,0 +1,3 @@
+# Security
+
+The development server is intended for local development and trusted networks. Do not expose it publicly without authentication, TLS, request limits, logging, and a security review. Never share PyPI API tokens or put them into source code.

artinforge-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "artinforge"
+version = "0.1.0"
+description = "A lightweight, modular Python toolkit for developer utilities."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{name = "Artin Karimian"}]
+keywords = ["python", "developer-tools", "automation", "files", "json", "networking"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.scripts]
+artinforge = "artinforge.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+artinforge = ["assets/*"]

artinforge-0.1.0/setup.cfg

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

artinforge-0.1.0/src/artinforge/__init__.py

@@ -0,0 +1,4 @@
+"""ArtinForge lightweight developer toolkit."""
+__version__ = "0.1.0"
+from . import files, jsonstore, net, system, text
+__all__ = ["files", "jsonstore", "net", "system", "text", "__version__"]

artinforge-0.1.0/src/artinforge/cli.py

@@ -0,0 +1,24 @@
+"""ArtinForge command line interface."""
+import argparse
+import json
+from .server import LocalServer
+from .system import info
+
+def main():
+    parser = argparse.ArgumentParser(prog="artinforge", description="ArtinForge developer toolkit")
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("info", help="show Python/platform information")
+    serve = sub.add_parser("serve", help="serve a directory for local development")
+    serve.add_argument("--host", default="127.0.0.1")
+    serve.add_argument("--port", type=int, default=8765)
+    serve.add_argument("--directory", default=".")
+    args = parser.parse_args()
+    if args.command == "info":
+        print(json.dumps(info(), indent=2, ensure_ascii=False))
+    elif args.command == "serve":
+        LocalServer(args.host, args.port, args.directory).serve()
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

artinforge-0.1.0/src/artinforge/files.py

@@ -0,0 +1,22 @@
+"""Filesystem helpers."""
+from pathlib import Path
+
+def ensure_dir(path) -> Path:
+    target = Path(path)
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+def read_text(path, encoding="utf-8") -> str:
+    return Path(path).read_text(encoding=encoding)
+
+def write_text(path, content, encoding="utf-8") -> Path:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(str(content), encoding=encoding)
+    return target
+
+def file_size(path) -> int:
+    return Path(path).stat().st_size
+
+def list_files(path=".", pattern="*") -> list:
+    return sorted(p for p in Path(path).glob(pattern) if p.is_file())

artinforge-0.1.0/src/artinforge/jsonstore.py

@@ -0,0 +1,23 @@
+"""JSON read/write helpers."""
+import json
+from pathlib import Path
+
+def load(path, default=None, encoding="utf-8"):
+    target = Path(path)
+    if not target.exists():
+        return default
+    try:
+        with target.open("r", encoding=encoding) as stream:
+            return json.load(stream)
+    except (json.JSONDecodeError, OSError) as exc:
+        raise ValueError(f"Could not load JSON from {target}: {exc}") from exc
+
+def save(path, data, *, indent=2, ensure_ascii=False, encoding="utf-8"):
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    temp = target.with_suffix(target.suffix + ".tmp")
+    with temp.open("w", encoding=encoding) as stream:
+        json.dump(data, stream, indent=indent, ensure_ascii=ensure_ascii)
+        stream.write("\n")
+    temp.replace(target)
+    return target

artinforge-0.1.0/src/artinforge/net.py

@@ -0,0 +1,37 @@
+"""Small HTTP helpers using Python's standard library."""
+import json
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+
+def validate_url(url):
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https") or not parsed.netloc:
+        raise ValueError("Expected an absolute http:// or https:// URL")
+    return url
+
+def get(url, *, timeout=10, headers=None):
+    request = Request(validate_url(url), headers=headers or {}, method="GET")
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            return response.read()
+    except (HTTPError, URLError, TimeoutError) as exc:
+        raise RuntimeError(f"GET request failed: {exc}") from exc
+
+def get_text(url, *, timeout=10, encoding="utf-8", headers=None):
+    return get(url, timeout=timeout, headers=headers).decode(encoding, errors="replace")
+
+def get_json(url, *, timeout=10, headers=None):
+    return json.loads(get_text(url, timeout=timeout, headers=headers))
+
+def post_json(url, data, *, timeout=10, headers=None):
+    request_headers = {"Content-Type": "application/json"}
+    request_headers.update(headers or {})
+    request = Request(validate_url(url), data=json.dumps(data).encode("utf-8"),
+                      headers=request_headers, method="POST")
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            body = response.read().decode("utf-8", errors="replace")
+            return json.loads(body) if body else None
+    except (HTTPError, URLError, TimeoutError) as exc:
+        raise RuntimeError(f"POST request failed: {exc}") from exc

artinforge-0.1.0/src/artinforge/server.py

@@ -0,0 +1,27 @@
+"""Local static-file server for development."""
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+class LocalServer:
+    def __init__(self, host="127.0.0.1", port=8765, directory="."):
+        if not 0 <= int(port) <= 65535:
+            raise ValueError("port must be between 0 and 65535")
+        self.host, self.port = host, int(port)
+        self.directory = str(Path(directory).resolve())
+        self._server = ThreadingHTTPServer(
+            (self.host, self.port),
+            partial(SimpleHTTPRequestHandler, directory=self.directory)
+        )
+
+    def serve(self):
+        print("ARTINFORGE LOCAL SERVER")
+        print(f"Serving: {self.directory}")
+        print(f"Open: http://{self.host}:{self._server.server_address[1]}")
+        print("Press Ctrl+C to stop.")
+        try:
+            self._server.serve_forever()
+        except KeyboardInterrupt:
+            print("\nStopping server...")
+        finally:
+            self._server.server_close()

artinforge-0.1.0/src/artinforge/system.py

@@ -0,0 +1,12 @@
+"""Basic runtime information."""
+import os
+import platform
+import sys
+
+def info() -> dict:
+    return {"python": sys.version.split()[0],
+            "implementation": platform.python_implementation(),
+            "platform": platform.platform(),
+            "executable": sys.executable,
+            "current_directory": os.getcwd(),
+            "pid": os.getpid()}

artinforge-0.1.0/src/artinforge/text.py

@@ -0,0 +1,23 @@
+"""Unicode-friendly text utilities."""
+import re
+import unicodedata
+
+def normalize_whitespace(value: str) -> str:
+    return " ".join(str(value).split())
+
+def word_count(value: str) -> int:
+    return len(str(value).split())
+
+def truncate(value: str, length: int, suffix: str = "...") -> str:
+    if length < 0:
+        raise ValueError("length must be >= 0")
+    value = str(value)
+    if len(value) <= length:
+        return value
+    if length <= len(suffix):
+        return suffix[:length]
+    return value[:length-len(suffix)] + suffix
+
+def slugify(value: str, separator: str = "-") -> str:
+    value = unicodedata.normalize("NFKD", str(value)).encode("ascii", "ignore").decode()
+    return re.sub(r"[^a-zA-Z0-9]+", separator, value.lower()).strip(separator)

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

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: artinforge
+Version: 0.1.0
+Summary: A lightweight, modular Python toolkit for developer utilities.
+Author: Artin Karimian
+License-Expression: MIT
+Keywords: python,developer-tools,automation,files,json,networking
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ArtinForge
+
+**A lightweight, modular Python toolkit for everyday developer tasks.**
+
+ArtinForge starts with useful, real features and avoids mandatory third-party runtime dependencies.
+
+## Features
+
+- **Text utilities:** normalize whitespace, count words, truncate text, create slugs.
+- **File utilities:** UTF-8 read/write, directory creation, file listing and size.
+- **JSON storage:** read and save JSON, including Persian/Unicode text.
+- **HTTP helpers:** GET text/JSON and POST JSON using Python's standard library.
+- **Local development server:** serve a folder for local testing.
+- **System information:** Python version, platform, executable and current directory.
+- **Command line:** inspect runtime details and launch the local server.
+
+> ArtinForge is a developer toolkit, not a bundled AI model. AI features require a model or service to be connected separately.
+
+## Install
+
+```bash
+python -m pip install artinforge
+```
+
+If a package mirror is stale, check the official PyPI index:
+
+```bash
+python -m pip install --index-url https://pypi.org/simple artinforge
+```
+
+The name must be available on PyPI before the first release. Check the project page before publishing.
+
+## Quick example
+
+```python
+from artinforge import text, files, jsonstore
+
+print(text.slugify("Hello ArtinForge!"))
+files.write_text("demo/hello.txt", "سلام آرتین")
+jsonstore.save("demo/settings.json", {"language": "fa", "theme": "dark"})
+print(jsonstore.load("demo/settings.json", default={}))
+```
+
+## Start a local test server
+
+```bash
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+Then open `http://127.0.0.1:8765` in your browser. This is for local development; do not expose it to the public internet without a security review and appropriate protections.
+
+## Commands
+
+```bash
+artinforge --help
+artinforge info
+artinforge serve --host 127.0.0.1 --port 8765 --directory .
+```
+
+## Package the project
+
+From the folder containing `pyproject.toml`:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Only after checks pass, upload with your PyPI token:
+
+```bash
+python -m twine upload dist/*
+```
+
+**Release rule:** every upload to PyPI needs a version that has not been published before. If you need to fix a release, increment `version` in `pyproject.toml`, rebuild from a clean `dist/` directory, and upload the new version. A mirror may take time to sync, so verify against the official PyPI index.
+
+
+## License
+
+MIT. See `LICENSE`.

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

@@ -0,0 +1,21 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+SECURITY.md
+pyproject.toml
+src/artinforge/__init__.py
+src/artinforge/cli.py
+src/artinforge/files.py
+src/artinforge/jsonstore.py
+src/artinforge/net.py
+src/artinforge/server.py
+src/artinforge/system.py
+src/artinforge/text.py
+src/artinforge.egg-info/PKG-INFO
+src/artinforge.egg-info/SOURCES.txt
+src/artinforge.egg-info/dependency_links.txt
+src/artinforge.egg-info/entry_points.txt
+src/artinforge.egg-info/top_level.txt
+src/artinforge/assets/artinforge-banner.png
+tests/test_core.py

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

@@ -0,0 +1 @@
+

artinforge-0.1.0/src/artinforge.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+artinforge = artinforge.cli:main

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

@@ -0,0 +1 @@
+artinforge

artinforge-0.1.0/tests/test_core.py

@@ -0,0 +1,22 @@
+from artinforge import files, jsonstore, text, system
+
+def test_text():
+    assert text.word_count("one two") == 2
+    assert text.normalize_whitespace(" a\n b ") == "a b"
+    assert text.truncate("abcdef", 4) == "a..."
+    assert text.slugify("Hello World!") == "hello-world"
+
+def test_files(tmp_path):
+    p = files.write_text(tmp_path / "sub" / "hi.txt", "سلام")
+    assert files.read_text(p) == "سلام"
+    assert files.file_size(p) > 0
+    assert len(files.list_files(tmp_path / "sub")) == 1
+
+def test_json(tmp_path):
+    p = tmp_path / "sub" / "x.json"
+    jsonstore.save(p, {"message": "سلام"})
+    assert jsonstore.load(p) == {"message": "سلام"}
+    assert jsonstore.load(tmp_path / "missing.json", default={}) == {}
+
+def test_system():
+    assert "python" in system.info()