parallex 0.1.0__py3-none-any.whl

parallex/ai/batch_processor.py

@@ -0,0 +1,42 @@
+import asyncio
+from uuid import UUID
+
+from openai import BadRequestError
+
+from parallex.ai.open_ai_client import OpenAIClient
+from parallex.models.upload_batch import build_batch, UploadBatch
+
+
+async def create_batch(
+    client: OpenAIClient, file_id: str, trace_id: UUID
+) -> UploadBatch:
+    """Creates a Batch for the given file_id"""
+    max_retries = 10
+    backoff_delay = 5
+
+    for attempt in range(max_retries):
+        try:
+            batch_response = await client.create_batch(upload_file_id=file_id)
+            batch = build_batch(open_ai_batch=batch_response, trace_id=trace_id)
+            return batch  # Return batch if successful
+        except BadRequestError as e:
+            if attempt == max_retries - 1:
+                raise e
+            await asyncio.sleep(backoff_delay)
+            backoff_delay *= 2
+
+
+# TODO handle errors
+async def wait_for_batch_completion(client: OpenAIClient, batch: UploadBatch) -> str:
+    """Waits for Batch to complete and returns output_file_id when available"""
+    status = "validating"
+    delay = 5
+    while status not in ("completed", "failed", "canceled"):
+        await asyncio.sleep(delay)
+        batch_response = await client.retrieve_batch(batch.id)
+        status = batch_response.status
+        batch.output_file_id = batch_response.output_file_id
+        batch.error_file_id = batch_response.error_file_id
+        delay = 30
+        if status == "completed":
+            return batch_response.output_file_id

parallex/ai/open_ai_client.py

@@ -0,0 +1,43 @@
+import os
+
+from openai import AsyncAzureOpenAI
+from openai._legacy_response import HttpxBinaryResponseContent
+from openai.types import FileObject, Batch, FileDeleted
+
+from parallex.utils.logger import logger
+
+
+# Exceptions for missing keys, etc
+class OpenAIClient:
+    def __init__(self, model: str):
+        self.model = model
+
+        self._client = AsyncAzureOpenAI(
+            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+            api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+            api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
+        )
+
+    async def upload(self, file_path: str) -> FileObject:
+        return await self._client.files.create(
+            file=open(file_path, "rb"), purpose="batch"
+        )
+
+    async def create_batch(self, upload_file_id: str) -> Batch:
+        return await self._client.batches.create(
+            input_file_id=upload_file_id,
+            endpoint="/chat/completions",
+            completion_window="24h",
+        )
+
+    async def retrieve_batch(self, batch_id: str) -> Batch:
+        return await self._client.batches.retrieve(batch_id)
+
+    async def retrieve_file(self, file_id: str) -> HttpxBinaryResponseContent:
+        return await self._client.files.content(file_id)
+
+    async def delete_file(self, file_id: str) -> FileDeleted:
+        try:
+            return await self._client.files.delete(file_id)
+        except Exception as e:
+            logger.info(f"Did not delete file: {e}")

parallex/ai/output_processor.py

@@ -0,0 +1,25 @@
+import json
+
+from parallex.ai.open_ai_client import OpenAIClient
+from parallex.models.page_response import PageResponse
+from parallex.utils.constants import CUSTOM_ID_DELINEATOR
+
+
+async def process_output(
+    client: OpenAIClient, output_file_id: str
+) -> list[PageResponse]:
+    """Gets content from completed Batch to create PageResponse with created markdown"""
+    file_response = await client.retrieve_file(output_file_id)
+    raw_responses = file_response.text.strip().split("\n")
+
+    pages = []
+    for raw_response in raw_responses:
+        json_response = json.loads(raw_response)
+        custom_id = json_response["custom_id"]
+        page_number = custom_id.split(CUSTOM_ID_DELINEATOR)[1].split(".")[0]
+        output_content = json_response["response"]["body"]["choices"][0]["message"][
+            "content"
+        ]
+        page = PageResponse(output_content=output_content, page_number=int(page_number))
+        pages.append(page)
+    return pages

