epsilab 0.1.0__tar.gz

epsilab-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+**.env
+**__pycache__
+**.logs
+/dist

epsilab-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Epsilab
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

epsilab-0.1.0/PKG-INFO

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: epsilab
+Version: 0.1.0
+Summary: Python SDK for Epsilab live portfolio data (signals, weights, trades).
+Project-URL: Homepage, https://www.epsilab.ai
+Author: Epsilab
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright 2025 Epsilab
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dotenv>=1.0.1
+Description-Content-Type: text/markdown
+
+# Epsilab Python SDK
+
+Minimal Python client and CLI for the Epsilab Website API (pass-through to Strategy-Engine). Auth uses an API key.
+
+## Install
+
+```bash
+pip install epsilab
+```
+
+### Install from source
+
+```bash
+cd /home/matthew/Epsilab/Epsilab-API
+python -m venv .venv && source .venv/bin/activate
+pip install --upgrade pip
+pip install .
+# or for development
+pip install -e .
+```
+
+## Environment
+
+Set these variables or pass explicitly to the client:
+
+- `EPSILAB_API_BASE` (default `https://www.epsilab.ai/api/ext/v1`)
+- `EPSILAB_API_KEY` (a user API key created in Account Settings)
+
+Note:
+- API access requires an active Pro subscription. Requests from accounts without Pro will be rejected.
+- Live endpoints are rate limited (e.g., ~1 request/second sustained with small bursts). Excessive requests will receive HTTP 429.
+- Use `nextEtaMin` from `get_live_status()` to poll intelligently. For example, if `nextEtaMin=80.07`, you can sleep ~80 minutes before the next refresh instead of tight-loop polling. The results will be the same.
+
+## Python Usage
+
+```python
+from epsilab import Epsilab
+
+client = Epsilab(api_base="https://www.epsilab.ai/api/ext/v1", api_key="<epsk_live_...>")
+
+# Note: Running the portfolio via API key is disabled. Use the website to initiate runs.
+
+# Fetch live data (typed models)
+latest = client.get_live_latest(return_results_if_fresh=True)          # epsilab.models.LiveLatest
+status = client.get_live_status()                                      # epsilab.models.LiveStatus
+signals = client.get_portfolio_signals(limit=500)                      # List[epsilab.models.PortfolioSignal]
+weights = client.get_portfolio_weights(limit=500)                      # List[epsilab.models.PortfolioWeight]
+trades = client.get_live_trades(status="PENDING,EXECUTED", include_positions=True)  # List[epsilab.models.PortfolioTrade]
+equity = client.get_live_equity(limit=200)                             # List[epsilab.models.EquityPoint]
+
+print(latest)
+```
+
+## CLI Usage
+
+```bash
+# Set API key in env
+export EPSILAB_API_KEY="<epsk_live_...>"
+```
+
+## Data models
+
+- `get_live_latest()` → `LiveLatest` with fields:
+  - `run_id: Optional[str]`
+  - `timeframe: Optional[str]`
+  - `signals: List[PortfolioSignal]`
+  - `weights: List[PortfolioWeight]`
+  - `fresh: Optional[bool]`
+  - `recomputed: Optional[bool]`
+
+- `get_live_status()` → `LiveStatus` with fields:
+  - `latest_run_id: Optional[str]`
+  - `timeframe: Optional[str]`
+  - `next_eta_minutes: Optional[float]`
+  - `counts: Dict[str, int]`
+
+- `get_portfolio_signals()` → `List[PortfolioSignal]` with fields:
+  - `symbol: str`, `signal_type: str`, `strength: Optional[float]`, `timestamp: Optional[str]`, `date: Optional[str]`
+
+- `get_portfolio_weights()` → `List[PortfolioWeight]` with fields:
+  - `symbol: str`, `final_weight: Optional[float]`, `raw_weight: Optional[float]`, `timestamp: Optional[str]`, `date: Optional[str]`
+
+- `get_live_trades()` → `List[PortfolioTrade]` with fields:
+  - `id: str`, `symbol: str`, `side: str`, `qty: Optional[float]`, `planned_price: Optional[float]`, `planned_at: Optional[str]`, `status: str`, `reasoning: Optional[str]`
+
+- `get_live_members()` → `List[PortfolioMember]` with fields:
+  - `strategy_id: str`, `effective_weight: Optional[float]`, `name: Optional[str]`, `visibility: Optional[str]`
+
+- `get_live_equity()` → `List[EquityPoint]` with fields:
+  - `date: str`, `value: float`
+
+All models expose `to_dict()`, `to_json()`, and `log()` helpers for convenient logging.

