semvec/pypi-packages huggingface dataset:
GTAlib-MonteCarlo 0.1.2
Libreria para calcular la integral definida sobre de un intérvalo de una funcion
License: MIT
Requires Python: >=3.11.6

# GTAlib_MonteCarlo - Clase para la Integracion Numerica con el Metodo de Monte Carlo

La clase `MonteCarlo` proporciona una forma de realizar la integracion numerica de una funcion utilizando el metodo de Monte Carlo. 

## Requisitos

- Python 3.11.6
- numpy 1.26.1


## Instalacion

Para instalar la libreria, utiliza el comando

```bash
pip install GTAlib_MonteCarlo
```


## Uso
La estructura base para implementar la libreria es:

1. Importa la clase `MonteCarlo` en tu script de Python:

    ```python
    from GTAlib_MonteCarlo import MonteCarlo 
    ```
2. Define la funcion que deseas integrar. Puede ser cualquier funcion que acepte un valor `x` y devuelva un valor numerico.

   ```python
   def function(x):
       return x**2  
   ```

3. Crea una instancia de `MonteCarlo` proporcionando los limites de integracion, la funcion y el numero de puntos aleatorios:

   ```python
   a = 0  # Limite inferior de integracion
   b = 1  # Limite superior de integracion
   n = 100000  # Numero de puntos aleatorios
   solver = MonteCarlo(a, b, function, n)
   ```

4. Llama al metodo `MonteCarlo` de la instancia de `MonteCarlo` para calcular la integral:

   ```python
   result = solver.integrate()
   ```

5. El resultado sera un valor numerico que representa la aproximacion de la integral de la funcion en el intervalo `[a, b]`.

6. Puedes imprimir el resultado o utilizarlo en tus calculos segun sea necesario.
pip-services4-observability 0.0.5
Observability components for Pip.Services in Python
License: MIT

# <img src="https://uploads-ssl.webflow.com/5ea5d3315186cf5ec60c3ee4/5edf1c94ce4c859f2b188094_logo.svg" alt="Pip.Services Logo" width="200"> <br/> Observability Components for Python

