carrot-transform 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

carrottransform/tools/record_builder.py

@@ -0,0 +1,413 @@
+from typing import Dict, List, Optional, Tuple, Set
+from abc import ABC, abstractmethod
+from carrottransform.tools.mapping_types import ConceptMapping
+from carrottransform.tools.date_helpers import get_datetime_value
+from carrottransform.tools.logger import logger_setup
+from carrottransform.tools.validation import valid_value
+from carrottransform.tools.types import (
+    RecordContext,
+    RecordResult,
+)
+from carrottransform.tools.concept_helpers import (
+    generate_combinations,
+    get_value_mapping,
+)
+
+logger = logger_setup()
+
+
+class TargetRecordBuilder(ABC):
+    """Base class for building target records"""
+
+    def __init__(self, context: RecordContext):
+        self.context = context
+
+    @abstractmethod
+    def build_records(self) -> RecordResult:
+        """Build target records - must be implemented by subclasses"""
+        pass
+
+    def create_empty_record(self) -> List[str]:
+        """Create an empty target record with proper initialization"""
+        tgtarray = [""] * len(self.context.tgtcolmap)
+
+        # Initialize numeric fields to 0
+        for req_integer in self.context.notnull_numeric_fields:
+            if req_integer in self.context.tgtcolmap:
+                tgtarray[self.context.tgtcolmap[req_integer]] = "0"
+
+        return tgtarray
+
+    def apply_concept_mapping(self, tgtarray: List[str], concept_combo: Dict[str, int]):
+        """Apply a single concept combination to target array"""
+        for dest_field, concept_id in concept_combo.items():
+            if dest_field in self.context.tgtcolmap:
+                tgtarray[self.context.tgtcolmap[dest_field]] = str(concept_id)
+
+    def apply_original_value_mappings(
+        self, tgtarray: List[str], original_value_fields: List[str], source_value: str
+    ):
+        """Apply original value mappings (direct field copying)"""
+        for dest_field in original_value_fields:
+            if dest_field in self.context.tgtcolmap:
+                tgtarray[self.context.tgtcolmap[dest_field]] = source_value
+
+    def apply_person_id_mapping(self, tgtarray: List[str]):
+        """Apply person ID mapping"""
+        if not self.context.v2_mapping.person_id_mapping:
+            return
+
+        person_id_mapping = self.context.v2_mapping.person_id_mapping
+        if (
+            person_id_mapping.dest_field in self.context.tgtcolmap
+            and person_id_mapping.source_field in self.context.srccolmap
+        ):
+            person_id = self.context.srcdata[
+                self.context.srccolmap[person_id_mapping.source_field]
+            ]
+            tgtarray[self.context.tgtcolmap[person_id_mapping.dest_field]] = person_id
+
+    def apply_date_mappings(self, tgtarray: List[str]) -> bool:
+        """Apply date mappings with proper error handling"""
+        if not self.context.v2_mapping.date_mapping:
+            return True
+
+        date_mapping = self.context.v2_mapping.date_mapping
+
+        if date_mapping.source_field not in self.context.srccolmap:
+            logger.warning(
+                f"Date mapping source field not found in source data: {date_mapping.source_field}"
+            )
+            return True
+
+        source_date = self.context.srcdata[
+            self.context.srccolmap[date_mapping.source_field]
+        ]
+
+        for dest_field in date_mapping.dest_fields:
+            if dest_field in self.context.tgtcolmap:
+                if not self._apply_single_date_field(tgtarray, dest_field, source_date):
+                    return False
+
+        return True
+
+    def _apply_single_date_field(
+        self, tgtarray: List[str], dest_field: str, source_date: str
+    ) -> bool:
+        """Apply a single date field mapping"""
+        # Handle date component fields (birth dates with year/month/day)
+        if dest_field in self.context.date_component_data:
+            dt = get_datetime_value(source_date.split(" ")[0])
+            if dt is None:
+                self.context.metrics.increment_key_count(
+                    source=self.context.srcfilename,
+                    fieldname=self.context.srcfield,
+                    tablename=self.context.tgtfilename,
+                    concept_id="all",
+                    additional="",
+                    count_type="invalid_date_fields",
+                )
+                logger.warning(f"Invalid date fields: {self.context.srcfield}")
+                return False
+
+            # Set individual date components
+            component_info = self.context.date_component_data[dest_field]
+            if (
+                "year" in component_info
+                and component_info["year"] in self.context.tgtcolmap
+            ):
+                tgtarray[self.context.tgtcolmap[component_info["year"]]] = str(dt.year)
+            if (
+                "month" in component_info
+                and component_info["month"] in self.context.tgtcolmap
+            ):
+                tgtarray[self.context.tgtcolmap[component_info["month"]]] = str(
+                    dt.month
+                )
+            if (
+                "day" in component_info
+                and component_info["day"] in self.context.tgtcolmap
+            ):
+                tgtarray[self.context.tgtcolmap[component_info["day"]]] = str(dt.day)
+
+            # Set the main date field
+            tgtarray[self.context.tgtcolmap[dest_field]] = source_date
+
+        # Handle regular date fields with linked date-only fields
+        elif dest_field in self.context.date_col_data:
+            tgtarray[self.context.tgtcolmap[dest_field]] = source_date
+            # Set the linked date-only field
+            if self.context.date_col_data[dest_field] in self.context.tgtcolmap:
+                tgtarray[
+                    self.context.tgtcolmap[self.context.date_col_data[dest_field]]
+                ] = source_date[:10]
+
+        # Handle simple date fields
+        else:
+            tgtarray[self.context.tgtcolmap[dest_field]] = source_date
+
+        return True
+
+    def write_record_directly(self, output_record: List[str]) -> bool:
+        """Write single record directly to output file with all necessary processing"""
+        # Set auto-increment ID
+        if self.context.auto_num_col is not None:
+            output_record[self.context.tgtcolmap[self.context.auto_num_col]] = str(
+                self.context.record_numbers[self.context.tgtfilename]
+            )
+            self.context.record_numbers[self.context.tgtfilename] += 1
+
+        # Map person ID
+        person_id = output_record[self.context.tgtcolmap[self.context.person_id_col]]
+        if person_id in self.context.person_lookup:
+            output_record[self.context.tgtcolmap[self.context.person_id_col]] = (
+                self.context.person_lookup[person_id]
+            )
+
+            # Update metrics
+            self.context.metrics.increment_with_datacol(
+                source_path=self.context.srcfilename,
+                target_file=self.context.tgtfilename,
+                datacol=self.context.srcfield,
+                out_record=output_record,
+            )
+
+            # Write directly to output file (files are kept open)
+            self.context.file_handles[self.context.tgtfilename].write(
+                "\t".join(output_record) + "\n"
+            )
+
+            return True
+        else:
+            # Invalid person ID
+            self.context.metrics.increment_key_count(
+                source=self.context.srcfilename,
+                fieldname="all",
+                tablename=self.context.tgtfilename,
+                concept_id="all",
+                additional="",
+                count_type="invalid_person_ids",
+            )
+            return False
+
+
+class PersonRecordBuilder(TargetRecordBuilder):
+    """Specialized builder for person table records"""
+
+    def __init__(self, context: RecordContext):
+        super().__init__(context)
+        self.processed_cache: Set[str] = set()
+
+    def build_records(self) -> RecordResult:
+        """Build person table records with special merging logic"""
+        # Check if person ID mapping exists
+        if not self.context.v2_mapping.person_id_mapping:
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Create a unique key for this source row
+        person_key = f"{self.context.srcfilename}:{self.context.srcdata[self.context.srccolmap[self.context.v2_mapping.person_id_mapping.source_field]]}"
+
+        # Only process if we haven't already processed this person record
+        if person_key in self.processed_cache:
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Mark this person as processed
+        self.processed_cache.add(person_key)
+
+        # Collect all mappings from all fields
+        all_concept_mappings, all_original_values = self._collect_all_mappings()
+
+        # If no valid mappings found, return empty
+        if not all_concept_mappings and not all_original_values:
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Generate combined concept combinations
+        concept_combinations = (
+            generate_combinations(all_concept_mappings)
+            if all_concept_mappings
+            else [{}]
+        )
+
+        # Create person records for each combination
+        record_count = 0
+        for concept_combo in concept_combinations:
+            record = self._build_single_person_record(
+                concept_combo, all_original_values
+            )
+            if record:
+                # Write record directly using the built-in method
+                if self.write_record_directly(record):
+                    record_count += 1
+
+        return RecordResult(record_count > 0, record_count, self.context.metrics)
+
+    def _collect_all_mappings(self) -> Tuple[Dict[str, List[int]], Dict[str, str]]:
+        """Collect all concept mappings and original values from all fields"""
+        all_concept_mappings = {}
+        all_original_values = {}
+
+        for (
+            field_name,
+            concept_mapping,
+        ) in self.context.v2_mapping.concept_mappings.items():
+            if field_name not in self.context.srccolmap:
+                continue
+
+            # Check if field has valid value
+            source_value = str(self.context.srcdata[self.context.srccolmap[field_name]])
+            if not valid_value(source_value):
+                continue
+
+            # Get value mapping for this field
+            value_mapping = get_value_mapping(concept_mapping, source_value)
+
+            if value_mapping:
+                # Add this field's mappings to the combined mappings
+                for dest_field, concept_ids in value_mapping.items():
+                    all_concept_mappings[dest_field] = concept_ids
+
+            # Collect original value mappings
+            if concept_mapping.original_value_fields:
+                for dest_field in concept_mapping.original_value_fields:
+                    all_original_values[dest_field] = source_value
+
+        return all_concept_mappings, all_original_values
+
+    def _build_single_person_record(
+        self, concept_combo: Dict[str, int], all_original_values: Dict[str, str]
+    ) -> Optional[List[str]]:
+        """Build a single person record"""
+        tgtarray = self.create_empty_record()
+
+        # Apply the merged concept combination
+        self.apply_concept_mapping(tgtarray, concept_combo)
+
+        # Handle original value fields (direct field copying)
+        for dest_field, source_value in all_original_values.items():
+            if dest_field in self.context.tgtcolmap:
+                tgtarray[self.context.tgtcolmap[dest_field]] = source_value
+
+        # Handle person ID mapping
+        self.apply_person_id_mapping(tgtarray)
+
+        # Handle date mappings
+        if not self.apply_date_mappings(tgtarray):
+            logger.warning("Failed to apply date mappings for person table")
+            return None
+
+        return tgtarray
+
+
+class StandardRecordBuilder(TargetRecordBuilder):
+    """Builder for standard (non-person) table records"""
+
+    def build_records(self) -> RecordResult:
+        """Build standard table records"""
+        # Check if source field has a value
+        if not valid_value(
+            str(self.context.srcdata[self.context.srccolmap[self.context.srcfield]])
+        ):
+            self.context.metrics.increment_key_count(
+                source=self.context.srcfilename,
+                fieldname=self.context.srcfield,
+                tablename=self.context.tgtfilename,
+                concept_id="all",
+                additional="",
+                count_type="invalid_source_fields",
+            )
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Check if we have a concept mapping for this field
+        if self.context.srcfield not in self.context.v2_mapping.concept_mappings:
+            return RecordResult(False, 0, self.context.metrics)
+
+        concept_mapping = self.context.v2_mapping.concept_mappings[
+            self.context.srcfield
+        ]
+        source_value = str(
+            self.context.srcdata[self.context.srccolmap[self.context.srcfield]]
+        )
+
+        # Get value mapping (concept mappings or wildcard)
+        value_mapping = get_value_mapping(concept_mapping, source_value)
+
+        # Only proceed if we have concept mappings OR original value fields
+        if not value_mapping and not concept_mapping.original_value_fields:
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Generate all concept combinations
+        concept_combinations = generate_combinations(value_mapping)
+
+        # If no concept combinations, don't build records
+        if not concept_combinations:
+            return RecordResult(False, 0, self.context.metrics)
+
+        # Create records for each concept combination
+        record_count = 0
+        for concept_combo in concept_combinations:
+            record = self._build_single_standard_record(
+                concept_combo, concept_mapping, source_value
+            )
+            if record:
+                # Write record directly using the built-in method
+                if self.write_record_directly(record):
+                    record_count += 1
+                else:
+                    # If write fails, return failure
+                    return RecordResult(False, 0, self.context.metrics)
+            else:
+                # If any record fails, return failure
+                return RecordResult(False, 0, self.context.metrics)
+
+        return RecordResult(record_count > 0, record_count, self.context.metrics)
+
+    def _build_single_standard_record(
+        self,
+        concept_combo: Dict[str, int],
+        concept_mapping: ConceptMapping,
+        source_value: str,
+    ) -> Optional[List[str]]:
+        """Build a single standard record"""
+        tgtarray = self.create_empty_record()
+
+        # Apply this specific concept combination
+        self.apply_concept_mapping(tgtarray, concept_combo)
+
+        # Handle original value fields (direct field copying)
+        if concept_mapping.original_value_fields:
+            self.apply_original_value_mappings(
+                tgtarray, concept_mapping.original_value_fields, source_value
+            )
+
+        # Handle person ID mapping
+        self.apply_person_id_mapping(tgtarray)
+
+        # Handle date mappings
+        if not self.apply_date_mappings(tgtarray):
+            logger.warning(f"Failed to apply date mappings for {self.context.srcfield}")
+            return None
+
+        return tgtarray
+
+
+class RecordBuilderFactory:
+    """Factory for creating appropriate record builders"""
+
+    # Class-level cache for person records
+    _person_processed_cache: Set[str] = set()
+
+    @classmethod
+    def create_builder(cls, context: RecordContext) -> TargetRecordBuilder:
+        """Create the appropriate record builder based on table type"""
+        if context.tgtfilename == "person":
+            builder = PersonRecordBuilder(context)
+            # Share the class-level cache across all person builders
+            builder.processed_cache = cls._person_processed_cache
+            return builder
+        else:
+            return StandardRecordBuilder(context)
+
+    @classmethod
+    def clear_person_cache(cls):
+        """Clear the person processed cache (useful for testing or new runs)"""
+        cls._person_processed_cache.clear()