epsilab-0.1.0/README.md

@@ -0,0 +1,92 @@
+# Epsilab Python SDK
+
+Minimal Python client and CLI for the Epsilab Website API (pass-through to Strategy-Engine). Auth uses an API key.
+
+## Install
+
+```bash
+pip install epsilab
+```
+
+### Install from source
+
+```bash
+cd /home/matthew/Epsilab/Epsilab-API
+python -m venv .venv && source .venv/bin/activate
+pip install --upgrade pip
+pip install .
+# or for development
+pip install -e .
+```
+
+## Environment
+
+Set these variables or pass explicitly to the client:
+
+- `EPSILAB_API_BASE` (default `https://www.epsilab.ai/api/ext/v1`)
+- `EPSILAB_API_KEY` (a user API key created in Account Settings)
+
+Note:
+- API access requires an active Pro subscription. Requests from accounts without Pro will be rejected.
+- Live endpoints are rate limited (e.g., ~1 request/second sustained with small bursts). Excessive requests will receive HTTP 429.
+- Use `nextEtaMin` from `get_live_status()` to poll intelligently. For example, if `nextEtaMin=80.07`, you can sleep ~80 minutes before the next refresh instead of tight-loop polling. The results will be the same.
+
+## Python Usage
+
+```python
+from epsilab import Epsilab
+
+client = Epsilab(api_base="https://www.epsilab.ai/api/ext/v1", api_key="<epsk_live_...>")
+
+# Note: Running the portfolio via API key is disabled. Use the website to initiate runs.
+
+# Fetch live data (typed models)
+latest = client.get_live_latest(return_results_if_fresh=True)          # epsilab.models.LiveLatest
+status = client.get_live_status()                                      # epsilab.models.LiveStatus
+signals = client.get_portfolio_signals(limit=500)                      # List[epsilab.models.PortfolioSignal]
+weights = client.get_portfolio_weights(limit=500)                      # List[epsilab.models.PortfolioWeight]
+trades = client.get_live_trades(status="PENDING,EXECUTED", include_positions=True)  # List[epsilab.models.PortfolioTrade]
+equity = client.get_live_equity(limit=200)                             # List[epsilab.models.EquityPoint]
+
+print(latest)
+```
+
+## CLI Usage
+
+```bash
+# Set API key in env
+export EPSILAB_API_KEY="<epsk_live_...>"
+```
+
+## Data models
+
+- `get_live_latest()` → `LiveLatest` with fields:
+  - `run_id: Optional[str]`
+  - `timeframe: Optional[str]`
+  - `signals: List[PortfolioSignal]`
+  - `weights: List[PortfolioWeight]`
+  - `fresh: Optional[bool]`
+  - `recomputed: Optional[bool]`
+
+- `get_live_status()` → `LiveStatus` with fields:
+  - `latest_run_id: Optional[str]`
+  - `timeframe: Optional[str]`
+  - `next_eta_minutes: Optional[float]`
+  - `counts: Dict[str, int]`
+
+- `get_portfolio_signals()` → `List[PortfolioSignal]` with fields:
+  - `symbol: str`, `signal_type: str`, `strength: Optional[float]`, `timestamp: Optional[str]`, `date: Optional[str]`
+
+- `get_portfolio_weights()` → `List[PortfolioWeight]` with fields:
+  - `symbol: str`, `final_weight: Optional[float]`, `raw_weight: Optional[float]`, `timestamp: Optional[str]`, `date: Optional[str]`
+
+- `get_live_trades()` → `List[PortfolioTrade]` with fields:
+  - `id: str`, `symbol: str`, `side: str`, `qty: Optional[float]`, `planned_price: Optional[float]`, `planned_at: Optional[str]`, `status: str`, `reasoning: Optional[str]`
+
+- `get_live_members()` → `List[PortfolioMember]` with fields:
+  - `strategy_id: str`, `effective_weight: Optional[float]`, `name: Optional[str]`, `visibility: Optional[str]`
+
+- `get_live_equity()` → `List[EquityPoint]` with fields:
+  - `date: str`, `value: float`
+
+All models expose `to_dict()`, `to_json()`, and `log()` helpers for convenient logging.

