147 lines
3.9 KiB
Python
147 lines
3.9 KiB
Python
import logging
|
|
from abc import abstractmethod
|
|
from collections.abc import Callable
|
|
from pathlib import Path
|
|
|
|
import pandas as pd
|
|
from pydantic import BaseModel
|
|
|
|
logger = logging.getLogger(__name__)
|
|
logger.setLevel(logging.DEBUG)
|
|
|
|
|
|
class Source(BaseModel):
|
|
filename: str
|
|
|
|
@abstractmethod
|
|
def get_df(self) -> pd.DataFrame:
|
|
raise NotImplementedError
|
|
|
|
|
|
class ExcelSource(Source):
|
|
sheet_name: str
|
|
|
|
def get_df(self, base_path: Path) -> pd.DataFrame:
|
|
filepath = base_path / self.filename
|
|
logger.debug(f"Get content of {filepath}")
|
|
return pd.read_excel(filepath, sheet_name=self.sheet_name)
|
|
|
|
|
|
class CSVSource(Source):
|
|
options: dict = {}
|
|
|
|
def get_df(self, base_path: Path) -> pd.DataFrame:
|
|
filepath = base_path / self.filename
|
|
logger.debug(f"Get content of {filepath}")
|
|
return pd.read_csv(filepath, **self.options)
|
|
|
|
|
|
class Transformation(BaseModel):
|
|
function: Callable
|
|
extra_kwrds: dict = {}
|
|
|
|
|
|
class Destination(BaseModel):
|
|
name: str
|
|
|
|
def write(
|
|
self, df: pd.DataFrame, dest_path: Path, writing_func: Callable
|
|
) -> list[Path]:
|
|
dest_basename = dest_path / self.name
|
|
return [writing_func(df, dest_basename)]
|
|
|
|
|
|
class SplitDestination(Destination):
|
|
split_column: str
|
|
|
|
def write(
|
|
self, df: pd.DataFrame, dest_path: Path, writing_func: Callable
|
|
) -> list[Path]:
|
|
wrote_files = []
|
|
|
|
for col_value in df[self.split_column].unique():
|
|
filtered_df = df[df[self.split_column] == col_value]
|
|
|
|
dest_basename = dest_path / f"{self.name}-{col_value}"
|
|
dest = writing_func(filtered_df, dest_basename)
|
|
wrote_files.append(dest)
|
|
|
|
return wrote_files
|
|
|
|
|
|
class Flux(BaseModel):
|
|
sources: list[Source]
|
|
transformation: Transformation
|
|
destination: Destination
|
|
|
|
|
|
def to_csv(df, dest_basename: Path) -> Path:
|
|
dest = dest_basename.parent / (dest_basename.stem + ".csv")
|
|
if dest.exists():
|
|
df.to_csv(dest, mode="a", header=False, index=False)
|
|
else:
|
|
df.to_csv(dest, index=False)
|
|
return dest
|
|
|
|
|
|
def write_split_by(
|
|
df: pd.DataFrame, column: str, dest_path: Path, name: str, writing_func
|
|
) -> list[Path]:
|
|
wrote_files = []
|
|
|
|
for col_value in df[column].unique():
|
|
filtered_df = df[df[column] == col_value]
|
|
|
|
dest_basename = dest_path / f"{name}-{col_value}"
|
|
dest = writing_func(filtered_df, dest_basename)
|
|
wrote_files.append(dest)
|
|
|
|
return wrote_files
|
|
|
|
|
|
def extract_sources(sources: list[Source], base_path: Path = Path()):
|
|
for src in sources:
|
|
if "*" in src.filename:
|
|
expanded_src = [
|
|
src.model_copy(update={"filename": str(p.relative_to(base_path))})
|
|
for p in base_path.glob(src.filename)
|
|
]
|
|
yield from extract_sources(expanded_src, base_path)
|
|
else:
|
|
filepath = base_path / src.filename
|
|
assert filepath.exists
|
|
yield src.filename, src.get_df(base_path)
|
|
|
|
|
|
def split_duplicates(
|
|
df, origin: str, duplicated: dict[str, pd.DataFrame]
|
|
) -> [pd.DataFrame, dict[str, pd.DataFrame]]:
|
|
duplicates = df.duplicated()
|
|
no_duplicates = df[~duplicates]
|
|
duplicated[origin] = df[duplicates]
|
|
return no_duplicates, duplicated
|
|
|
|
|
|
def consume_fluxes(
|
|
fluxes: dict[str, Flux],
|
|
origin_path: Path,
|
|
dest_path: Path,
|
|
writing_func=to_csv,
|
|
):
|
|
duplicated = {}
|
|
wrote_files = []
|
|
|
|
for name, flux in fluxes.items():
|
|
print(name)
|
|
logger.info(f"Processing flux {name}")
|
|
src_df = []
|
|
for filename, df in extract_sources(flux.sources, origin_path):
|
|
df, duplicated = split_duplicates(df, str(filename), duplicated)
|
|
src_df.append(df)
|
|
|
|
df = flux.transformation.function(src_df, **flux.transformation.extra_kwrds)
|
|
|
|
files = flux.destination.write(df, dest_path, writing_func)
|
|
wrote_files += files
|
|
return wrote_files
|