semvec/pypi-packages huggingface dataset:
simpleqlearn 0.1.1
A tiny Q-learning update function for RL beginners.
License: MIT
Requires Python: >=3.8
Keywords: reinforcement-learning, q-learning, education, rl

# simpleqlearn

A minimal, well-documented **Q-learning table update** function.

## Install
```bash
pip install simpleqlearn
from simpleqlearn import q_update

Q = {}
Q = q_update(Q, state="s1", action="a1", reward=1.0, next_state="s2")
print(Q)  # {'s1': {'a1': 0.1}} for default alpha=0.1, gamma=0.99
fyle 1.1.2
Python SDK for accessing Fyle Platform APIs
License: MIT
Keywords: fyle, api, python, sdk

# Fyle

Python SDK for accessing Fyle Platform APIs. [Fyle](https://www.fylehq.com/) is an expense management system.

## Installation

This project requires [Python 3+](https://www.python.org/downloads/) and [Requests](https://pypi.org/project/requests/) library (pip install requests).

1. Download this project and use it (copy it in your project, etc).
2. Install it from [pip](https://pypi.org).
        
        $ pip install fyle

## Usage

To use this SDK you'll need these Fyle credentials used for OAuth2 authentication: **client ID**, **client secret** and **refresh token**. You can follow the steps on this [Article](https://www.fylehq.com/help/en/articles/3045578-integrating-with-fyle) or reach out to support@fylehq.com.

This SDK is very easy to use.
* First you'll need to create a connection using the main class Platform.
```python
from fyle.platform import Platform

fyle = Platform(
    server_url='FYLE SERVER URL',
    token_url='FYLE TOKEN URL',
    refresh_token='FYLE REFRESH TOKEN',
    client_id='FYLE CLIENT ID',
    client_secret='FYLE CLIENT SECRET'
)
```

*  You can access the V1 version of the APIs as follows:
```python
"""
USAGE: <Platform INSTANCE>.<VERSION: eg. v1>.<FYLE ROLE: eg. admin>.<API_NAME: eg. expenses>.<API_METHOD: eg. get>(<PARAMETERS>)
"""

# Get a list of all Expenses in a paginated manner and add to a list
expenses = []

query_params = {
    'order': 'created_at.desc'
}

expenses_generator = fyle.v1.admin.expenses.list_all(query_params=query_params)

for response in expenses_generator:
    if response.get('data'):
        expenses.extend(response['data'])

```

## Integration Tests

1. Install [pytest](https://pypi.org/project/pytest/) package using pip as follows:

```
pip install pytest
```

2. Add the following environment variables to test_credentials.sh file

```
    export SERVER_URL=<FYLE SERVER URL>
    export TOKEN_URL=<FYLE TOKEN URL>
    export REFRESH_TOKEN=<FYLE REFRESH TOKEN>
    export CLIENT_ID=<FYLE CLIENT ID>
    export CLIENT_SECRET=<FYLE CLIENT SECRET>
```
##### NOTE: The credentials used should have required roles assigned to them

3. Apply secrets and Run integration tests as follows:

```
source test_credentials.sh  && python -m pytest test/integration
```
4. To get the code coverage execute the following:

```
pytest test/ --cov
```
Currently the code coverage is at 95%

## Release latest version to [PyPi](https://pypi.org/project/fyle/)

* Open the releases section on GitHub and [Draft a new release](https://github.com/fylein/fyle-platform-sdk-py/releases/new).
* Check the version in setup.py, make sure you update that version along with your changes.
* Add the version and description and click ok `Publish Release` button.
* This will trigger the github action and automatically push the SDK to PyPi

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
epsilonpolicy 0.1.1
A tiny epsilon-greedy action selection function for reinforcement learning.
License: MIT
Requires Python: >=3.8
Keywords: reinforcement-learning, epsilon-greedy, rl

# epsilonpolicy

A minimal epsilon-greedy action selection function.

## Install
```bash
pip install epsilonpolicy
from epsilonpolicy import epsilon_greedy

Q = {}
actions = ["left", "right", "up", "down"]
action = epsilon_greedy(Q, state="S", actions=actions, epsilon=0.2)
print(action)
pyfunclog 2.0.1
Comprehensive function logging with async support and sensitive data protection
License: MIT
Requires Python: >=3.7
Keywords: logging, debugging, security, async, fastapi, sensitive-data

# PyFuncLog

Comprehensive function logging with automatic sensitive data protection.

## Features

- 🕵️‍♂️ **Automatic Variable Capture**: Captures all local variables and function arguments
- 🔒 **Sensitive Data Protection**: Automatically masks passwords, tokens, API keys, etc.
- 🎯 **Flexible Decorators**: Choose what to log - everything, returns, or just locals
- 📝 **Structured Logging**: JSON-formatted logs with clear structure
- 🚀 **Easy Integration**: Simple decorator-based approach

## Installation

```bash
pip install pyfunclog
```

## usage example:
```python
import asyncio
from pyfunclog import async_secure_log_function

@async_secure_log_function()
async def fetch_data(api_key: str, user_id: int):
    # api_key will be automatically masked
    await asyncio.sleep(0.1)
    result = {"user_id": user_id, "data": "sample"}
    return result

# Or use universal decorator for both sync and async
from pyfunclog import universal_log

@universal_log
async def async_function(x):
    return x * 2

@universal_log
def sync_function(x):
    return x * 2
```

## fastapi integration
```python
from fastapi import FastAPI
from pyfunclog import FastAPILoggingSupport, async_secure_log_function

app = FastAPI()
logging_support = FastAPILoggingSupport()
logging_support.middleware(app)  # Add request/response logging

@app.get("/users/{user_id}")
@async_secure_log_function()
async def get_user(user_id: int, token: str):
    # token will be automatically masked
    return {"user_id": user_id, "name": "John Doe"}
```

## configure logging
```python
from pyfunclog import configure_logging

# Configure logging
configure_logging(
    level="DEBUG",
    format_string='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename="app.log"
)
```