earningscall 0.0.4__py3-none-any.whl

earningscall/__init__.py

@@ -0,0 +1,2 @@
+from earningscall.symbols import Symbols, load_symbols
+from earningscall.exports import get_company, get_all_companies

earningscall/api.py

@@ -0,0 +1,67 @@
+import logging
+import os
+from typing import Optional
+
+import requests
+
+
+log = logging.getLogger(__file__)
+
+DOMAIN = os.environ.get("ECALL_DOMAIN", "earningscall.biz")
+API_BASE = f"https://v2.api.{DOMAIN}"
+api_key: Optional[str] = None
+
+
+def get_api_key():
+    global api_key
+    if api_key is None:
+        return os.environ.get("ECALL_API_KEY", "demo")
+    return api_key
+
+
+def get_events(exchange: str,
+               symbol: str):
+
+    log.debug(f"get_events exchange: {exchange} symbol: {symbol}")
+    params = {
+        "apikey": get_api_key(),
+        "exchange": exchange,
+        "symbol": symbol,
+    }
+    response = requests.get(f"{API_BASE}/events", params=params)
+    if response.status_code != 200:
+        return None
+    return response.json()
+
+
+def get_transcript(exchange: str,
+                   symbol: str,
+                   year: int,
+                   quarter: int) -> Optional[str]:
+
+    log.debug(f"get_transcript year: {year} quarter: {quarter}")
+    params = {
+        "apikey": "demo",
+        "exchange": exchange,
+        "symbol": symbol,
+        "year": str(year),
+        "quarter": str(quarter),
+    }
+    response = requests.get(f"{API_BASE}/transcript", params=params)
+    if response.status_code != 200:
+        return None
+    return response.json()
+
+
+def get_symbols_v1():
+    response = requests.get(f"{API_BASE}/symbols.txt")
+    if response.status_code != 200:
+        return None
+    return response.text
+
+
+def get_symbols_v2():
+    response = requests.get(f"{API_BASE}/symbols-v2.txt")
+    if response.status_code != 200:
+        return None
+    return response.text

earningscall/company.py

@@ -0,0 +1,51 @@
+import logging
+from typing import Optional
+
+from earningscall import api
+from earningscall.event import EarningsEvent
+from earningscall.symbols import CompanyInfo
+from earningscall.transcript import Transcript
+
+log = logging.getLogger(__file__)
+
+
+class Company:
+
+    company_info: CompanyInfo
+    name: str
+    _events: [EarningsEvent]
+
+    def __init__(self, company_info):
+        self.company_info = company_info
+        self.name = company_info.name
+        self._events = None
+
+    def __str__(self):
+        return str(self.name)
+
+    def name(self) -> str:
+        return self.company_info.name
+
+    def _get_events(self):
+        raw_response = api.get_events(self.company_info.exchange, self.company_info.symbol)
+        return [EarningsEvent.from_dict(event) for event in raw_response["events"]]
+
+    def events(self) -> [EarningsEvent]:
+        if not self._events:
+            self._events = self._get_events()
+        return self._events
+
+    def get_transcript(self,
+                       year: Optional[int] = None,
+                       quarter: Optional[int] = None,
+                       event: Optional[EarningsEvent] = None) -> Optional[Transcript]:
+
+        if (not year or not quarter) and event:
+            year = event.year
+            quarter = event.quarter
+        elif (not year or not quarter) and not event:
+            raise ValueError("Must specify either event or year and quarter")
+        resp = api.get_transcript(self.company_info.exchange, self.company_info.symbol, year, quarter)
+        if not resp:
+            return None
+        return Transcript.from_dict(resp)

earningscall/errors.py

@@ -0,0 +1,25 @@
+
+
+class BaseError(RuntimeError):
+    """
+    Base error
+    """
+
+    def __init__(self, msg=None):
+        self.msg = msg
+
+    def __str__(self):
+        if self.msg:
+            return str(self.msg)
+        return ""
+
+
+class ClientError(BaseError):
+    """
+    Used to return 4XX errors.
+    """
+    status: int = 400  # https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400
+
+
+class MissingApiKeyError(ClientError):
+    pass

earningscall/event.py

