pydorky 2.1.8

package/google-drive-credentials.json

@@ -0,0 +1,16 @@
+{
+    "web": {
+        "client_id": "549624816041-j9tr8es6megehe18i0c04vmpno6q78ld.apps.googleusercontent.com",
+        "project_id": "dorky-445907",
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+        "client_secret": "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",
+        "redirect_uris": [
+            "http://localhost:3000/oauth2callback"
+        ],
+        "javascript_origins": [
+            "http://localhost:3000"
+        ]
+    }
+}

package/openapi/openapi.yaml

@@ -0,0 +1,257 @@
+openapi: 3.0.1
+info:
+  title: Pydorky Artifact Service
+  description: Language-agnostic HTTP service for artifact storage, streaming, metadata, idempotency, and versioning
+  version: 0.2.0
+servers:
+  - url: http://localhost:3000
+    description: Local development server
+
+paths:
+  /health:
+    get:
+      summary: Health check
+      operationId: health
+      tags:
+        - service
+      responses:
+        '200':
+          description: Service is healthy
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    example: healthy
+                  timestamp:
+                    type: string
+                    format: date-time
+
+  /artifacts:
+    post:
+      summary: Upload an artifact
+      operationId: uploadArtifact
+      tags:
+        - artifacts
+      requestBody:
+        required: true
+        content:
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                file:
+                  type: string
+                  format: binary
+                  description: The file to upload
+                metadata:
+                  type: string
+                  description: JSON metadata as string
+                idempotency_key:
+                  type: string
+                  description: Unique key to prevent duplicate uploads
+              required:
+                - file
+      responses:
+        '201':
+          description: Artifact created successfully
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Artifact'
+        '400':
+          description: Bad request (missing file, invalid metadata)
+        '409':
+          description: Conflict (artifact already exists with same idempotency key)
+
+  /artifacts/{id}:
+    get:
+      summary: Download an artifact
+      operationId: downloadArtifact
+      tags:
+        - artifacts
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+          description: Artifact ID
+        - name: version
+          in: query
+          required: false
+          schema:
+            type: string
+          description: Specific version to download (optional)
+      responses:
+        '200':
+          description: Artifact stream
+          content:
+            application/octet-stream: {}
+        '404':
+          description: Artifact not found
+        '416':
+          description: Range not satisfiable
+
+    delete:
+      summary: Delete an artifact
+      operationId: deleteArtifact
+      tags:
+        - artifacts
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '204':
+          description: Artifact deleted successfully
+        '404':
+          description: Artifact not found
+
+  /artifacts/{id}/metadata:
+    get:
+      summary: Get artifact metadata
+      operationId: getMetadata
+      tags:
+        - metadata
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Artifact metadata
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Metadata'
+        '404':
+          description: Artifact not found
+
+    patch:
+      summary: Update artifact metadata
+      operationId: updateMetadata
+      tags:
+        - metadata
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              additionalProperties: true
+      responses:
+        '200':
+          description: Metadata updated
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Metadata'
+        '404':
+          description: Artifact not found
+
+  /artifacts/{id}/versions:
+    get:
+      summary: List all versions of an artifact
+      operationId: listVersions
+      tags:
+        - versioning
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: List of versions
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Version'
+        '404':
+          description: Artifact not found
+
+components:
+  schemas:
+    Artifact:
+      type: object
+      required:
+        - id
+        - url
+      properties:
+        id:
+          type: string
+          example: "1a2b3c"
+        url:
+          type: string
+          example: "/artifacts/1a2b3c"
+        metadata:
+          $ref: '#/components/schemas/Metadata'
+        version:
+          type: string
+          example: "1"
+
+    Metadata:
+      type: object
+      required:
+        - content_hash
+        - file_size
+        - last_updated
+      properties:
+        content_hash:
+          type: string
+          description: SHA256 hash of file content
+          example: "abc123def456..."
+        file_size:
+          type: integer
+          description: File size in bytes
+          example: 1024
+        compressed_size:
+          type: integer
+          description: Compressed file size (if applicable)
+        compression_type:
+          type: string
+          description: Compression algorithm used
+          enum: [gzip, lz4, brotli, null]
+        last_updated:
+          type: string
+          format: date-time
+          description: Last update timestamp (UTC ISO 8601)
+        uploaded_by:
+          type: string
+          description: User/identifier who uploaded
+        custom:
+          type: object
+          description: User-defined metadata
+          additionalProperties: true
+
+    Version:
+      type: object
+      required:
+        - version_id
+        - created_at
+        - metadata
+      properties:
+        version_id:
+          type: string
+          example: "1"
+        created_at:
+          type: string
+          format: date-time
+        metadata:
+          $ref: '#/components/schemas/Metadata'

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "pydorky",
+  "version": "2.1.8",
+  "description": "DevOps Records Keeper.",
+  "bin": {
+    "dorky": "bin/index.js"
+  },
+  "scripts": {
+    "start": "node bin/index.js",
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pratham-Jain-3903/pydorky.git"
+  },
+  "keywords": [
+    "DevOps",
+    "env",
+    "yaml",
+    "json"
+  ],
+  "author": "Pydorky contributors",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Pratham-Jain-3903/pydorky/issues"
+  },
+  "homepage": "https://github.com/Pratham-Jain-3903/pydorky#readme",
+  "engines": {
+    "node": ">=16"
+  },
+  "devDependencies": {
+    "tsc": "^2.0.4",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.679.0",
+    "@google-cloud/local-auth": "^3.0.1",
+    "chalk": "^4.1.2",
+    "glob": "^13.0.0",
+    "googleapis": "^144.0.0",
+    "md5": "^2.3.0",
+    "mime-type": "^4.0.0",
+    "mime-types": "^2.1.35",
+    "yargs": "^17.7.2"
+  }
+}

