semvec/pypi-packages huggingface dataset:
bisectlib 0.1.0
array bisection algorithm helper
Requires Python: >=3.8

# bisectlib
array bisection algorithm helper

## install
```
pip install bisectlib
```

## usage
you should subclass from `Bisect` and implement 1 method `is_bad` or `is_good`.
This method should return `True/False` which indicates is option good or bad.
When instantiating your class you should provide a sequence of options to check. They should be sorted by `is_bad`. By default, left side of options are considered good options and on the right are bad ones. (You can change this by passing `sort_order='bad-good'` argument)


## simple example
```py
from bisectlib import Bisect

class FirstGreaterThan3(Bisect):
    def is_bad(self, op) -> bool:
        return op > 3

# or you can use is_good:
class FirstGreaterThan3(Bisect):
    def is_good(self, op) -> bool:
        return op <= 3

first_greater_than_3 = FirstGreaterThan3(options = (1, 2, 3, 4, 5, 6))
```

```py
>>> first_greater_than_3.is_bad(2)
False

>>> first_greater_than_3.is_bad(5)
True

>>> first_greater_than_3()
4 start
4: BAD
2 start
2: GOOD
3 start
3: GOOD
====================================================================================================
first bad option is: 4
4
```


## more complex example - find first bad version of poetry dependency
```py
import subprocess
from bisectlib import Bisect

class FirstBadDependencyVersion(Bisect):
    def is_bad(self, op) -> bool:
        # kinda setup
        subprocess.check_call(f'git checkout HEAD -- poetry.lock pyproject.toml && poetry add "my_library=={op}"', shell=True)

        # check is_bad
        return bool(subprocess.run('make test', shell=True).returncode)

first_bad_dependency_version = FirstBadDependencyVersion(options='''\
v0.0.1
v0.0.2
v0.0.3
v0.1.0
v0.1.1
v0.1.2
v0.2.0
v0.2.1
'''.splitlines())
```

```py
>>> first_bad_dependency_version()
v0.1.1 start
v0.1.1: GOOD
v0.2.0 start
v0.2.0: BAD
v0.1.2 start
v0.1.2: BAD
====================================================================================================
first bad option is: v0.1.2
'v0.1.2'
```
CloudEdgeAssetsOptimizer 0.1.4
# CloudEdgeAssetsOptimizer

# CloudEdgeAssetsOptimizer   
    
CloudEdgeAssetsOptimizer is a software tool designed to evaluate and 
optimize the assets within a Cloud and Edge computing network. Its primary 
purpose is to provide insights and estimations to ensure efficient resource
allocation and decision-making. 

The developed software simulates the queues in Cloud and Edge devices, 
providing waiting times, battery consumption of Edge devices, and Servers' 
load. With a fore mentioned parameters available, valuable insights 
for decision-making can be obtained to optimize the network. Alternatively 
automated optimization can be performed using the embedded functions. 
CloudEdgeAssetsOptimizer aims to optimize operational efficiency, 
enhance resource utilization, and ultimately improve overall system 
performance. 

CloudEdgeAssetsOptimizer functions utilize queueing theory principles, 
therefore it also enables users to explore and fine-tune system parameters 
across diverse domains,including telecommunication networks, transportation
and manufacturing systems.

Author: Paulius Tervydis
 
Date: 2023-07-23
timberas 0.3.0
timberas is a Python package for the design of timber structures to relevant Australian Standards
Requires Python: >=3.10
Keywords: AS1170,AS1684,timber structures,structural engineering

# About
*timberas* is a Python package with tools to support research and design of Australian timber structures. It can be used to determine the material properties, section properties, and design capacities for structural members as per Australian Standard AS1720.1:2020 (Timber Structures Part 1: Design Methods). 

# Documentation
Detailed information on *timberas* is available in package documentation at [timberas.readthedocs.io](https://timber-as.readthedocs.io/). This includes project background, examples, and an API reference guide.

# Installation
*timberas* can be installed from the Python Package index:
```
pip install timberas
```
For more detailed instructions, please refer to the [documentation]([https://timberas.readthedocs.io]).

# Current Features
- **Section library**: define sections and calculate section properties from typical Australian timber product dimensions, or from custom user input. 
- **Material library**: create timber materials from typical Australian grade classifications (F-Grade, MGP, Glulam), or from custom user input.
- **Design capacity calculations**: solve the design capacities of structural timber members in tension, compression, bending, and shear, following AS1720.1 design methods.

# Questions, Feedback, and Contributions 
If you have questions, feedback, or suggestions for further development, please email [Joe Gattas](https://researchers.uq.edu.au/researcher/9443) or create an issue on the *timberas* github repository.

Similarly, if you find any bugs, or are interested to contribute to the project, please create an issue or email Joe.


# License 
*timberas* is an open source engineering tool provided under an MIT License. Please refer to the [LICENSE](./LICENSE.md) file for more information. 

Please note that this software has been developed by student and academic engineering researchers, NOT by chartered or registered engineers. 

# Acknowledgements
This package has been developed from research projects supported by the [University of Queensland](https://civil.uq.edu.au/), [ARC Future Timber Hub](https://futuretimberhub.org/) (2016-2021), and [ARC Advance Timber Hub](https://www.advance-timber-hub.org/) (2022-).


If you use *timberas* for projects or scientific publications, please consider citing our journal paper:
> Jiang, J., Ottenhaus, L. M., & Gattas, J. M. (2023). A parametric design framework for timber framing span tables. *Australian Journal of Civil Engineering*, 1-16. [doi:10.1080/14488353.2023.2227432](https://doi.org/10.1080/14488353.2023.2227432).
flake8-numba 0.4.0
Perform checks over numba usage
Requires Python: >=3.9,<4.0

# flake8-numba

Improve your Python development experience with flake8-numba. This plugin integrates with Flake8 to provide
comprehensive code analysis for projects that make use of numba. When working with numba, many errors are not
discovered until the code is run. However, many of these issues can be perfectly caught by performing some basic
syntactical analysis. This tool helps you catch potential errors and enhance code quality effortlessly.

## Installation

Make sure that you have `flake8` installed. Then:

```
pip install flake8-numba
```

After it calling `flake8` will include all rules defined by this plugin.

## Rules

Some examples are:

```python
@vectorize([float64(float64, float64)])
def f(x, y):
    return x + y, 2  # ERROR: only 1 value can be returned
```

or:

```python
# ERROR: Dimensions mismatch (second argument at left is an array but an scalar at right)
@guvectorize([(float32, float32[:], float32)], "(), () -> ()")
def func(...) -> None:
    ...
```


All available rules can be read in `RULES.md`