@@ -0,0 +1,28 @@
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+from dataclasses_json import config
+from dataclasses_json import dataclass_json
+from marshmallow import fields
+
+log = logging.getLogger(__file__)
+
+
+@dataclass_json
+@dataclass
+class EarningsEvent:
+    """
+    EarningsEvent
+    """
+    year: int
+    quarter: int
+    conference_date: Optional[datetime] = field(
+        default=None,
+        metadata=config(
+            encoder=lambda date: date.isoformat() if date else None,
+            decoder=lambda date: datetime.fromisoformat(date) if date else None,
+            mm_field=fields.DateTime(format="iso")
+        )
+    )

earningscall/exports.py

@@ -0,0 +1,17 @@
+from earningscall.symbols import get_symbols
+
+from earningscall.company import Company
+
+
+def get_company(symbol: str) -> Company:
+    return Company(company_info=get_symbols().lookup_company(symbol))
+
+
+def get_all_companies() -> [Company]:
+    for company_info in get_symbols().get_all():
+        yield Company(company_info=company_info)
+
+
+def get_sp500_companies() -> [Company]:
+    for company_info in get_symbols().get_all():
+        yield Company(company_info=company_info)

earningscall/sectors.py

@@ -0,0 +1,234 @@
+import json
+import logging
+
+
+log = logging.getLogger(__file__)
+sectors_file_name = "sectors.json"
+
+
+SECTORS_IN_ORDER = [
+    'Basic Materials',
+    'Communication Services',
+    'Consumer Cyclical',
+    'Consumer Defensive',
+    'Energy',
+    'Financial Services',
+    'Healthcare',
+    'Industrials',
+    'Real Estate',
+    'Technology',
+    'Utilities'
+]
+
+
+INDUSTRIES_IN_ORDER = [
+    'Advertising Agencies',
+    'Aerospace & Defense',
+    'Agricultural Inputs',
+    'Airlines',
+    'Airports & Air Services',
+    'Aluminum',
+    'Apparel Manufacturing',
+    'Apparel Retail',
+    'Asset Management',
+    'Auto & Truck Dealerships',
+    'Auto Manufacturers',
+    'Auto Parts',
+    'Banks - Diversified',
+    'Banks - Regional',
+    'Beverages - Brewers',
+    'Beverages - Non-Alcoholic',
+    'Beverages - Wineries & Distilleries',
+    'Biotechnology',
+    'Broadcasting',
+    'Building Materials',
+    'Building Products & Equipment',
+    'Business Equipment & Supplies',
+    'Capital Markets',
+    'Chemicals',
+    'Coking Coal',
+    'Communication Equipment',
+    'Computer Hardware',
+    'Confectioners',
+    'Conglomerates',
+    'Consulting Services',
+    'Consumer Electronics',
+    'Copper',
+    'Credit Services',
+    'Department Stores',
+    'Diagnostics & Research',
+    'Discount Stores',
+    'Drug Manufacturers - General',
+    'Drug Manufacturers - Specialty & Generic',
+    'Education & Training Services',
+    'Electrical Equipment & Parts',
+    'Electronic Components',
+    'Electronic Gaming & Multimedia',
+    'Electronics & Computer Distribution',
+    'Engineering & Construction',
+    'Entertainment',
+    'Farm & Heavy Construction Machinery',
+    'Farm Products',
+    'Financial Conglomerates',
+    'Financial Data & Stock Exchanges',
+    'Food Distribution',
+    'Footwear & Accessories',
+    'Furnishings, Fixtures & Appliances',
+    'Gambling',
+    'Gold',
+    'Grocery Stores',
+    'Health Information Services',
+    'Healthcare Plans',
+    'Home Improvement Retail',
+    'Household & Personal Products',
+    'Industrial Distribution',
+    'Information Technology Services',
+    'Infrastructure Operations',
+    'Insurance - Diversified',
+    'Insurance - Life',
+    'Insurance - Property & Casualty',
+    'Insurance - Reinsurance',
+    'Insurance - Specialty',
+    'Insurance Brokers',
+    'Integrated Freight & Logistics',
+    'Internet Content & Information',
+    'Internet Retail',
+    'Leisure',
+    'Lodging',
+    'Lumber & Wood Production',
+    'Luxury Goods',
+    'Marine Shipping',
+    'Medical Care Facilities',
+    'Medical Devices',
+    'Medical Distribution',
+    'Medical Instruments & Supplies',
+    'Metal Fabrication',
+    'Mortgage Finance',
+    'Oil & Gas Drilling',
+    'Oil & Gas E&P',
+    'Oil & Gas Equipment & Services',
+    'Oil & Gas Integrated',
+    'Oil & Gas Midstream',
+    'Oil & Gas Refining & Marketing',
+    'Other Industrial Metals & Mining',
+    'Other Precious Metals & Mining',
+    'Packaged Foods',
+    'Packaging & Containers',
+    'Paper & Paper Products',
+    'Personal Services',
+    'Pharmaceutical Retailers',
+    'Pollution & Treatment Controls',
+    'Publishing',
+    'REIT - Diversified',
+    'REIT - Healthcare Facilities',
+    'REIT - Hotel & Motel',
+    'REIT - Industrial',
+    'REIT - Mortgage',
+    'REIT - Office',
+    'REIT - Residential',
+    'REIT - Retail',
+    'REIT - Specialty',
+    'Railroads',
+    'Real Estate - Development',
+    'Real Estate - Diversified',
+    'Real Estate Services',
+    'Recreational Vehicles',
+    'Rental & Leasing Services',
+    'Residential Construction',
+    'Resorts & Casinos',
+    'Restaurants',
+    'Scientific & Technical Instruments',
+    'Security & Protection Services',
+    'Semiconductor Equipment & Materials',
+    'Semiconductors',
+    'Shell Companies',
+    'Silver',
+    'Software - Application',
+    'Software - Infrastructure',
+    'Solar',
+    'Specialty Business Services',
+    'Specialty Chemicals',
+    'Specialty Industrial Machinery',
+    'Specialty Retail',
+    'Staffing & Employment Services',
+    'Steel',
+    'Telecom Services',
+    'Textile Manufacturing',
+    'Thermal Coal',
+    'Tobacco',
+    'Tools & Accessories',
+    'Travel Services',
+    'Trucking',
+    'Uranium',
+    'Utilities - Diversified',
+    'Utilities - Independent Power Producers',
+    'Utilities - Regulated Electric',
+    'Utilities - Regulated Gas',
+    'Utilities - Regulated Water',
+    'Utilities - Renewable',
+    'Waste Management'
+]
+
+
+def sector_to_index(_sector: str) -> int:
+    try:
+        return SECTORS_IN_ORDER.index(_sector)
+    except ValueError:
+        return -1
+
+
+def index_to_sector(_index: int) -> str:
+    if _index == -1:
+        return "UNKNOWN"
+    return SECTORS_IN_ORDER[_index]
+
+
+def index_to_industry(_index: int) -> str:
+    if _index == -1:
+        return "UNKNOWN"
+    return INDUSTRIES_IN_ORDER[_index]
+
+
+def industry_to_index(_industry: str) -> int:
+    try:
+        return INDUSTRIES_IN_ORDER.index(_industry)
+    except ValueError:
+        return -1
+
+
+class Sectors:
+
+    def __init__(self,
+                 sectors: set = None,
+                 industries: set = None):
+        if sectors:
+            self.sectors = sectors
+        else:
+            self.sectors = set()
+        if industries:
+            self.industries = industries
+        else:
+            self.industries = set()
+
+    def add_sector(self, sector: str):
+        if sector is not None:
+            self.sectors.add(sector)
+
+    def add_industry(self, industry: str):
+        if industry is not None:
+            self.industries.add(industry)
+
+    def to_dicts(self) -> {}:
+        return {
+            "sectors": list(self.sectors),
+            "industries": list(self.industries),
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dicts())
+
+    @staticmethod
+    def from_json(json_str):
+        data = json.loads(json_str)
+        return Sectors(set(data["sectors"]), set(data["industries"]))
+

