Add tests for new ttl

.

Fix lock file

Author: jgielstra-cs

Makefile

@@ -12,6 +12,7 @@ clean:
 
 dev.install:
 	pip install poetry
+	poetry self add "poetry-dynamic-versioning[plugin]"
 	poetry install
 
 ifdef ALPHA_BUILD
@@ -23,26 +24,13 @@ docker:
 	docker build -t c12e/cortex-python .
 
 build.alpha: clean
-	python setup.py egg_info --tag-build a$(shell \
-		curl https://pypi.org/pypi/${DISTRIBUTION_NAME}/json | \
-		jq '[ \
-				.releases | \
-				to_entries[] | \
-				.key | \
-				select(. | contains("${DISTRIBUTION_VERSION}a")) | \
-				ltrimstr("${DISTRIBUTION_VERSION}a") \
-			] | \
-			last // "0" | \
-			tonumber + 1' \
-	) sdist bdist_wheel
-
+	poetry version alpha
+	poetry build
 build.release: clean
-	python setup.py sdist bdist_wheel
+	poetry build
 
 dev.test:
-	poetry run pylint --recursive=y cortex
-	poetry run pytest --cache-clear  --html=coverage/test-report.html --self-contained-html --cov=cortex/ --cov-report=html:coverage --cov-report=xml:coverage.xml --cov-report=term test/unit
-
+	poetry run tox -epython3.10
 test:
 	poetry run tox -r # tox runs make dev.test internally
 

README.md

@@ -9,39 +9,56 @@ Refer to the Cortex documentation for details on how to use the library:
 ## Installation
 
 To install: 
-```
-  > pip install cortex-python
+
+```bash
+pip install cortex-python
 ```
 
 or from source code:
-```
-  > git clone git@github.com:CognitiveScale/cortex-python.git
-  > cd cortex-python
-  > pip install -e .
+
+```bash
+git clone git@github.com:CognitiveScale/cortex-python.git
+cd cortex-python
+pip install -e .
 ```
 
 To install the optional components: 
+
+When developing models using jupyter within notebooks
+
+```bash
+poetry install cortex-python[models_dev]
 ```
-  > pip install cortex-python[viz]
-  > pip install cortex-python[jupyter]
+
+When using model SDK using jupyter within notebooks
+
+```bash
+poetry install cortex-python[models_dev]
+```
+
+When 
+
+```bash
+poetry install cortex-python[models_dev]
 ```
 
 ## Development 
 
 ### Setup
 
 When developing, it's a best practice to work in a virtual environment. Create and activate a virtual environment:
-```
-  > virtualenv --python=python3.10 _venv
-  > source _venv/bin/activate
+
+```bash
+poetry install
+poetry shell
 ```
 
 Install developer dependencies:
 
-```
-  > git clone git@github.com:CognitiveScale/cortex-python.git
-  > cd cortex-python
-  > make dev.install
+```bash
+git clone git@github.com:CognitiveScale/cortex-python.git
+cd cortex-python
+make dev.install
 ```
 
 Run Developer test and linting tasks:
@@ -84,33 +101,38 @@ After contributing to the library, and before you submit changes as a PR, please
 ### Documentation
 
 Activate your virtual environment:
-```
-> source _venv/bin/activate
+
+```bash
+poetry shell
 ```
 
 Set up your environment, if you have not done so:
-```
-> make dev.install 
+
+```bash
+make dev.install 
 ```
 
 The package documentation is built with Sphinx and generates versioned documentation for all tag matching the `release/X.Y.Z` pattern and for the `master` branch. To build the documentation:
 