parallex/ai/uploader.py

@@ -0,0 +1,91 @@
+import base64
+import json
+import os
+
+from parallex.ai.open_ai_client import OpenAIClient
+from parallex.file_management.utils import file_in_temp_dir
+from parallex.models.batch_file import BatchFile
+from parallex.models.image_file import ImageFile
+from parallex.utils.constants import CUSTOM_ID_DELINEATOR
+
+MAX_FILE_SIZE = 150 * 1024 * 1024  # 150 MB in bytes
+
+
+async def upload_images_for_processing(
+    client: OpenAIClient,
+    image_files: list[ImageFile],
+    temp_directory: str,
+    prompt_text: str,
+):
+    """Base64 encodes image, converts to expected jsonl format and uploads"""
+    trace_id = image_files[0].trace_id
+    current_index = 0
+    batch_files = []
+    upload_file_location = file_in_temp_dir(
+        directory=temp_directory, file_name=f"image-{trace_id}-{current_index}.jsonl"
+    )
+
+    for image_file in image_files:
+        if (
+            os.path.exists(upload_file_location)
+            and os.path.getsize(upload_file_location) > MAX_FILE_SIZE
+        ):
+            """When approaching upload file limit, upload and start new file"""
+            batch_file = await _create_batch_file(
+                client, trace_id, upload_file_location
+            )
+            batch_files.append(batch_file)
+            current_index += 1
+            upload_file_location = file_in_temp_dir(
+                directory=temp_directory, file_name=f"{trace_id}-{current_index}.jsonl"
+            )
+
+        with open(image_file.path, "rb") as image:
+            base64_encoded_image = base64.b64encode(image.read()).decode("utf-8")
+
+        prompt_custom_id = (
+            f"{image_file.trace_id}{CUSTOM_ID_DELINEATOR}{image_file.page_number}.jsonl"
+        )
+        jsonl = _jsonl_format(prompt_custom_id, base64_encoded_image, prompt_text)
+        with open(upload_file_location, "a") as jsonl_file:
+            jsonl_file.write(json.dumps(jsonl) + "\n")
+    batch_file = await _create_batch_file(client, trace_id, upload_file_location)
+    batch_files.append(batch_file)
+    return batch_files
+
+
+async def _create_batch_file(client, trace_id, upload_file_location):
+    file_response = await client.upload(upload_file_location)
+    return BatchFile(
+        id=file_response.id,
+        name=file_response.filename,
+        purpose=file_response.purpose,
+        status=file_response.status,
+        trace_id=trace_id,
+    )
+
+
+def _jsonl_format(prompt_custom_id: str, encoded_image: str, prompt_text: str):
+    return {
+        "custom_id": prompt_custom_id,
+        "method": "POST",
+        "url": "/chat/completions",
+        "body": {
+            "model": os.getenv("AZURE_OPENAI_API_DEPLOYMENT"),
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": prompt_text},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{encoded_image}"
+                            },
+                        },
+                    ],
+                }
+            ],
+            "max_tokens": 2000,
+        },
+    }

parallex/file_management/converter.py

@@ -0,0 +1,37 @@
+import asyncio
+
+from pdf2image import convert_from_path
+
+from parallex.models.image_file import ImageFile
+from parallex.models.raw_file import RawFile
+from parallex.utils.logger import logger
+
+
+async def convert_pdf_to_images(
+    raw_file: RawFile, temp_directory: str
+) -> list[ImageFile]:
+    """Converts a PDF file to a series of images in the temp_directory. Returns a list ImageFile objects."""
+    options = {
+        "pdf_path": raw_file.path,
+        "output_folder": temp_directory,
+        "dpi": 300,
+        "fmt": "png",
+        "size": (None, 1056),
+        "thread_count": 4,
+        "use_pdftocairo": True,
+        "paths_only": True,
+    }
+
+    try:
+        image_paths = await asyncio.to_thread(convert_from_path, **options)
+        return [
+            ImageFile(
+                path=path,
+                trace_id=raw_file.trace_id,
+                given_file_name=raw_file.given_name,
+                page_number=(i + 1),
+            )
+            for i, path in enumerate(image_paths)
+        ]
+    except Exception as err:
+        logger.error(f"Error converting PDF to images: {err}")

