traccess 0.0.2__tar.gz

traccess-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Willem Klumpenhouwer
+
+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.

traccess-0.0.2/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: traccess
+Version: 0.0.2
+Summary: Transportation access to opportunities and equity analysis
+Author: Willem Klumpenhouwer
+Author-email: willem@klumpentown.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Traccess
+Transportation access and equity computations.
+
+Traccess offers a set of fast and convenient functions to calculate multiple
+transport accessibility measures. Given a pre-computed travel cost matrix, and
+using data sets on land use supply, demand, and demographics, the package
+computes accessibility levels using multiple accessibility measures, such as:
+cumulative opportunities, minimum travel cost to closest *n* number of activities,
+gravity-based (with different decay functions) and different floating catchment
+area methods.
+
+The package also contains a number of different methods for computing
+distributive and sufficientarian equity measures to compare the level of access
+provided across demographic groups.

traccess-0.0.2/README.md

@@ -0,0 +1,14 @@
+# Traccess
+Transportation access and equity computations.
+
+Traccess offers a set of fast and convenient functions to calculate multiple
+transport accessibility measures. Given a pre-computed travel cost matrix, and
+using data sets on land use supply, demand, and demographics, the package
+computes accessibility levels using multiple accessibility measures, such as:
+cumulative opportunities, minimum travel cost to closest *n* number of activities,
+gravity-based (with different decay functions) and different floating catchment
+area methods.
+
+The package also contains a number of different methods for computing
+distributive and sufficientarian equity measures to compare the level of access
+provided across demographic groups.

traccess-0.0.2/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

traccess-0.0.2/setup.cfg

@@ -0,0 +1,24 @@
+[metadata]
+name = traccess
+version = attr: traccess.__version__
+author = Willem Klumpenhouwer
+author_email = willem@klumpentown.com
+description = Transportation access to opportunities and equity analysis
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT
+
+[options]
+packages = find:
+install_requires = 
+	pandas >= 2.0
+package_dir = 
+	=src
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

traccess-0.0.2/setup.py

@@ -0,0 +1,3 @@
+import setuptools
+
+setuptools.setup()

traccess-0.0.2/src/traccess/__init__.py

@@ -0,0 +1,6 @@
+"Python library for computing access to opportunities and equity metrics"
+
+__version__ = "0.0.2"
+
+from .data import Cost, Demographic, Supply, Access
+from .access import AccessComputer, EquityComputer

traccess-0.0.2/src/traccess/access.py

