semvec/pypi-packages huggingface dataset:
mtneedlet 0.0.5
A Python package for needlet filtering and Multiple Testing

# MTNeedlet

This is a Python Package aimed at the use of needlets to filter spherical maps,
detecting the maxima within the maps and analysing them using a multiple
testing approach.

The documentation and information on the installation can be found at https://javicarron.github.io/mtneedlet/

For more information on the theoretical background that inspired this work, see:

Cheng, D., Cammarota, V., Fantaye, Y., Marinucci, D., & Schwartzman, A. (2016). Multiple testing of local maxima for detection of peaks on the (celestial) sphere. *Bernoulli, in press*, arXiv preprint arXiv:1602.08296.

Carron Duque, J., Buzzelli, A., Fantaye, Y., Marinucci, D., Schwartzman, A., & Vittorio, N. (2019). Point Source Detection and False Discovery Rate Control on CMB Maps. https://doi.org/10.1016/j.ascom.2019.100310 .
Broadworks-Django-Authentication 0.0.1
Broadworks Authentication for your django app
Keywords: Broadworks,Django

# Broadworks-Django-Auth 

## Install the app
settings.py
```python
INSTALLED_APPS = [
    ...
    'broadworks_django_auth'
]

```
## Adding to Authentication Backends

settings.py
```python
AUTHENTICATION_BACKENDS = [
    'broadworks_django_auth.backends.BraodworksAuthentication',
]
```


## Adding your OCIP Address

settings.py

```python
BROADWORKS_ADDRESS = "https://api.broadsoft.com/webservice/services/ProvisioningService"

```
mood-ring 0.1.1
Novelty mood ring object that returns a mood as a string
Requires Python: >=3.5


# Mood-Ring
Mood-ring object to return a user's mood with available configurations - practice for packaging and distributing software.

# Installation

Mood-ring can be installed with pip:

`pip install mood-ring`

# Documentation

The ring class can be instantiated and used as a string to display a mood.

```
>>> from mood_ring import Ring
>>>
>>> r = Ring()
>>> print(r)
active
```
The Ring class comes with the following options:
- stressed
- nervous
- unsettled
- active
- relaxed
- lovable
- romantic
- happy
- tired
- calm
### Methods
The **change** method will update the mood of the ring object.

NOTE: When using the change method, the mood will be reset to a different option than currently selected - there is no chance the same mood option will be set again.

```
>>> r = Ring()
>>> str(r)
'tired'
>>> r.change()
>>> str(r)
'unsettled'
```
If the possibility of the same outcome is desired, instantiate a new instance of the Ring object.
```
>>> r = Ring(); str(r)
'stressed'
>>> r = Ring(); str(r)
'stressed'
```
### Custom User-Inputs
To over-write the default outputs, am optional list argument can be accepted to specify the pool of output options the class will output.

```
>>> r = Ring(['suave', 'sophisticated'])
>>> str(r)
'suave'
```
To retain the default output list while also adding user-defined outputs, the optional keyword argument 'extend' can accept a list of strings to extend the out-of-the-box behavior.
```
>>> r = Ring(extend=['million bucks'])
>>> str(r)
'tired'
```
### Weighted User-Inputs
Either of the above arguments can also be passed a dictionary that weights the probability of a certain option being picked - keys are mood option names, and values are weights. In the example below, 'mad' has a 1/5 chance of being returned and 'happy' has a 4/5 chance of being returned.
```
>>> r = Ring({'mad': 1, 'happy': 4})
>>> str(r)
'happy'
```
NOTE: The 10 default options are weighted with 1. If using the 'extend' keyword, setting a key as weight 1 gives it equal probability as the original options.
```
>>> # New option weighted equally with default options
>>> r = Ring(extend={'dopey': 1})
>>> str(r)
'stressed'
>>>
>>> # New option weighted 99x as likely of returning as defaults
>>> r = Ring(extend={'dopey': 99})
>>> str(r)
'dopey'
```
cpie 1.0.0
An evolutionary computation algorithm named CPIE in Python.
Requires Python: >=3.6

# cpie
Clustering-based Promising Individual Enclosre(CPIE) in Python.  

CPIE is an evolutionary computation algorithm which aims to search best parameters minimizing black-box function, especially UV-function.  
UV-function has U-valley, which occupies large search space but  contains only local optima, and V-valley, which occupies small search space but contains global optima.  
e.g. Double-sphere: f(x) = min((x-2)^2 + 0.1, 10*(x+2)^2)  

# Installation
```
$ pip install cpie
```
CPIE depends on numpy, so please install numpy if needed.

# Example of usage
First, you can import CPIE module as below.  
```python
    from cpie import CPie
```

Then, you need to prepare objective function to be minimized.  
```python
    def sphere(x):
        return sum(xi*xi for xi in x)

    def objective_func(x):
        return min(sphere(x-2)+0.1, 10*sphere(x+2))
```

You can minimize objective function like below.  
```python
    dimension = 2
    bounds_min = [-10.0] * dimension
    bounds_max = [ 10.0] * dimension
    cpie = CPie(bounds_min, bounds_max, Ns=7*dimension)
    for i in range(2000):
        solution = cpie.sample()
        f_value = objective_func(solution)
        cpie.update(f_value)
        cpie.print()
```
"bounds_min" and "bounds_max" means search space.  
CPIE starts optimization with Ns solutions sampled unimormally in the search space.  

After optimization loop, you can get optimized solution.
```python
    print("global best x", cpie.best.x)
    print("global best f", cpie.best.f)
```

CPIE is niching algorithm, so you can also get best solutions from each mode.  
```python
    bests = cpie.get_bests()
    for i, b in enumerate(bests):
        print("mode", i, " f", b.f)
```

example_main.py shows full example code.
tex2txt 1.7.0
A flexible LaTeX filter


# Tex2txt: a flexible LaTeX filter

This Python script or module extracts plain text from LaTeX documents.
Due to the following characteristics, it may be integrated with a
proofreading software:
- tracking of line numbers or character positions during text manipulations,
- simple inclusion of own LaTeX macros and environments with tailored
  treatment,
- careful conservation of text flows,
- detection of trailing interpunction in equations,
- proper handling of nestable LaTeX elements like {} braces.

A more complete description is available at the
[GitHub page](https://github.com/matze-dd/Tex2txt).
For instance, the LaTeX input
```
Only few people\footnote{We use
\textcolor{red}{redx colour.}}
is lazy.
```
will lead to the subsequent output from example application script shell.py.
The script invokes [LanguageTool](https://www.languagetool.org)
as proofreading software, using a local installation or the Web server
hosted by LanguageTool.
```
1.) Line 2, column 17, Rule ID: MORFOLOGIK_RULE_EN_GB
Message: Possible spelling mistake found
Suggestion: red; Rex; reds; redo; Red; Rede; redox; red x
Only few people is lazy.    We use redx colour. 
                                   ^^^^
2.) Line 3, column 1, Rule ID: PEOPLE_VBZ[1]
Message: If 'people' is plural here, don't use the third-person singular verb.
Suggestion: am; are; aren
Only few people is lazy.    We use redx colour. 
                ^^
```
Run with option --html, the script produces an HTML report:

![HTML report](https://raw.githubusercontent.com/matze-dd/Tex2txt/master/shell.png)