semvec/pypi-packages huggingface dataset:
superstocks 0.0.1
Unified AI trading platform powered by human intelligence.
Requires Python: >=3.8

# Superstocks
Unified AI trading platform powered by human intelligence.

## References

1. [LikeFolio](https://developer.twitter.com/en/community/success-stories/likefolio) - LikeFolio uses Twitter data to gain unique financial insights for investors.
2. [SMA](https://developer.twitter.com/en/community/success-stories/sma) - SMA uses derived analytics to forecast more effectively in volatile markets.
3. [Smallcase](https://www.smallcase.com/) - A smallcase is a basket of stocks that reflects an idea.
4. [Kya Trade](https://www.kyatrade.com/) - KyaTrade instantly identifies and streams tons of trading and investing ideas so that you can trade opportunities from anywhere and anytime of the day.
marker 2.1.5
Marker: A highly configurable automarker for university assignments.
Requires Python: >=3.8

# Marker

A marking utility to help automate code testing, and interfacing with the submission platform. Currently, the following platforms are supported:

- Canvas
- MarkUs


This package installs the program `marker`. It can either be run as an interactive REPL or through the command line directly. It supports the following commands:

- `download`: Downloads files from the given LMS.
- `prepare`: Copies needed files into student directories, compiles code.
- `run`: Runs all the test cases, creates logs and compiles marks.
- `upload-marks`: Uploads the student marks to the LMS.
- `upload-reports`: Uploads the testing logs to the LMS for the student.
- `delete-reports`: Deletes the testing logs from the LMS for the student.
- `set-status`: Sets the marking state of the submission (MarkUs only).
- `stats`: Gives you some basic statistics of the results.

Each of the commands can be run either for individual students or for everyone. Run `marker help` or `marker help command` for more information.

---

## How to install

There are 2 ways to install this marker. 

### (1) Using PIP
This is by far the recommended way of installing this utility. Simply run:
```bash
pip install marker
```

### (2) Build from source

Alternatively, if you want to develop, you will need to build from source. First, clone this repository to your machine:

```bash
git clone https://github.com/mustafaquraish/marker
```

Then, go into the cloned repo and use `flit` to install
```bash
cd marker
pip install flit
flit install
```

---

## How to use

Some examples on how to use this marker with Python and C code are provided
in the `templates` directory, however it is designed to work with any programming
language as long as you can run tests from the command line. Even if you're not
using C, the template will be helpful in showing you how to set it up to work
with your environment.

---

[Full Documentation](https://marker-docs.readthedocs.io/en/latest/)
olop-ShadowLugia650 0.0.2
One-Line and Obfuscated Python
Requires Python: >=3.9

# OLOP: One-Line &amp; Obfuscated Python

This repository contains useful python modules for one-line and obfuscated python.

```
pip install olop-ShadowLugia650
```

[Wiki](https://github.com/ShadowLugia650/olop/wiki): [FAQ](https://github.com/ShadowLugia650/olop/wiki/Frequently-Asked-Questions) and [OLP Tips and Tricks](https://github.com/ShadowLugia650/olop/wiki/OLP-Tips-and-Tricks)

## One-Line python (olp)
These files are located within [src/olp](https://github.com/ShadowLugia650/olop/tree/master/src/olp)

### [olp.py](https://github.com/ShadowLugia650/olop/blob/master/src/olp/olp.py): primitives within olp to be imported for olp scripts
```py
__import__("olp").olp.primitives
```
includes: one-line while loop, one-line do while loop, inheritance

### [oldec.py](https://github.com/ShadowLugia650/olop/blob/master/src/olp/oldec.py): a one-line python decoder file which can be called from a python script. Common Usage:
```py
globals().update(oldec = __import__("olp").oldec) or oldec.beautify(oldec.parse_recursive("SOME_OLP_STRING"))
```
or, for non olp programmers
```py
from olp import oldec

code = oldec.beautify(oldec.parse_recursive("SOME_OLP_STRING"))
```
NOTE: oldec.py cannot parse all arbitrary one-line python files, as they can take numerous different forms (such as `and` OLP vs `or` OLP), and it looks for specific aspects within some one-line python programs (it doesn't work on itself either) 

### [oldec_cmd.py](https://github.com/ShadowLugia650/olop/blob/master/src/olp/oldec_cmd.py): a one-line python decoding command line utility, for decoding olp outside of a python script. Common Usage:
```
python oldec_cmd.py <olp_file.py> -r -b
```
`python oldec_cmd.py` can also be used to see usage information.

## Obfuscated Python
Prototyping this is still a work in progress.
enp 0.1.0
Implementation of deep learning, machine learning and math algorithms in NumPy and pure Python
Requires Python: >=3.6

**enp** (stands for Everything in NumPy) provides implementation of deep learning, machine learning, and math algorithms in
NumPy and pure Python.

Installation
----------------------

You can install the library using pip: ::

    pip install enp

Description
----------------------

The library consists of 3 main parts:

- deep learning
    - examples of usage are in examples/nn
    - impementation is in enp/nn
    - loosely follows PyTorch conventions
- machine learning
    - examples of usage are in examples/ml
    - impementation is in enp/ml
    - loosly follows scikit-learn conventions
- linear algebra
    - examples of usage are in tests/test_linear_algebra.py and tests/test_linear_algebra_additional.py
    - impementation is in enp/linalg

Deep Learning
----------------------
Example of building, prediction, and training a simple neural network consisting of linear layers: ::

    from enp.nn import *

    model = Model(learning_rate=0.0075)
    input_layer = InputLayer(layer_dim=12288)
    linear_1 = Linear(layer_dim=7, prev_layer=input_layer, activation='relu')
    linear_2 = Linear(layer_dim=1, prev_layer=linear_1, activation='sigmoid')
    cost_layer = BCELoss(layer_dim=1, prev_layer=linear_2)
    model.layers = [input_layer, linear_1, linear_2, cost_layer]
    model.train(x=train_x, y=train_y, num_iterations=2500)
    test_y_pred = model.predict(test_x)

Machine Learning
----------------------
Example of building, prediction, and training a linear regression: ::

    from enp.ml import LinearRegression
    import numpy as np

    X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
    y = np.dot(X, np.array([1, 2])) + 3
    reg = LinearRegression().fit(X, y)
    prediction = reg.predict(np.array([[3, 5]]))

Linear Algebra
----------------------
Example of solving a system of linear equations Ax=b: ::

    from enp.linalg import solve_system_of_linear_equations
    import numpy as np

    a = np.array([[0, -2],
                  [4, 7]])
    b = np.array([1, 2])
    x = solve_system_of_linear_equations(a, b)