jgtcore 0.1.0__py3-none-any.whl

jgtcore/__init__.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+
+"""
+jgtcore - Core library functions extracted from jgtutils
+
+This module provides the core configuration, settings, and utility functions
+from jgtutils without CLI dependencies, making them suitable for use in
+other libraries and applications.
+
+Main Functions:
+- Configuration: readconfig(), get_config(), get_config_value()
+- Settings: load_settings(), get_settings(), get_setting()
+- Environment: setup_environment(), export_env_if_any()
+- Utilities: str_to_datetime(), is_market_open(), print_exception()
+- Trading: read_fx_str_from_config(), is_demo_mode()
+"""
+
+from .core import (
+    # Core configuration functions
+    readconfig,
+    load_settings,
+    get_settings,
+    
+    # Simple API wrappers
+    get_config,
+    get_setting,
+    setup_environment,
+    get_config_value,
+    is_demo_mode,
+    
+    # Environment helpers
+    load_arg_from_jgt_env,
+    load_arg_default_from_settings,
+    export_env_if_any,
+    
+    # Utility functions
+    str_to_datetime,
+    print_exception,
+    is_market_open,
+    dt_from_last_week_as_datetime,
+    dt_from_last_week_as_string_fxformat,
+    
+    # Trading helpers
+    read_fx_str_from_config,
+    
+    # Helper functions for advanced use
+    update_settings,
+    load_arg_default_from_settings_if_exist,
+)
+
+__version__ = "1.0.0"
+__author__ = "JGWill"
+__description__ = "Core library functions extracted from jgtutils"
+
+# Export the main functions that external packages are likely to use
+__all__ = [
+    # Configuration functions
+    'readconfig',
+    'load_settings', 
+    'get_settings',
+    
+    # Simple API wrappers
+    'get_config',
+    'get_setting',
+    'setup_environment',
+    'get_config_value',
+    'is_demo_mode',
+    
+    # Environment helpers
+    'load_arg_from_jgt_env',
+    'load_arg_default_from_settings',
+    'export_env_if_any',
+    
+    # Utility functions
+    'str_to_datetime',
+    'print_exception',
+    'is_market_open',
+    'dt_from_last_week_as_datetime',
+    'dt_from_last_week_as_string_fxformat',
+    
+    # Trading helpers
+    'read_fx_str_from_config',
+    
+    # Helper functions
+    'update_settings',
+    'load_arg_default_from_settings_if_exist',
+]

jgtcore/core.py