carrottransform/tools/stream_helpers.py

@@ -0,0 +1,71 @@
+from typing import Dict, Set, Any
+from collections import defaultdict
+from carrottransform.tools.mappingrules import MappingRules
+from carrottransform.tools.omopcdm import OmopCDM
+
+
+class StreamingLookupCache:
+    """Pre-computed lookup tables for efficient streaming processing"""
+
+    def __init__(self, mappingrules: MappingRules, omopcdm: OmopCDM):
+        self.mappingrules = mappingrules
+        self.omopcdm = omopcdm
+
+        # Pre-compute lookups
+        self.input_to_outputs = self._build_input_to_output_lookup()
+        self.file_metadata_cache = self._build_file_metadata_cache()
+        self.target_metadata_cache = self._build_target_metadata_cache()
+
+    def _build_input_to_output_lookup(self) -> Dict[str, Set[str]]:
+        """Build lookup: input_file -> set of output tables it can map to"""
+        lookup = defaultdict(set)
+
+        for target_file, source_mappings in self.mappingrules.v2_mappings.items():
+            for source_file in source_mappings.keys():
+                lookup[source_file].add(target_file)
+
+        return dict(lookup)
+
+    def _build_file_metadata_cache(self) -> Dict[str, Dict[str, Any]]:
+        """Pre-compute metadata for each input file"""
+        cache = {}
+
+        for input_file in self.mappingrules.get_all_infile_names():
+            datetime_source, person_id_source = (
+                self.mappingrules.get_infile_date_person_id(input_file)
+            )
+
+            data_fields = self.mappingrules.get_infile_data_fields(input_file)
+
+            cache[input_file] = {
+                "datetime_source": datetime_source,
+                "person_id_source": person_id_source,
+                "data_fields": data_fields,
+            }
+
+        return cache
+
+    def _build_target_metadata_cache(self) -> Dict[str, Dict[str, Any]]:
+        """Pre-compute metadata for each target table"""
+        cache = {}
+
+        for target_file in self.mappingrules.get_all_outfile_names():
+            auto_num_col = self.omopcdm.get_omop_auto_number_field(target_file)
+            person_id_col = self.omopcdm.get_omop_person_id_field(target_file)
+            date_col_data = self.omopcdm.get_omop_datetime_linked_fields(target_file)
+            date_component_data = self.omopcdm.get_omop_date_field_components(
+                target_file
+            )
+            notnull_numeric_fields = self.omopcdm.get_omop_notnull_numeric_fields(
+                target_file
+            )
+
+            cache[target_file] = {
+                "auto_num_col": auto_num_col,
+                "person_id_col": person_id_col,
+                "date_col_data": date_col_data,
+                "date_component_data": date_component_data,
+                "notnull_numeric_fields": notnull_numeric_fields,
+            }
+
+        return cache