This module is a part of the [Pip.Services](http://pipservices.org) polyglot microservices toolkit.

The Observability module contains observability component definitions that can be used to build applications and services.

The module contains the following packages:
- **Count** - performance counters
- **Log** - basic logging components that provide console and composite logging, as well as an interface for developing custom loggers
- **Trace** - tracing components

<a name="links"></a> Quick links:

* [Logging](https://www.pipservices.org/recipies/logging)
* [API Reference](https://pip-services3-python.github.io/pip-services4-observability-python/index.html)
* [Change Log](CHANGELOG.md)
* [Get Help](https://www.pipservices.org/community/help)
* [Contribute](https://www.pipservices.org/community/contribute)

## Use

Install the Python package as
```bash
pip install pip_services4_observability
```

Example how to use Logging and Performance counters.
Here we are going to use CompositeLogger and CompositeCounters components.
They will pass through calls to loggers and counters that are set in references.

```python
class MyComponent(IConfigurable, IReferenceable):
    __logger = CompositeLogger()
    __counters = CompositeCounters()

    def configure(self, config):
        self.__logger.configure(config)

    def set_references(self, references):
        self.__logger.set_references(references)
        self.__counters.set_references(references)

    def my_method(self, context, param1):
        try:
            self.__logger.trace(context, "Executed method mycomponent.mymethod")
            self.__counters.increment("mycomponent.mymethod.exec_count", 1)
            timing = self.__counters.begin_timing("mycomponent.mymethod.exec_time")
            # ...
            timing.end_timing()
        except Exception as ex:
            self.__logger.error(context, ex, "Failed to execute mycomponent.mymethod")
            self.__counters.increment("mycomponent.mymethod.error_count", 1)
```

## Develop

For development you shall install the following prerequisites:
* Python 3.7+
* Visual Studio Code or another IDE of your choice
* Docker

Install dependencies:
```bash
pip install -r requirements.txt
```

Run automated tests:
```bash
python test.py
```

Generate API documentation:
```bash
./docgen.ps1
```

Before committing changes run dockerized build and test as:
```bash
./build.ps1
./test.ps1
./clear.ps1
```

## Contacts

The initial implementation is done by **Sergey Seroukhov**. Pip.Services team is looking for volunteers to 
take ownership over Python implementation in the project.
pip-services4-kafka 0.0.1
Communication components for Pip.Services in Python
License: MIT


Pip.Services Kafka
----------------------

Pip.Services is an open-source library of basic microservices.

Links
`````

* `website <http://github.com/pip-services-python/>`_
* `development version <http://github.com/pip-services4-python/pip-services4-kafka-python>`
pip-services4-gcp 0.0.1
Google Cloud components for Pip.Services in Python
License: MIT


Pip.Services GCP
----------------------

Pip.Services is an open-source library of basic microservices.
pip_services4_gcp provides synchronous and asynchronous communication components.

Links
`````

* `website <http://github.com/pip-services-python/>`_
* `development version <http://github.com/pip-services4/pip-services4-python/tree/main/pip-services4-gcp-python>`
pip-services4-prometheus 0.0.1
Prometheus components for Pip.Services in Python
License: MIT


Pip.Services Prometheus
--------------------

Pip.Services is an open-source library of basic microservices.
pip_services4_prometheus contains components for working with meters in the Prometheus service.

Links
`````

* `website <http://github.com/pip-services/pip-services>`
* `development version <http://github.com/pip-services-python/pip-services-prometheus-python>`
pip-services4-messaging 0.0.1
Messaging components for Pip.Services in Python
License: MIT


Pip.Services Net
----------------------

Pip.Services is an open-source library of basic microservices.
pip_services4_messaging provides messaging components.

Links
`````

* `website <http://github.com/pip-services-python/pip-services-python-messaging>`_
* `development version <http://github.com/pip-services4/pip-services4-python/tree/main/pip-services4-messaging-python>`
pip-services4-memcached 0.0.1
Communication components for Pip.Services in Python
License: MIT


Pip.Services Memcached
----------------------

Pip.Services is an open-source library of basic microservices.
The Memcached module contains the following components: MemcachedLock and MemcachedCache for working with locks and cache on the Memcached server.
Links
`````

* `website <http://github.com/pip-services-python/>`_
* `development version <http://github.com/pip-services3-python/pip-services4-memcached-python>`
pip-services4-data 0.0.4
Data processing and persistence components for Pip.Services in Python
License: MIT


Pip.Services Data
------------------

Pip.Services is an open-source library of basic microservices.
pip_services4_data provides data processing and persistence components.

Links
`````

* `website <http://github.com/pip-services/pip-services>`_
* `development version <http://github.com/pip-services4/pip-services4-python/tree/main/pip-services4-data-python>`
ubertyped 0.1.2
Convert dataclass to TypedDict for fun and type safety 🪄
License: MIT
Requires Python: >=3.11,<4.0

# Übertyped

Convert `dataclass` to `TypedDict` for fun and type safety 🪄

> **uber-** _/ˈuːbə/_ to a great or extreme degree

## Requirements

- `python>=3.11`
- `mypy>=1.0.1`

## Installation

```shell
pip install ubertyped
```

### Mypy plugin

Add `ubertyped.mypy_plugin` to the list of plugins in your [mypy config file](https://mypy.readthedocs.io/en/latest/config_file.html)
(for example `pyproject.toml`)

```toml
[tool.mypy]
python_version = "3.11"
plugins = ["ubertyped.mypy_plugin"]
```

## Features

- ✅ `AsTypedDict[T]` generic type converting `dataclasse`s to `TypeDict`s
- ✅ `as_typed_dict` utility function wrapping `dataclasses.asdict`
- ✅ Support for usage with `TypeVar`s
- ✅ Nested dataclasses
- ✅ Compatibility with other typecheckers such as `Pylance` and `Pyright`
- ✅ Zero dependencies

## Usage

```python
from dataclasses import asdict, dataclass
from typing import Self, reveal_type

from ubertyped import AsTypedDict, as_typed_dict


@dataclass
class Base:
    base: bool


@dataclass
class IntWrapper:
    value: int


@dataclass
class Data(Base):
    version: IntWrapper
    command: str

    def as_typed_dict(self) -> AsTypedDict[Self]:
        return as_typed_dict(self)


data = Data(version=IntWrapper(1), command="c", base=False)

# 🎉 Type-safe conversion!
td = as_typed_dict(data)
reveal_type(td)
# Revealed type is "TypedDict({'version': TypedDict({'value': builtins.int}), 'command': builtins.str, 'base': builtins.bool})"

# 🎉 Works with nested dataclasses too!
reveal_type(td["version"]["value"])
# Revealed type is "builtins.int"


# 🎉 Binding `Self` in methods is resolved correctly!
reveal_type(data.as_typed_dict)
# Revealed type is "def () -> TypedDict({'version': TypedDict({'value': builtins.int}), 'command': builtins.str, 'base': builtins.bool})"

# 🎉 In runtime, `as_typed_dict` is just a wrapper around `asdict`!
if asdict(data) == data.as_typed_dict():
    print("✅")
else:
    print("❌")
```