semvec/pypi-packages huggingface dataset:
scm203lab267101691 0.1.1
Roots of equation and Differential equation
Requires Python: >=3.7

`scm203lab267101691` is a lightweight Python package that provides simple utility functions
for **The bisection method**, **Newton's method**, **3-order Runge-Kutta method** and **4-order Runge-Kutta method**.
It is designed mainly for learning purposes and as an example of Python packaging.

---

## Features
- **Module 1**
    - **The bisection method**: finding root of f in [a,b] with error tolerance
    - **Newton's method**: finding root of f with initial guess x0 and error tolerance
- **Module 2**
    - **3-order Runge-Kutta method**: solve the ODE y' = f(t, y) using the 3rd-order Runge-Kutta method.
    - **4-order Runge-Kutta method**: solve the ODE y' = f(t, y) using the 4th-order Runge-Kutta method.

---

## Installation

You can install the package directly from PyPI:

```bash
pip install scm203lab267101691
```

## Examples
```bash
import scm203lab267101691 as scm
print("bisection ≈",scm.bisection(lambda x: x**3+x-1,0,1,0.001,10))
print("newton ≈",scm.newton(lambda x: x**3+x-1,lambda x: 3*x**2+1,1,0.001,10))
print(scm.order_3_runge(lambda t, y: y - t**2 + 1, 0, 2, 10, 0.5))
print(scm.order_4_runge(lambda t, y: y - t**2 + 1, 0, 2, 10, 0.5))
```
torch-numopt 0.3.1
Classic numerical optimizaton methods for Pytorch neural networks
Requires Python: >=3.10

# Torch Numerical Optimization

This package implements classic numerical optimization methods for training Artificial Neural Networks. 

These methods are not very common in Deep learning frameworks due to their computational requirements, like in the case of Newton-Raphson and Levemberg-Marquardt, which require a large amount of memory since they use information about the second derivative of the loss function. For this reason, it is recommended that these algorithms are applied only to Neural Networks with few hidden layers.

There are also a couple of methods that do not require that much memory such as SGD with line search and the Conjugate Gradient method.

## References
[Numerical Optimization, Jorge Nocedal, Stephen J. Wright](https://link.springer.com/book/10.1007/978-0-387-40065-5)

[Review of second-order optimization techniques in artificial neural networks backpropagation, Hong Hui Tan, Kim Hann Lin](https://iopscience.iop.org/article/10.1088/1757-899X/495/1/012003/meta)

Note: Approximate Greatest Descent is not interesting enough to be included, the author of the method is shared with the author of the review paper, making it's inclusion in the review seem biased. The method can be replicated by applying damping to the hessian on Newton's method along with a trust region method to calculate $\mu$.

## Planned optimizers

- [x] Newton-Raphson
- [x] Gauss-Newton
- [x] Levenberg-Marquard (LM)
- [x] Stochastic Gradient Descent with Line Search
- [x] Conjugate Gradient
- [x] AdaHessian
- [ ] Quasi-Newton (LBFGS already in pytorch)
- [ ] Hessian-free / truncated Newton

If you feel like there's a missing algorithm you can open an issue with the name of the algorithm with some references and a justification why you think it should be included in the package.
trasor-sdk 2.1.0
Official Python SDK for Trasor.io trust infrastructure platform
Requires Python: >=3.8.1
Keywords: audit, logging, security, ai, agents, blockchain, verification, trust, infrastructure

# Trasor Python SDK

Official Python SDK for [Trasor.io](https://trasor.io) - AI Agent Security & Governance Platform

## Installation

```bash
pip install trasor-sdk
```

## Quick Start

```python
from trasor import TrasorClient

# Initialize the client
client = TrasorClient(api_key="trasor_live_your_api_key_here")

# Log an audit event
result = client.log_event(
    agent_name="my_agent",
    action="process_data",
    inputs={"user_id": "12345", "query": "Hello world"},
    outputs={"response": "Hello! How can I help you?"},
    status="success"
)

print(f"Event logged: {result['id']}")
```

## Security & Governance Features

### Zero-Knowledge Proofs
Generate cryptographic proofs for audit verification without exposing sensitive data:

```python
# Generate proof
proof = client.generate_zk_proof(
    agent_name="payment_processor",
    start_date="2025-01-01", 
    end_date="2025-01-31"
)

# Verify proof
verification = client.verify_zk_proof(proof["hash"])
```

### Behavioral Drift Detection
Monitor agent behavior and detect anomalies:

```python
# Set baseline behavior
client.set_agent_baseline("my_agent", {
    "average_response_time": 150,
    "error_rate": 0.01,
    "normal_actions": ["process_payment", "validate_card"]
})

# Get drift alerts
alerts = client.get_drift_alerts(
    agent_name="my_agent",
    severity="critical"
)
```

### Role-Based Access Control (RBAC)
Manage agent permissions and monitor violations:

```python
# Assign role to agent
client.assign_agent_role(
    agent_name="data_processor",
    role_id=2,  # Writer role
    enforcement_mode="block_violations"
)

# Monitor violations
violations = client.get_rbac_violations(limit=50)
```

### Compliance & Monitoring
Track ISO 42001 compliance and security threats:

```python
# Get compliance score
compliance = client.get_iso_compliance_score()
print(f"Overall Score: {compliance['overallScore']}%")

# Analyze security threats
threats = client.get_threat_analysis(time_range="24h")

# Get real-time metrics
metrics = client.get_observability_metrics(
    agent_name="my_agent",
    metric_type="performance"
)
```

## Framework Integrations

### CrewAI Integration
```python
from trasor.integrations.crewai import TrasorCrewCallbacks

crew = Crew(
    agents=[agent],
    tasks=[task],
    callbacks=[TrasorCrewCallbacks(api_key="trasor_live_xxx")]
)
```

### LangChain Integration
```python
from trasor.integrations.langchain import TrasorLangChainCallback
from langchain.callbacks import CallbackManager

callback_manager = CallbackManager([
    TrasorLangChainCallback(api_key="trasor_live_xxx")
])
```

## API Reference

For complete API documentation, visit: https://docs.trasor.io/api

## Support

- Documentation: https://docs.trasor.io
- Email: support@trasor.io
- GitHub Issues: https://github.com/trasor-io/trasor-python/issues

## License

MIT License. See LICENSE file for details.
plumed 2.10.0
Python interface to PLUMED
Requires Python: >=3

Python wrappers for plumed
==========================

Install using the following command::

     python -m pip install plumed

WARNING: You will need to also build and install the plumed library (see http://www.plumed.org) and make sure the file `libplumedKernel.so` (or `libplumedKernel.dylib`) is available on your system.

You should then make sure the library is found setting the environment variable `PLUMED_KERNEL`::

     export PLUMED_KERNEL=/path/to/libplumedKernel.so
     python
     >>> import plumed
     >>> p=plumed.Plumed()

If you manage multiple plumed versions on your system using tcl environment modules, this should be taken care automatically
by the plumed module.

Alternatively, a pure python solution is::

    >>> import plumed
    >>> os.environ["PLUMED_KERNEL"]="/path/to/libplumedKernel.so"
    >>> p=plumed.Plumed()

Finally, notice that you can set the path to the plumed library directly when declaring a Plumed object::

    >>> import plumed
    >>> p=plumed.Plumed(kernel="/path/to/libplumedKernel.so")

This will allow you to mix different plumed versions in the same python script.

CHANGES: See the PLUMED documentation.