carrottransform/tools/types.py

@@ -0,0 +1,71 @@
+from typing import Dict, List, Optional, TextIO
+from dataclasses import dataclass
+from pathlib import Path
+import carrottransform.tools as tools
+from carrottransform.tools.omopcdm import OmopCDM
+from carrottransform.tools.mapping_types import V2TableMapping
+from carrottransform.tools.mappingrules import MappingRules
+
+
+@dataclass
+class ProcessingContext:
+    """Context object containing all processing configuration and state"""
+
+    mappingrules: MappingRules
+    omopcdm: OmopCDM
+    input_dir: Path
+    person_lookup: Dict[str, str]
+    record_numbers: Dict[str, int]
+    file_handles: Dict[str, TextIO]
+    target_column_maps: Dict[str, Dict[str, int]]
+    metrics: tools.metrics.Metrics
+
+    @property
+    def input_files(self) -> List[str]:
+        return self.mappingrules.get_all_infile_names()
+
+    @property
+    def output_files(self) -> List[str]:
+        return self.mappingrules.get_all_outfile_names()
+
+
+@dataclass
+class RecordResult:
+    """Result of record building operation"""
+
+    success: bool
+    record_count: int
+    metrics: tools.metrics.Metrics
+
+
+@dataclass
+class RecordContext:
+    """Context object containing all the data needed for record building"""
+
+    tgtfilename: str
+    tgtcolmap: Dict[str, int]
+    v2_mapping: V2TableMapping
+    srcfield: str
+    srcdata: List[str]
+    srccolmap: Dict[str, int]
+    srcfilename: str
+    omopcdm: OmopCDM
+    metrics: tools.metrics.Metrics
+    person_lookup: Dict[str, str]
+    record_numbers: Dict[str, int]
+    file_handles: Dict[str, TextIO]
+    auto_num_col: Optional[str]
+    person_id_col: str
+    date_col_data: Dict[str, str]
+    date_component_data: Dict[str, Dict[str, str]]
+    notnull_numeric_fields: List[str]
+
+
+@dataclass
+class ProcessingResult:
+    """Result of data processing operation"""
+
+    output_counts: Dict[str, int]
+    rejected_id_counts: Dict[str, int]
+    success: bool = True
+    error_message: Optional[str] = None

