cacheproxy-byiambaka-v2 0.1.0__tar.gz

cacheproxy_byiambaka_v2-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: cacheproxy-byiambaka-v2
+Version: 0.1.0
+Summary: A reverse proxy with redis cahing
+Author: Aryan
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn>=0.35
+Requires-Dist: typer>=0.16
+Requires-Dist: httpx>=0.28
+Requires-Dist: redis>=6.2
+Requires-Dist: pydantic>=2.11
+
+Markdown
+
+# cacheproxy ⚡
+
+A high-performance command-line reverse proxy that automatically intercepts HTTP requests and caches them in Redis. Built with FastAPI, Typer, and Async Redis.
+
+
+
+## Features
+
+* **Smart Caching:** Automatically caches safe `GET` 200 responses for 24 hours.
+* **Header Optimization:** Seamlessly handles browser headers (strips encodings to prevent decoding bugs).
+* **Binary Safe:** Uses `base64` encoding to store complex body types safely in Redis strings.
+* **On-Demand Cache Purging:** Instantly flush the entire cache pool using the `/refresh` endpoint.
+* **Flexible Configuration:** Fully configurable via Environment Variables or CLI arguments.
+
+## Installation
+
+Install the utility directly via pip:
+
+```bash
+pip install cacheproxy
+
+How to Run
+1. Configure Redis (Optional)
+
+The proxy automatically searches for a local Redis instance on port 6379. If your Redis instance lives elsewhere, pass the configuration using environment variables before running the tool:
+Bash
+
+# Linux/macOS
+export REDDIS_HOST="127.0.0.1"
+export REDIS_PORT="6379"
+export REDDIS_DB="0"
+
+# Windows (Command Prompt)
+set REDDIS_HOST=127.0.0.1
+set REDIS_PORT=6379
+set REDDIS_DB=0
+
+2. Start the Proxy
+
+Fire up the CLI command by pointing it to your destination origin API server:
+Bash
+
+cacheproxy start --origin [http://api.yourbackend.com](http://api.yourbackend.com) --port 3000
+
+Now target your applications/frontend to run through http://localhost:3000.
+API & Testing Endpoints
+Checking Cache Status
+
+When you run a request through the proxy, check your response headers to verify the status:
+
+    Cache: HIT - Served instantly out of Redis.
+
+    Cache: MISS - Fetched fresh from the origin server and saved for next time.
+
+Flushing the Cache
+
+If you update your backend data and want to wipe the proxy cache clean immediately, send a POST request to the refresh route:
+Bash
+
+curl -X POST http://localhost:3000/refresh
+
+Response:
+JSON
+
+{"message": "cache cleared"}
+
+License
+
+MIT © 2026

cacheproxy_byiambaka_v2-0.1.0/README.md

@@ -0,0 +1,71 @@
+Markdown
+
+# cacheproxy ⚡
+
+A high-performance command-line reverse proxy that automatically intercepts HTTP requests and caches them in Redis. Built with FastAPI, Typer, and Async Redis.
+
+
+
+## Features
+
+* **Smart Caching:** Automatically caches safe `GET` 200 responses for 24 hours.
+* **Header Optimization:** Seamlessly handles browser headers (strips encodings to prevent decoding bugs).
+* **Binary Safe:** Uses `base64` encoding to store complex body types safely in Redis strings.
+* **On-Demand Cache Purging:** Instantly flush the entire cache pool using the `/refresh` endpoint.
+* **Flexible Configuration:** Fully configurable via Environment Variables or CLI arguments.
+
+## Installation
+
+Install the utility directly via pip:
+
+```bash
+pip install cacheproxy
+
+How to Run
+1. Configure Redis (Optional)
+
+The proxy automatically searches for a local Redis instance on port 6379. If your Redis instance lives elsewhere, pass the configuration using environment variables before running the tool:
+Bash
+
+# Linux/macOS
+export REDDIS_HOST="127.0.0.1"
+export REDIS_PORT="6379"
+export REDDIS_DB="0"
+
+# Windows (Command Prompt)
+set REDDIS_HOST=127.0.0.1
+set REDIS_PORT=6379
+set REDDIS_DB=0
+
+2. Start the Proxy
+
+Fire up the CLI command by pointing it to your destination origin API server:
+Bash
+
+cacheproxy start --origin [http://api.yourbackend.com](http://api.yourbackend.com) --port 3000
+
+Now target your applications/frontend to run through http://localhost:3000.
+API & Testing Endpoints
+Checking Cache Status
+
+When you run a request through the proxy, check your response headers to verify the status:
+
+    Cache: HIT - Served instantly out of Redis.
+
+    Cache: MISS - Fetched fresh from the origin server and saved for next time.
+
+Flushing the Cache
+
+If you update your backend data and want to wipe the proxy cache clean immediately, send a POST request to the refresh route:
+Bash
+
+curl -X POST http://localhost:3000/refresh
+
+Response:
+JSON
+
+{"message": "cache cleared"}
+
+License
+
+MIT © 2026

cacheproxy_byiambaka_v2-0.1.0/cacheproxy/app/main.py

@@ -0,0 +1,77 @@
+from fastapi import FastAPI,HTTPException,status
+import httpx
+import os
+import redis.asyncio as redis
+import json
+import base64
+from fastapi.responses import Response
+from datetime import datetime
+last_edit=0
+
+app=FastAPI()
+ORIGIN_URL=os.getenv("ORIGIN_URL")
+
+redis_client= redis.Redis(host=os.getenv("REDIS_HOST", "localhost"),port=int(os.getenv("REDIS_PORT", 6379)),db=int(os.getenv("REDDIS_DB", 0)),decode_responses=True) #here decode is nessary otherwise i get byte objet
+
+@app.get("/{path:path}",status_code=status.HTTP_200_OK)#here we use path to get values after main link
+async def proxy_intercept(path:str):
+    if not ORIGIN_URL:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,detail="URL dont found ")
+    target_url=f"{ORIGIN_URL}/{path}"
+    try:
+       cached_data=await redis_client.get(target_url)
+       if cached_data is not None:
+          cached_response=json.loads(cached_data) # convert json to python dict
+          body=base64.b64decode(cached_response["body"])#reddis cant store json
+          dict_header=dict(cached_response["headers"])
+          dict_header.pop("content-encoding", None) # browsee try to unzip on own thus to prevent 
+          dict_header.pop("content-length", None)
+          dict_header.pop("transfer-encoding", None)
+
+          response=Response(
+             content=body,
+             status_code=cached_response["status_code"],
+             headers=dict_header
+             )
+          response.headers["Cache"]="HIT"
+          
+          return response
+    except Exception as e:
+       print(f"Redis Error:{e}")
+          
+
+
+    async with httpx.AsyncClient() as client:# if i dont use client each .get will create and destry thus waste 
+        web_res = await client.get(target_url)
+    encode_body=base64.b64encode(web_res.content).decode('utf-8')
+    redis_value={
+        "status_code":web_res.status_code,
+        "headers": dict(web_res.headers),
+        "body":encode_body
+    }
+    if web_res.status_code == 200 and web_res.request.method=="GET":
+        try: 
+            await redis_client.set(target_url,json.dumps(redis_value),ex=86400)#python object to json
+            global last_edit
+            last_edit =  datetime.now().timestamp()
+
+        except Exception as e:
+            print(f"Redis save error:{e}")
+    output_header=dict(web_res.headers)
+    output_header.pop("content-encoding", None)
+    output_header.pop("content-length", None)
+    output_header.pop("transfer-encoding", None)
+    response = Response(
+        content=web_res.content,
+        status_code=web_res.status_code,
+        headers=output_header
+    )
+    response.headers["Cache"] = "MISS" # if it is already we chanced we already return a header of hit thus all will be not hit 
+    
+    return response
+@app.post("/refresh",status_code=status.HTTP_200_OK)
+async def refresh_cache():
+    await redis_client.flushdb()
+    return {"message":"cache cleared"}
+
+