@@ -0,0 +1,607 @@
+#!/usr/bin/env python3
+
+# Copyright 2019 Gehtsoft USA LLC
+# Copyright 2023 JGWill (extended/variations)
+
+# Licensed under the license derived from 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://fxcodebase.com/licenses/open-source/license.html
+
+# 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.
+
+"""
+jgtcore.core - Core library functions extracted from jgtutils
+Provides configuration, settings, and utility functions without CLI dependencies.
+"""
+
+import json
+import ruamel.yaml
+yaml = ruamel.yaml.YAML()
+
+import os
+import sys
+import traceback
+from datetime import datetime, time, timezone, timedelta
+from typing import Dict, Tuple, Optional, Any
+
+# Global variables for caching
+settings: Dict[str, Any] = {}
+_JGT_CONFIG_JSON_SECRET: Optional[str] = None
+
+# Core Configuration Functions
+
+def _load_settings_from_path(path: str) -> Dict[str, Any]:
+    """Load settings from a JSON file path."""
+    if os.path.exists(path):
+        with open(path, 'r') as f:
+            loaded_data = json.load(f)
+            return loaded_data
+    return {}
+
+
+def _load_settings_from_path_yaml(path: str, key: Optional[str] = None) -> Dict[str, Any]:
+    """Load settings from a YAML file path, optionally extracting a specific key."""
+    if os.path.exists(path):
+        with open(path, 'r') as f:
+            if key is not None:
+                try:
+                    yaml_value = yaml.load(f)
+                except yaml.YAMLError as exc:
+                    print(exc)
+                if yaml_value is not None and key in yaml_value:
+                    return yaml_value[key]
+                else:
+                    return {}
+            yaml_data = yaml.load(f)
+            if yaml_data is None:
+                return {}
+            return yaml_data
+    return {}
+
+
+def update_settings(old_settings: Dict[str, Any], new_settings: Dict[str, Any], keys: list = ['patterns']) -> None:
+    """Update old_settings with new_settings, handling special keys separately."""
+    # if our old settings has a key in our keys list, then we will update it on their own 
+    # (meaning we will not merge it directly but update it independently)
+    for key in keys:
+        if key in old_settings:
+            if new_settings is not None and key in new_settings:
+                test_if_key_not_none = new_settings[key]
+                if test_if_key_not_none is not None:
+                    old_settings[key].update(new_settings[key])
+                # remove the key from the new settings
+                new_settings.pop(key)
+    if new_settings is not None:
+        old_settings.update(new_settings)
+
+
+def _settings_loaded(_settings: Dict[str, Any]) -> None:
+    """Hook called when settings are loaded. Override for custom behavior."""
+    return
+
+
+def load_settings(custom_path: Optional[str] = None, old: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Load settings from multiple locations in order of precedence.
+    
+    Args:
+        custom_path: Optional custom path to settings file
+        old: Existing settings to merge with
+        
+    Returns:
+        Merged settings dictionary
+    """
+    system_settings_path = os.path.join('/etc', 'jgt', 'settings.json')
+    home_settings_path = os.path.join(os.path.expanduser('~'), '.jgt', 'settings.json')
+    current_settings_path = os.path.join(os.getcwd(), '.jgt', 'settings.json')
+    yaml_current_settings_path = os.path.join(os.getcwd(), '.jgt', 'settings.yml')
+    jgt_yaml_current_settings_path = os.path.join(os.getcwd(), 'jgt.yml')
+    jubook_jgt_yaml_current_settings_path = os.path.join(os.getcwd(), '_config.yml')
+    
+    _settings = {}
+    if old is not None:
+        _settings = old
+    
+    # Load system settings
+    system_settings = _load_settings_from_path(system_settings_path)
+    update_settings(_settings, system_settings)
+
+    # Load from env JGT_SETTINGS_SYSTEM if exists
+    if 'JGT_SETTINGS_SYSTEM' in os.environ:
+        env_settings_system = json.loads(os.environ['JGT_SETTINGS_SYSTEM'])
+        update_settings(_settings, env_settings_system)
+        
+    # Load user settings
+    user_settings = _load_settings_from_path(home_settings_path)
+    update_settings(_settings, user_settings)
+    
+    # Load from env JGT_SETTINGS or JGT_SETTINGS_USER if exists
+    if 'JGT_SETTINGS' in os.environ:
+        env_settings_user = json.loads(os.environ['JGT_SETTINGS'])
+        update_settings(_settings, env_settings_user)
+    
+    if 'JGT_SETTINGS_USER' in os.environ:
+        env_settings_user = json.loads(os.environ['JGT_SETTINGS_USER'])
+        update_settings(_settings, env_settings_user)
+    
+    # Load current directory settings
+    current_settings = _load_settings_from_path(current_settings_path)    
+    update_settings(_settings, current_settings)
+    
+    current_settings_yaml = _load_settings_from_path_yaml(yaml_current_settings_path)
+    update_settings(_settings, current_settings_yaml)
+    
+    jubook_jgt_current_settings_yaml = _load_settings_from_path_yaml(jubook_jgt_yaml_current_settings_path, key='jgt')
+    update_settings(_settings, jubook_jgt_current_settings_yaml)
+    
+    jgt_current_settings_yaml = _load_settings_from_path_yaml(jgt_yaml_current_settings_path)
+    update_settings(_settings, jgt_current_settings_yaml)
+    
+    # Load custom settings if provided
+    if custom_path is not None and custom_path != '':
+        custom_settings = {}
+        if '.json' in custom_path:
+            custom_settings = _load_settings_from_path(custom_path)
+        else:
+            if '.yml' in custom_path:
+                custom_settings = _load_settings_from_path_yaml(custom_path)
+        update_settings(_settings, custom_settings)
+    
+    # Load process-level settings from environment
+    if 'JGT_SETTINGS_PROCESS' in os.environ:
+        env_settings_process = json.loads(os.environ['JGT_SETTINGS_PROCESS'])
+        update_settings(_settings, env_settings_process)
+    
+    _settings_loaded(_settings)
+    
+    return _settings
+
+
+def get_settings(custom_path: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Get cached settings, loading them if necessary.
+    
+    Args:
+        custom_path: Optional custom path to settings file
+        
+    Returns:
+        Settings dictionary
+    """
+    global settings
+    if settings is None or len(settings) == 0:
+        settings = load_settings(custom_path=custom_path)
+    return settings
+
+
+def load_arg_default_from_settings(argname: str, default_value: Any, alias: Optional[str] = None, 
+                                  from_jgt_env: bool = False, exclude_env_alias: bool = False) -> Any:
+    """
+    Load argument default value from settings.
+    
+    Args:
+        argname: Argument name to look up
+        default_value: Default value if not found
+        alias: Alternative name to check
+        from_jgt_env: Whether to load from JGT environment
+        exclude_env_alias: Whether to exclude alias when loading from env
+        
+    Returns:
+        Setting value or default
+    """
+    global settings
+    if settings is None or len(settings) == 0:
+        settings = load_settings()
+    
+    _value = settings.get(argname, default_value)
+    if alias is not None and _value == default_value:
+        _value = settings.get(alias, default_value)  # try alias might be used
+    
+    if from_jgt_env:
+        _alias = None if exclude_env_alias else alias
+        _value = load_arg_from_jgt_env(argname, _alias)
+    
+    return _value
+
+
+def load_arg_from_jgt_env(argname: str, alias: Optional[str] = None) -> Optional[str]:
+    """
+    Load argument value from JGT environment variables.
+    
+    Args:
+        argname: Argument name to look up
+        alias: Alternative name to check
+        
+    Returns:
+        Environment variable value or None
+    """
+    _value = None
+    # Note: load_env() is from jgtenv, but we'll just check the environment directly
+    if argname in os.environ:
+        _value = os.getenv(argname, None)
+    if alias is not None and _value is None:
+        _value = os.getenv(alias, None)
+    return _value
+
+
+def load_arg_default_from_settings_if_exist(argname: str, alias: Optional[str] = None) -> Optional[Any]:
+    """
+    Load argument default from settings only if it exists.
+    
+    Args:
+        argname: Argument name to look up
+        alias: Alternative name to check
+        
+    Returns:
+        Setting value or None
+    """
+    global settings
+    if settings is None or len(settings) == 0:
+        settings = load_settings()
+    
+    _value = settings.get(argname, None)
+    if alias is not None and _value == None:
+        _value = settings.get(alias, None)  # try alias might be used
+    return _value
+
+
+def export_env_if_any(config: Dict[str, Any]) -> None:
+    """Export certain config values to environment variables if they exist."""
+    # if has a key : "keep_bid_ask" and if yes and set to "true", export an env variable "JGT_KEEP_BID_ASK" to "1"
+    if 'keep_bid_ask' in config and config['keep_bid_ask'] == True:
+        os.environ['JGT_KEEP_BID_ASK'] = '1'
+
+
+def _set_demo_credential(config: Dict[str, Any], demo: bool = False) -> None:
+    """Set demo credentials in config if demo mode is enabled."""
+    if demo:
+        config["user_id"] = config["user_id_demo"]
+        config["password"] = config["password_demo"]
+        config["account"] = config["account_demo"]
+        config["connection"] = "Demo"
+
+
+def readconfig(json_config_str: Optional[str] = None, config_file: str = 'config.json', 
+               export_env: bool = False, config_file_path_env_name: str = 'JGT_CONFIG_PATH', 
+               config_values_env_name: str = 'JGT_CONFIG', force_read_json: bool = False, 
+               demo: bool = False, use_demo_json_config: bool = False) -> Dict[str, Any]:
+    """
+    Read configuration from various sources.
+    
+    Args:
+        json_config_str: JSON string containing config
+        config_file: Config file name
+        export_env: Whether to export config to environment variables
+        config_file_path_env_name: Environment variable name for config file path
+        config_values_env_name: Environment variable name for config JSON
+        force_read_json: Force reading from default JSON file
+        demo: Whether to use demo credentials
+        use_demo_json_config: Whether to use demo-specific config file
+        
+    Returns:
+        Configuration dictionary
+    """
+    global _JGT_CONFIG_JSON_SECRET
+    
+    try:
+        home_dir = os.path.expanduser("~")
+    except:
+        home_dir = os.environ["HOME"]
+    if home_dir == "":
+        home_dir = os.environ["HOME"]
+        
+    # demo_config are assumed to be $HOME/.jgt/config_demo.json
+    if demo and use_demo_json_config:
+        config_file = os.path.join(home_dir, '.jgt/config_demo.json')
+        # check if exist, advise and raise exception if not
+        if not os.path.exists(config_file):
+            print(f"Configuration not found. create : {config_file} or we will try to use the _demo in the usual config.json")
+            config = readconfig(force_read_json=True)
+            _set_demo_credential(config, demo)
+            return config
+ 
+    # force_read_json are assumed to be $HOME/.jgt/config.json
+    if force_read_json:
+        config_file = os.path.join(home_dir, '.jgt/config.json')
+        # check if exist, advise and raise exception if not
+        if not os.path.exists(config_file):
+            raise Exception(f"Configuration not found. create : {config_file})")
+        # load and return config
+        with open(config_file, 'r') as f:
+            config = json.load(f)
+            if export_env:
+                export_env_if_any(config)
+            _set_demo_credential(config, demo)
+            return config
+            
+    # Try reading config from JSON string first
+    if json_config_str is not None:
+        config = json.loads(json_config_str)
+        _JGT_CONFIG_JSON_SECRET = json_config_str
+        if export_env:
+            export_env_if_any(config)
+        _set_demo_credential(config, demo)
+        return config
+    
+    # Try cached config
+    if _JGT_CONFIG_JSON_SECRET is not None:
+        config = json.loads(_JGT_CONFIG_JSON_SECRET)
+        if export_env:
+            export_env_if_any(config)
+        _set_demo_credential(config, demo)
+        return config
+    
+    config = None
+
+    # if file does not exist try set the path to the file in the HOME
+    if not os.path.exists(config_file):
+        config_file = os.path.join(home_dir, config_file)
+        
+    if os.path.exists(config_file):
+        with open(config_file, 'r') as f:
+            config = json.load(f)
+            if export_env:
+                export_env_if_any(config)
+            _set_demo_credential(config, demo)
+            return config
+    else:
+        config_file = os.path.join(home_dir, config_file)
+        if os.path.isfile(config_file):
+            with open(config_file, 'r') as f:
+                config = json.load(f)
+        else:
+            # If config file still not found, try reading from environment variable
+            config_json_str = os.getenv('JGT_CONFIG_JSON_SECRET')
+            if config_json_str:
+                config = json.loads(config_json_str)
+                if export_env:
+                    export_env_if_any(config)
+                _set_demo_credential(config, demo)
+                return config
+
+    # if file dont exist, try loading from env var JGT_CONFIG
+    if not os.path.exists(config_file):
+        config_json_str = os.getenv(config_values_env_name)
+        
+        if config_json_str:
+            config = json.loads(config_json_str)
+            if export_env:
+                export_env_if_any(config)
+        else:
+            # if not found, try loading from env var JGT_CONFIG_PATH
+            config_file = os.getenv(config_file_path_env_name)
+            if config_file:
+                with open(config_file, 'r') as f:
+                    config = json.load(f)
+                    if export_env:
+                        export_env_if_any(config)
+           
+    # Read config file
+    if config is None:
+        if config_file is not None and os.path.exists(config_file):
+            with open(config_file, 'r') as file:
+                config = json.load(file)
+        
+    if config is None:
+        # Last attempt to read
+        try:
+            another_config = "config.json"
+            if not os.path.exists(another_config):
+                another_config = os.path.join(os.path.expanduser('~'), '.jgt', 'config.json')
+                
+            if not os.path.exists(another_config):
+                another_config = "/etc/jgt/config.json"
+            with open(another_config, 'r') as file:
+                config = json.load(file)
+        except:
+            pass
+            
+        if config is None:
+            try:
+                with open("/home/jgi/.jgt/config.json", 'r') as file:
+                    config = json.load(file)
+            except:
+                pass
+        if config is None:
+            try:                                                                                  
+                with open("/etc/jgt/config.json", 'r') as file:                             
+                    config = json.load(file)
+            except:
+                pass
+                
+        if config is None:    
+            raise Exception(f"Configuration not found. Please provide a config file or set the JGT_CONFIG environment variable to the JSON config string. (config_file={config_file})")
+    
+    if export_env:
+        export_env_if_any(config)
+    _set_demo_credential(config, demo)
+    return config
+
+
+# Utility Functions
+
+def str_to_datetime(date_str: str) -> Optional[datetime]:
+    """
+    Convert string to datetime using multiple format attempts.
+    
+    Args:
+        date_str: Date string to parse
+        
+    Returns:
+        datetime object or None if parsing fails
+    """
+    formats = ['%m.%d.%Y %H:%M:%S', '%Y-%m-%d %H:%M:%S', '%Y/%m/%d %H:%M:%S', '%Y/%m/%d', '%Y-%m-%d']
+    
+    for fmt in formats:
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            continue
+    return None
+
+
+def print_exception(exception: Exception) -> None:
+    """Print exception with traceback."""
+    print("Exception: {0}\n{1}".format(exception, traceback.format_exc()))
+
+
+def is_market_open(current_time: Optional[datetime] = None, exit_cli_if_closed: bool = False, 
+                  market_closed_callback: Optional[callable] = None) -> bool:
+    """
+    Check if forex market is currently open.
+    
+    Args:
+        current_time: Time to check (defaults to now)
+        exit_cli_if_closed: Whether to exit if market is closed (not recommended for library use)
+        market_closed_callback: Callback to call if market is closed
+        
+    Returns:
+        True if market is open
+    """
+    if current_time is None:
+        current_time = datetime.utcnow()
+
+    # Define market open and close times
+    market_open_time = time(21, 0)  # 21:00 UTC
+    market_close_time = time(21, 15)  # 21:15 UTC
+
+    # Get the current day of the week (0=Monday, 6=Sunday)
+    current_day = current_time.weekday()
+
+    current_time_utc = current_time.time()
+    # Check if the market is open
+    if current_day == 6:  # Sunday
+        if current_time_utc >= market_open_time:
+            return True
+    elif current_day == 4:  # Friday
+        if current_time_utc < market_close_time:
+            return True
+    elif 0 <= current_day < 4:  # Monday to Thursday
+        return True
+    
+    if market_closed_callback is not None:
+        market_closed_callback()
+    if exit_cli_if_closed:
+        print("Market is closed.")
+        sys.exit(1)  # Simplified exit code for library use
+    return False
+
+
+def dt_from_last_week_as_datetime() -> datetime:
+    """Get datetime from last week."""
+    today = datetime.now()
+    last_week = today - timedelta(days=7)
+    return last_week
+
+
+def dt_from_last_week_as_string_fxformat() -> str:
+    """Get datetime from last week as FX format string."""
+    last_week = dt_from_last_week_as_datetime()
+    _str = last_week.strftime('%m.%d.%Y')
+    return _str + " 00:00:00"
+
+
+def read_fx_str_from_config(demo: bool = False) -> Tuple[str, str, str, str, str]:
+    """
+    Read FX connection parameters from config.
+    
+    Args:
+        demo: Whether to use demo credentials
+        
+    Returns:
+        Tuple of (user_id, password, url, connection, account)
+    """
+    config = readconfig(demo=demo)
+    if config["connection"] == "Real" and demo:  # Make sure we have our demo credentials
+        _set_demo_credential(config, True)
+    str_user_id = config['user_id']
+    str_password = config['password']
+    str_url = config['url']
+    str_connection = "Real" if not demo else "Demo"
+    str_account = config['account']
+    return str_user_id, str_password, str_url, str_connection, str_account
+
+
+# Simple API wrappers for external packages
+
+def get_config(demo: bool = False, export_env: bool = False) -> Dict[str, Any]:
+    """
+    Simple configuration loader for external packages.
+    
+    Args:
+        demo: Whether to use demo credentials
+        export_env: Whether to export config to environment variables
+    
+    Returns:
+        Configuration dictionary
+    """
+    return readconfig(demo=demo, export_env=export_env)
+
+
+def get_setting(key: str, default: Any = None, custom_path: Optional[str] = None) -> Any:
+    """
+    Get a single setting value.
+    
+    Args:
+        key: Setting key to retrieve
+        default: Default value if key not found
+        custom_path: Optional custom path to settings file
+    
+    Returns:
+        Setting value or default
+    """
+    settings = get_settings(custom_path=custom_path)
+    return settings.get(key, default)
+
+
+def setup_environment(demo: bool = False, custom_settings_path: Optional[str] = None) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    One-call setup for external packages.
+    Sets up configuration and settings, exports environment variables.
+    
+    Args:
+        demo: Whether to use demo credentials
+        custom_settings_path: Optional custom path to settings file
+    
+    Returns:
+        Tuple of (config_dict, settings_dict)
+    """
+    config = readconfig(demo=demo, export_env=True)
+    settings = get_settings(custom_path=custom_settings_path)
+    return config, settings
+
+
+def get_config_value(key: str, default: Any = None, demo: bool = False) -> Any:
+    """
+    Get a single configuration value.
+    
+    Args:
+        key: Configuration key to retrieve
+        default: Default value if key not found
+        demo: Whether to use demo credentials
+    
+    Returns:
+        Configuration value or default
+    """
+    config = readconfig(demo=demo)
+    return config.get(key, default)
+
+
+def is_demo_mode() -> bool:
+    """
+    Check if running in demo mode based on current configuration.
+    
+    Returns:
+        True if demo mode is active
+    """
+    try:
+        config = readconfig()
+        return config.get('connection', '').lower() == 'demo'
+    except:
+        return False

jgtcore/example.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+"""
+Example usage of jgtcore library
+
+This demonstrates how to use the extracted core functions
+from jgtutils without CLI dependencies.
+"""
+
+import sys
+import os
+
+# Add the current directory to Python path so we can import jgtcore
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import core as jgtcore
+
+
+def main():
+    """Example usage of jgtcore functions."""
+    
+    print("=== jgtcore Example Usage ===\n")
+    
+    # 1. Simple setup for external packages
+    print("1. Setting up environment...")
+    try:
+        config, settings = jgtcore.setup_environment(demo=True)
+        print(f"   ✓ Config loaded with {len(config)} keys")
+        print(f"   ✓ Settings loaded with {len(settings)} keys")
+    except Exception as e:
+        print(f"   ✗ Setup failed: {e}")
+    
+    # 2. Get specific configuration values
+    print("\n2. Getting configuration values...")
+    try:
+        url = jgtcore.get_config_value('url', 'default-url')
+        print(f"   URL: {url}")
+        
+        demo_mode = jgtcore.is_demo_mode()
+        print(f"   Demo mode: {demo_mode}")
+    except Exception as e:
+        print(f"   ✗ Config access failed: {e}")
+    
+    # 3. Get specific settings
+    print("\n3. Getting settings...")
+    try:
+        timeframe = jgtcore.get_setting('timeframe', 'H1')
+        instrument = jgtcore.get_setting('instrument', 'EUR/USD')
+        print(f"   Default timeframe: {timeframe}")
+        print(f"   Default instrument: {instrument}")
+    except Exception as e:
+        print(f"   ✗ Settings access failed: {e}")
+    
+    # 4. Utility functions
+    print("\n4. Utility functions...")
+    
+    # Date/time utilities
+    last_week = jgtcore.dt_from_last_week_as_string_fxformat()
+    print(f"   Last week (FX format): {last_week}")
+    
+    # Market status
+    market_open = jgtcore.is_market_open()
+    print(f"   Market open: {market_open}")
+    
+    # String to datetime conversion
+    test_date = "2024-01-15 10:30:00"
+    parsed_date = jgtcore.str_to_datetime(test_date)
+    print(f"   Parsed date '{test_date}': {parsed_date}")
+    
+    # 5. Trading connection parameters
+    print("\n5. Trading connection...")
+    try:
+        user_id, password, url, connection, account = jgtcore.read_fx_str_from_config(demo=True)
+        print(f"   Connection: {connection}")
+        print(f"   URL: {url}")
+        print(f"   Account: {account}")
+        print(f"   User ID: {user_id[:3]}... (hidden)")
+    except Exception as e:
+        print(f"   ✗ Trading config failed: {e}")
+    
+    print("\n=== Example completed ===")
+
+
+if __name__ == "__main__":
+    main()

jgtcore/test_core.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+
+"""
+Test script for jgtcore library
+
+Tests the core functionality extracted from jgtutils
+"""
+
+import os
+import sys
+import tempfile
+import json
+from datetime import datetime
+
+# Add jgtcore to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import core
+
+
+def test_str_to_datetime():
+    """Test string to datetime conversion."""
+    print("Testing str_to_datetime...")
+    
+    test_cases = [
+        ("2024-01-15 10:30:00", True),
+        ("01.15.2024 10:30:00", True),  
+        ("2024/01/15", True),
+        ("invalid-date", False),
+        ("", False)
+    ]
+    
+    for date_str, should_succeed in test_cases:
+        result = core.str_to_datetime(date_str)
+        if should_succeed:
+            assert result is not None, f"Expected {date_str} to parse successfully"
+            assert isinstance(result, datetime), f"Expected datetime object for {date_str}"
+            print(f"   ✓ {date_str} -> {result}")
+        else:
+            assert result is None, f"Expected {date_str} to fail parsing"
+            print(f"   ✓ {date_str} -> None (as expected)")
+
+
+def test_market_open():
+    """Test market open functionality."""
+    print("Testing is_market_open...")
+    
+    # Test with current time
+    result = core.is_market_open()
+    print(f"   Current market status: {'Open' if result else 'Closed'}")
+    
+    # Test with specific times (without exit behavior)
+    test_time = datetime(2024, 1, 15, 10, 0)  # Monday 10:00 UTC
+    result = core.is_market_open(test_time)
+    print(f"   Monday 10:00 UTC: {'Open' if result else 'Closed'}")
+
+
+def test_datetime_helpers():
+    """Test datetime helper functions."""
+    print("Testing datetime helpers...")
+    
+    last_week_dt = core.dt_from_last_week_as_datetime()
+    last_week_str = core.dt_from_last_week_as_string_fxformat()
+    
+    assert isinstance(last_week_dt, datetime), "Expected datetime object"
+    assert isinstance(last_week_str, str), "Expected string"
+    assert "00:00:00" in last_week_str, "Expected time suffix in FX format"
+    
+    print(f"   ✓ Last week datetime: {last_week_dt}")
+    print(f"   ✓ Last week FX format: {last_week_str}")
+
+
+def test_settings_with_temp_file():
+    """Test settings loading with temporary files."""
+    print("Testing settings loading...")
+    
+    # Create temporary settings file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        test_settings = {
+            "instrument": "GBP/USD",
+            "timeframe": "M15",
+            "test_value": 42
+        }
+        json.dump(test_settings, f)
+        temp_path = f.name
+    
+    try:
+        # Test loading settings from custom path
+        settings = core.load_settings(custom_path=temp_path)
+        
+        assert "instrument" in settings, "Expected instrument in settings"
+        assert settings["instrument"] == "GBP/USD", "Expected correct instrument value"
+        assert settings["timeframe"] == "M15", "Expected correct timeframe value"
+        assert settings["test_value"] == 42, "Expected correct test value"
+        
+        print(f"   ✓ Loaded settings: {len(settings)} keys")
+        print(f"   ✓ Instrument: {settings['instrument']}")
+        print(f"   ✓ Timeframe: {settings['timeframe']}")
+        
+        # Test get_settings caching
+        cached_settings = core.get_settings()
+        print(f"   ✓ Cached settings: {len(cached_settings)} keys")
+        
+    finally:
+        # Clean up
+        os.unlink(temp_path)
+
+
+def test_config_loading():
+    """Test configuration loading.""" 
+    print("Testing configuration loading...")
+    
+    # Create temporary config file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        test_config = {
+            "url": "https://test.example.com",
+            "user_id": "test_user",
+            "password": "test_pass",
+            "account": "test_account",
+            "connection": "Demo",
+            "user_id_demo": "demo_user",
+            "password_demo": "demo_pass", 
+            "account_demo": "demo_account"
+        }
+        json.dump(test_config, f)
+        temp_path = f.name
+    
+    try:
+        # Test direct JSON string loading
+        config_str = json.dumps(test_config)
+        config = core.readconfig(json_config_str=config_str)
+        
+        assert config["url"] == "https://test.example.com", "Expected correct URL"
+        assert config["user_id"] == "test_user", "Expected correct user ID"
+        
+        print(f"   ✓ Config from JSON string: {len(config)} keys")
+        
+        # Test demo mode
+        demo_config = core.readconfig(json_config_str=config_str, demo=True)
+        assert demo_config["connection"] == "Demo", "Expected demo connection"
+        assert demo_config["user_id"] == "demo_user", "Expected demo user ID"
+        
+        print(f"   ✓ Demo mode: {demo_config['connection']}")
+        
+    finally:
+        # Clean up
+        os.unlink(temp_path)
+
+
+def test_api_wrappers():
+    """Test simple API wrapper functions."""
+    print("Testing API wrappers...")
+    
+    # Create test config
+    test_config = {
+        "url": "https://api.example.com",
+        "connection": "Demo",
+        "test_key": "test_value"
+    }
+    config_str = json.dumps(test_config)
+    
+    # Test get_config
+    config = core.get_config()
+    print(f"   ✓ get_config returned {len(config)} keys")
+    
+    # Test get_config_value with JSON string
+    os.environ['JGT_CONFIG_JSON_SECRET'] = config_str
+    value = core.get_config_value('test_key', 'default')
+    # Clean up environment
+    del os.environ['JGT_CONFIG_JSON_SECRET']
+    
+    print(f"   ✓ get_config_value: {value}")
+    
+    # Test is_demo_mode
+    demo_mode = core.is_demo_mode()
+    print(f"   ✓ is_demo_mode: {demo_mode}")
+
+
+def main():
+    """Run all tests."""
+    print("=== jgtcore Test Suite ===\n")
+    
+    try:
+        test_str_to_datetime()
+        print()
+        
+        test_market_open()
+        print()
+        
+        test_datetime_helpers()
+        print()
+        
+        test_settings_with_temp_file()
+        print() 
+        
+        test_config_loading()
+        print()
+        
+        test_api_wrappers()
+        
+        print("\n=== All tests passed! ===")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        core.print_exception(e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

jgtcore-0.1.0.dist-info/LICENSE

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

jgtcore-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: jgtcore
+Version: 0.1.0
+Summary: Core library for JGT utilities - configuration, settings, and utility functions
+Author-email: Guillaume Isabelle <jgi@jgwill.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jgwill/jgtcore
+Project-URL: Bug Tracker, https://github.com/jgwill/jgtcore/issues
+Project-URL: Documentation, https://github.com/jgwill/jgtcore#readme
+Project-URL: Source Code, https://github.com/jgwill/jgtcore
+Keywords: configuration,settings,utilities,jgt
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv
+Requires-Dist: ruamel.yaml (>=0.18.6)
+Provides-Extra: dev
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: flake8 ; extra == 'dev'
+
+# jgtcore
+
+Core library for JGT utilities - configuration, settings, and utility functions.
+
+This is a pure Python library extracted from `jgtutils` to provide clean programmatic access to JGT configuration and settings without CLI dependencies.
+
+## Installation
+
+```bash
+pip install jgtcore
+```
+
+## Usage
+
+### Simple Configuration Access
+```python
+import jgtcore
+
+# Load configuration
+config = jgtcore.get_config()
+demo_config = jgtcore.get_config(demo=True)
+
+# Get specific config values
+user_id = jgtcore.get_config_value('user_id')
+quotes_count = jgtcore.get_config_value('quotes_count', 1000)
+```
+
+### Settings Management
+```python
+import jgtcore
+
+# Get all settings
+settings = jgtcore.get_settings()
+
+# Get specific setting with default
+instrument = jgtcore.get_setting('instrument', 'EUR/USD')
+timeframes = jgtcore.get_setting('_timeframes', 'D1')
+```
+
+### Environment Setup
+```python
+import jgtcore
+
+# One-call environment setup
+config, settings = jgtcore.setup_environment(demo=True)
+
+# Check demo mode
+if jgtcore.is_demo_mode():
+    print("Running in demo mode")
+```
+
+### Advanced Usage
+```python
+from jgtcore import readconfig, load_settings
+
+# Load with specific options
+config = readconfig(demo=True, export_env=True)
+settings = load_settings(custom_path="/path/to/settings.json")
+```
+
+## Configuration Files
+
+- **config.json**: Trading credentials and connection settings
+- **settings.json**: Application settings and preferences
+
+See `examples/` directory for sample configuration files.
+
+## File Locations
+
+### config.json lookup order:
+1. Current directory: `config.json`
+2. User home: `~/.jgt/config.json`
+3. System: `/etc/jgt/config.json`
+4. Environment variables: `JGT_CONFIG`, `JGT_CONFIG_PATH`
+
+### settings.json lookup order:
+1. System: `/etc/jgt/settings.json`
+2. User home: `~/.jgt/settings.json`
+3. Current directory: `.jgt/settings.json`
+4. YAML variants: `jgt.yml`, `_config.yml`
+5. Environment variables: `JGT_SETTINGS`
+
+## License
+
+MIT License

jgtcore-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+jgtcore/__init__.py,sha256=dqVduCjlUX03mQIORp8Jf_NZuRhaQ4l8Eb76pNAIWfs,2159
+jgtcore/core.py,sha256=hOfj_SK8yBMvroWmSQSm9hcGEFb5l7g_m-LEIuCcHAQ,21409
+jgtcore/example.py,sha256=FnHo1NR0zFllAhk4Z590w-ZtlXdA9QH0oht4MPotViY,2631
+jgtcore/test_core.py,sha256=xqCvRNa2MQrSoaLa6ACLZrTvkf4Bxx_RIk5fwlflBjo,6432
+jgtcore-0.1.0.dist-info/LICENSE,sha256=uCA_HysYVK9qIMbDEFjcDYhCoKTg19AJhKhM71EKSGA,1086
+jgtcore-0.1.0.dist-info/METADATA,sha256=GCdtDp84Sr5YOO56rknyrUSyjD3lXl3kTkCU7Pt4NgI,3234
+jgtcore-0.1.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+jgtcore-0.1.0.dist-info/top_level.txt,sha256=Chh0dpqpr0NjebGncKO5fsd_FaQzPyUb0Q0WTTfuPsA,8
+jgtcore-0.1.0.dist-info/RECORD,,

jgtcore-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jgtcore-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jgtcore