carrottransform/tools/validation.py

@@ -0,0 +1,62 @@
+import datetime
+from carrottransform.tools.logger import logger_setup
+
+logger = logger_setup()
+
+
+def valid_value(value: str) -> bool:
+    """Check if a value is valid (not empty/null)"""
+    return value.strip() != ""
+
+
+def valid_date_value(item: str) -> bool:
+    """
+    Check if a date item is non null and parses as ISO (YYYY-MM-DD), reverse-ISO
+    or dd/mm/yyyy or mm/dd/yyyy
+    """
+    if item.strip() == "":
+        return False
+    if (
+        not _valid_iso_date(item)
+        and not _valid_reverse_iso_date(item)
+        and not _valid_uk_date(item)
+    ):
+        logger.warning("Bad date : `{0}`".format(item))
+        return False
+    return True
+
+
+def _valid_iso_date(item: str) -> bool:
+    """
+    Check if a date item is non null and parses as ISO (YYYY-MM-DD)
+    """
+    try:
+        datetime.datetime.strptime(item, "%Y-%m-%d")
+    except ValueError:
+        return False
+
+    return True
+
+
+def _valid_reverse_iso_date(item: str) -> bool:
+    """
+    Check if a date item is non null and parses as reverse ISO (DD-MM-YYYY)
+    """
+    try:
+        datetime.datetime.strptime(item, "%d-%m-%Y")
+    except ValueError:
+        return False
+
+    return True
+
+
+def _valid_uk_date(item: str) -> bool:
+    """
+    Check if a date item is non null and parses as UK format (DD/MM/YYYY)
+    """
+    try:
+        datetime.datetime.strptime(item, "%d/%m/%Y")
+    except ValueError:
+        return False
+
+    return True