parallex/file_management/file_finder.py

@@ -0,0 +1,44 @@
+import uuid
+
+import httpx
+
+from parallex.file_management.utils import file_in_temp_dir
+from parallex.models.raw_file import RawFile
+
+
+# TODO get from URL or from file system
+async def add_file_to_temp_directory(
+    pdf_source_url: str, temp_directory: str
+) -> RawFile:
+    """Downloads file and adds to temp directory"""
+    given_file_name = pdf_source_url.split("/")[-1]
+    file_trace_id = uuid.uuid4()
+    async with httpx.AsyncClient() as client:
+        async with client.stream("GET", pdf_source_url) as response:
+            response.raise_for_status()  # Check for HTTP errors
+            content_type = response.headers.get("Content-Type")
+            file_name = _determine_file_name(
+                given_file_name, file_trace_id, content_type
+            )
+            path = file_in_temp_dir(temp_directory, file_name)
+            with open(path, "wb") as file:
+                async for chunk in response.aiter_bytes():
+                    file.write(chunk)
+
+            return RawFile(
+                name=file_name,
+                path=path,
+                content_type=content_type,
+                given_name=given_file_name,
+                pdf_source_url=pdf_source_url,
+                trace_id=file_trace_id,
+            )
+
+
+def _determine_file_name(given_file_name: str, file_trace_id, content_type: str):
+    # TODO custom errors
+    # TODO other types besides pdf
+    name, extension = given_file_name.split(".")
+    if "application/pdf" not in content_type:
+        raise ValueError("Content-Type must be application/pdf")
+    return f"{file_trace_id}.{extension}"

parallex/file_management/utils.py

@@ -0,0 +1,2 @@
+def file_in_temp_dir(directory: str, file_name: str):
+    return "/".join([directory, file_name])

parallex/models/batch_file.py

@@ -0,0 +1,11 @@
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class BatchFile(BaseModel):
+    id: str = Field(description="ID of the OpenAI Batch")
+    name: str = Field(description="Name of file batch was created with")
+    purpose: str = Field(description="Purpose 'batch")
+    status: str = Field(description="Status of the batch")
+    trace_id: UUID = Field(description="Unique trace for each file")

parallex/models/image_file.py

@@ -0,0 +1,11 @@
+from uuid import UUID
+
+from pydantic import BaseModel
+from pydantic.fields import Field
+
+
+class ImageFile(BaseModel):
+    path: str = Field(description="Path to the image in temp directory")
+    page_number: int = Field(description="Associated page of the PDF")
+    given_file_name: str = Field(description="Name of the given file")
+    trace_id: UUID = Field(description="Unique trace for each file")

parallex/models/page_response.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class PageResponse(BaseModel):
+    output_content: str = Field(description="Markdown generated for the page")
+    page_number: int = Field(description="Page number of the associated PDF")

parallex/models/parallex_callable_output.py

@@ -0,0 +1,12 @@
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from parallex.models.page_response import PageResponse
+
+
+class ParallexCallableOutput(BaseModel):
+    file_name: str = Field(description="Name of file that is processed")
+    pdf_source_url: str = Field(description="Given URL of the source of output")
+    trace_id: UUID = Field(description="Unique trace for each file")
+    pages: list[PageResponse] = Field(description="List of PageResponse objects")

parallex/models/raw_file.py

@@ -0,0 +1,12 @@
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+class RawFile(BaseModel):
+    name: str = Field(description="Name of the file given by Parallex")
+    path: str = Field(description="Path to file in temp directory")
+    content_type: str = Field(description="Given file type")
+    given_name: str = Field(description="Name of file given")
+    pdf_source_url: str = Field(description="Source of file")
+    trace_id: UUID = Field(description="Unique trace for each file")

parallex/models/upload_batch.py