earningscall/symbols.py

@@ -0,0 +1,226 @@
+import json
+import logging
+import re
+from collections import defaultdict
+from typing import Optional
+
+from earningscall.api import get_symbols_v2
+from earningscall.sectors import sector_to_index, industry_to_index, index_to_sector, index_to_industry
+
+# WARNING: Add new indexes to the *END* of this list
+EXCHANGES_IN_ORDER = ["NYSE", "NASDAQ", "AMEX", "TSX", "TSXV", "OTC"]
+
+log = logging.getLogger(__file__)
+
+
+def exchange_to_index(_exchange: str) -> int:
+    try:
+        return EXCHANGES_IN_ORDER.index(_exchange)
+    except ValueError:
+        return -1
+
+
+def index_to_exchange(_index: int) -> str:
+    if _index == -1:
+        return "UNKNOWN"
+    return EXCHANGES_IN_ORDER[_index]
+
+
+security_type_pattern = {
+    "NASDAQ": r" - .*$",
+    "NYSE": r" (Common Stock|Warrants)$",
+    "AMEX": r" (Common Stock|Warrants)$",
+}
+
+
+class CompanyInfo:
+
+    exchange: Optional[str]
+    symbol: Optional[str]
+    name: Optional[str]
+    security_name: Optional[str]
+    sector: Optional[str]
+    industry: Optional[str]
+
+    def __init__(self, **kwargs):
+        self.exchange = None
+        self.name = None
+        self.security_name = None
+        self.sector = None
+        self.industry = None
+        for key, value in kwargs.items():
+            self.__setattr__(key, value)
+        # If name is not set upon initialization, we'll set it from the security name.  Also, include
+        # sanitization (removing "Common Stock" from the security name for example)
+        if not self.name:
+            if self.exchange == "OTC":
+                self.security_name = self.security_name.title()
+            if self.exchange in security_type_pattern:
+                self.name = re.sub(security_type_pattern[self.exchange], "", self.security_name)
+            else:
+                self.name = self.security_name
+
+    def __str__(self):
+        return f"({self.exchange}: {self.symbol} - {self.name})"
+
+    def to_json(self):
+        return json.dumps(self.__dict__)
+
+    def to_txt_row(self):
+        return [
+            str(exchange_to_index(self.exchange)),
+            self.symbol,
+            self.name,
+        ]
+
+    def to_txt_v2_row(self):
+        return [
+            str(exchange_to_index(self.exchange)),
+            self.symbol,
+            self.name,
+            str(sector_to_index(self.sector)),
+            str(industry_to_index(self.industry)),
+        ]
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+    def __hash__(self):
+        k = self.__dict__.keys()
+        sorted(k)
+        return sum(map(lambda x: f"{x}-{self.__dict__[x]}".__hash__(), k))
+
+    def exchange_symbol(self):
+        return f"{self.exchange}_{self.symbol}"
+
+
+class Symbols:
+
+    def __init__(self):
+        self.exchanges = set()
+        self.by_name = defaultdict(set)
+        self.by_exchange_and_sym = {}
+
+    def add(self, _sym: CompanyInfo):
+        size_before = len(self.by_exchange_and_sym)
+        self.exchanges.add(_sym.exchange)
+        self.by_name[_sym.name].add(_sym)
+        self.by_exchange_and_sym[f"{_sym.exchange}_{_sym.symbol}"] = _sym
+        if len(self.by_exchange_and_sym) == size_before:
+            log.debug(f"Duplicate: {_sym}")
+
+    def get_all(self) -> [CompanyInfo]:
+        for _exchange_symbol, _symbol in self.by_exchange_and_sym.items():
+            yield _symbol
+
+    def get(self, _exchange: str, _symbol: str) -> CompanyInfo:
+        return self.get_exchange_symbol(f"{_exchange}_{_symbol}")
+
+    def get_exchange_symbol(self, exchange_symbol: str) -> CompanyInfo:
+        return self.by_exchange_and_sym[exchange_symbol]
+
+    def lookup_company(self, symbol: str) -> Optional[CompanyInfo]:
+        for exchange in EXCHANGES_IN_ORDER:
+            try:
+                _symbol = self.get(exchange, symbol.upper())
+                if _symbol:
+                    return _symbol
+            except KeyError:
+                pass
+        return None
+
+    def remove_exchange_symbol(self, exchange_symbol: str):
+        _symbol = self.by_exchange_and_sym[exchange_symbol]
+        del self.by_name[_symbol.name]
+        del self.by_exchange_and_sym[exchange_symbol]
+
+    @staticmethod
+    def remove_keys(symbol_as_dict: dict, keys_to_remove: set):
+        return {key: value for key, value in symbol_as_dict.items() if key not in keys_to_remove}
+
+    def without_security_names(self) -> [dict]:
+        return [self.remove_keys(symbol_as_dict, {"security_name", "sector", "industry"})
+                for symbol_as_dict in self.to_dicts()]
+
+    def to_dicts(self) -> [dict]:
+        return [__symbol.__dict__ for __symbol in self.get_all()]
+
+    def to_json(self, remove_security_names: bool = False) -> str:
+        if remove_security_names:
+            return json.dumps(self.without_security_names())
+        return json.dumps(self.to_dicts())
+
+    def to_json_v2(self) -> str:
+        return json.dumps([[exchange_to_index(__symbol.exchange), __symbol.company_info, __symbol.name]
+                           for __symbol in self.get_all()])
+
+    def to_txt(self) -> str:
+        exchange_symbol_names = [__symbol.to_txt_row() for __symbol in self.get_all()]
+        sorted_rows = sorted(exchange_symbol_names, key=lambda row: row[1])
+        return "\n".join(["\t".join(row) for row in sorted_rows])
+
+    def to_txt_v2(self) -> str:
+        exchange_symbol_names = [__symbol.to_txt_v2_row() for __symbol in self.get_all()]
+        sorted_rows = sorted(exchange_symbol_names, key=lambda row: row[1])
+        return "\n".join(["\t".join(row) for row in sorted_rows])
+
+    @staticmethod
+    def from_json(json_str):
+        __symbols = Symbols()
+        for item in json.loads(json_str):
+            __symbols.add(CompanyInfo(**item))
+        return __symbols
+
+    @staticmethod
+    def from_json_v2(json_str):
+        __symbols = Symbols()
+        for [_exchange_index, _symbol, _name] in json.loads(json_str):
+            __symbols.add(CompanyInfo(exchange=index_to_exchange(_exchange_index), symbol=_symbol, name=_name))
+        return __symbols
+
+    @staticmethod
+    def from_txt(txt_str):
+        __symbols = Symbols()
+        for line in txt_str.split("\n"):
+            _exchange_index, _symbol, _name = line.split("\t")
+            __symbols.add(CompanyInfo(exchange=index_to_exchange(int(_exchange_index)), symbol=_symbol, name=_name))
+        return __symbols
+
+    @staticmethod
+    def from_txt_v2(txt_str):
+        __symbols = Symbols()
+        for line in txt_str.split("\n"):
+            _exchange_index, _symbol, _name, _sector_index, _industry_index = line.split("\t")
+            __symbols.add(CompanyInfo(
+                exchange=index_to_exchange(int(_exchange_index)),
+                symbol=_symbol,
+                name=_name,
+                sector=index_to_sector(int(_sector_index)),
+                industry=index_to_industry(int(_industry_index)),
+            ))
+        return __symbols
+
+    @staticmethod
+    def load_txt_v2():
+        return Symbols.from_txt_v2(get_symbols_v2())
+
+    def __iter__(self):
+        for _exchange_symbol, _symbol in self.by_exchange_and_sym.items():
+            yield _symbol
+
+    def __len__(self):
+        return len(self.by_exchange_and_sym)
+
+
+def load_symbols() -> Symbols:
+    return Symbols.load_txt_v2()
+
+
+_symbols = None
+
+
+def get_symbols() -> Symbols:
+    global _symbols
+    if not _symbols:
+        _symbols = load_symbols()
+    return _symbols