carrot_transform-0.3.4.dist-info/RECORD

@@ -1,24 +0,0 @@
-carrottransform/__init__.py,sha256=cQJKTCpG2qmKxDl-VtSWQ3_WFjyzg4u_8nZacWAHFcU,73
-carrottransform/_version.py,sha256=bm7SM-_MN0gstlNsCDO6dAajKcjQD-NxI_xpvfRx0Ts,172
-carrottransform/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carrottransform/cli/command.py,sha256=xYTaJsVZyRYv0CzUwrh7ZPK8hhGyC3MDfvVYxHcXYSM,508
-carrottransform/cli/subcommands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-carrottransform/cli/subcommands/run.py,sha256=r2XanTvy4QowPbziZ5lqs-Tm8CAzCquL7DRy4lTT9Ak,23977
-carrottransform/config/OMOPCDM_postgresql_5.3_ddl.sql,sha256=fXrPfdL3IzU5ux55ogsQKjjd-c1KzdP_N2A_JjlY3gk,18084
-carrottransform/config/omop.json,sha256=OT3jvfPjKhjsDnQcQw1OAEOHhQLoHXNxTj_MDwNbYqo,1934
-carrottransform/examples/test/inputs/Covid19_test.csv,sha256=d5t7Lfhkwbfe3Uk2IBqB2ZT5o0h9QaeraC8E5-IMERo,67521
-carrottransform/examples/test/inputs/Demographics.csv,sha256=_ukUTpD4g751sL_mSL3f26T_Edd2kvH-evwm54VfXJI,85237
-carrottransform/examples/test/inputs/Symptoms.csv,sha256=5dvGv16PNJJO_lFc0reRmQbE3m7iWfWajl51JDsqg0M,78447
-carrottransform/examples/test/inputs/covid19_antibody.csv,sha256=SPCpyqpTbVq9987jXZ8AS4FEkrchRMAIYhTQJjfpwfY,98927
-carrottransform/examples/test/inputs/vaccine.csv,sha256=_gcM-SIymyt2Dkkr_zGmQI9keIdmDm-gDI_QvXXLFrY,44037
-carrottransform/examples/test/rules/rules_14June2021.json,sha256=n2OYNFhbx-NLhmqjAad6RsfXjQFknZIgQ7a5uyJF0Co,13226
-carrottransform/tools/__init__.py,sha256=b3JuCwgJVx0rqx5igB8hNNKO0ktlbQjHGHwy-vzpdo0,198
-carrottransform/tools/file_helpers.py,sha256=xlODDAUpsx0H4sweGZ81ttjJjNQGn2spNUa1Fndotw8,316
-carrottransform/tools/mappingrules.py,sha256=IiZx24G27Rag-YgV-4jDxprJea9Ce7SZUbjxMm0n49k,7040
-carrottransform/tools/metrics.py,sha256=LOzm80-YIVM9mvgvQXRpyArl2nSfSTTW9DikqJ5M2Yg,5700
-carrottransform/tools/omopcdm.py,sha256=MwS_MwwBrypwjbFLuxoE0xlddWIi0T3BEPgN9LPkGAs,8508
-carrot_transform-0.3.4.dist-info/LICENSE,sha256=pqIiuuTs6Na-oFd10MMsZoZmdfhfUhHeOtQzgzSkcaw,1082
-carrot_transform-0.3.4.dist-info/METADATA,sha256=mbB8-GgOH6EnJXDr2j46Q97R3ID4Dro9IbgAFcJVAXY,4219
-carrot_transform-0.3.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-carrot_transform-0.3.4.dist-info/entry_points.txt,sha256=z7qmjTl7C8shrYiPBy6yZo9RRZ31Jcvo6L8ntdqbs2E,74
-carrot_transform-0.3.4.dist-info/RECORD,,

carrot_transform-0.3.4.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-carrot-transform=carrottransform.cli.command:transform
-