epsilab-0.1.0/epsilab/__init__.py

@@ -0,0 +1,6 @@
+from .client import EpsilabClient as Epsilab
+from . import models
+
+__all__ = ["Epsilab", "models"]
+
+__version__ = "0.1.0"

epsilab-0.1.0/epsilab/__main__.py

@@ -0,0 +1,40 @@
+import argparse
+import json
+import os
+
+from dotenv import dotenv_values
+from epsilab.client import EpsilabClient
+
+
+def main():
+    # Read environment variables from .env (does not modify process env)
+    env = dotenv_values()
+
+    parser = argparse.ArgumentParser(prog="epsilab", description="Epsilab Strategy-Engine CLI")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    # run default portfolio
+    p_run = sub.add_parser("run-default-portfolio", help="Run user's default portfolio")
+    p_run.add_argument("--params", help="JSON dict of parameters to pass", default=None)
+
+    args = parser.parse_args()
+
+    client = EpsilabClient(
+        api_base=env.get("EPSILAB_API_BASE") or "https://www.epsilab.ai/api/ext/v1",
+        api_key=env.get("EPSILAB_API_KEY"),
+    )
+
+    if args.cmd == "run-default-portfolio":
+        # Require API key
+        api_key = env.get("EPSILAB_API_KEY")
+        if api_key:
+            client.set_api_key(api_key)
+        if not client._api_key:
+            raise SystemExit("Not authenticated. Set EPSILAB_API_KEY.")
+        params = json.loads(args.params) if args.params else None
+        result = client.run_default_portfolio(params)
+        print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

epsilab-0.1.0/epsilab/client.py