@@ -0,0 +1,422 @@
+import numpy
+import pandas
+from typing import Union
+
+from .data import Cost, Demand, Demographic, Supply, Access
+
+
+class AccessComputer:
+    """Compute access to destinations."""
+
+    def __init__(
+        self,
+        supply: Supply,
+        cost: Cost,
+        demand: Demand = None,
+    ):
+        """Compute access to opportunity metrics.
+
+        The access computer uses supplied datasets on supply, cost, and
+        optionally demand to compute popular access to opportunity measures.
+
+        Parameters
+        ----------
+        supply : Supply
+            The supply or destination set to compute access to
+        cost : Cost
+            A matrix of cost values (travel time, other cost, etc)
+        demand : Demand, optional
+            The demand for destinations, used for competitive measures
+        """
+        if not isinstance(supply, Supply):
+            raise TypeError(
+                "The supply must be of type Supply. Check the order of arguments passed."
+            )
+        if not isinstance(cost, Cost):
+            raise TypeError(
+                "The cost must be of type Cost. Check the order of arguments passed."
+            )
+        self._supply = supply
+        self._cost = cost
+        self._demand = demand
+
+    @property
+    def cost(self) -> Cost:
+        """Access or set the cost object"""
+        return self._cost
+
+    @cost.setter
+    def cost(self, cost: Cost):
+        self._cost = cost
+
+    @property
+    def supply(self):
+        """Access or set the supply object"""
+        return self._supply
+
+    @supply.setter
+    def supply(self, supply: Supply):
+        self._supply = supply
+
+    def cost_to_closest(
+        self, cost_column: str, supply_columns: list[str], n=1
+    ) -> Access:
+        """Compute the cost to the nth closest destination.
+
+        This function is generic over any kind of numeric travel cost, such as
+        distance, time and money.
+
+        Parameters
+        ----------
+        cost_column : str
+            The column in the Cost object that contains the travel cost
+        supply_columns : list[str]
+            The columns in the Supply data to compute access to
+        n : int, optional
+            The nth closest to compute, by default 1
+
+        Returns
+        -------
+        Access
+            An Access data object with an `id_column` matching the origin zone.
+        """
+        # First we join the destinations
+        with_dest = self.cost.data.reset_index().set_index(self.cost._to_id)
+        with_dest = with_dest.join(self.supply.data, how="right")
+
+        if isinstance(supply_columns, str):
+            supply_columns = [supply_columns]
+
+        columns = []
+
+        for c in supply_columns:
+            # Keep only columns with actual destinations
+            this_column = with_dest[with_dest[c] > 0]
+
+            result = (
+                this_column[[self.cost._from_id, cost_column, c]]
+                .groupby(self.cost._from_id)
+                .apply(_get_nth, o=c, n=n, cost=cost_column)
+            )
+            columns.append(result)
+
+        final = pandas.concat(columns, axis="columns", join="outer")
+
+        final.columns = supply_columns
+
+        final = final.reset_index()
+
+        return Access(final, id_column=self.cost._from_id)
+
+    def cumulative_cutoff(
+        self,
+        cost_columns: list[str],
+        cutoffs: list[float],
+        supply_columns: list[str] = None,
+    ) -> Access:
+        """Compute the total number of opportunities within a specified travel
+        cost cutoff.
+
+        Parameters
+        ----------
+        cost_columns : list[str]
+            A list of cost columns to apply cutoffs to. Can be a single string
+            for a single column.
+        cutoffs : list[float]
+            A list of cutoff values corresponding to each cost column. Can be a
+            single value for a single cutoff column. Must be the same length as
+            `cost_columns`.
+        supply_columns : list[str]
+            An optional list of supply columns to use and return. If None, all
+            supply columns are used. By default, None.
+
+        Returns
+        -------
+        Access
+            An Access data object with an `id_column` matching the origin zone.
+
+        Raises
+        ------
+        ValueError
+            If the supplied column list and cutoff lists are not the same length.
+        """
+        if isinstance(cost_columns, str):
+            cost_columns = [cost_columns]
+        if isinstance(cutoffs, float) or isinstance(cutoffs, int):
+            cutoffs = [cutoffs]
+        if isinstance(supply_columns, str):
+            supply_columns = [supply_columns]
+
+        if len(cost_columns) != len(cutoffs):
+            raise ValueError("Cost and cutoff columns must be the same length")
+
+        join_column = self.cost._to_id
+        group_column = self.cost._from_id
+
+        # Set the join index and join
+        df = self.cost.data.reset_index().set_index(join_column)
+
+        if supply_columns is None:
+            supply_columns = self.supply.columns
+
+        df = df.join(self.supply.data[supply_columns])
+
+        df["_weights"] = 1.0
+        # Iterate through the columns and update weights based on columns
+        for idx, c in enumerate(cost_columns):
+            df["_weights"] = numpy.where(df[c] <= cutoffs[idx], df["_weights"], 0)
+
+        # Multily all opportunities by the weights
+        df[supply_columns] = df[supply_columns].multiply(df["_weights"], axis="index")
+        # Set the group columns
+        df.index.rename(join_column, inplace=True)
+        df.reset_index(inplace=True)
+        # Group and return
+        columns = [group_column]
+        columns.extend(supply_columns)
+        access_df = df[columns].groupby(group_column).sum().reset_index()
+        return Access(
+            access_df,
+            id_column=group_column,
+        )
+
+    def cumulative_decay(self, cost_columns: list[str], decay_function) -> Access:
+        pass
+
+
+class EquityComputer:
+    """Compute distributive equity across population demograhics"""
+
+    def __init__(self, access: Access, demographic: Demographic):
+        """Compute distributive equity metrics across population demographics
+
+        An EquityComputer allows for the combination of access measures and
+        demographic data to compute various metrics of distributive equity or
+        transportation justice.
+
+        Parameters
+        ----------
+        access : Access
+            An `Access` object which contains data on access to opportunities.
+        demographic : Demographic
+            A `Demographic` data object which contains data on demographics and
+            populations
+        """
+        self._access = access
+        self._demographic = demographic
+
+    @property
+    def access(self) -> Access:
+        return self._access
+
+    @access.setter
+    def access(self, access: Access):
+        assert isinstance(access, Access)
+        self._access = access
+
+    @property
+    def demographic(self) -> Demographic:
+        return self._demographic
+
+    @demographic.setter
+    def demographic(self, demographic: Demographic):
+        assert isinstance(demographic, Demographic)
+        self._demographic = demographic
+
+    def in_poverty(
+        self, access_column: str, poverty_line: float, is_dual=False
+    ) -> pandas.Series:
+        """Compute the number of individuals in poverty in any given demographic.
+
+        Parameters
+        ----------
+        access_column : str
+            The access column to compare the poverty line to
+        poverty_line : float
+            The poverty line
+        is_dual: bool, optional
+            Whether the measure is a dual measure, where lower values are
+            better, by default False
+
+        Returns
+        -------
+        pandas.Series
+            A series with each row consisting of a demogrphic group, containing
+            the number of that group in poverty.
+        """
+        # Count the number of people in poverty
+        df = self.access.data.join(self.demographic.data)
+        if is_dual == True:
+            df[df[access_column] > poverty_line][self.demographic.columns].sum()
+        else:
+            return df[df[access_column] < poverty_line][self.demographic.columns].sum()
+
+    def fgt_poverty(
+        self, access_column: str, poverty_line: float, alpha: float, is_dual=False
+    ) -> pandas.Series:
+        """Compute a Foster-Greer-Thorbecke (FGT) index for all demographics.
+
+        FGT measures consider the average amount of poverty in a given
+        population by comparing the distance of each individual from the poverty
+        line, raised to some exponent alpha. Common values of alpha are 0, 1,
+        and 2.
+
+        When alpha = 0, the function returns the poverty rate
+
+        When alpha = 1, the function returns the poverty gap index
+
+        When alpha = 2, the function returns the poverty gap weighted by the
+        poverty gap.
+
+        Parameters
+        ----------
+        access_column : str
+            The access to opportunity column to compare the measure against
+        poverty_line : float
+            The poverty line to compare the access measure against
+        alpha : float
+            The alpha parameter, or the extent which to weight those further
+            below the poverty line
+        is_dual: bool, optional
+            Whether the measure is a dual measure, where lower values are
+            better, by default False
+
+        Returns
+        -------
+        pandas.Series
+            A series with an index for each demographic column, containing the
+            specified measure.
+        """
+        df = self.access.data.join(self.demographic.data)
+
+        # Keep the total of each population group
+        n = self.demographic.data.sum().rename("n")
+
+        if is_dual == True:
+            df["_delta"] = df[access_column] - poverty_line
+        else:
+            df["_delta"] = poverty_line - df[access_column]
+
+        # We only do the math on the set of those in poverty
+        df = df[df["_delta"] > 0]
+        df["_delta"] = df["_delta"] / poverty_line
+        df["_delta"] = df["_delta"].pow(alpha)
+        df[self.demographic.columns] = df[self.demographic.columns].multiply(
+            df["_delta"], axis="index"
+        )
+        totals = df[self.demographic.columns].sum().rename("count")
+        totals = pandas.concat([totals, n], axis="columns")
+        totals["fgt"] = totals["count"] / totals["n"]
+
+        return totals["fgt"].rename(f"fgt{alpha}")
+
+    def poverty_index(
+        self, access_column: str, poverty_line: float, is_dual=False
+    ) -> pandas.Series:
+        """Compute the poverty index at each location.
+
+        This method computes the poverty index for each location, which is the
+        difference between the poverty line and the supplied access value,
+        divided by the poverty line.
+
+        Values above the poverty line are returned as null values.
+
+        Parameters
+        ----------
+        access_column : str
+            The column to compare the poverty line to
+        poverty_line : float
+            The poverty line value for access
+        is_dual: bool, optional
+            Whether the measure is a dual measure, where lower values are
+            better, by default False
+
+        Returns
+        -------
+        pandas.Series
+            A pandas Series containing the poverty index for each location
+        """
+        df = self.access.data.copy()
+        if is_dual == True:
+            df["poverty_index"] = (df[access_column] - poverty_line) / poverty_line
+        else:
+            df["poverty_index"] = (poverty_line - df[access_column]) / poverty_line
+        df["poverty_index"] = numpy.where(
+            df.poverty_index < 0, pandas.NA, df.poverty_index
+        )
+        return df["poverty_index"]
+
+    def weighted_average(self, access_column: str) -> pandas.Series:
+        """Compute the population group-weighted average access for all groups.
+
+        Parameters
+        ----------
+        access_column : str
+            The access value to weight
+
+        Returns
+        -------
+        pandas.Series
+            A series with a row for demographic group, with the weighted average
+            access.
+        """
+        df = self.access.data.join(self.demographic.data)
+        # Normalize the population columns
+        for c in self.demographic.columns:
+            df[c] = df[c] / df[c].sum()
+        # Multiply and sum
+        df[self.demographic.columns] = df[self.demographic.columns].multiply(
+            df[access_column], axis="index"
+        )
+        df = df[self.demographic.columns].sum()
+        df = df.rename(access_column)
+        return df
+
+    def weighted_quantile(
+        self, access_column: str, quantile=0.5, is_dual=False
+    ) -> pandas.Series:
+        """Compute a population-weighted quantile for all demographics.
+
+        Population-weighted quantiles are *not interpolated*, meaning that the
+        values returned by this function are the highest value in the dataset
+        not exceeding the quantile value.
+
+        Parameters
+        ----------
+        access_column : str
+            The column to compute the quantile over
+        quantile : float, optional
+            The quantile to use, by default 0.5
+        is_dual: bool, optional
+            Whether the measure is a dual measure, where lower values are
+            better, by default False
+
+        Returns
+        -------
+        pandas.Series
+            A series containing each demographic group and the access value of
+            that quantile.
+        """
+
+        if is_dual == True:
+            quantile = 1.0 - quantile
+
+        df = self.access.data.join(self.demographic.data)
+        df.sort_values(access_column, inplace=True)
+
+        result = dict()
+        for c in self.demographic.columns:
+            total_weight = df[c].sum()
+            df["_cumulative"] = df[c].cumsum()
+            result[c] = df[df["_cumulative"] <= (total_weight) * quantile][
+                access_column
+            ].iloc[-1]
+
+        return pandas.Series(result, name=f"q{int(quantile * 100)}")
+
+
+def _get_nth(df, o, n, cost):
+    df = df.sort_values(by=cost, ascending=True, na_position="last")
+    df["_cumsum"] = df[o].cumsum()
+    df = df[df["_cumsum"] >= n]
+    return df[cost].min()