package/python-client/README.md

@@ -0,0 +1,19 @@
+Dorky Python client
+
+This is a minimal scaffold for the Dorky Python client. It implements a thin wrapper
+around the Dorky HTTP API (see `openapi/openapi.yaml`).
+
+Install (local editable):
+
+```bash
+pip install -e python-client
+```
+
+Usage example:
+
+```python
+from dorky_client import DorkyClient
+
+client = DorkyClient('http://localhost:3000')
+client.upload('path/to/file.txt', metadata={'note':'example'})
+```

package/python-client/dorky_client/__init__.py

@@ -0,0 +1,3 @@
+from .client import DorkyClient
+
+__all__ = ["DorkyClient"]

package/python-client/dorky_client/client.py

@@ -0,0 +1,32 @@
+import os
+import requests
+from typing import Optional, Dict
+
+CHUNK_SIZE = 1024 * 64
+
+class DorkyClient:
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip('/')
+
+    def upload(self, file_path: str, metadata: Optional[Dict]=None, idempotency_key: Optional[str]=None):
+        url = f"{self.base_url}/artifacts"
+        files = {'file': open(file_path, 'rb')}
+        data = {}
+        if metadata:
+            data['metadata'] = requests.utils.requote_uri(str(metadata))
+        if idempotency_key:
+            data['idempotency_key'] = idempotency_key
+        resp = requests.post(url, files=files, data=data)
+        resp.raise_for_status()
+        return resp.json()
+
+    def download(self, artifact_id: str, dest_path: str):
+        url = f"{self.base_url}/artifacts/{artifact_id}"
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            os.makedirs(os.path.dirname(dest_path) or '.', exist_ok=True)
+            with open(dest_path, 'wb') as f:
+                for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
+                    if chunk:
+                        f.write(chunk)
+        return dest_path

package/python-client/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "pydorky-client"
+version = "0.1.0"
+description = "Pydorky Python client (minimal scaffold)"
+readme = "README.md"
+requires-python = ">=3.8"
+
+[project.dependencies]
+requests = "^2.28"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

package/python-client/tests/test_integration.py

@@ -0,0 +1,20 @@
+import os
+import tempfile
+
+from dorky_client import DorkyClient
+
+
+def test_upload_and_download(tmp_path):
+    client = DorkyClient('http://localhost:3000')
+
+    src = tmp_path / 'hello.txt'
+    src.write_bytes(b'hello-pydorky')
+
+    resp = client.upload(str(src), metadata={'test': 'integration'})
+    assert 'id' in resp
+    artifact_id = resp['id']
+
+    dest = tmp_path / 'out.txt'
+    client.download(artifact_id, str(dest))
+    assert dest.exists()
+    assert dest.read_bytes() == b'hello-pydorky'

package/server/index.js