@@ -0,0 +1,155 @@
+import os
+import httpx
+from typing import Optional, Dict, Any, List
+from dotenv import dotenv_values
+from . import models
+from .exceptions import AuthError, SubscriptionRequiredError, RateLimitError, ApiError
+
+
+class EpsilabClient:
+    """
+    Minimal Python client for the Epsilab Website API (pass-through to Strategy-Engine).
+
+    - Auth via API key sent as X-API-Key
+    - Persistent HTTP/2 connection via httpx.Client
+    - Targets the Website API base (e.g. https://www.epsilab.ai/api/ext/v1)
+    """
+
+    def __init__(
+        self,
+        api_base: Optional[str] = None,
+        api_key: Optional[str] = None,
+        timeout_seconds: Optional[int] = None,
+    ) -> None:
+        # Read variables from .env without mutating process env
+        env = {}
+        try:
+            env = dotenv_values()
+        except Exception:
+            env = {}
+        # Prefer Website API base (pass-through proxy). Example: https://www.epsilab.ai/api/ext/v1
+        self.api_base = (
+            (api_base or env.get("EPSILAB_API_BASE") or "https://www.epsilab.ai/api/ext/v1").rstrip("/")
+        )
+        # Default to 300s, can be overridden by param or env EPSILAB_HTTP_TIMEOUT
+        env_timeout = env.get("EPSILAB_HTTP_TIMEOUT")
+        self.timeout_seconds = (
+            int(timeout_seconds)
+            if timeout_seconds is not None
+            else int(env_timeout) if env_timeout else 300
+        )
+        # API key auth (preferred for service usage)
+        self._api_key: Optional[str] = api_key or env.get("EPSILAB_API_KEY")
+        # Persistent client (HTTP/2) with keep-alive
+        self._client = httpx.Client(base_url=self.api_base, timeout=self._make_timeout(), http2=True)
+        # Apply auth headers if present
+        if self._api_key:
+            self._client.headers.update({"X-API-Key": self._api_key})
+
+    def _make_timeout(self) -> httpx.Timeout:
+        # Longer read timeout for long-running operations; moderate connects/writes
+        return httpx.Timeout(read=float(self.timeout_seconds), connect=30.0, write=30.0, pool=60.0)
+
+    def _request(self, method: str, path: str, *, params: Optional[Dict[str, Any]] = None, json: Optional[Dict[str, Any]] = None) -> httpx.Response:
+        rel = path.lstrip("/")
+        resp = self._client.request(method.upper(), rel, params=params, json=json)
+        # Central error mapping
+        if resp.status_code >= 400:
+            msg = resp.text
+            if resp.status_code in (401, 403):
+                raise AuthError(msg)
+            if resp.status_code == 402:
+                raise SubscriptionRequiredError("Pro plan required for API access")
+            if resp.status_code == 429:
+                retry_after = None
+                try:
+                    ra = resp.headers.get("Retry-After")
+                    retry_after = float(ra) if ra is not None else None
+                except Exception:
+                    retry_after = None
+                raise RateLimitError("Rate limit exceeded", retry_after)
+            raise ApiError(f"API error {resp.status_code}: {msg}")
+        return resp
+
+    # Context manager support for deterministic close
+    def close(self) -> None:
+        try:
+            self._client.close()
+        except Exception:
+            pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()
+
+    # -----------------------------
+    # Authentication helpers
+    # -----------------------------
+    def set_api_key(self, api_key: str) -> None:
+        """Use a per-user API key (recommended for headless/service clients)."""
+        self._api_key = api_key
+        self._client.headers.update({"X-API-Key": api_key})
+
+    # -----------------------------
+    # Strategy-Engine API: Live Portfolio
+    # -----------------------------
+
+    def get_live_latest(self, *, force: bool = False, tolerance_minutes: Optional[int] = None, return_results_if_fresh: bool = False) -> models.LiveLatest:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params: Dict[str, Any] = {"force": force, "return_results_if_fresh": return_results_if_fresh}
+        if tolerance_minutes is not None:
+            params["tolerance_minutes"] = int(tolerance_minutes)
+        resp = self._request("GET", "api/portfolio/live/latest", params=params)
+        return models.parse_live_latest(resp.json())
+
+    def get_live_status(self) -> models.LiveStatus:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        resp = self._request("GET", "api/portfolio/live/status")
+        return models.LiveStatus.from_dict(resp.json())
+
+    def get_live_trades(self, *, status: Optional[str] = None, include_positions: bool = False, limit: int = 100) -> List[models.PortfolioTrade]:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params: Dict[str, Any] = {"limit": int(limit), "include_positions": bool(include_positions)}
+        if status:
+            params["status"] = status
+        resp = self._request("GET", "api/portfolio/live/trades", params=params)
+        return models.parse_trades(resp.json())
+
+    def get_live_members(self, *, run_id: Optional[str] = None) -> List[models.PortfolioMember]:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params: Dict[str, Any] = {}
+        if run_id:
+            params["run_id"] = run_id
+        resp = self._request("GET", "api/portfolio/live/members", params=params)
+        return models.parse_members(resp.json())
+
+    def get_live_equity(self, *, limit: int = 200) -> List[models.EquityPoint]:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params = {"limit": int(limit)}
+        resp = self._request("GET", "api/portfolio/live/equity", params=params)
+        return models.parse_equity(resp.json())
+
+    def get_portfolio_signals(self, *, run_id: Optional[str] = None, limit: int = 1000, offset: int = 0) -> List[models.PortfolioSignal]:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params: Dict[str, Any] = {"limit": int(limit), "offset": int(offset)}
+        if run_id:
+            params["run_id"] = run_id
+        resp = self._request("GET", "api/portfolio/signals", params=params)
+        return models.parse_signals(resp.json())
+
+    def get_portfolio_weights(self, *, run_id: Optional[str] = None, limit: int = 1000, offset: int = 0) -> List[models.PortfolioWeight]:
+        if not self._api_key:
+            raise RuntimeError("Not authenticated. Set EPSILAB_API_KEY or call set_api_key().")
+        params: Dict[str, Any] = {"limit": int(limit), "offset": int(offset)}
+        if run_id:
+            params["run_id"] = run_id
+        resp = self._request("GET", "api/portfolio/weights", params=params)
+        return models.parse_weights(resp.json())