-```
-> make docs.multi
+```bash
+make docs.multi
 ```
 The documentation will be rendered in HTML format under the `docs/_build/${VERSION}` directory.
 
 ### Pre-release to staging
 
 1. Create and push an alpha release:
-    ```
-    > make dev.push
-    ```
+
+```bash
+make dev.push
+```
     This will build an alpha-tagged package.
 2. Merge `develop` to `staging` branch:
-    ```
-    > make stage
-    ```
+
+```bash
+make stage
+```
+
 3. In GitHub, create a pull request from `staging` to `master`.
 
 

c12e-ci.yml

@@ -3,6 +3,7 @@ builder:
     ALPHA_BUILD: "${ALPHA_BUILD}"
   image: python:3.11-bullseye
   command: bash -cx 'apt-get update
+    && git config --system --add safe.directory '/work'
     && apt-get install -y jq
     && make dev.install
     && make test

cortex/__version__.py

@@ -20,6 +20,7 @@
 import os
 from typing import Optional, Dict, Any
 from cortex.serviceconnector import _Client
+from cortex.utils import generate_token
 
 try:
     import mlflow
@@ -42,32 +43,27 @@ class ModelClient(_Client):
     Client for model registry, this class requires the `models_sdk` extras to be installed
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # Setup model registry by default
-        if mlflow is not None:
-            self._setup_model_client()
-
-    def _setup_model_client(self):
+    def _setup_model_client(self, verify_ssl_cert=True, ttl="2h"):
         # Generate a JWT, this call stores the JWT in `_serviceconnector.jwt` ( meh )
-        self._serviceconnector._construct_headers({})  # pylint: disable=protected-access
-
+        token = generate_token(self._serviceconnector._config, verify_ssl_cert=verify_ssl_cert, validity=ttl) # pylint: disable=protected-access
         mlflow.set_tracking_uri(self._serviceconnector.url)
         os.environ['MLFLOW_TRACKING_URI'] = self._serviceconnector.url
-        os.environ['MLFLOW_TRACKING_TOKEN'] = self._serviceconnector.token
+        os.environ['MLFLOW_TRACKING_TOKEN'] = token
         #  detect cortex client setting to avoid invalid SSL cert errors
         # os.environ['MLFLOW_TRACKING_TOKEN']='true'
         # os.environ['MLFLOW_TRACKING_CLIENT_CERT_PATH']=
         # Need api to fetch serverside userid..
         # os.environ['MLFLOW_TRACKING_USERNAME']=_Client.???
 
-    def login(self):
+
+    def login(self, ttl: Optional[str|int]='2h'):
         """
         Configure connection settings for model registry.
-        This also setup by `Cortex.client()`
+        :param ttl: Time to live, DEFAULT: 2h
+        :param project: Project name to use for experiments
         """
         check_installed()
-        self._setup_model_client()
+        self._setup_model_client(ttl=ttl)
         print("Configuring connection for model registry")
 
     def create_experiment(self,

cortex/models.py

@@ -21,20 +21,18 @@
 import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
-
+from importlib_metadata import metadata
 from .constant import VERSION
-from .__version__ import __version__, __title__
-
 from .utils import get_logger, get_cortex_profile, verify_JWT, generate_token
 from .utils import raise_for_status_with_detail
 
 log = get_logger(__name__)
 
 JSONType = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
 T = TypeVar("T", bound="_Client")
-
+package_meta = metadata('cortex-python')
 userAgent = (
-    f"{__title__}/{__version__} ({sys.platform};"
+    f"{package_meta.get('Name')}/{package_meta.get('Version')} ({sys.platform};"
     f"{platform.architecture()[0]}; {platform.release()})"
 )
 

cortex/serviceconnector.py

@@ -20,12 +20,13 @@
 import logging
 import urllib.parse
 from collections import namedtuple
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Union
 
 import python_jwt as py_jwt
 import jwcrypto.jwk as jwkLib
+from pytimeparse2 import parse
 from requests.exceptions import HTTPError
 from requests import request
 from .exceptions import BadTokenException, AuthenticationHeaderError
@@ -152,14 +153,15 @@ def _get_fabric_server_ts(config: dict, verify_ssl_cert: Union[bool, str]=True):
     return _get_fabric_info(config, verify_ssl_cert).get("serverTs")
 
 
-def generate_token(config, verify_ssl_cert: Union[bool, str]=True, validity=2):
+def generate_token(config, verify_ssl_cert: Union[bool, str, None]=True, validity: Union[int, str, None]='2m'):
     """
     Use the Personal Access Token (JWK) obtained from Cortex's console
     to generate JWTs to access cortex services..
     
     :param verify_ssl_cert: (optional) Either a boolean, in which case it controls whether we verify
             the server's TLS certificate, or a string, in which case it must be a path
             to a CA bundle to use. Defaults to ``True``.
+    :param validity: (optional) Token validity duration. Defaults to `2m`
     """
     try:
         server_ts = int(
@@ -174,8 +176,7 @@ def generate_token(config, verify_ssl_cert: Union[bool, str]=True, validity=2):
         }
 
         server_ts_dt = datetime.fromtimestamp(server_ts, tz=timezone.utc)
-
-        expiry = server_ts_dt + timedelta(minutes=validity)
+        expiry = server_ts_dt + parse(validity, as_timedelta=True)
 
         token = py_jwt.generate_jwt(
             claims=token_payload,