cacheproxy_byiambaka_v2-0.1.0/cacheproxy/cli/cli_input.py

@@ -0,0 +1,25 @@
+import typer
+import os
+import uvicorn 
+from pydantic import ValidationError
+from cacheproxy.cli.cli_verification import CLIValidation
+app=typer.Typer()
+@app.command()
+def start(port:int=typer.Option(3000,"--port",help="port on which you want to run "),origin:str=typer.Option(...,"--origin",help="the url you want to cache ")):# used in context as first thing it can be start etc anything
+    try:
+        config=CLIValidation(
+            port=port,
+            origin=origin,
+        )
+    except ValidationError as e:
+        typer.echo(e)
+        raise typer.Exit(code=1)
+    typer.echo("The Server Is Successfully Started \n The Server Is Hosted At :-")
+    typer.echo(f"http://localhost:{port}")
+    
+    os.environ["ORIGIN_URL"]=str(config.origin)
+    os.environ["PORT"]=str(config.port)
+    uvicorn.run("cacheproxy.app.main:app",host="0.0.0.0",port=config.port,)#can run in any network
+    
+if __name__=="__main__":
+    app()# it will not auto run even fastapi need uvicorn and python auto craeted __name__="__main__"

cacheproxy_byiambaka_v2-0.1.0/cacheproxy/cli/cli_verification.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, HttpUrl,Field
+class CLIValidation(BaseModel):
+    port: int = Field(3000,ge=1,le=65535)#maximum port is 16 bit
+    origin: HttpUrl
+
+    

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

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: cacheproxy-byiambaka-v2
+Version: 0.1.0
+Summary: A reverse proxy with redis cahing
+Author: Aryan
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn>=0.35
+Requires-Dist: typer>=0.16
+Requires-Dist: httpx>=0.28
+Requires-Dist: redis>=6.2
+Requires-Dist: pydantic>=2.11
+
+Markdown
+
+# cacheproxy ⚡
+
+A high-performance command-line reverse proxy that automatically intercepts HTTP requests and caches them in Redis. Built with FastAPI, Typer, and Async Redis.
+
+
+
+## Features
+
+* **Smart Caching:** Automatically caches safe `GET` 200 responses for 24 hours.
+* **Header Optimization:** Seamlessly handles browser headers (strips encodings to prevent decoding bugs).
+* **Binary Safe:** Uses `base64` encoding to store complex body types safely in Redis strings.
+* **On-Demand Cache Purging:** Instantly flush the entire cache pool using the `/refresh` endpoint.
+* **Flexible Configuration:** Fully configurable via Environment Variables or CLI arguments.
+
+## Installation
+
+Install the utility directly via pip:
+
+```bash
+pip install cacheproxy
+
+How to Run
+1. Configure Redis (Optional)
+
+The proxy automatically searches for a local Redis instance on port 6379. If your Redis instance lives elsewhere, pass the configuration using environment variables before running the tool:
+Bash
+
+# Linux/macOS
+export REDDIS_HOST="127.0.0.1"
+export REDIS_PORT="6379"
+export REDDIS_DB="0"
+
+# Windows (Command Prompt)
+set REDDIS_HOST=127.0.0.1
+set REDIS_PORT=6379
+set REDDIS_DB=0
+
+2. Start the Proxy
+
+Fire up the CLI command by pointing it to your destination origin API server:
+Bash
+
+cacheproxy start --origin [http://api.yourbackend.com](http://api.yourbackend.com) --port 3000
+
+Now target your applications/frontend to run through http://localhost:3000.
+API & Testing Endpoints
+Checking Cache Status
+
+When you run a request through the proxy, check your response headers to verify the status:
+
+    Cache: HIT - Served instantly out of Redis.
+
+    Cache: MISS - Fetched fresh from the origin server and saved for next time.
+
+Flushing the Cache
+
+If you update your backend data and want to wipe the proxy cache clean immediately, send a POST request to the refresh route:
+Bash
+
+curl -X POST http://localhost:3000/refresh
+
+Response:
+JSON
+
+{"message": "cache cleared"}
+
+License
+
+MIT © 2026

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

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+cacheproxy/__init__.py
+cacheproxy/app/__init__.py
+cacheproxy/app/main.py
+cacheproxy/cli/__init__.py
+cacheproxy/cli/cli_input.py
+cacheproxy/cli/cli_verification.py
+cacheproxy_byiambaka_v2.egg-info/PKG-INFO
+cacheproxy_byiambaka_v2.egg-info/SOURCES.txt
+cacheproxy_byiambaka_v2.egg-info/dependency_links.txt
+cacheproxy_byiambaka_v2.egg-info/entry_points.txt
+cacheproxy_byiambaka_v2.egg-info/requires.txt
+cacheproxy_byiambaka_v2.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+cacheproxy = cacheproxy.cli.cli_input:app

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

@@ -0,0 +1,6 @@
+fastapi>=0.115
+uvicorn>=0.35
+typer>=0.16
+httpx>=0.28
+redis>=6.2
+pydantic>=2.11

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

@@ -0,0 +1,2 @@
+cacheproxy
+dist

cacheproxy_byiambaka_v2-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires=["setuptools>=68","wheel"]
+build-backend="setuptools.build_meta" #these files help me to create my project exceture for other
+[project]
+name="cacheproxy-byiambaka-v2"
+version="0.1.0"
+description="A reverse proxy with redis cahing"
+readme="README.md"
+requires-python=">=3.11"
+license={ text = "MIT" } # we create dict thus add morem licence if want
+authors=[
+    {name="Aryan"}
+]
+dependencies=[
+    "fastapi>=0.115",
+    "uvicorn>=0.35",
+    "typer>=0.16",
+    "httpx>=0.28",
+    "redis>=6.2",
+    "pydantic>=2.11"
+]
+[project.scripts]
+cacheproxy="cacheproxy.cli.cli_input:app"
+[tool.setuptools.packages.find]
+where = ["."] #find this src folder serch files in current directory 
+
+
+

cacheproxy_byiambaka_v2-0.1.0/setup.cfg

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