semvec/pypi-packages huggingface dataset:
nbs-srednji-kurs 1.2.0
Get average currency values for Serbia
Requires Python: >=3.12

# NBS Srednji Kurs

## O projektu

Ovo je Python paket koji omogućava jednostavno preuzimanje i prikaz zvaničnog srednjeg kursa valuta Narodne Banke Srbije (NBS). Aplikacija preuzima najnovije podatke sa zvaničnog sajta NBS i prikazuje ih u preglednom tabelarnom formatu.

### Funkcionalnosti

- Preuzimanje aktuelnog srednjeg kursa za sve valute
- Mogućnost filtriranja prikaza za određene valute
- Pregled kursa za određeni datum
- Pregledan tabelarni prikaz rezultata u terminalu

## Instalacija

### Preduslovi

- Python 3.12 ili noviji
- pip (Python Package Installer)

### Postupak instalacije

Instalirajte `nbs-srednji-kurs` koristeći sledeću komandu:

```shell
pip install nbs-srednji-kurs
```

## Kako koristiti

### Osnovne komande

1. Prikaz svih valuta za današnji dan:
   ```shell
   nbskurs
   ```

2. Prikaz svih dostupnih opcija i pomoći:
   ```shell
   nbskurs -h
   ```

### Napredne opcije

1. Prikaz kursa za određeni datum:
   ```shell
   nbskurs --date 01.08.2025
   ```

2. Prikaz kursa samo za određene valute:
   ```shell
   nbskurs --currency EUR,USD,CHF
   ```

3. Kombinovanje opcija:
   ```shell
   nbskurs --date 01.08.2025 --currency EUR,USD
   ```

### Korišćenje u Python projektu

Paket možete koristiti i programski u vašim Python projektima:

1. Prvo uvezite potrebne funkcije:
   ```python
   from nbs_kurs import get_all_currency_values, get_value_by_currency, get_currency_by_name
   ```

2. Preuzimanje svih kurseva za određeni datum:
   ```python
   # Format datuma: DD.MM.YYYY
   kursevi = get_all_currency_values("01.08.2025")
   print(f"Broj preuzetih valuta: {len(kursevi)}")
   ```

3. Filtriranje kurseva za određene valute:
   ```python
   # Prvo preuzmite sve kurseve
   svi_kursevi = get_all_currency_values("01.08.2025")
   
   # Zatim filtrirajte samo željene valute
   filtrirani_kursevi = get_value_by_currency(["EUR", "USD", "CHF"], svi_kursevi)
   
   # Prikaz rezultata
   for kurs in filtrirani_kursevi:
       print(f"{kurs.short_name}: {kurs.value} RSD za {kurs.valid_for} {kurs.country}")
   ```

4. Preuzimanje pojedinačne valute po imenu:
   ```python
   # Prvo preuzmite sve kurseve
   svi_kursevi = get_all_currency_values("01.08.2025")
   
   # Zatim pronađite specifičnu valutu po njenom kratkom imenu
   euro = get_currency_by_name("EUR", svi_kursevi)
   
   if euro:
       print(f"Kurs za {euro.short_name}: {euro.value} RSD za {euro.valid_for} {euro.country}")
   else:
       print("Valuta nije pronađena")
   ```

## Tehnički detalji

Paket koristi sledeće biblioteke:
- beautifulsoup4 - za parsiranje HTML sadržaja
- requests - za preuzimanje podataka sa sajta NBS
- rich - za formatiran prikaz rezultata u terminalu

## Autor

Ivan Miletić (milemik68@gmail.com)

## Licenca

Ovaj projekat je dostupan pod MIT licencom.

## Doprinos projektu

Doprinosi su dobrodošli! Ako želite da doprinesete projektu, molimo vas da:
1. Napravite fork repozitorijuma
2. Kreirate novu granu za vašu funkcionalnost
3. Pošaljete pull request

## Kontakt

Za sva pitanja i sugestije, možete kontaktirati autora putem email adrese navedene iznad.
safelib 0.6.1
An advanced library for safe importing and scoped imports management.
Requires Python: >=3.10

##  SafeLib - Import Everything Safe

Safelib is an importer that supports fallback mechanism.

### 0.6.0 Changelog

* Fixed several issues
* Added safelib.valid instead importer.valid
* Added search_builtins feature
* Extended exception handling

## Example Usage

### Using Context Manager (sync/async)
```python
import safelib

from safelib import Import
with Import('sqlalchemy', 'peewee', raises=False, search_builtins=True) as orm:
    from safelib import declarative_base # use traditional import
    Base = orm.declarative_base # use orm to access the declarative_base

    # declarative_base can be found entity or safelib.NotFound
    # because we set raises=False, it will not raise an exception if the entity is not found

    # when we search for `int` with orm.int, it will search first in the builtins module
    # and return the int type if found, or safelib.NotFound if not found.

    # to validate whether an entity is valid, use:
    if safelib.valid(orm.entity):
        do_something_with(orm.entity)
```

### Using Classical Imports

```python
from safelib import _main, typing, _fallback, typing_extensions

from safelib import Protocol, _no_raise

#> Protocol is safelib.NotFound, typing.Protocol or typing_extensions.Protocol

from safelib import _no_raise # catch errors by defaulting missing entities
```

### No-Raise Statement

Import `_no_raise` sentinel to catch exceptions in current state.

```python
from safelib import _main, typing
from safelib import _no_raise, Protocool
# Protocool is safelib.NotFound, otherwise raises exception

import safelib

with safelib.Import(raises=False) as foo:
    # use context manager of Import with raises=False
    # or call safelib.catch() before context manager
    pass
```

### Reset Statement

Import `_reset` sentinel to reset current state of safelib.

```python
from safelib import _main, httpx
# after get method returned, state will be restored to initial state
from safelib import get, _reset 
```

```python
from safelib import Import

async with Import('sqlalchemy', 'peewee') as importer:
    SafeEntity = importer.SafeEntity
    importer.reset_state()
```

For inquiries, feature request and bug reports, please contact me at contact@tomris.dev