earningscall/transcript.py

@@ -0,0 +1,14 @@
+import logging
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+log = logging.getLogger(__file__)
+
+
+@dataclass_json
+@dataclass
+class Transcript:
+
+    text: str
+

earningscall/utils.py

@@ -0,0 +1,15 @@
+import os
+import pathlib
+
+import earningscall
+
+
+def project_file_path(base_dir, file_name):
+    result = os.path.join(pathlib.Path(earningscall.__file__).resolve().parent.parent, base_dir)
+    if file_name is None:
+        return result
+    return os.path.join(result, file_name)
+
+
+def data_path(file_name=None):
+    return project_file_path("tests/data", file_name)

earningscall-0.0.4.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.3
+Name: earningscall
+Version: 0.0.4
+Summary: The EarningsCall Python library.
+Project-URL: Documentation, https://github.com/EarningsCall/earningscall-python
+Project-URL: Issues, https://github.com/EarningsCall/earningscall-python/issues
+Project-URL: Source, https://github.com/EarningsCall/earningscall-python
+Author-email: EarningsCall <dev@earningscall.biz>
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: dataclasses-json>=0.6.4
+Requires-Dist: dataclasses>=0.6
+Requires-Dist: more-itertools>=10.0.0
+Requires-Dist: requests>=2.30.0
+Description-Content-Type: text/markdown
+
+# EarningsCall Python Library
+
+The EarningsCall Python library provides convenient access to the EarningsCall API from
+applications written in the Python language. It includes a pre-defined set of
+classes for API resources that initialize themselves dynamically from API
+responses.
+
+# Installation
+
+You don't need this source code unless you want to modify the package. If you just want to use the package, just run:
+
+```sh
+pip install --upgrade earningscall
+```
+
+# Requirements
+
+* Python 3.8+ (PyPI supported)
+
+
+## Get Transcript for a Single Quarter
+
+```python
+from earningscall import get_company
+
+
+company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"
+
+transcript = company.get_transcript(year=2021, quarter=3)
+print(f"{company} Q3 2021 Transcript Text: \"{transcript.text[:100]}...\"")
+```
+
+Output
+
+```text
+Apple Inc. Q3 2021 Transcript Text: "Good day, and welcome to the Apple Q3 FY 2021 Earnings Conference Call. Today's call is being record..."
+```
+
+
+## Get All Transcripts for a company
+
+
+```python
+from earningscall import get_company
+
+
+company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"
+
+print(f"Getting all transcripts for: {company}..")
+# Retrieve all earnings conference call events for a company, and iterate through each one
+for event in company.events():
+    transcript = company.get_transcript(event)  # Fetch the earnings call transcript for this event
+    print(f"* Q{event.quarter} {event.year}")
+    if transcript:
+        print(f"  Transcript Text: \"{transcript.text[:100]}...\"")
+    else:
+        print(f"  No transcript found.")
+
+```
+
+Output
+
+```text
+Getting all transcripts for: Apple Inc...
+* Q4 2023
+  Transcript Text: "Good day and welcome to the Apple Q4 Fiscal Year 2023 earnings conference call. Today's call is bein..."
+* Q3 2023
+  Transcript Text: "Good day and welcome to the Apple Q3 Fiscal Year 2023 earnings conference call. Today's call is bein..."
+* Q2 2023
+  Transcript Text: "At this time for opening remarks and introductions, I would like to turn the call over to Suhasini T..."
+* Q1 2023
+
+  ...
+```
+
+
+
+## List All Companies
+
+```python
+from earningscall import get_all_companies
+
+for company in get_all_companies():
+    print(f"{company.company_info} -- {company.company_info.sector} -- {company.company_info.industry}")
+```