@@ -0,0 +1,193 @@
+const express = require('express');
+const multer = require('multer');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const upload = multer({ dest: 'tmp/' });
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// In-memory storage for metadata and idempotency (in production: use database)
+const artifactStore = new Map(); // id -> { path, metadata, versions }
+const idempotencyStore = new Map(); // idempotency_key -> artifact_id
+
+// Utility: compute SHA256 hash of file
+function hashFile(filePath) {
+  const fileBuffer = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(fileBuffer).digest('hex');
+}
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Serve OpenAPI spec
+app.get('/openapi.yaml', (req, res) => {
+  res.sendFile(path.resolve(__dirname, '..', 'openapi', 'openapi.yaml'));
+});
+
+// POST /artifacts - Upload artifact with metadata and idempotency
+app.post('/artifacts', upload.single('file'), (req, res) => {
+  if (!req.file) {
+    return res.status(400).json({ error: 'no file provided' });
+  }
+
+  const idempotencyKey = req.body.idempotency_key;
+  
+  // Check idempotency: if same key uploaded before, return cached result
+  if (idempotencyKey && idempotencyStore.has(idempotencyKey)) {
+    const existingId = idempotencyStore.get(idempotencyKey);
+    const existing = artifactStore.get(existingId);
+    return res.status(409).json({
+      error: 'artifact already exists with this idempotency key',
+      artifact: {
+        id: existingId,
+        url: `/artifacts/${existingId}`,
+        metadata: existing.metadata
+      }
+    });
+  }
+
+  // Generate artifact ID
+  const id = Date.now().toString(36) + '_' + Math.random().toString(36).substr(2, 9);
+  const dest = path.resolve(__dirname, '..', 'data', id + '_' + req.file.originalname);
+  
+  // Create data directory
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.renameSync(req.file.path, dest);
+
+  // Compute file hash and size
+  const fileSize = fs.statSync(dest).size;
+  const contentHash = hashFile(dest);
+
+  // Parse custom metadata
+  let customMetadata = {};
+  try {
+    if (req.body.metadata) {
+      customMetadata = JSON.parse(req.body.metadata);
+    }
+  } catch (e) {
+    return res.status(400).json({ error: 'invalid metadata JSON' });
+  }
+
+  // Build complete metadata
+  const metadata = {
+    content_hash: contentHash,
+    file_size: fileSize,
+    compression_type: null,
+    compressed_size: fileSize,
+    last_updated: new Date().toISOString(),
+    uploaded_by: req.body.uploaded_by || 'anonymous',
+    custom: customMetadata
+  };
+
+  // Store artifact and metadata
+  artifactStore.set(id, {
+    path: dest,
+    metadata: metadata,
+    versions: [{ version_id: '1', created_at: metadata.last_updated, metadata: metadata }]
+  });
+
+  // Store idempotency mapping
+  if (idempotencyKey) {
+    idempotencyStore.set(idempotencyKey, id);
+  }
+
+  res.status(201).json({
+    id,
+    url: `/artifacts/${id}`,
+    metadata,
+    version: '1'
+  });
+});
+
+// GET /artifacts/{id} - Download artifact
+app.get('/artifacts/:id', (req, res) => {
+  const id = req.params.id;
+  const artifact = artifactStore.get(id);
+
+  if (!artifact) {
+    // Fallback: check legacy data directory
+    const dir = path.resolve(__dirname, '..', 'data');
+    if (fs.existsSync(dir)) {
+      const file = fs.readdirSync(dir).find(f => f.startsWith(id + '_'));
+      if (file) {
+        return res.sendFile(path.resolve(dir, file));
+      }
+    }
+    return res.status(404).json({ error: 'artifact not found' });
+  }
+
+  res.sendFile(artifact.path);
+});
+
+// DELETE /artifacts/{id} - Delete artifact
+app.delete('/artifacts/:id', (req, res) => {
+  const id = req.params.id;
+  const artifact = artifactStore.get(id);
+
+  if (!artifact) {
+    return res.status(404).json({ error: 'artifact not found' });
+  }
+
+  // Delete file from disk
+  if (fs.existsSync(artifact.path)) {
+    fs.unlinkSync(artifact.path);
+  }
+
+  // Remove from store
+  artifactStore.delete(id);
+
+  res.status(204).send();
+});
+
+// GET /artifacts/{id}/metadata - Get metadata
+app.get('/artifacts/:id/metadata', (req, res) => {
+  const id = req.params.id;
+  const artifact = artifactStore.get(id);
+
+  if (!artifact) {
+    return res.status(404).json({ error: 'artifact not found' });
+  }
+
+  res.json(artifact.metadata);
+});
+
+// PATCH /artifacts/{id}/metadata - Update metadata
+app.patch('/artifacts/:id/metadata', express.json(), (req, res) => {
+  const id = req.params.id;
+  const artifact = artifactStore.get(id);
+
+  if (!artifact) {
+    return res.status(404).json({ error: 'artifact not found' });
+  }
+
+  // Merge custom metadata
+  artifact.metadata.custom = { ...artifact.metadata.custom, ...req.body };
+  artifact.metadata.last_updated = new Date().toISOString();
+
+  res.json(artifact.metadata);
+});
+
+// GET /artifacts/{id}/versions - List all versions
+app.get('/artifacts/:id/versions', (req, res) => {
+  const id = req.params.id;
+  const artifact = artifactStore.get(id);
+
+  if (!artifact) {
+    return res.status(404).json({ error: 'artifact not found' });
+  }
+
+  res.json(artifact.versions || []);
+});
+
+app.listen(PORT, () => {
+  console.log(`Dorky artifact service listening on port ${PORT}`);
+  console.log(`Health check: GET http://localhost:${PORT}/health`);
+  console.log(`OpenAPI spec: GET http://localhost:${PORT}/openapi.yaml`);
+});

package/server/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "dorky-server-stub",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "multer": "^2.0.2"
+  }
+}