@@ -0,0 +1,45 @@
+from typing import Optional
+from uuid import UUID
+
+from openai.types.batch import Errors, Batch
+from pydantic import BaseModel, Field
+
+
+class UploadBatch(BaseModel):
+    # page_number: int = Field(description="Page number of associated file")
+    trace_id: UUID = Field(description="Unique trace for each file")
+    id: str = Field(description="ID of the OpenAI Batch")
+    completion_window: str = Field(description="When batch can complete (24hrs)")
+    created_at: int = Field(description="When batch was created")
+    endpoint: str = Field(description="Endpoint used for retreival")
+    input_file_id: str = Field(description="File that is input to batch")
+    output_file_id: Optional[str] = Field(
+        None, description="File that is output when batch completes"
+    )
+    status: str = Field(description="Current status of the batch")
+    cancelled_at: Optional[int] = Field(None, description="When batch cancelled")
+    cancelling_at: Optional[int] = Field(
+        None, description="When batch started cancelling"
+    )
+    completed_at: Optional[int] = Field(None, description="When batch completed")
+    expired_at: Optional[int] = Field(None, description="When batch expired")
+    expires_at: Optional[int] = Field(None, description="When batch expires")
+    failed_at: Optional[int] = Field(None, description="When batch failed")
+    finalizing_at: Optional[int] = Field(
+        None, description="When batch started finalizing"
+    )
+    in_progress_at: Optional[int] = Field(
+        None, description="When batch started processing"
+    )
+    error_file_id: Optional[str] = Field(
+        None, description="File that is created during error of batch"
+    )
+    errors: Optional[Errors] = Field(None, description="List of errors")
+
+
+def build_batch(open_ai_batch: Batch, trace_id: UUID) -> UploadBatch:
+    fields = UploadBatch.model_fields
+    input_fields = {key: getattr(open_ai_batch, key, None) for key in fields}
+    input_fields["trace_id"] = trace_id
+    # input_fields["page_number"] = page_number
+    return UploadBatch(**input_fields)

parallex/parallex.py