epsilab-0.1.0/epsilab/exceptions.py

@@ -0,0 +1,23 @@
+class EpsilabError(Exception):
+    """Base exception for Epsilab SDK."""
+
+
+class AuthError(EpsilabError):
+    """Authentication or authorization failed (HTTP 401/403)."""
+
+
+class SubscriptionRequiredError(EpsilabError):
+    """Subscription is required (HTTP 402)."""
+
+
+class RateLimitError(EpsilabError):
+    """Rate limit exceeded (HTTP 429)."""
+
+    def __init__(self, message: str, retry_after: float | None = None) -> None:
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+class ApiError(EpsilabError):
+    """Generic API error (any other 4xx/5xx)."""
+

epsilab-0.1.0/epsilab/models.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, List, Optional
+import json
+
+
+@dataclass
+class PortfolioSignal:
+    symbol: str
+    signal_type: str
+    strength: Optional[float] = None
+    timestamp: Optional[str] = None
+    date: Optional[str] = None
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "PortfolioSignal":
+        return PortfolioSignal(
+            symbol=str(d.get("symbol") or ""),
+            signal_type=str(d.get("signalType") or d.get("signal_type") or d.get("type") or "").upper(),
+            strength=(None if d.get("strength") is None else float(d.get("strength"))),
+            timestamp=(d.get("signalTimestamp") or d.get("signal_timestamp")),
+            date=(d.get("signalDate") or d.get("signal_date")),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        base = f"{self.symbol} {self.signal_type}"
+        if self.strength is not None:
+            base += f" {self.strength}"
+        return base
+
+
+@dataclass
+class PortfolioWeight:
+    symbol: str
+    final_weight: Optional[float] = None
+    raw_weight: Optional[float] = None
+    timestamp: Optional[str] = None
+    date: Optional[str] = None
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "PortfolioWeight":
+        return PortfolioWeight(
+            symbol=str(d.get("symbol") or ""),
+            final_weight=(None if d.get("final_weight") is None else float(d.get("final_weight"))),
+            raw_weight=(None if d.get("raw_weight") is None else float(d.get("raw_weight"))),
+            timestamp=(d.get("weightTimestamp") or d.get("weight_timestamp")),
+            date=(d.get("weightDate") or d.get("weight_date")),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        val = self.final_weight if self.final_weight is not None else self.raw_weight
+        return f"{self.symbol}:{val}"
+
+
+@dataclass
+class PortfolioTrade:
+    id: str
+    symbol: str
+    side: str
+    qty: Optional[float]
+    planned_price: Optional[float]
+    planned_at: Optional[str]
+    status: str
+    reasoning: Optional[str]
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "PortfolioTrade":
+        return PortfolioTrade(
+            id=str(d.get("id") or ""),
+            symbol=str(d.get("symbol") or ""),
+            side=str(d.get("side") or "").upper(),
+            qty=(None if d.get("qty") is None else float(d.get("qty"))),
+            planned_price=(None if d.get("planned_price") is None else float(d.get("planned_price"))),
+            planned_at=(d.get("planned_at") or None),
+            status=str(d.get("status") or "").upper(),
+            reasoning=d.get("reasoning"),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        return f"{self.symbol} {self.side} {self.status} x{self.qty}"
+
+
+@dataclass
+class PortfolioMember:
+    strategy_id: str
+    effective_weight: Optional[float]
+    name: Optional[str] = None
+    visibility: Optional[str] = None
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "PortfolioMember":
+        return PortfolioMember(
+            strategy_id=str(d.get("strategy_id") or ""),
+            effective_weight=(None if d.get("effective_weight") is None else float(d.get("effective_weight"))),
+            name=d.get("name"),
+            visibility=d.get("visibility"),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        return f"{self.name or self.strategy_id}:{self.effective_weight}"
+
+
+@dataclass
+class EquityPoint:
+    date: str
+    value: float
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "EquityPoint":
+        return EquityPoint(
+            date=str(d.get("date") or ""),
+            value=float(d.get("value") or 0.0),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        return f"{self.date} {self.value}"
+
+
+@dataclass
+class LiveStatus:
+    latest_run_id: Optional[str]
+    timeframe: Optional[str]
+    next_eta_minutes: Optional[float]
+    counts: Dict[str, int]
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "LiveStatus":
+        lr = (d or {}).get("latestRun") or {}
+        return LiveStatus(
+            latest_run_id=(lr.get("id") if isinstance(lr, dict) else None),
+            timeframe=(lr.get("timeframe") if isinstance(lr, dict) else None),
+            next_eta_minutes=(None if d.get("nextEtaMinutes") is None else float(d.get("nextEtaMinutes"))),
+            counts={k: int(v) for k, v in ((d.get("counts") or {}).items())},
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        return f"runId={self.latest_run_id} tf={self.timeframe} nextEtaMin={self.next_eta_minutes} counts={self.counts}"
+
+
+@dataclass
+class LiveLatest:
+    run_id: Optional[str]
+    timeframe: Optional[str]
+    signals: List[PortfolioSignal]
+    weights: List[PortfolioWeight]
+    fresh: Optional[bool]
+    recomputed: Optional[bool]
+
+    @staticmethod
+    def from_dict(d: Dict[str, Any]) -> "LiveLatest":
+        results = (d or {}).get("results") or {}
+        run_id = d.get("runId") or None
+        tf = d.get("timeframe") or None
+        sigs = parse_signals(results)
+        wts = parse_weights(results)
+        return LiveLatest(
+            run_id=run_id,
+            timeframe=tf,
+            signals=sigs,
+            weights=wts,
+            fresh=d.get("fresh"),
+            recomputed=d.get("recomputed"),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "run_id": self.run_id,
+            "timeframe": self.timeframe,
+            "signals": [s.to_dict() for s in self.signals],
+            "weights": [w.to_dict() for w in self.weights],
+            "fresh": self.fresh,
+            "recomputed": self.recomputed,
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def log(self) -> str:
+        return (
+            f"runId={self.run_id} tf={self.timeframe} "
+            f"signals={len(self.signals)} weights={len(self.weights)} fresh={self.fresh} recomputed={self.recomputed}"
+        )
+
+
+def parse_signals(payload: Dict[str, Any]) -> List[PortfolioSignal]:
+    rows = (payload or {}).get("signals", []) if isinstance(payload, dict) else []
+    return [PortfolioSignal.from_dict(r) for r in rows]
+
+
+def parse_weights(payload: Dict[str, Any]) -> List[PortfolioWeight]:
+    rows = (payload or {}).get("weights", []) if isinstance(payload, dict) else []
+    return [PortfolioWeight.from_dict(r) for r in rows]
+
+
+def parse_trades(payload: Dict[str, Any]) -> List[PortfolioTrade]:
+    rows = (payload or {}).get("trades", []) if isinstance(payload, dict) else []
+    return [PortfolioTrade.from_dict(r) for r in rows]
+
+
+def parse_members(payload: Dict[str, Any]) -> List[PortfolioMember]:
+    rows = (payload or {}).get("members", []) if isinstance(payload, dict) else []
+    return [PortfolioMember.from_dict(r) for r in rows]
+
+
+def parse_equity(payload: Dict[str, Any]) -> List[EquityPoint]:
+    rows = (payload or {}).get("series", []) if isinstance(payload, dict) else []
+    return [EquityPoint.from_dict(r) for r in rows]
+
+
+def parse_live_latest(payload: Dict[str, Any]) -> LiveLatest:
+    return LiveLatest.from_dict(payload or {})
+
+

epsilab-0.1.0/examples/example.py

@@ -0,0 +1,108 @@
+import os
+import time
+from datetime import datetime, timezone
+
+try:
+    from dotenv import load_dotenv  # type: ignore
+except Exception:
+    load_dotenv = None
+
+from epsilab import Epsilab
+
+
+def main():
+    if load_dotenv is not None:
+        try:
+            load_dotenv()
+        except Exception:
+            pass
+
+    api_key = os.getenv("EPSILAB_API_KEY")
+    api_base = os.getenv("EPSILAB_API_BASE", "https://www.epsilab.ai/api/ext/v1")
+
+    if not api_key:
+        print("EPSILAB_API_KEY not set. Create an API key in Account Settings and export it.")
+        return
+
+    client = Epsilab(api_base=api_base, api_key=api_key)
+
+    start = time.time()
+    iterations = 5  # 5 * 5s = 25s
+    print(f"Polling live portfolio for ~{iterations * 5} seconds (every 5s)...\n")
+    try:
+        for i in range(iterations):
+            try:
+                ts = datetime.now(timezone.utc).isoformat()
+                latest = client.get_live_latest(return_results_if_fresh=True)
+                status = client.get_live_status()
+
+                # Determine run id and timeframe
+                run_id = latest.run_id or status.latest_run_id
+                timeframe = status.timeframe or latest.timeframe
+
+                # Fetch live data for this (or latest) run
+                signals = client.get_portfolio_signals(run_id=run_id, limit=200)
+                weights = client.get_portfolio_weights(run_id=run_id, limit=200)
+                trades = client.get_live_trades(status="PENDING,EXECUTED,CLOSED", include_positions=False, limit=200)
+                equity = client.get_live_equity(limit=200)
+                members = client.get_live_members(run_id=run_id)
+
+                next_eta = status.next_eta_minutes
+                sig_rows = signals
+                wt_rows = weights
+                tr_rows = trades
+                eq_series = equity
+                mem_rows = members
+
+                # Build samples for easy inspection
+                def _sample_sig(r) -> str:
+                    return r.log()
+
+                def _sample_wt(r) -> str:
+                    return r.log()
+
+                def _sample_tr(r) -> str:
+                    return r.log()
+
+                def _sample_mem(r) -> str:
+                    return r.log()
+
+                eq_last = (eq_series[-1] if eq_series else None)
+                eq_last_str = (eq_last.log() if eq_last else "n/a")
+
+                print(f"[{ts}] runId={run_id} tf={timeframe} nextEtaMin={next_eta}")
+                print(
+                    f"  signals: {len(sig_rows)} | sample: " + ", ".join(map(_sample_sig, sig_rows[:2]))
+                )
+                print(
+                    f"  weights: {len(wt_rows)} | sample: " + ", ".join(map(_sample_wt, wt_rows[:2]))
+                )
+                print(
+                    f"  trades : {len(tr_rows)} | sample: " + ", ".join(map(_sample_tr, tr_rows[:2]))
+                )
+                print(
+                    f"  members: {len(mem_rows)} | sample: " + ", ".join(map(_sample_mem, mem_rows[:2]))
+                )
+                print(
+                    f"  equity : {len(eq_series)} pts | last: {eq_last_str}"
+                )
+            except Exception as e:
+                print(f"Error during poll: {e}")
+
+            # Wait ~5 seconds between polls
+            try:
+                time.sleep(5)
+            except KeyboardInterrupt:
+                print("Interrupted by user during sleep. Exiting...")
+                break
+    except KeyboardInterrupt:
+        print("Interrupted by user. Exiting...")
+
+    elapsed = time.time() - start
+    print(f"\nDone. Elapsed ~{int(elapsed)}s.")
+
+
+if __name__ == "__main__":
+    main()
+
+

epsilab-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling>=1.18"]
+build-backend = "hatchling.build"
+
+[project]
+name = "epsilab"
+version = "0.1.0"
+description = "Python SDK for Epsilab live portfolio data (signals, weights, trades)."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [ { name = "Epsilab" } ]
+requires-python = ">=3.9"
+dependencies = [
+  "httpx>=0.27.0",
+  "python-dotenv>=1.0.1",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: Apache Software License",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://www.epsilab.ai"
+
+[project.scripts]
+epsilab = "epsilab.__main__:main"
+
+[tool.hatch.build]
+include = [
+  "epsilab/**",
+  "README.md",
+  "LICENSE",
+  "examples/**",
+]
+exclude = [
+  "portfolio.logs",
+]
+
+