traccess-0.0.2/src/traccess/data.py

@@ -0,0 +1,210 @@
+from abc import ABC, abstractmethod
+
+import pandas
+
+
+class AbstractDataSet(ABC):
+    """An abstract data set
+
+    Parameters
+    ----------
+    dataframe : pandas.DataFrame
+        The dataframe containing the data
+    id_column : str, optional
+        The column which should be used as a unique ID, by default "id"
+    """
+
+    def __init__(self, dataframe: pandas.DataFrame, id_column="id"):
+        self._data = dataframe.copy()
+        self._data.set_index(id_column, inplace=True)
+
+        self._id = id_column
+
+    @property
+    def columns(self):
+        return [i for i in self._data.columns]
+
+    @property
+    def data(self) -> pandas.DataFrame:
+        return self._data
+
+    @data.setter
+    def data(self, data: pandas.DataFrame):
+        self._data = data
+
+    def normalize(self, columns=None, min=0.0, max=1.0):
+        """Normalize one or more columns between a range
+
+        This method scales a column based on its minimum
+        and maximum values.
+
+        Parameters
+        ----------
+        columns : list, optional
+            The list of columns to normalise. If None, all columns are used, by default None
+        min : float, optional
+            The minimum of the scaled range, by default 0
+        max : float, optional
+            The maximum of the scaled range, by default 1
+        """
+        if columns == None:
+            columns = self._data.columns
+
+        for c in columns:
+            self._data[c] = (self._data[c] - self._data[c].min()) / (
+                self._data[c].max() - self._data[c].min()
+            ) * (max - min) + min
+
+    @classmethod
+    def from_csv(cls, csv_filepath, id_column="id", **kwargs):
+        """Create a Supply object from a csv file
+
+        Parameters
+        ----------
+        csv_filepath : str or path
+            The filepath of the CSV to parse
+        id_column : str, optional
+            The column used as the reference id, by default "id"
+
+        Returns
+        -------
+        Supply
+            A supply object containing opportunities or land use data
+        """
+        dataframe = pandas.read_csv(csv_filepath, **kwargs)
+        return cls(dataframe, id_column)
+
+
+class AbstractMatrix(ABC):
+    """A representation of a matrix object.
+
+    Parameters
+    ----------
+    dataframe : pandas.DataFrame
+        The dataframe for the matrix object
+    from_id : str, optional
+        The first reference id (the origin), by default "from_id"
+    to_id : str, optional
+        The second reference id (the destination), by default "to_id"
+    """
+
+    def __init__(
+        self, dataframe: pandas.DataFrame, from_id="from_id", to_id="to_id"
+    ) -> None:
+        self._data = dataframe.copy()
+        self._data.set_index([from_id, to_id], inplace=True)
+
+        self._from_id = from_id
+        self._to_id = to_id
+
+    @property
+    def columns(self) -> list:
+        """The list of columns in the dataset"""
+        return self._data.columns
+
+    @property
+    def data(self) -> pandas.DataFrame:
+        """The object's dataframe"""
+        return self._data
+
+    @classmethod
+    def from_csv(cls, csv_filepath, from_id="from_id", to_id="to_id", **kwargs):
+        """Load data and create an object from a CSV file
+
+        Parameters
+        ----------
+        csv_filepath : str
+            The filepath of the CSV file to load
+        from_id : str, optional
+            The column name of the origin, by default "from_id"
+        to_id : str, optional
+            The column name of the destination, by default "to_id"
+
+        Returns
+        -------
+        AbstractMatrix
+            A matrix dataset.
+        """
+        dataframe = pandas.read_csv(csv_filepath, **kwargs)
+        return cls(dataframe, from_id, to_id)
+
+    @classmethod
+    def from_parquet(cls, parquet_filepath, from_id="from_id", to_id="to_id", **kwargs):
+        """Load data and create an object from a Parquet file
+
+        Parameters
+        ----------
+        csv_filepath : str
+            The filepath of the Parquet file to load
+        from_id : str, optional
+            The column name of the origin, by default "from_id"
+        to_id : str, optional
+            The column name of the destination, by default "to_id"
+
+        Returns
+        -------
+        AbstractMatrix
+            A matrix dataset.
+        """
+        dataframe = pandas.read_parquet(parquet_filepath, **kwargs)
+        return cls(dataframe, from_id, to_id)
+
+
+class Access(AbstractDataSet):
+    pass
+
+
+class Cost(AbstractMatrix):
+    def quantile(self, quantile: float, use_to_id=False) -> pandas.DataFrame:
+        """Compute the quantile cost values across all origins or destinations
+
+        Parameters
+        ----------
+        quantile : float
+            The quantile to compute (0 to 1)
+        use_to_id : bool, optional
+            If true, group by the destination column instead of the origin, by default False
+
+        Returns
+        -------
+        pandas.DataFrame
+            A dataframe with an index for each id and the quantile value
+        """
+        if use_to_id:
+            return self.data.groupby(self._to_id).quantile(quantile)
+        else:
+            return self.data.groupby(self._from_id).quantile(quantile)
+
+    def median(self, use_to_id=False) -> pandas.DataFrame:
+        """Compute the median cost values across all origins or destinations.
+
+        This function is a shorthand for `Cost.quantile(quantile=0.5)`
+
+        Parameters
+        ----------
+        use_to_id : bool, optional
+            If true, group by the destination column instead of the origin, by default False
+
+        Returns
+        -------
+        pandas.DataFrame
+            A dataframe with an index for each id and a median value
+        """
+        return self.quantile(0.5, use_to_id)
+
+
+class Demand(AbstractDataSet):
+    pass
+
+
+class Supply(AbstractDataSet):
+    def generalized_cost(self):
+        raise NotImplementedError
+
+    def intrazonal(self):
+        raise NotImplementedError
+
+
+class Demographic(AbstractDataSet):
+    def something(self):
+        raise NotImplementedError

traccess-0.0.2/src/traccess/exception.py

@@ -0,0 +1 @@
+

traccess-0.0.2/src/traccess.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: traccess
+Version: 0.0.2
+Summary: Transportation access to opportunities and equity analysis
+Author: Willem Klumpenhouwer
+Author-email: willem@klumpentown.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Traccess
+Transportation access and equity computations.
+
+Traccess offers a set of fast and convenient functions to calculate multiple
+transport accessibility measures. Given a pre-computed travel cost matrix, and
+using data sets on land use supply, demand, and demographics, the package
+computes accessibility levels using multiple accessibility measures, such as:
+cumulative opportunities, minimum travel cost to closest *n* number of activities,
+gravity-based (with different decay functions) and different floating catchment
+area methods.
+
+The package also contains a number of different methods for computing
+distributive and sufficientarian equity measures to compare the level of access
+provided across demographic groups.

traccess-0.0.2/src/traccess.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/traccess/__init__.py
+src/traccess/access.py
+src/traccess/data.py
+src/traccess/exception.py
+src/traccess.egg-info/PKG-INFO
+src/traccess.egg-info/SOURCES.txt
+src/traccess.egg-info/dependency_links.txt
+src/traccess.egg-info/requires.txt
+src/traccess.egg-info/top_level.txt
+tests/test_access.py
+tests/test_cost.py
+tests/test_supply.py

traccess-0.0.2/src/traccess.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

traccess-0.0.2/src/traccess.egg-info/requires.txt

@@ -0,0 +1 @@
+pandas>=2.0

traccess-0.0.2/src/traccess.egg-info/top_level.txt

@@ -0,0 +1 @@
+traccess

traccess-0.0.2/tests/test_access.py

@@ -0,0 +1,11 @@
+import traccess
+
+
+class TestAccessComputer:
+    def test_cumulative_cutoff(self, access_object: traccess.AccessComputer):
+        df = access_object.cumulative_cutoff(access_object.cost.columns, [29, 2]).data
+        assert df.loc[1]["oj"] == 16.0
+
+    def test_cost_to_closest(self, access_object: traccess.AccessComputer):
+        df = access_object.cost_to_closest("c", ["oj2"], n=2).data
+        assert df.loc[3]["oj2"] == 20.0

traccess-0.0.2/tests/test_cost.py

@@ -0,0 +1,7 @@
+import traccess
+
+
+class TestCost:
+    def test_load_from_csv(self, cost_csv_filepath):
+        cost = traccess.Cost.from_csv(cost_csv_filepath, "o", "d")
+        assert cost.data.loc[(1, 3), "c"] == 20

traccess-0.0.2/tests/test_supply.py

@@ -0,0 +1,8 @@
+import traccess
+
+
+class TestSupply:
+    def test_load_from_csv(self, supply_csv_filepath):
+        supply = traccess.Supply.from_csv(supply_csv_filepath, id_column="dd")
+        assert supply.columns[0] == "oj"
+        assert supply.data.loc[2]["oj2"] == 1