@@ -0,0 +1,117 @@
+import asyncio
+import tempfile
+from typing import Callable, Optional
+from uuid import UUID
+
+from parallex.ai.batch_processor import wait_for_batch_completion, create_batch
+from parallex.ai.open_ai_client import OpenAIClient
+from parallex.ai.output_processor import process_output
+from parallex.ai.uploader import upload_images_for_processing
+from parallex.file_management.converter import convert_pdf_to_images
+from parallex.file_management.file_finder import add_file_to_temp_directory
+from parallex.models.image_file import ImageFile
+from parallex.models.parallex_callable_output import ParallexCallableOutput
+from parallex.models.upload_batch import UploadBatch
+from parallex.utils.constants import DEFAULT_PROMPT
+from parallex.utils.logger import logger, setup_logger
+
+
+# TODO pdf_source_url: str change to be URL or path
+async def parallex(
+    model: str,
+    pdf_source_url: str,
+    post_process_callable: Optional[Callable[..., None]] = None,
+    concurrency: int = 20,
+    prompt_text: str = DEFAULT_PROMPT,
+    log_level: str = "ERROR",
+) -> ParallexCallableOutput:
+    setup_logger(log_level)
+    with tempfile.TemporaryDirectory() as temp_directory:
+        open_ai_client = OpenAIClient(model=model)
+
+        raw_file = await add_file_to_temp_directory(
+            pdf_source_url=pdf_source_url, temp_directory=temp_directory
+        )
+        trace_id = raw_file.trace_id
+        image_files = await convert_pdf_to_images(
+            raw_file=raw_file, temp_directory=temp_directory
+        )
+
+        batch_files = await upload_images_for_processing(
+            client=open_ai_client,
+            image_files=image_files,
+            temp_directory=temp_directory,
+            prompt_text=prompt_text,
+        )
+        start_batch_semaphore = asyncio.Semaphore(concurrency)
+        start_batch_tasks = []
+        for file in batch_files:
+            batch_task = asyncio.create_task(
+                _create_images_and_batch_jobs(
+                    batch_file=file,
+                    client=open_ai_client,
+                    trace_id=trace_id,
+                    semaphore=start_batch_semaphore,
+                )
+            )
+            start_batch_tasks.append(batch_task)
+        batches = await asyncio.gather(*start_batch_tasks)
+
+        pages_tasks = []
+        process_semaphore = asyncio.Semaphore(concurrency)
+        for batch in batches:
+            page_task = asyncio.create_task(
+                _wait_and_create_pages(
+                    batch=batch, client=open_ai_client, semaphore=process_semaphore
+                )
+            )
+            pages_tasks.append(page_task)
+        page_groups = await asyncio.gather(*pages_tasks)
+
+        pages = [page for batch_pages in page_groups for page in batch_pages]
+        logger.debug(f"pages done. total pages- {len(pages)} - {trace_id}")
+        sorted_pages = sorted(pages, key=lambda x: x.page_number)
+
+        # TODO add combined version of MD to output / save to file system
+        callable_output = ParallexCallableOutput(
+            file_name=raw_file.given_name,
+            pdf_source_url=raw_file.pdf_source_url,
+            trace_id=trace_id,
+            pages=sorted_pages,
+        )
+        if post_process_callable is not None:
+            post_process_callable(output=callable_output)
+        return callable_output
+
+
+async def _wait_and_create_pages(
+    batch: UploadBatch, client: OpenAIClient, semaphore: asyncio.Semaphore
+):
+    async with semaphore:
+        logger.debug(f"waiting for batch to complete - {batch.id} - {batch.trace_id}")
+        output_file_id = await wait_for_batch_completion(client=client, batch=batch)
+        logger.debug(f"batch completed - {batch.id} - {batch.trace_id}")
+        page_responses = await process_output(
+            client=client, output_file_id=output_file_id
+        )
+        await _remove_global_batch_files(client=client, batch=batch)
+        return page_responses
+
+
+async def _remove_global_batch_files(client: OpenAIClient, batch: UploadBatch):
+    file_ids = [batch.input_file_id, batch.output_file_id, batch.error_file_id]
+    for file_id in file_ids:
+        await client.delete_file(file_id)
+
+
+async def _create_images_and_batch_jobs(
+    batch_file: ImageFile,
+    client: OpenAIClient,
+    trace_id: UUID,
+    semaphore: asyncio.Semaphore,
+):
+    async with semaphore:
+        batch = await create_batch(
+            client=client, file_id=batch_file.id, trace_id=trace_id
+        )
+        return batch

parallex/utils/constants.py

@@ -0,0 +1,9 @@
+DEFAULT_PROMPT = """
+    Convert the following PDF page to markdown.
+    Return only the markdown with no explanation text.
+    Leave out any page numbers and redundant headers or footers.
+    Do not include any code blocks (e.g. "```markdown" or "```") in the response.
+    If unable to parse, return an empty string.
+    """
+
+CUSTOM_ID_DELINEATOR = "--page--"

parallex/utils/logger.py

@@ -0,0 +1,20 @@
+import logging
+
+from aiologger import Logger
+
+logger = Logger.with_default_handlers(name="parallex")
+
+
+def setup_logger(level: str = "ERROR"):
+    level = {
+        "CRITICAL": logging.CRITICAL,
+        "ERROR": logging.ERROR,
+        "WARNING": logging.WARNING,
+        "INFO": logging.INFO,
+        "DEBUG": logging.DEBUG,
+        "NOTSET": logging.NOTSET,
+    }.get(level, logging.INFO)
+
+    logging.basicConfig(
+        level=level, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )

parallex-0.1.0.dist-info/LICENSE

@@ -0,0 +1,19 @@
+The MIT License (MIT)
+
+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.

