sqless 0.1.0__tar.gz

sqless-0.1.0/LICENSE

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

sqless-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: sqless
+Version: 0.1.0
+Summary: An async HTTP server for SQLite, FileStorage and WebPage.
+Home-page: https://github.com/pro1515151515/sqless
+Author: pro1515151515
+Author-email: pro1515151515@qq.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiosqlite>=0.17.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: orjson>=3.6.0
+Requires-Dist: aiofiles>=0.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# sqless
+
+An async HTTP server for SQLite, FileStorage and WebPage.
+
+## Description
+
+sqless is a Python application that provides web service with local database and local file storage.
+
+## Installation
+
+```bash
+pip install sqless
+```
+
+## Quick Start
+
+### Running the server
+
+```bash
+sqless --host 127.0.0.1 --port 12239 --secret your-secret-key
+```
+
+This will create `www` directory in the current directory, which is used for WebPage.
+You can access the `www/index.html` at `http://127.0.0.1:12239/index.html`
+
+It will also creates `db` and `fs` directories in the current directory, when saving data by database API and file storage API.
+
+### Using the database API
+
+```python
+import requests
+
+# Set up the base URL and authentication
+BASE_URL = "http://127.0.0.1:12239"
+SECRET = "your-secret-key"
+DB_TABLE = "users"
+
+# Insert or update data
+r = requests.post(
+    f"{BASE_URL}/db/{DB_TABLE}",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json={"key": "U001", "name": "Tom", "age": 14}
+)
+
+# Query data
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Fuzzy query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/name like %om%?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Value query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/age > 10?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Delete data
+r = requests.delete(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+```
+
+`DB_TABLE = "users"` will read/write records in `users` table in `db/default.sqlite`.
+`DB_TABLE = "mall-users"` will read/write records in `users` table in `db/mall.sqlite`.
+`DB_TABLE = "east-mall-users"` will read/write records in `users` table in `db/east/mall.sqlite`.
+
+### Using the FileStorage API
+```python
+import requests
+
+# Upload a file to ./fs/example.txt
+with open("example.txt", "rb") as f:
+    r = requests.post(
+        f"{BASE_URL}/fs/example.txt",
+        headers={"Authorization": f"Bearer {SECRET}"},
+        files={"file": f}
+    )
+
+# Check if a file exists
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt?check=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Download a file
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    stream=True
+)
+with open("downloaded_example.txt", "wb") as f:
+    for chunk in r.iter_content(chunk_size=8192):
+        f.write(chunk)
+```
+
+### Using the Proxy API
+```python
+import requests
+import base64
+
+payload = {
+    "method": "POST",
+    "url": "https://httpbin.org/post",
+    "headers": {
+        "User-Agent": "SQLESS-Client/1.0",
+        "Authorization": "Bearer mytoken"
+    },
+    "type": "form",
+    "data": {"foo": "bar"},
+    "files": [
+        {
+            "field": "file1",
+            "filename": "example.txt",
+            "content_type": "text/plain",
+            "base64": base64.b64encode(open("example.txt", "rb").read()).decode()
+        }
+    ]
+}
+
+r = requests.post(
+    f"{BASE_URL}/xmlhttpRequest",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json=payload
+)
+print(r.json())
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

sqless-0.1.0/README.md

@@ -0,0 +1,137 @@
+# sqless
+
+An async HTTP server for SQLite, FileStorage and WebPage.
+
+## Description
+
+sqless is a Python application that provides web service with local database and local file storage.
+
+## Installation
+
+```bash
+pip install sqless
+```
+
+## Quick Start
+
+### Running the server
+
+```bash
+sqless --host 127.0.0.1 --port 12239 --secret your-secret-key
+```
+
+This will create `www` directory in the current directory, which is used for WebPage.
+You can access the `www/index.html` at `http://127.0.0.1:12239/index.html`
+
+It will also creates `db` and `fs` directories in the current directory, when saving data by database API and file storage API.
+
+### Using the database API
+
+```python
+import requests
+
+# Set up the base URL and authentication
+BASE_URL = "http://127.0.0.1:12239"
+SECRET = "your-secret-key"
+DB_TABLE = "users"
+
+# Insert or update data
+r = requests.post(
+    f"{BASE_URL}/db/{DB_TABLE}",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json={"key": "U001", "name": "Tom", "age": 14}
+)
+
+# Query data
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Fuzzy query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/name like %om%?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Value query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/age > 10?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Delete data
+r = requests.delete(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+```
+
+`DB_TABLE = "users"` will read/write records in `users` table in `db/default.sqlite`.
+`DB_TABLE = "mall-users"` will read/write records in `users` table in `db/mall.sqlite`.
+`DB_TABLE = "east-mall-users"` will read/write records in `users` table in `db/east/mall.sqlite`.
+
+### Using the FileStorage API
+```python
+import requests
+
+# Upload a file to ./fs/example.txt
+with open("example.txt", "rb") as f:
+    r = requests.post(
+        f"{BASE_URL}/fs/example.txt",
+        headers={"Authorization": f"Bearer {SECRET}"},
+        files={"file": f}
+    )
+
+# Check if a file exists
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt?check=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Download a file
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    stream=True
+)
+with open("downloaded_example.txt", "wb") as f:
+    for chunk in r.iter_content(chunk_size=8192):
+        f.write(chunk)
+```
+
+### Using the Proxy API
+```python
+import requests
+import base64
+
+payload = {
+    "method": "POST",
+    "url": "https://httpbin.org/post",
+    "headers": {
+        "User-Agent": "SQLESS-Client/1.0",
+        "Authorization": "Bearer mytoken"
+    },
+    "type": "form",
+    "data": {"foo": "bar"},
+    "files": [
+        {
+            "field": "file1",
+            "filename": "example.txt",
+            "content_type": "text/plain",
+            "base64": base64.b64encode(open("example.txt", "rb").read()).decode()
+        }
+    ]
+}
+
+r = requests.post(
+    f"{BASE_URL}/xmlhttpRequest",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json=payload
+)
+print(r.json())
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

sqless-0.1.0/setup.cfg

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

sqless-0.1.0/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="sqless",
+    version="0.1.0",
+    author="pro1515151515",
+    author_email="pro1515151515@qq.com",
+    description="An async HTTP server for SQLite, FileStorage and WebPage.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/pro1515151515/sqless",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "aiosqlite>=0.17.0",
+        "aiohttp>=3.8.0",
+        "orjson>=3.6.0",
+        "aiofiles>=0.8.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "sqless=sqless.server:main",
+        ],
+    },
+)

sqless-0.1.0/sqless/__init__.py

@@ -0,0 +1,14 @@
+"""
+sqless - An async HTTP server for SQLite, FileStorage and WebPage.
+"""
+
+__version__ = "0.1.0"
+__author__ = "pro1515151515"
+__email__ = "pro1515151515@qq.com"
+
+from .database import DB
+from .server import run_server
+
+def hello():
+    """A simple function to test the package."""
+    return "Hello from sqless!"

sqless-0.1.0/sqless/database.py

@@ -0,0 +1,382 @@
+import os
+import re
+import asyncio
+import aiosqlite
+import orjson
+import pickle
+from collections import defaultdict
+
+type_map = {
+    str:'TEXT',
+    int:'INTEGER',
+    float:'REAL'
+}
+value_map = {
+    str:None,
+    int:None,
+    float:None
+}
+if 'np' in globals():
+    try:
+        _np = globals()['np']
+        type_map[_np.integer]   = 'INTEGER'
+        type_map[_np.int8]      = 'INTEGER'
+        type_map[_np.int16]     = 'INTEGER'
+        type_map[_np.int32]     = 'INTEGER'
+        type_map[_np.int64]     = 'INTEGER'
+        type_map[_np.uint8]     = 'INTEGER'
+        type_map[_np.uint16]    = 'INTEGER'
+        type_map[_np.uint32]    = 'INTEGER'
+        type_map[_np.uint64]    = 'INTEGER'
+        type_map[_np.floating]  = 'REAL'
+        type_map[_np.float16]   = 'REAL'
+        type_map[_np.float32]   = 'REAL'
+        type_map[_np.float64]   = 'REAL'
+        value_map[_np.integer]  = int
+        value_map[_np.int8]     = int
+        value_map[_np.int16]    = int
+        value_map[_np.int32]    = int
+        value_map[_np.int64]    = int
+        value_map[_np.uint8]    = int
+        value_map[_np.uint16]   = int
+        value_map[_np.uint32]   = int
+        value_map[_np.uint64]   = int
+        value_map[_np.floating] = float
+        value_map[_np.float16]  = float
+        value_map[_np.float32]  = float
+        value_map[_np.float64]  = float
+    except:
+        pass
+
+
+def encode(obj):
+    if type(obj) == None:
+        return None
+    if isinstance(obj, bytes):
+        return b'B' + obj
+    try:
+        return b'J' + orjson.dumps(obj,option=orjson.OPT_SERIALIZE_NUMPY)
+    except:
+        return b'P' + pickle.dumps(obj)
+
+def decode(binary):
+    if type(binary) != bytes:
+        return binary
+    if binary[0] == ord('J'):
+        return orjson.loads(binary[1:])
+    if binary[0] == ord('P'):
+        return pickle.loads(binary[1:])
+    return binary[1:]
+
+identifier_re = re.compile(r"^[A-Za-z_][A-Za-z0-9_\-]*[A-Za-z0-9]$")
+
+def valid_identifier(name: str) -> bool:
+    return bool(name and identifier_re.fullmatch(name))
+def sanitize_table_name(name: str):
+    if not valid_identifier(name):
+        raise ValueError(f"Invalid identifier: {name}")
+    return name
+
+def split(s, sep=',', L="{[(\"'", R="}])\"'"):
+    stack = []
+    temp = ''
+    esc = False
+    for c in s:
+        if c == '\\':
+            esc = True
+            temp += c
+            continue
+        if not esc and c in R and stack:
+            if c == R[L.index(stack[-1])]:
+                stack.pop()
+        elif not esc and c in L:
+            stack.append(c)
+        elif c == sep and not stack:
+            if temp:
+                yield temp
+            temp = ''
+            continue
+        temp += c
+        esc = False
+    if temp:
+        yield temp
+
+def parse_where(where_str):
+    """Parse limited where expressions into (sql, params).
+       This function is intentionally conservative: reject suspicious chars
+       and require simple pattern: col op value [and|or ...]
+    """
+    if not where_str:
+        return '', []
+    s = where_str.strip()
+    # reject common SQL injection characters / comments
+    if ';' in s or '--' in s or '/*' in s or '*/' in s:
+        return {'suc': False, 'msg': 'Invalid where clause: contains forbidden characters'}, []
+    # basic tokenization by spaces while respecting quotes
+    try:
+        tokens = list(split(s, ' ', "\"'"))
+        # expect pattern: col op value [and|or col op value ...]
+        if len(tokens) < 3 or (len(tokens) - 1) % 4 not in (0,):
+            # attempt fallback: allow "order by" presence handled below
+            pass
+        # detect 'order by' part
+        lower = s.lower()
+        if ' order by ' in lower:
+            where_part, order_part = s.rsplit('order by', 1)
+        else:
+            where_part, order_part = s, ''
+        # simple parser: split by and/or
+        # we will only allow operators in this set:
+        allowed_ops = {'=', '==', '!=', '<', '>', '<=', '>=', 'like', 'ilike', 'is'}
+        parts = re.split(r'\s+(and|or)\s+', where_part, flags=re.IGNORECASE)
+        sql_parts = []
+        params = []
+        # parts example: [cond1, connector, cond2, ...]
+        i = 0
+        while i < len(parts):
+            cond = parts[i].strip()
+            connector = ''
+            if i + 1 < len(parts):
+                connector = parts[i + 1]
+            # parse cond -> col op val
+            m = re.match(r'^\s*([A-Za-z_][A-Za-z0-9_]*)\s*(=|==|!=|<=|>=|<|>|like|ilike|is)\s*(.+)$', cond, flags=re.I)
+            if not m:
+                return {'suc': False, 'msg': f"Invalid condition: {cond}"}, []
+            col, op, val = m.group(1), m.group(2).lower(), m.group(3).strip()
+            if op not in allowed_ops:
+                return {'suc': False, 'msg': f"Operator not allowed: {op}"}, []
+            if not valid_identifier(col):
+                return {'suc': False, 'msg': f"Invalid column name: {col}"}, []
+            # handle null
+            if val.lower() == 'null' and op == 'is':
+                sql_parts.append(f"{col} is null")
+            else:
+                # strip quotes if present
+                if (val.startswith("'") and val.endswith("'")) or (val.startswith('"') and val.endswith('"')):
+                    raw = val[1:-1]
+                else:
+                    raw = val
+                sql_parts.append(f"{col} {op} ?")
+                params.append(raw)
+            if connector:
+                sql_parts.append(connector.lower())
+            i += 2
+        sql = "where " + " ".join(sql_parts)
+        # order by parsing (very minimal)
+        order_clause = ''
+        if order_part:
+            cols = []
+            for part in order_part.split(','):
+                y = part.strip().split()
+                if not y:
+                    continue
+                colname = y[0]
+                if not valid_identifier(colname):
+                    return {'suc': False, 'msg': f"Invalid order column: {colname}"}, []
+                if len(y) == 1:
+                    cols.append(colname)
+                elif len(y) == 2 and y[1].lower() in ('asc', 'desc'):
+                    cols.append(f"{colname} {y[1].lower()}")
+                else:
+                    return {'suc': False, 'msg': f"Invalid order clause: {part}"}, []
+            if cols:
+                order_clause = " order by " + ", ".join(cols)
+                sql += order_clause
+        return sql, params
+    except Exception as e:
+        return {'suc': False, 'msg': f"parse error: {e}"}, []
+
+# ---------- DB class ----------
+class DB:
+    def __init__(self, path_db):
+        self.path_db = path_db
+        self.conn = None
+        # use per-table locks to reduce contention
+        self._locks = defaultdict(asyncio.Lock)
+        self._global_lock = asyncio.Lock()
+
+    async def connect(self):
+        os.makedirs(os.path.dirname(self.path_db) or '.', exist_ok=True)
+        self.conn = await aiosqlite.connect(self.path_db)
+        await self.conn.execute("PRAGMA journal_mode=WAL;")
+        await self.conn.commit()
+        self.conn.row_factory = aiosqlite.Row
+
+    async def close(self):
+        if self.conn:
+            await self.conn.close()
+
+    async def ensure_table_and_fields(self, table: str, data: dict, pkey='key'):
+        # 校验标识符
+        for name in [table, pkey] + list(data.keys()):
+            if not name.isidentifier():
+                return False, f"Illegal identifier: {name}"
+
+        # 查看现有表头
+        async with self.conn.execute(f"PRAGMA table_info({table});") as cursor:
+            rows = await cursor.fetchall()
+
+        is_pkey_exists = any(row[5] for row in rows)
+        existing_fields = {row[1] for row in rows}
+
+        # 新增字段
+        add_fields = {
+            k: type_map.get(type(v), 'BLOB')
+            for k, v in data.items()
+            if k not in existing_fields
+        }
+
+        if pkey in add_fields:
+            add_fields[pkey] += ' PRIMARY KEY'
+        elif not is_pkey_exists:
+            add_fields = {pkey: 'INTEGER PRIMARY KEY AUTOINCREMENT', **add_fields}
+
+        # 构建 SQL
+        if not rows:
+            sql_fields = ','.join(f'{k} {v}' for k, v in add_fields.items())
+            sql = f"CREATE TABLE {table} ({sql_fields});"
+        else:
+            sql = '\n'.join(f"ALTER TABLE {table} ADD COLUMN {k} {v};" for k, v in add_fields.items())
+
+        # 执行 SQL
+        try:
+            await self.conn.executescript(sql)
+            await self.conn.commit()
+            return True,'ok'
+        except Exception as e:
+            return False,f"Ensuring fields error: {e}({sql})"
+
+    async def upsert(self, table, data, key='key'):
+        if not isinstance(data, dict):
+            return {"suc": False, "msg": "data must be a dict"}
+        if key not in data:
+            return {"suc": False, "msg": f"Missing key field: '{key}'"}
+        try:
+            table = sanitize_table_name(table)
+        except ValueError as e:
+            return {"suc": False, "msg": str(e)}
+        lock = self._locks[table]
+        async with lock:
+            ok,msg = await self.ensure_table_and_fields(table, data, key)
+            if not ok:
+                return {"suc": False, "msg": msg}
+            keys = []
+            pins = []
+            values = []
+            for k,v in data.items():
+                keys.append(k)
+                pins.append('?')
+                L=value_map.get(type(v),encode)
+                values.append(L(v) if L else v)
+            updates = ", ".join([f"{k}=excluded.{k}" for k in keys])
+            keys = ','.join(keys)
+            pins = ','.join(pins)
+            
+            sql = f"""
+            INSERT INTO {table} ({keys})
+            VALUES ({pins})
+            ON CONFLICT({key}) DO UPDATE SET {updates}
+            RETURNING *;
+            """
+            try:
+                async with self.conn.execute(sql, values) as cursor:
+                    row = await cursor.fetchone()
+                await self.conn.commit()
+                if row:
+                    return {'suc': True, 'data': {k: decode(row[k]) for k in row.keys()}}
+                return {'suc': True, 'data': {}}
+            except aiosqlite.Error as e:
+                return {'suc': False, 'msg': str(e), 'debug': sql}
+
+    async def query(self, table, where='', limit=0, offset=0):
+        try:
+            table = sanitize_table_name(table)
+        except ValueError as e:
+            return {'suc': False, 'msg': str(e)}
+        parsed = parse_where(where)
+        if isinstance(parsed, tuple):
+            sql, param = parsed
+        else:
+            sql, param = parsed
+        if isinstance(sql, dict) and sql.get('suc') is False:
+            return sql
+        if limit > 0:
+            sql += f" LIMIT {int(limit)}"
+            if offset > 0:
+                sql += f" OFFSET {int(offset)}"
+        try:
+            async with self.conn.execute(f"SELECT * from {table} {sql};", param) as cursor:
+                rows = await cursor.fetchall()
+                return {'suc': True, 'data': [{k: decode(row[k]) for k in row.keys()} for row in rows]}
+        except aiosqlite.Error as e:
+            return {'suc': False, 'msg': str(e), 'debug': sql}
+        except Exception as e:
+            return {'suc': False, 'msg': str(e)}
+
+    async def count(self, table, where=''):
+        try:
+            table = sanitize_table_name(table)
+        except ValueError as e:
+            return {'suc': False, 'msg': str(e)}
+        sql, param = parse_where(where)
+        if isinstance(sql, dict) and sql.get('suc') is False:
+            return sql
+        async with self.conn.execute(f"SELECT count(*) from {table} {sql};", param) as cursor:
+            return (await cursor.fetchone())[0]
+
+    async def list(self, table, where='', total=None):
+        limit = min(total, 10) if total else 10
+        if not total:
+            total = await self.count(table, where)
+            if isinstance(total, dict) and total.get('suc') is False:
+                return
+        max_page, rest = divmod(total, limit)
+        if rest != 0:
+            max_page += 1
+        for i in range(max_page):
+            ret = await self.query(table, where, limit=limit, offset=i * limit)
+            if not ret['suc']:
+                break
+            for row in ret['data']:
+                yield row
+
+    async def delete(self, table, where):
+        try:
+            table = sanitize_table_name(table)
+        except ValueError as e:
+            return {'suc': False, 'msg': str(e)}
+        sql, param = parse_where(where)
+        if isinstance(sql, dict) and sql.get('suc') is False:
+            return sql
+        try:
+            async with self.conn.execute(f"DELETE FROM {table} {sql};", param) as cursor:
+                await self.conn.commit()
+                return {'suc': True, 'data': cursor.rowcount}
+        except aiosqlite.Error as e:
+            return {'suc': False, 'msg': str(e), 'debug': sql}
+
+    async def columns(self, table):
+        try:
+            table = sanitize_table_name(table)
+        except ValueError as e:
+            return {'suc': False, 'msg': str(e)}
+        try:
+            async with self.conn.execute(f"PRAGMA table_info({table});") as cursor:
+                rows = await cursor.fetchall()
+                return {'suc': True, 'data': [row[1] for row in rows]}
+        except aiosqlite.Error as e:
+            return {'suc': False, 'msg': str(e)}
+
+#if __name__ == '__main__':
+#    import asyncio
+#    async def main():
+#        db = DB(path_db = "your_database.db")
+#        await db.connect()
+#        r = await db.upsert("users", {"key": 'U0001', "name": "Tom", 'age':12, 'sex':'M', 'hobby':["football", 'basketball'],'meta':{"height": 1.75, "weight": 70}})
+#        print(r)
+#        r = await db.upsert("users", {"key": 'U0002', "name": "Jerry", 'age':8, 'sex':'M', 'hobby':["football", 'basketball'],'meta':{"height": 1.25, "weight": 30}})
+#        print(r)
+#        r = await db.count("users", 'meta like %"height":1.25%')
+#        print(r)
+#        await db.close()
+#    asyncio.run(main())

sqless-0.1.0/sqless/server.py

@@ -0,0 +1,286 @@
+import os
+import time
+import base64
+import asyncio
+from aiohttp import web, ClientSession, FormData, ClientTimeout
+import orjson
+import aiofiles
+from .database import DB
+import re
+path_src = os.path.dirname(os.path.abspath(__file__))
+# ---------- Configuration (use env vars in production) ----------
+DEFAULT_SECRET = os.environ.get("SQLESS_SECRET", None)
+
+num2time = lambda t=None, f="%Y%m%d-%H%M%S": time.strftime(f, time.localtime(int(t if t else time.time())))
+tspToday = lambda: int(time.time() // 86400 * 86400 - 8 * 3600)  # UTC+8 today midnight
+
+identifier_re = re.compile(r"^[A-Za-z_][A-Za-z0-9_\-]*[A-Za-z0-9]$")
+
+def valid_identifier(name: str) -> bool:
+    return bool(name and identifier_re.fullmatch(name))
+
+def sanitize_table_name(name: str):
+    if not valid_identifier(name):
+        raise ValueError(f"Invalid identifier: {name}")
+    return name
+
+def check_path(path_file, path_base):
+    normalized_path = os.path.realpath(path_file)
+    try:
+        if os.path.commonpath([path_base, normalized_path]) == path_base:
+            return True, normalized_path
+    except Exception as e:
+        pass
+    return False, f"unsafe path: {normalized_path}"
+
+
+
+async def run_server(
+    host='0.0.0.0',
+    port=27018,
+    secret=DEFAULT_SECRET,
+    path_this = os.getcwd(),
+    max_filesize = 200, # MB
+):
+    path_base_db = os.path.realpath(f"{path_this}/db")
+    path_base_fs = os.path.realpath(f"{path_this}/fs")
+    if not secret:
+        print("[ERROR] Please set SQLESS_SECRET environment variable or pass --secret <secret>")
+        return
+    
+    dbs = {}
+    async def get_db(db_key='default'):
+        if db_key not in dbs:
+            suc, path_db = check_path(f"{path_this}/db/{db_key}.sqlite", path_base_db)
+            if not suc:
+                return False, path_db
+            db = DB(path_db)
+            await db.connect()
+            dbs[db_key] = db
+        return dbs[db_key]
+
+    async def auth_middleware(app, handler):
+        async def middleware_handler(request):
+            try:
+                request['client_ip'] = request.headers.get('X-Real-IP',request.transport.get_extra_info('peername')[0])
+            except:
+                request['client_ip'] = 'unknown'
+            route = request.match_info.route
+            if route and getattr(route, "handler", None) == handle_static:
+                return await handler(request)
+            auth = request.headers.get('Authorization', '')
+            if not auth.startswith("Bearer "):
+                return web.Response(status=401, text='Unauthorized')
+            token = auth.split(" ", 1)[1].strip()
+            if token != secret:
+                return web.Response(status=401, text='Unauthorized')
+            return await handler(request)
+        return middleware_handler
+
+    async def handle_post_db(request):
+        db_table = request.match_info['db_table']
+        if request.content_type == 'application/json':
+            data = await request.json()
+        else:
+            post = await request.post()
+            data = dict(post)
+        db_key, table = os.path.split(db_table.replace('-', '/'))
+        db_key = db_key or 'default'
+        try:
+            table = sanitize_table_name(table)
+        except ValueError:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'invalid table name'}), content_type='application/json')
+        db = await get_db(db_key)
+        if isinstance(db, tuple) and db[0] is False:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': db[1]}), content_type='application/json')
+        print(f"[{num2time()}]{request['client_ip']}|POST {db_key}|{table}|{data}")
+        if not isinstance(data, dict):
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'invalid data type'}), content_type='application/json')
+        ret = await db.upsert(table, data, 'key')
+        return web.Response(body=orjson.dumps(ret), content_type='application/json')
+
+    async def handle_delete_db(request):
+        db_table = request.match_info['db_table']
+        db_key, table = os.path.split(db_table.replace('-', '/'))
+        db_key = db_key or 'default'
+        try:
+            table = sanitize_table_name(table)
+        except ValueError:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'invalid table name'}), content_type='application/json')
+        db = await get_db(db_key)
+        where = request.match_info['where']
+        print(f"[{num2time()}]{request['client_ip']}|DELETE {db_key}|{table}|{where}")
+        ret = await db.delete(table, where)
+        return web.Response(body=orjson.dumps(ret), content_type='application/json')
+
+    async def handle_get_db(request):
+        db_table = request.match_info['db_table']
+        db_key, table = os.path.split(db_table.replace('-', '/'))
+        db_key = db_key or 'default'
+        try:
+            table = sanitize_table_name(table)
+        except ValueError:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'invalid table name'}), content_type='application/json')
+        db = await get_db(db_key)
+        where = request.match_info['where']
+        page = max(int(request.query.get('page', 1)), 1)
+        limit = min(max(int(request.query.get('per_page', 20)), 0), 100)
+        offset = (page - 1) * limit
+        print(f"[{num2time()}]{request['client_ip']}|GET {db_key}|{table}|{where}?page={page}&per_page={limit}")
+        ret = await db.query(table, where, limit, offset)
+        if isinstance(ret, dict) and ret.get('suc') and limit > 1 and not offset:
+            cnt = await db.count(table, where)
+            ret['count'] = cnt
+            ret['max_page'], rest = divmod(ret['count'], limit)
+            if rest:
+                ret['max_page'] += 1
+        return web.Response(body=orjson.dumps(ret), content_type='application/json')
+
+    async def handle_get_fs(request):
+        suc, path_file = check_path(f"fs/{request.match_info['path_file']}", path_base_fs)
+        if suc and os.path.isfile(path_file):
+            if request.query.get('check') is not None:
+                print(f"[{num2time()}]{request['client_ip']}|CHECK {path_file}")
+                return web.Response(body=orjson.dumps({'suc': True}), content_type='application/json')
+            else:
+                print(f"[{num2time()}]{request['client_ip']}|DOWNLOAD {path_file}")
+                return web.FileResponse(path_file)
+        else:
+            if request.query.get('check') is not None:
+                return web.Response(body=orjson.dumps({'suc': False}), content_type='application/json')
+            else:
+                return web.Response(status=404, text='File not found')
+
+    async def handle_post_fs(request):
+        suc, path_file = check_path(f"fs/{request.match_info['path_file']}", path_base_fs)
+        print(f"[{num2time()}]{request['client_ip']}|UPLOAD attempt {suc} {path_file}")
+        if not suc:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'Unsafe path'}), content_type='application/json')
+        folder = os.path.dirname(path_file)
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+        reader = await request.multipart()
+        field = await reader.next()
+        if not field:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': 'No file uploaded'}), content_type='application/json')
+        # write file safely
+        try:
+            async with aiofiles.open(path_file, 'wb') as f:
+                while True:
+                    chunk = await field.read_chunk()
+                    if not chunk:
+                        break
+                    await f.write(chunk)
+            # ensure uploaded file isn't executable
+            try:
+                os.chmod(path_file, 0o644)
+            except Exception:
+                pass
+            return web.Response(body=orjson.dumps({'suc': True, 'data': 'File Saved'}), content_type='application/json')
+        except Exception as e:
+            return web.Response(body=orjson.dumps({'suc': False, 'data': str(e)}), content_type='application/json')
+
+    async def handle_static(request):
+        file = request.match_info.get('file') or 'index.html'
+        return web.FileResponse(f"{path_this}/www/{file}")
+
+    async def handle_xmlhttpRequest(request):
+        try:
+            data = await request.json()
+            method = data.get("method", "POST").upper()
+            url = data.get("url")
+            if not url:
+                return web.Response(body=orjson.dumps({"suc": False, "text": "no url"}), content_type='application/json')
+            headers = data.get("headers", {})
+            payload = None
+            if data.get('type') == 'form':
+                payload = FormData()
+                for k, v in data.get("data", {}).items():
+                    payload.add_field(k, v)
+                for f in data.get("files", []):
+                    content = base64.b64decode(f["base64"])
+                    payload.add_field(
+                        name=f["field"],
+                        value=content,
+                        filename=f["filename"],
+                        content_type=f["content_type"]
+                    )
+            else:
+                payload = data.get('data')
+            # enclose outgoing request with timeout
+            timeout = ClientTimeout(total=15)
+            async with ClientSession(timeout=timeout) as session:
+                async with session.request(method, url, headers=headers, data=payload, allow_redirects=True) as resp:
+                    text = await resp.text()
+                    return web.Response(body=orjson.dumps({
+                        "suc": True,
+                        "status": resp.status,
+                        "text": text,
+                        "url": str(resp.url)
+                    }), content_type='application/json')
+        except Exception as e:
+            return web.Response(body=orjson.dumps({"suc": False, "text": str(e)}), content_type='application/json')
+
+    app = web.Application(middlewares=[auth_middleware], client_max_size=max_filesize * 1024 ** 2)
+    app.router.add_post('/db/{db_table}', handle_post_db)
+    app.router.add_get('/db/{db_table}/{where:.*}', handle_get_db)
+    app.router.add_delete('/db/{db_table}/{where:.*}', handle_delete_db)
+    app.router.add_get('/fs/{path_file:.*}', handle_get_fs)
+    app.router.add_post('/fs/{path_file:.*}', handle_post_fs)
+    app.router.add_post('/xmlhttpRequest', handle_xmlhttpRequest)
+    app.router.add_get('/{file:.*}', handle_static)
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, host, port)
+    await site.start()
+    print(f"Serving on http://{'127.0.0.1' if host == '0.0.0.0' else host}:{port}")
+    print(f"Serving at {path_this.replace('\\','/')}")
+    if not os.path.exists(f"{path_this}/www"):
+        os.makedirs(f"{path_this}/www")
+    if not os.path.exists(f"{path_this}/www/openapi.yaml"):
+        with open(f"{path_src}/openapi.yaml",'r',encoding='utf-8') as f:
+            txt = f.read()
+        with open(f"{path_this}/www/openapi.yaml",'w',encoding='utf-8') as f:
+            f.write(txt.replace('127.0.0.1:12239',f"{'127.0.0.1' if host == '0.0.0.0' else host}:{port}"))
+    if not os.path.exists(f"{path_this}/www/index.html"):
+        with open(f"{path_src}/docs.html",'r',encoding='utf-8') as f:
+            txt = f.read()
+        with open(f"{path_this}/www/index.html",'w',encoding='utf-8') as f:
+            f.write(txt)
+    stop_event = asyncio.Event()
+    try:
+        # simplified loop, exit on Cancelled/Error
+        while not stop_event.is_set():
+            await asyncio.sleep(86400)
+    except asyncio.CancelledError:
+        pass
+    finally:
+        print("Cleaning up...")
+        await runner.cleanup()
+        for db_key in list(dbs.keys()):
+            await dbs[db_key].close()
+            del dbs[db_key]
+
+def main():
+    import argparse
+    import asyncio
+    
+    parser = argparse.ArgumentParser(description='Run the sqless server')
+    parser.add_argument('--host', default='127.0.0.1', help='Host to bind to (default: 127.0.0.1)')
+    parser.add_argument('--port', type=int, default=12239, help='Port to bind to (default: 12239)')
+    parser.add_argument('--secret', default=DEFAULT_SECRET, help='Secret for authentication')
+    parser.add_argument('--path', default=os.getcwd(), help=f'Base path for database and file storage (default: {os.getcwd()})')
+    parser.add_argument('--fsize', type=int, default=200, help='Max file size (in MB) allowed in POST /fs')
+    args = parser.parse_args()
+    
+    asyncio.run(run_server(
+        host=args.host,
+        port=args.port,
+        secret=args.secret,
+        path_this=args.path,
+        max_filesize=args.fsize
+    ))
+
+if __name__ == "__main__":
+    main()

sqless-0.1.0/sqless.egg-info/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: sqless
+Version: 0.1.0
+Summary: An async HTTP server for SQLite, FileStorage and WebPage.
+Home-page: https://github.com/pro1515151515/sqless
+Author: pro1515151515
+Author-email: pro1515151515@qq.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiosqlite>=0.17.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: orjson>=3.6.0
+Requires-Dist: aiofiles>=0.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# sqless
+
+An async HTTP server for SQLite, FileStorage and WebPage.
+
+## Description
+
+sqless is a Python application that provides web service with local database and local file storage.
+
+## Installation
+
+```bash
+pip install sqless
+```
+
+## Quick Start
+
+### Running the server
+
+```bash
+sqless --host 127.0.0.1 --port 12239 --secret your-secret-key
+```
+
+This will create `www` directory in the current directory, which is used for WebPage.
+You can access the `www/index.html` at `http://127.0.0.1:12239/index.html`
+
+It will also creates `db` and `fs` directories in the current directory, when saving data by database API and file storage API.
+
+### Using the database API
+
+```python
+import requests
+
+# Set up the base URL and authentication
+BASE_URL = "http://127.0.0.1:12239"
+SECRET = "your-secret-key"
+DB_TABLE = "users"
+
+# Insert or update data
+r = requests.post(
+    f"{BASE_URL}/db/{DB_TABLE}",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json={"key": "U001", "name": "Tom", "age": 14}
+)
+
+# Query data
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Fuzzy query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/name like %om%?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Value query
+r = requests.get(
+    f"{BASE_URL}/db/{DB_TABLE}/age > 10?limit=10&page=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Delete data
+r = requests.delete(
+    f"{BASE_URL}/db/{DB_TABLE}/key = U001",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+```
+
+`DB_TABLE = "users"` will read/write records in `users` table in `db/default.sqlite`.
+`DB_TABLE = "mall-users"` will read/write records in `users` table in `db/mall.sqlite`.
+`DB_TABLE = "east-mall-users"` will read/write records in `users` table in `db/east/mall.sqlite`.
+
+### Using the FileStorage API
+```python
+import requests
+
+# Upload a file to ./fs/example.txt
+with open("example.txt", "rb") as f:
+    r = requests.post(
+        f"{BASE_URL}/fs/example.txt",
+        headers={"Authorization": f"Bearer {SECRET}"},
+        files={"file": f}
+    )
+
+# Check if a file exists
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt?check=1",
+    headers={"Authorization": f"Bearer {SECRET}"}
+)
+
+# Download a file
+r = requests.get(
+    f"{BASE_URL}/fs/example.txt",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    stream=True
+)
+with open("downloaded_example.txt", "wb") as f:
+    for chunk in r.iter_content(chunk_size=8192):
+        f.write(chunk)
+```
+
+### Using the Proxy API
+```python
+import requests
+import base64
+
+payload = {
+    "method": "POST",
+    "url": "https://httpbin.org/post",
+    "headers": {
+        "User-Agent": "SQLESS-Client/1.0",
+        "Authorization": "Bearer mytoken"
+    },
+    "type": "form",
+    "data": {"foo": "bar"},
+    "files": [
+        {
+            "field": "file1",
+            "filename": "example.txt",
+            "content_type": "text/plain",
+            "base64": base64.b64encode(open("example.txt", "rb").read()).decode()
+        }
+    ]
+}
+
+r = requests.post(
+    f"{BASE_URL}/xmlhttpRequest",
+    headers={"Authorization": f"Bearer {SECRET}"},
+    json=payload
+)
+print(r.json())
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

sqless-0.1.0/sqless.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+sqless/__init__.py
+sqless/database.py
+sqless/server.py
+sqless.egg-info/PKG-INFO
+sqless.egg-info/SOURCES.txt
+sqless.egg-info/dependency_links.txt
+sqless.egg-info/entry_points.txt
+sqless.egg-info/requires.txt
+sqless.egg-info/top_level.txt

sqless-0.1.0/sqless.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqless-0.1.0/sqless.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqless = sqless.server:main

sqless-0.1.0/sqless.egg-info/requires.txt

@@ -0,0 +1,4 @@
+aiosqlite>=0.17.0
+aiohttp>=3.8.0
+orjson>=3.6.0
+aiofiles>=0.8.0

sqless-0.1.0/sqless.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqless