bardata 0.0.1__py3-none-any.whl

bardata/__init__.py

@@ -0,0 +1,9 @@
+"""
+bardata package
+
+basic bar data manipulation routines based on pandas
+"""
+
+from .tickers import get_tickers
+from .prices import get_prices, price_engine
+

bardata/dates.py

@@ -0,0 +1,113 @@
+""" date utils """
+
+import re
+import datetime
+
+from dateutil.tz import gettz
+from dateutil.relativedelta import relativedelta
+
+DEFAULT_CLOSING = 1700
+
+NEW_YORK = gettz('America/New_York')
+
+
+def last_busday(date):
+    """ last business day as of given date, backtracks on weekends  """
+
+    weekend = max(date.weekday() - 4, 0)
+    if weekend > 0:
+        date -= datetime.timedelta(days=weekend)
+
+    return date
+
+
+def add_busdays(date, nbdays=0):
+    """ adds number of business days to given date, backtracks on weekends   """
+
+    offset = date.weekday()  # offset to monday (backward)
+    nbdays = nbdays + min(offset, 5)  # add offset back (forward)
+    delta = (nbdays // 5) * 7 + (nbdays % 5) - offset
+    date += datetime.timedelta(days=delta)
+
+    return date
+
+
+def last_busday_close(asof: datetime.datetime = None, *,
+                      closing_time: int = None, tzinfo: str = None,
+                      days_back: int = 0):
+    """ last business day close for specified closing time, backtracks on weekends """
+
+    if closing_time is None:
+        closing_time = DEFAULT_CLOSING
+
+    if tzinfo is None:
+        tzinfo = NEW_YORK
+
+    if isinstance(tzinfo, str):
+        tzinfo = gettz(tzinfo)
+
+    if isinstance(closing_time, int):
+        hour, minute = int(closing_time / 100), (closing_time % 100)
+        closing_time = datetime.time(hour=hour, minute=minute)
+
+    if not isinstance(closing_time, datetime.time):
+        raise ValueError(f"Expected an int or time, got {closing_time!r}")
+
+    # keep closing_time a naive time
+    if closing_time.tzinfo is not None:
+        tzinfo = closing_time.tzinfo
+        closing_time.replace(tzinfo=None)
+
+    if asof is None:
+        asof = datetime.datetime.now(tzinfo)
+
+    if not isinstance(asof, datetime.datetime):
+        raise ValueError(f"Expected a datetime value {asof}")
+
+    if tzinfo:
+        asof = asof.astimezone(tzinfo)
+
+    if closing_time and asof.time() < closing_time:
+        days_back += 1
+
+    date = asof.date()
+
+    if days_back:
+        date -= datetime.timedelta(days=days_back)
+
+    # backtrack to last business day
+    weekend = max(date.weekday() - 4, 0)
+    if weekend > 0:
+        date -= datetime.timedelta(days=weekend)
+
+    time = closing_time or datetime.time(0)
+
+    result = datetime.datetime.combine(date, time, tzinfo)
+
+    return result
+
+
+def quick_timedelta(period: str) -> relativedelta:
+    """ relativedelta from a period pecification string like 1D, 1W, 1M, 4H, 300T etc ... """
+
+    if match := re.fullmatch(r"(\d+)(\w)", period):
+        count, freq = int(match.group(1)), match.group(2)
+    else:
+        raise ValueError(f"Invalid period {period!r}")
+
+    if freq in "D":
+        kwargs = relativedelta(days=count)
+    elif freq in "W":
+        kwargs = dict(weeks=count)
+    elif freq == "M":
+        kwargs = dict(months=count)
+    elif freq == "Y":
+        kwargs = dict(months=count * 12)
+    elif freq == "H":
+        kwargs = dict(hours=count)
+    elif freq == "T":
+        kwargs = dict(minutes=count)
+    else:
+        raise ValueError(f"Invalid period {period!r}")
+
+    return relativedelta(**kwargs)

bardata/errors.py

@@ -0,0 +1,6 @@
+""" exceptions """
+
+
+class DataNotFoundError(Exception):
+    """ Data Not Found Error """
+    pass

bardata/freqs.py

@@ -0,0 +1,48 @@
+""" frequency utils """
+
+# see https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases
+
+import re
+
+PANDAS_FREQ = dict(day='B', week='W', month='M', year='Y', hour='H', minute='T')
+
+
+def split_frequency(freq: str) -> str:
+    """ split freq string into count and frequency (long name) """
+
+    if match := re.fullmatch(r"(\d+)(\w+)", freq):
+        count, freq = int(match.group(1)), match.group(2)
+    elif match := re.fullmatch(r"(\w+)", freq):
+        count, freq = 1, match.group(1)
+    else:
+        raise ValueError(f"Invalid freq {freq!r}")
+
+    if freq in ('D', 'day', 'daily'):
+        freq = 'day'
+    elif freq in ('W', 'week', 'weekly'):
+        freq = 'week'
+    elif freq in ('M', 'month', 'monthly'):
+        freq = 'month'
+    elif freq in ('Y', 'year', 'yearly'):
+        freq = 'year'
+    elif freq in ('H', 'hour', 'hourly'):
+        freq = 'hour'
+    elif freq in ('T', 'min', 'minute'):
+        freq = 'minute'
+    else:
+        raise ValueError(f"Invalid freq {freq!r}")
+
+    return count, freq
+
+
+def pandas_freq(freq: str) -> str:
+    """ map a frequency string to a pandas frequency string """
+
+    count, freq = split_frequency(freq)
+    freq = PANDAS_FREQ.get(freq)
+
+    if count != 1:
+        freq = f"{count}{freq}"
+
+    return freq
+

bardata/model.py

@@ -0,0 +1,33 @@
+""" model classes """
+
+from abc import ABC, abstractmethod
+
+
+class PriceEngine(ABC):
+    """ Price Engine """
+
+    priority: int = 0
+
+    def __init__(self, source=None):
+        self.source = source
+
+    @abstractmethod
+    def get_prices(self,
+                   ticker: str, freq: str = 'daily', *,
+                   start_date=None, end_date=None,
+                   max_bars=None, adjusted=True):
+        """ fetch prices data """
+        ...
+
+
+class TickerHandler(ABC):
+    """ Ticker Handler """
+
+    priority: int = 0
+
+    def __init__(self, source=None):
+        self.source = source
+
+    @abstractmethod
+    def get_tickers(self, moniker: str):
+        ...

bardata/prices.py

@@ -0,0 +1,159 @@
+""" price data """
+
+import sys
+
+import numpy as np
+import pandas as pd
+
+from functools import lru_cache
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from .freqs import pandas_freq, split_frequency
+from .dates import quick_timedelta
+from .model import PriceEngine
+
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
+# MAYBE add caching (boolean) parameter ... where ?
+# MAYBE add source, start_date and end_date to combine_prices ?
+# MAYBE can we remove resample param from combine prices ???
+
+
+DEFAULT_PRICES = 'rawdata'
+DEFAULT_INTRADAY = 'polygon'
+
+ENTRY_POINTS = "bardata_prices"
+
+
+@lru_cache
+def default_source(freq: str = None) -> str:
+    """ best source for given freq """
+
+    count, freq = split_frequency(freq or 'daily')
+
+    if freq in ('hour', 'minute'):
+        return DEFAULT_INTRADAY
+
+    return DEFAULT_PRICES
+
+
+@lru_cache
+def price_engine(source: str = None) -> PriceEngine:
+    """ engine for source """
+
+    if source is None:
+        source = default_source()
+
+    entries = entry_points(group=ENTRY_POINTS, name=source)
+
+    if not entries:
+        raise ValueError(f"No price engine for {source=}")
+
+    entry = tuple(entries)[0]
+
+    engine: PriceEngine = entry.load()(source=source)
+
+    return engine
+
+
+def get_prices(ticker: str, freq: str = 'daily', *,
+               source=None, start_date=None, end_date=None,
+               max_bars=None, adjusted=True):
+    """ get prices from default engine """
+
+    if freq is None:
+        freq = 'daily'
+
+    if source is None:
+        source = default_source(freq=freq)
+
+    engine = price_engine(source)
+
+    return engine.get_prices(
+        ticker, freq=freq,
+        start_date=start_date,
+        end_date=end_date,
+        max_bars=max_bars,
+        adjusted=adjusted
+    )
+
+
+def collect_prices(tickers, *, freq='daily', source=None,
+                   start_date=None, end_date=None,
+                   max_bars=None, use_threads=True):
+    """ yields ticker, prices pais overs list of tickers  """
+
+    if source is None:
+        source = default_source(freq=freq)
+
+    kwds = dict(
+        freq=freq,
+        source=source,
+        start_date=start_date,
+        end_date=end_date,
+        max_bars=max_bars
+    )
+
+    if use_threads:
+        executor = ThreadPoolExecutor()
+
+        fvmap = {
+            executor.submit(get_prices, ticker, **kwds): ticker
+            for ticker in tickers
+        }
+
+        for fv in as_completed(fvmap):
+            ticker = fvmap[fv]
+            prices = fv.result()
+            if prices is not None:
+                yield ticker, prices
+    else:
+        for ticker in tickers:
+            prices = get_prices(ticker, **kwds)
+            if prices is not None:
+                yield ticker, prices
+
+
+def combine_prices(tickers, *, freq='daily', source=None, item='close',
+                   max_bars=None, period=None, resample=None,
+                   pct_change=False, log_returns=False,
+                   use_threads=True):
+    """
+    matrix of closing prices aligned by date
+    to insure better aliognement use resample instead of freq
+    """
+
+    data = {
+        k: v[item]
+        for k, v in collect_prices(
+            tickers,
+            freq=freq,
+            source=source,
+            max_bars=max_bars,
+            use_threads=use_threads
+        )
+    }
+
+    result = pd.DataFrame(data).dropna()
+
+    if resample is not None:
+        rule = pandas_freq(resample)
+        result = result.resample(rule).agg('last')
+
+    if period:
+        delta = quick_timedelta(period)
+        enddate = result.index[-1]
+        begdate = enddate - delta
+        result = result.loc[begdate:]
+
+    if log_returns:
+        result = result.apply(np.log).diff().dropna()
+
+    if pct_change:
+        result = result.apply(np.log).diff().dropna().apply(np.exp) - 1
+
+    return result

bardata/sample.py

@@ -0,0 +1,170 @@
+""" sample routines """
+
+import string
+import itertools
+
+import numpy as np
+import pandas as pd
+import datetime as dt
+
+from . import model
+from .freqs import pandas_freq, split_frequency
+
+DEFAULT_MAX_DATES = 500
+
+MAXIMUM_PERIODS = dict(
+    day=5000,
+    week=1000,
+    month=200,
+    hour=20000,
+    minute=20000
+)
+
+
+def maximum_periods(freq: str):
+    count, freq = split_frequency(freq)
+    return MAXIMUM_PERIODS.get(freq, 200) / count
+
+
+def sample_dates(max_dates=None, freq=None, *,
+                 start_date=None, end_date=None):
+    """ sample dates (wrapper around pandas date_range) """
+
+    if freq is None:
+        freq = 'daily'
+
+    if not start_date and not end_date:
+        end_date = dt.date.today()
+
+    if start_date and end_date:
+        periods = None
+    elif max_dates:
+        periods = max_dates
+    else:
+        periods = DEFAULT_MAX_DATES
+
+    max_periods = maximum_periods(freq)
+    if periods > max_periods:
+        periods = max_periods
+
+    freq = pandas_freq(freq)
+
+    if isinstance(start_date, str):
+        start_date = pd.to_datetime(start_date)
+
+    if isinstance(end_date, str):
+        end_date = pd.to_datetime(end_date)
+
+    dates = pd.date_range(periods=periods, start=start_date, end=end_date, freq=freq)
+
+    if max_dates and len(dates) > max_dates:
+        dates = dates[-max_dates:]
+
+    return dates
+
+
+def random_walk(max_bars=None, freq='daily', *,
+                start_date=None, end_date=None,
+                start_value=100.0, volatility=0.20, fwd_rate=0.10,
+                name=None, seed=None):
+    """ series of random walk prices """
+
+    generator = np.random.default_rng(seed)
+
+    dates = sample_dates(freq=freq, max_dates=max_bars, start_date=start_date, end_date=end_date)
+    count = len(dates)
+
+    avgdelta = dates.diff().mean()
+    sampling = pd.Timedelta(days=365) / avgdelta
+
+    fwd = np.log(1 + fwd_rate) / sampling
+    std = volatility / np.sqrt(sampling)
+
+    change = generator.standard_normal(count - 1) * std + np.log(1 + fwd)
+    price = start_value * np.exp(np.r_[0.0, change.cumsum(0)])
+
+    series = pd.Series(price, index=dates.values, name=name).rename_axis(index='date')
+
+    return series
+
+
+def sample_prices(max_bars=None, freq='daily', *,
+                  start_date=None, end_date=None,
+                  start_value=100.0, volatility=0.20, fwd_rate=0.10,
+                  skip=0, volume_as_int=True, seed=None):
+    """ dataframe of random prices """
+
+    generator = np.random.default_rng(seed)
+
+    dates = sample_dates(freq=freq, max_dates=max_bars, start_date=start_date, end_date=end_date)
+    count = len(dates)
+
+    avgdelta = dates.diff().mean()
+    sampling = pd.Timedelta(days=365) / avgdelta
+
+    fwd = np.log(1 + fwd_rate) / sampling
+    std = volatility / np.sqrt(sampling)
+
+    rnd = generator.standard_normal((count, 4)).cumsum(1) * std + fwd
+    cum = np.r_[0.0, rnd[:, -1].cumsum(0)[:-1]]
+
+    op = start_value * np.exp(rnd[:, 0] + cum)
+    hi = start_value * np.exp(rnd.max(1) + cum)
+    lo = start_value * np.exp(rnd.min(1) + cum)
+    cl = start_value * np.exp(rnd[:, -1] + cum)
+
+    vol = np.exp(generator.standard_normal(count) * 0.2 + 1.0) * 50000.0
+
+    data = dict()
+
+    data['date'] = dates.values
+    data['open'] = op.round(2)
+    data['high'] = hi.round(2)
+    data['low'] = lo.round(2)
+    data['close'] = cl.round(2)
+    data['volume'] = vol.astype(int) if volume_as_int else vol.round(2)
+
+    prices = pd.DataFrame(data).set_index('date')
+
+    if skip > 0:
+        prices.iloc[:skip] = np.nan
+
+    if skip < 0:
+        prices.iloc[skip:] = np.nan
+
+    return prices
+
+
+def sample_tickers(count=10, *, ticker_length=3):
+    """ sample tickers """
+
+    def ticker_generator(chars=string.ascii_uppercase):
+        for length in itertools.count(ticker_length):
+            for item in itertools.product(chars, repeat=length):
+                yield "".join(item)
+
+    tickers = ticker_generator()
+
+    return list(itertools.islice(tickers, count))
+
+
+class Prices(model.PriceEngine):
+    """ Price Engine """
+
+    def get_prices(self,
+                   ticker: str, freq: str = 'daily', *,
+                   start_date=None, end_date=None,
+                   max_bars=None, adjusted=True):
+        prices = sample_prices(freq=freq, max_bars=max_bars,
+                               start_date=start_date, end_date=end_date)
+        return prices
+
+
+class Tickers(model.TickerHandler):
+    """ Ticker Handler """
+
+    def get_tickers(self, moniker: str = None):
+        if moniker is not None:
+            raise ValueError(f"Moniker {moniker!r} unexppected")
+        tickers = sample_tickers()
+        return tickers

bardata/tickers.py

@@ -0,0 +1,45 @@
+""" ticker data """
+
+import sys
+
+from functools import lru_cache
+
+from .model import TickerHandler
+
+if sys.version_info < (3, 10):
+    from importlib_metadata import entry_points
+else:
+    from importlib.metadata import entry_points
+
+DEFAULT_SOURCE = "rawdata"
+ENTRY_POINTS = "bardata_tickers"
+
+
+@lru_cache
+def default_source() -> str:
+    return DEFAULT_SOURCE
+
+
+@lru_cache
+def ticker_handler(source: str = None) -> TickerHandler:
+    if source is None:
+        source = default_source()
+
+    entries = entry_points(group=ENTRY_POINTS, name=source)
+
+    if not entries:
+        raise ValueError(f"No ticker engine for {source=}")
+
+    entry = list(entries)[0]
+
+    engine: TickerHandler = entry.load()(source)
+
+    return engine
+
+
+def get_tickers(moniker: str = None, *, source: str = None):
+    """ tickers for index/portfolio symbol """
+
+    handler = ticker_handler(source=source)
+
+    return handler.get_tickers(moniker)

bardata/utils.py

@@ -0,0 +1,289 @@
+""" utility routines """
+
+import logging
+import warnings
+
+import numpy as np
+import pandas as pd
+
+from .freqs import pandas_freq
+
+logger = logging.getLogger(__name__)
+
+
+def extract_dates(prices):
+    """ series of dates from column or index data """
+
+    if 'date' in prices:
+        dates = prices.get('date')
+
+    elif 'date' in prices.index.names:
+        dates = prices.index.get_level_values('date').to_series(index=prices.index)
+
+    else:
+        raise ValueError("Dataframe has no date column or index!")
+
+    return dates
+
+
+def date_offset(prices, *, delta=None, warn=True):
+    """
+    relative date offset from a prices dataframe
+
+    Returns:
+        a series of integers
+    """
+
+    dates = extract_dates(prices)
+
+    if delta is None:
+        delta = dates.drop_duplicates().sort_values().diff().min()
+
+    minutes = delta / pd.Timedelta(minutes=1)
+
+    if warn and minutes not in (1, 2, 5, 10, 15, 30, 60, 120, 1440):
+        warnings.warn(
+            f"Implied timedelta {delta} not standard. Use delta parameter!",
+            stacklevel=2
+        )
+
+    lastd = dates.max()
+
+    offset = (lastd - dates) / delta
+
+    return offset
+
+
+def get_sampling(prices, basis=365):
+    """ average yearly sampling rate """
+
+    dates = extract_dates(prices)
+
+    period = dates.diff().mean()
+
+    return pd.Timedelta(days=basis) / period
+
+
+def resample_prices(prices, freq):
+    """ resample prices """
+
+    freq = pandas_freq(freq)
+
+    aggspec = dict(open='first', high='max', low='min', close='last', volume='sum')
+    prices = prices.resample(freq).agg(aggspec).dropna(subset=['close'])
+
+    return prices
+
+
+def concat_prices(frames, convert_utc=True, remove_duplicates=True):
+    """ concatanate prices and remove duplicates """
+
+    if convert_utc:
+        frames = [f.tz_convert('UTC') for f in frames]
+
+    prices = pd.concat(frames)
+
+    if remove_duplicates:
+        prices = prices[~prices.index.duplicated(keep='last')]
+
+    return prices
+
+
+def adjust_prices(prices, splits=None, include_divs=False, inplace=False):
+    """ adjust prices using split_factor and div_pct """
+
+    if splits is None:
+        splits = prices
+
+    split_factor = splits.split_factor.fillna(1.0)
+
+    if include_divs and hasattr(splits, 'div_pct'):
+        div_pct = splits.div_pct.fillna(0.0)
+        split_factor = split_factor * (div_pct + 1.0)
+
+    cumprod = split_factor[::-1].cumprod()[::-1]
+
+    bak_adjust, adj_factor = cumprod.iloc[0], cumprod.shift(-1).fillna(1.0)
+
+    if splits is not None:
+        adj_factor = adj_factor.asof(prices.index).fillna(bak_adjust)
+
+    if not inplace:
+        prices = prices.copy()
+
+    for column in ['open', 'high', 'low', 'close', 'vwap', 'price', 'mid']:
+        if column in prices:
+            prices[column] /= adj_factor
+
+    for column in ['volume']:
+        if column in prices:
+            prices[column] *= adj_factor
+
+    return prices
+
+
+def extract_splits(prices):
+    """ extracts split & dividend data from daily prices """
+
+    split_factor = prices.split_factor.fillna(1.0)
+    columns = [split_factor]
+    mask = (split_factor != 1.0)
+
+    if hasattr(prices, 'div_pct'):
+        div_pct = prices.div_pct
+    elif hasattr(prices, 'div_cash'):
+        div_pct = prices.div_cash / prices.close
+    else:
+        div_pct = None
+
+    if div_pct is not None:
+        div_pct = div_pct.fillna(0.0)
+        columns.append(div_pct)
+        mask = mask | (div_pct != 0.0)
+
+    if np.any(mask):
+        splits = pd.concat(columns, axis=1)[mask]
+        return splits
+
+    return None
+
+
+def price_gaps(prices, resample_freq=None):
+    """ price gaps in series """
+
+    if resample_freq is not None:
+        prices = resample_prices(prices, freq=resample_freq)
+
+    if not prices.index.is_monotonic_increasing:
+        raise ValueError("Data is not ordered!")
+
+    if 'adj_close' in prices:
+        close = prices.adj_close
+        trange = prices.adj_high / prices.adj_low - 1.0
+    else:
+        close = prices.close
+        trange = prices.high / prices.low - 1.0
+
+    change = close.pct_change()
+
+    std = change.rolling(30).std()
+
+    max_change = 0.25
+
+    mask = (change.abs() > max_change) & \
+           (change.abs() > std * 5.0) & \
+           (change.abs() > trange * 2.0)
+
+    result = change[mask].rename("price gap")
+
+    return result
+
+
+def time_gaps(prices, max_days=7):
+    """ time gaps in series """
+
+    dates = prices.index.to_series()
+    dspan = dates.diff()
+
+    result = dspan[dspan > pd.Timedelta(days=max_days)].rename("time gap")
+
+    return result
+
+
+def check_prices(prices, ticker='series', warn=True, verbose=False):
+    """ check prices for possible gaps in price or time """
+
+    if prices is None:
+        return False
+
+    result = True
+
+    pgaps = price_gaps(prices)
+    tgaps = time_gaps(prices)
+
+    if len(pgaps):
+        result = False
+        if warn:
+            warnings.warn(
+                f"{ticker} has {len(pgaps)} price gaps!",
+                stacklevel=2
+            )
+        if verbose:
+            print(pgaps)
+
+    if len(tgaps):
+        result = False
+        if warn:
+            warnings.warn(
+                f"{ticker} has {len(tgaps)} time gaps!",
+                stacklevel=2
+            )
+        if verbose:
+            print(tgaps)
+
+    return result
+
+
+def fix_price_gaps(prices, gaps=None, verbose=None):
+    """ fixes price gaps """
+
+    if gaps is None:
+        gaps = price_gaps(prices)
+
+    if gaps.empty:
+        logger.debug("No gaps found!")
+        return prices
+
+    gaps = gaps.reindex_like(prices).fillna(0.0)
+
+    if verbose:
+        for ts, gap in gaps[gaps != 0].iteritems():
+            print("Correcting gap of {gap} on {date}...".format(date=ts.date(), gap=gap))
+
+    factor = 1.0 / (1.0 + gaps)
+    factor = factor.shift(-1, fill_value=1.0)
+    factor = factor[::-1].cumprod()[::-1]
+
+    for col in ['open', 'high', 'low', 'close']:
+        if col in prices:
+            prices[col] /= factor
+
+    for col in ['volume']:
+        if col in prices:
+            prices[col] *= factor
+
+    return prices
+
+
+def append_quote(prices, quote):
+    """ append quote (dict with timestamp) to prices (df) """
+
+    ts = quote.get('timestamp')
+
+    if not ts:
+        raise ValueError("timestamp is missing!")
+
+    date = pd.to_datetime(ts[:10])
+
+    if date <= prices.index[-1]:
+        return
+
+    record = dict(quote, close=quote['last'], split_factor=1.0, div_pct=0.0)
+    record = {k: record.get(k) for k in prices.columns if k in record}
+
+    prices.loc[date] = record
+
+
+def slice_prices(prices, start_date=None, end_date=None, max_bars=None):
+    """ slice prices dataframe """
+
+    if start_date is not None:
+        prices = prices.loc[start_date:]
+
+    if end_date is not None:
+        prices = prices.loc[:end_date]
+
+    if max_bars:
+        prices = prices.tail(max_bars)
+
+    return prices

bardata-0.0.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: bardata
+Version: 0.0.1
+Summary: Bar data manipulation utilities
+Author-email: Furechan <furechan@xsmail.com>
+License: Copyright (c) 2016 The Python Packaging Authority (PyPA)
+        
+        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.
+License-File: LICENSE.txt
+Keywords: data,finance
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: importlib-metadata; python_version < '3.10'
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: python-dateutil
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Bar data utilities in Python
+
+This package includes utilities and a plugin model to fetch and manipulate bar data
+for stocks and other financial series. This is work in progress.
+
+Bar data is represented as a datafrane with a `date` timestamp index
+and `open`, `high`, `low`, `close`, `volume` columns all in lower case.
+Data for stocks prices is always assumed adjusted.
+
+The main conventions are:
+- data sources are referenced by an opaque `source` parameter
+- flexible definition of frequencies with the `freq` parameter
+- maximum number of bars is indicated with the `max_bars` parameter
+- date range is optional with `start_date` and `end_date` parameters
+
+## Typical Usage
+
+```python
+from bardata import get_tickers, get_prices
+
+SOURCE = 'sample'
+FREQ = 'daily'
+
+tickers = get_tickers(source=SOURCE)
+
+for ticker in tickers:
+    prices = get_prices(ticker, freq=FREQ, source=SOURCE)
+    ...
+```
+
+

bardata-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+bardata/__init__.py,sha256=6riuYC6jI1-k1ezMLCxkFwOtqjIMuBUqemnIS-cS67w,158
+bardata/dates.py,sha256=wLdElD_wHfAVVkif6pI5KULqyPImdsMz0IDZULBgKK0,3122
+bardata/errors.py,sha256=rgCGFKV4iffDAwhK32WLKFFaditPa7zv-FPZ39T8tqI,99
+bardata/freqs.py,sha256=IOxsuDChmKKI2QPQjbBq5w4kUIH0cZeLsZ3c82G5waw,1292
+bardata/model.py,sha256=Cl-vbVcqiSHM5tEGzlTyLTbUErI1h1ctTTz1nJqLVvY,668
+bardata/prices.py,sha256=DHLy-wBzzS2BjNaIzKR4zamGeM-IxJ4hofRlYENg3vI,3909
+bardata/sample.py,sha256=PmmIj_PGKiG2vhoX_zEezRK_GM_mzX5hvDmN-MOsJdM,4636
+bardata/tickers.py,sha256=kzeSnpp6ItkxhMdPpy7D6QVVWN1RJo1Ll-0GImSSFDo,926
+bardata/utils.py,sha256=3kLIYqbr3oNr7wvFyPZSzQhpge_Oi0YhQKXEXwkGapo,6823
+bardata-0.0.1.dist-info/METADATA,sha256=JxfM_8-laLtgLleyCt_gf_EkY0Jgu3j6zYAYEmN_ICg,2593
+bardata-0.0.1.dist-info/WHEEL,sha256=mRYSEL3Ih6g5a_CVMIcwiF__0Ae4_gLYh01YFNwiq1k,87
+bardata-0.0.1.dist-info/entry_points.txt,sha256=HPQcVQg4NHicE3kKH6xE7k7eK5-NVeU99tg2ctcFVNI,99
+bardata-0.0.1.dist-info/licenses/LICENSE.txt,sha256=ceC9ZJOV9H6CtQDcYmHOS46NA3dHJ_WD4J9blH513pc,1081
+bardata-0.0.1.dist-info/RECORD,,

bardata-0.0.1.dist-info/WHEEL

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

bardata-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[bardata_prices]
+sample = bardata.sample:Prices
+
+[bardata_tickers]
+sample = bardata.sample:Tickers

bardata-0.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2016 The Python Packaging Authority (PyPA)
+
+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.