parallex-0.1.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.1
+Name: parallex
+Version: 0.1.0
+Summary: 
+Author: Jeff Hostetler
+Author-email: jeff@summed.ai
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiologger (>=0.7.0,<0.8.0)
+Requires-Dist: asyncio (>=3.4.3,<4.0.0)
+Requires-Dist: httpx (>=0.27.2,<0.28.0)
+Requires-Dist: openai (>=1.54.4,<2.0.0)
+Requires-Dist: pdf2image (>=1.17.0,<2.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Parallex
+
+### What it does
+- Converts file into images
+- Makes requests to OpenAI to covert the images to markdown
+  - [Azure OpenAPI Batch](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/batch?tabs=standard-input%2Cpython-secure&pivots=programming-language-python)
+  - [OpenAPI Batch](https://platform.openai.com/docs/guides/batch)
+- Post batch processing to do what you wish with the resulting markdown
+
+
+# Notes for us as we build
+### Poetry
+- Using [poetry](https://python-poetry.org/docs/) for dependency management
+- add dependency `poetry add pydantic`
+- add dev dependency `poetry add --group dev black`
+- run main script `poetry run python main.py`
+- run dev commands `poetry run black parallex`
+
+
+# General behavior
+- parallex takes args to do things with file
+- parallex takes args to specify llm model
+- parallex takes a callable to execute once batch process is "ready"
+

parallex-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+parallex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parallex/ai/batch_processor.py,sha256=wftq7-EKWbWO_tzz2PqVZa8XRVf7MoJlr7EcllX4-5I,1481
+parallex/ai/open_ai_client.py,sha256=Yvnvg5MGEyQrmN3HF5k8fEWse9Slthy3J-oumO6ZKkQ,1459
+parallex/ai/output_processor.py,sha256=P6ak7cblRHnsR1W7oEtbOGM7zd7tzZbRKigixQaXWyw,966
+parallex/ai/uploader.py,sha256=M8g8dC_bwiGNDI_S5qxcRqJljDu6KSan_eIcQWA-ERA,3162
+parallex/file_management/converter.py,sha256=Rj-93LXNl2gCY-XUOCZv7DdCNI2-GyRpS5FobnTqwzo,1111
+parallex/file_management/file_finder.py,sha256=BPvrkxZlwOYmRXzzS138wGTsVzuhDIKfQZn0CISUj3o,1598
+parallex/file_management/utils.py,sha256=WMdXd9UOFbJDHnL2IWfDXyyD2jhwnGtpCVI_npiSlIk,98
+parallex/models/batch_file.py,sha256=JwARFB48sMOTN-wf7J5YbsWIac2rxXnZ4fBABFESA0M,405
+parallex/models/image_file.py,sha256=LjQne2b6rIDWpQpdYT41KXNDWpg5kv9bkM1SCx6jnAI,402
+parallex/models/page_response.py,sha256=KADCAV3XnkqWm-q_FBCfbt5nqDbiHg9MroZvFXaBbt0,228
+parallex/models/parallex_callable_output.py,sha256=CkJKA8mwsc5olNnG1K6nrWUu4xTkJvp8bp3SSPQEX5c,465
+parallex/models/raw_file.py,sha256=Nlv6u_jlDCXDgU2_Ff7DRbDCx27pB1NZugNhEoaBMQU,483
+parallex/models/upload_batch.py,sha256=jrnds9ryXg9drL4TF8TGimMVTCDfKaWsBzFv_ed0i88,2068
+parallex/parallex.py,sha256=2XXmG54eXtXnw2ElC12zjbWDnwDIHPgzKY1ktP8V93M,4472
+parallex/utils/constants.py,sha256=c6i_-OSfCXAzW9ILzddSSHfldqHnsPEID3G3VYGYXUg,362
+parallex/utils/logger.py,sha256=5dpTogztRq4NCgYWnbbkFNx3V2sFCN-Mtoagwj8i18Q,505
+parallex-0.1.0.dist-info/LICENSE,sha256=wPwCqGrisXnEcpaUxSO79C2mdOUTbtjhLjyy8mVW6p8,1046
+parallex-0.1.0.dist-info/METADATA,sha256=ICDxk_FnofGhJgeGXv_g-awaZm_g4zU23PkfuXOndNs,1485
+parallex-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+parallex-0.1.0.dist-info/RECORD,,

parallex-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any