earningscall-0.0.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+earningscall/__init__.py,sha256=Hfh2BCnihAqfWV9niZrlfHmTNuL5tEKTW37bAXGLrF0,119
+earningscall/api.py,sha256=lBUzBUjq_WNt4DH1usszG6OYJtBQbGYOy6KY0ags8ZI,1613
+earningscall/company.py,sha256=fGbfh4S1m1K0rgkzpToYOrkPOZSJQieen6RJlSIvCjY,1610
+earningscall/errors.py,sha256=Y5LVdvOMz_FgCXu4gXnyHceGvQwWmjHbkbRU2dsgdtA,433
+earningscall/event.py,sha256=a5mcyfuCqPCopcKQUZ1HJyqHfAf-RNKnux_o68DIUHM,689
+earningscall/exports.py,sha256=bG2ehoILyGTUrgRleuub4tXkiVGUdUZgsmoJ6giQgj4,478
+earningscall/sectors.py,sha256=9aw14krRzdLJSTFC72Nwk3MQaXAIgkTBk5S-KTiki3U,5946
+earningscall/symbols.py,sha256=mYWVO3YcUEr6JDxoH238_lsz67QHJGhk-o6jN1ot7R4,7372
+earningscall/transcript.py,sha256=gV0Pqc9iilg4QQc89-ADEIcFQkQhFSnsJo8rvF7zKp0,192
+earningscall/utils.py,sha256=g0MI9apoAQ2L7Ccj91mOHUWAE7zFbAvWqHPMjMJesFk,367
+earningscall-0.0.4.dist-info/METADATA,sha256=1U9i621evx8KJEcdpm9iOgVV8Vrkeyr19APTa-DqTek,2935
+earningscall-0.0.4.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+earningscall-0.0.4.dist-info/licenses/LICENSE,sha256=ktEB_UcRMg2cQlX9wiDs544xWncWizwS9mEZuGsCLrM,1069
+earningscall-0.0.4.dist-info/RECORD,,

earningscall-0.0.4.dist-info/WHEEL

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

earningscall-0.0.4.dist-info/licenses/LICENSE

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