semvec/pypi-packages huggingface dataset:
dsws 0.49
dsws
License: MIT
Keywords: Data Science WorkSpace JDBC

# DSWS

**Data Science WorkSpace**: Management solution for Data Science Workspaces.

[![DatabricksRuntime](https://img.shields.io/badge/Databricks%20Runtime-12.2%20LTS-orange)](https://docs.databricks.com/release-notes/runtime/releases.html)
[![PyPi](https://img.shields.io/pypi/v/dsws)](https://pypi.org/project/dsws)
[![PyPi](https://img.shields.io/pypi/wheel/dsws)](https://pypi.org/project/dsws)

## Interactive Evaluation

```python
from dsws.duct import Duct
```
taleb 0.0.4
A pure python version of ta-lib.
License: MIT
Keywords: talib ta-lib taleb technical analysis

# taleb

<a href="https://pypi.org/project/taleb/">
    <img alt="PyPi" src="https://img.shields.io/pypi/v/taleb">
</a>

A pure python version of [ta-lib](https://ta-lib.org/).

## Dependencies :globe_with_meridians:

Python 3.11.6:

- [numpy 1.26.4](https://numpy.org/)
- [pandas 2.2.1](https://pandas.pydata.org/)
- [scipy 1.12.0](https://scipy.org/)

## Raison D'être :thought_balloon:

taleb is a pure python implementation of the [ta-lib](https://ta-lib.org/) C library that doesn't call out to any library other than python dependencies.
Thus it doesn't require ta-lib to be installed on a system before use, and is extremely portable.
In addition to this it uses vectorisation where applicable.
This library has the exact API as [ta-lib-python](https://github.com/TA-Lib/ta-lib-python) where implemented.

```python
import taleb
import numpy as np

close = np.random.random(100)
taleb.MOM(close)
```

It is designed to be a drop-in replacement where instead of importing `talib` you import `taleb`.

## Installation :inbox_tray:

This is a python package hosted on pypi, so to install simply run the following command:

`pip install taleb`

Note that upon running this package for the first time, you may notice a slight delay as it downloads the relevant R packages.

## Usage example :eyes:

To get familiar with the individual functions and charts check out the documents in the [ta-lib documentation](https://ta-lib.org/functions/). This library ports over 200 functions.

## License :memo:

The project is available under the [MIT License](LICENSE).
test-mongo-connector 0.0.6
A python package for connecting with database.
License: MIT
Requires Python: >=3.10

# Created a new Package: pip install test-mongo-connector

## requirements_dev.txt -  Used for the testing
It makes it easier to install and manage dependencies for development and testing, separate from the dependencies required for production.

## Difference between requirements_dev.txt and requirements.txt
requirements.txt is used to specify the dependencies required to run the production code of a Python project, while requirements_dev.txt is used to specify the dependencies required for development and testing purposes.

## tox.ini
We use if for the testing in the python package testing against different version of the python

## how tox works tox environment creation
Install depedencies and packages
Run commands
Its a combination of the (virtualenvwrapper and makefile)
It creates a .tox

## pyproject.toml
it is being used for configuration the python project it is a alternative of the setup.cfg file. its containts configuration related to the build system such as the build tool used package name version author license and dependencies

## setup.cfg
In summary, setup.cfg is used by setuptools to configure the packaging and installation of a Python projec

## Testing python application
*types of testing*

1. Automated testing
2. Manual testing

*Mode of testing*
1. Unit testing
2. Integration tests

## Testing frameworks
pytest
unittest
robotframework
selenium
behave
doctest

## check with the code style formatting and syntax(coding standard)
pylint
flake8(it is best because it containt 3 library pylint pycodestyle mccabe)
pycodestyle
pyfractions 0.1.0
A Python library for working with fractions
License: MIT
Keywords: fraction math

# Fraction Calculator

The Fraction Calculator is a versatile Python library designed for performing various operations in ```numerator/denominator``` format. It enables users to work with fractions seamlessly and includes features like basic arithmetic operations, comparison methods, and more.

## Features

- **Basic Arithmetic Operations:**
  - Addition
  - Subtraction
  - Multiplication
  - Division
  - Floor Division
  - Modulus

- **Comparison Methods:**
  - Compare fractions using the following methods:
    - Less than (`<`)
    - Less than or equal to (`<=`)
    - Equal to (`==`)
    - Not equal to (`!=`)
    - Greater than (`>`)
    - Greater than or equal to (`>=`)

## Usage

To utilize the Fraction Calculator, create instances of the `Fraction` class and perform operations. Here's an example showcasing basic usage:

```python
from pyfractions import Fraction

# Create Fraction objects
fraction1 = Fraction(1, 2)
fraction2 = Fraction(3, 4)

# Perform operations
sum_result = fraction1 + fraction2
difference_result = fraction1 - fraction2
product_result = fraction1 * fraction2
quotient_result = fraction1 / fraction2

# Display results
print(f'Sum: {sum_result}')               # Sum: 5/4
print(f'Difference: {difference_result}') # Difference: -1/4
print(f'Product: {product_result}')       # Product: 3/8
print(f'Quotient: {quotient_result}')     # Quotient: 2/3

# Check if fraction1 is greater than fraction2
is_greater = fraction1 > fraction2

# Display result
print(f'Is fraction1 greater than fraction2? {is_greater}') 
# Is fraction1 greater than fraction2? False
```
opfuncs 1.0.1
A package to enable the usage of operators on python functions
License: MIT
Requires Python: >=3.10

# opfuncs
A package to enable the usage of operators on python functions.

```pycon
>>> from opfuncs import opfunc
>>> @opfunc
... def add_7(x):
...     return x + 7
...
>>> @opfunc
... def times_4(x):
...     return x * 4
...
>>> (add_7 + times_4)(5)
32
>>> (add_7 * times_4)(3)
120
>>> times_4[add_7](4)  # supports composition
44
```

---

# Installation
The opfuncs package can be installed from PyPI using pip:

```
pip install opfuncs
```

---

# Features
Can be used alongside normal functions occupying the right-side argument of the operator.
```pycon
>>> def line(x):
...     return 3 * x + 4
...
>>> (times_4 * line)(3)
156
```

---

You can restrict a function to only allow/disallow certain operators using the
`include` and `exclude` parameters:
```pycon
>>> @opfunc(include=('add', ))
>>> def mod_3(x):
...     return x % 3
```
Refer to the `SUPPORTED_OPERATORS` constant within the package for the list operator names supported by `include` and `exclude`.

---

You can customize an operator to use a function you define in place of the usual operator. Custom operators are supplied to the `opfunc` wrapper through the `custom_ops` parameter, which accepts a dictionary mapping operator names to operator function builders.
```pycon
>>> def custom_xor(
...     f: Callable[[float], float],
...     g: Callable[[float], float],
... ) -> Callable[[float], float]:
...     def xor_as_pow(x: float) -> float:
...         return f(x) ** g(x)
...
...     return xor_as_pow
...
>>> custom_times_4 = opfunc(times_4, custom_ops={"xor": custom_xor})
>>> custom_add_7 = opfunc(add_7, custom_ops={"xor": custom_xor})
>>> (custom_times_4 ^ custom_add_7)(-5)
400
```
Refer to the `SUPPORTED_OPERATORS` constant within the package for the list operator names supported by `custom_ops`.

---

# Supported Operators
The opfuncs package supports the following python operators and functions:
- `&`
- `|`
- `^`
- `+`
- `-`
- `*`
- `@`
- `/`
- `//`
- `%`
- `divmod()`
- `**` and `pow()`
- `<<`
- `>>`
- `-()`
- `+()`
- `abs()`
- `~`
- `round()`
- `math.trunc()`
- `math.floor()`
- `math.ceil()`