| Name | k-inertia JSON |
| Version |
1.0.0
JSON |
| download |
| home_page | |
| Summary | K-Inertia: A User-Friendly Machine Learning Library K-Inertia or Kavish Inertia is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering. |
| upload_time | 2023-12-16 07:13:18 |
| maintainer | |
| docs_url | None |
| author | Kavish Tomar |
| requires_python | |
| license | MIT |
| keywords |
machine learning
k_inertia
k-inertia
learning
ai
ai
ml
ml
k-inertia
machine learning
|
| VCS |
|
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# K-Inertia (Kavish Inertia)
**K-Inertia: A User-Friendly Machine Learning Library**
K-Inertia or ***Kavish Inertia*** is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.
**Key Features:**
+ **Diverse Algorithms:**
K-Inertia offers a range of algorithms, covering both supervised and unsupervised learning tasks. Users can seamlessly implement regression, classification (logistic regression, k-nearest neighbors, naive Bayes, support vector machines), and clustering (k-means) with minimal effort.
+ **User-Friendly Interface:**
K-Inertia is designed to be user-friendly, making it accessible for both beginners and experienced users. The library provides clear and intuitive APIs for easy integration into machine learning workflows.
+ **Simplified Usage:**
Users can leverage the library's simplified syntax to perform complex machine learning tasks without extensive coding. K-Inertia aims to streamline the implementation process, reducing the learning curve for users new to machine learning.
+ **Flexibility:**
K-Inertia allows users to experiment with different algorithms and easily switch between them based on their specific needs. The library's flexibility encourages exploration and experimentation with various machine learning techniques.
K-Inertia strives to empower users with a straightforward and accessible machine learning experience. Whether you are building predictive models, classifying data, or clustering patterns, K-Inertia is designed to be a reliable companion for your machine learning endeavors.
***
# Documentation
## Installation
You can use K-Inertia library in your python project by typing the command below in your CLI.
```
pip install k-inertia
```
***
## Regression
```
class kinertia.supervised.Regression(learning_rate=0.0001, iterations=1000)
```
Ordinary least squares Linear Regression.
LinearRegression fits a linear model with coefficients w = (w1, …, wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model
`predict(X)` : Takes the independent features of data as parameter and predicts the result
`mse(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the mean squared error for accuracy of Regression. The less the value of mse, the more accurate model is.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying regression
from kinertia.supervised import Regression
regresion = Regression(learning_rate=0.005)
regresion.fit(x_train, y_train)
predict = regresion.predict(x_test)
```
***
## Logistic Regression
```
class kinertia.supervised.LogisticRegression(learning_rate=0.0001, iterations=1000)
```
For binary logistic regression, the logistic function (also called the sigmoid function) is employed to map the output of a linear combination of features into a range between 0 and 1.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Logistic regression
from kinertia.supervised import LogisticRegression
lr = LogisitcRegression(learning_rate=0.005)
lr.fit(x_train, y_train)
predict = lr.predict(x_test)
```
***
## K-Nearest Neighbors
```
class kinertia.supervised.KNN(k=3)
```
K-Nearest Neighbors (KNN) is a supervised machine learning algorithm used for both classification and regression tasks. It's a simple and intuitive algorithm that makes predictions based on the majority class (for classification) or the average (for regression) of the k-nearest data points in the feature space. The key idea behind KNN is that instances with similar feature values are likely to belong to the same class or have similar target values.
#### Parameters:
`k` : This parameter defines how many neighbors will be checked to determine the classification of a specific query point.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying KNN
from kinertia.supervised import KNN
knn = KNN(k=3)
knn.fit(x_train, y_train)
predict = knn.predict(x_test)
```
***
## Naive Bayes
```
class kinertia.supervised.NaiveBayes()
```
The "naive" part of Naive Bayes comes from the assumption of independence among features, given the class label. This means that the presence or absence of a particular feature is assumed to be unrelated to the presence or absence of any other feature. While this assumption is often not strictly true in real-world data, it simplifies the calculation and makes the algorithm computationally efficient.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Naive Bayes
from kinertia.supervised import NaiveBayes
bayes = NaiveBayes()
bayes.fit(x_train, y_train)
predict = bayes.predict(x_test)
```
***
## Support Vector Machine
```
class kinertia.supervised.SVM(learning_rate = 0.001, lambda_param = 0.01, iterations = 1000)
```
Support Vector Machines (SVMs) are supervised machine learning models used for both classification and regression tasks. SVMs are particularly effective in high-dimensional spaces and are widely used in various applications, including image classification, text categorization, and bioinformatics. The primary objective of SVM is to find a hyperplane that best separates the data into different classes while maximizing the margin between the classes.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`lambda_param` : Thid parameter serves as a degree of importance that is given to miss-classifications.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Support Vector Machine
from kinertia.supervised import SVM
svm = SVM(learning_rate = 0.0001, lambda_param = 0.01)
svm.fit(x_train, y_train)
predict = svm.predict(x_test)
```
***
## K-Means Clustering
```
class kinertia.unsupervised.KMeans(k=5, max_iters=100)
```
K-Means Clustering is an unsupervised machine learning algorithm used for partitioning a dataset into K distinct, non-overlapping subsets (clusters). Each data point belongs to the cluster with the nearest mean, and the mean of each cluster serves as a representative or centroid of that cluster. K-Means is commonly used for grouping data points based on similarity and is widely applied in various fields, including image segmentation, customer segmentation, and anomaly detection.
#### Parameters:
'k' : Number of clusters
'max_iters' : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Applying K-Means Clustering
from kinertia.unsupervised import KMeans
means = KMeans(k = 3)
predict = svm.predict(x)
```
***
# Credits
## Developer
**Kavish Tomar**
+ GitHub: https://github.com/KavishTomar4
+ Email: kavishtomar2@gmail.com
+ Instagram: https://www.instagram.com/_kavishtomar
Raw data
{
"_id": null,
"home_page": "",
"name": "k-inertia",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "machine learning,k_inertia,k-inertia,learning,ai,AI,ml,ML,K-Inertia,Machine Learning",
"author": "Kavish Tomar",
"author_email": "kavishtomar2@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/60/46/9adb5da56b500353d3acdc60cd7080a750386cb97fe1e90e079fea750b3f/k-inertia-1.0.0.tar.gz",
"platform": null,
"description": "# K-Inertia (Kavish Inertia)\r\n\r\n\r\n**K-Inertia: A User-Friendly Machine Learning Library**\r\nK-Inertia or ***Kavish Inertia*** is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.\r\n\r\n**Key Features:**\r\n\r\n+ **Diverse Algorithms:**\r\nK-Inertia offers a range of algorithms, covering both supervised and unsupervised learning tasks. Users can seamlessly implement regression, classification (logistic regression, k-nearest neighbors, naive Bayes, support vector machines), and clustering (k-means) with minimal effort.\r\n\r\n+ **User-Friendly Interface:**\r\nK-Inertia is designed to be user-friendly, making it accessible for both beginners and experienced users. The library provides clear and intuitive APIs for easy integration into machine learning workflows.\r\n\r\n+ **Simplified Usage:**\r\nUsers can leverage the library's simplified syntax to perform complex machine learning tasks without extensive coding. K-Inertia aims to streamline the implementation process, reducing the learning curve for users new to machine learning.\r\n\r\n+ **Flexibility:**\r\nK-Inertia allows users to experiment with different algorithms and easily switch between them based on their specific needs. The library's flexibility encourages exploration and experimentation with various machine learning techniques.\r\n\r\nK-Inertia strives to empower users with a straightforward and accessible machine learning experience. Whether you are building predictive models, classifying data, or clustering patterns, K-Inertia is designed to be a reliable companion for your machine learning endeavors.\r\n\r\n***\r\n\r\n# Documentation\r\n\r\n## Installation\r\nYou can use K-Inertia library in your python project by typing the command below in your CLI.\r\n```\r\npip install k-inertia\r\n```\r\n***\r\n\r\n## Regression\r\n```\r\nclass kinertia.supervised.Regression(learning_rate=0.0001, iterations=1000)\r\n```\r\nOrdinary least squares Linear Regression.\r\n\r\nLinearRegression fits a linear model with coefficients w = (w1, \u00e2\u20ac\u00a6, wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result\r\n\r\n`mse(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the mean squared error for accuracy of Regression. The less the value of mse, the more accurate model is.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying regression\r\nfrom kinertia.supervised import Regression\r\nregresion = Regression(learning_rate=0.005)\r\nregresion.fit(x_train, y_train)\r\npredict = regresion.predict(x_test)\r\n```\r\n***\r\n## Logistic Regression\r\n```\r\nclass kinertia.supervised.LogisticRegression(learning_rate=0.0001, iterations=1000)\r\n```\r\nFor binary logistic regression, the logistic function (also called the sigmoid function) is employed to map the output of a linear combination of features into a range between 0 and 1.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Logistic regression\r\nfrom kinertia.supervised import LogisticRegression\r\nlr = LogisitcRegression(learning_rate=0.005)\r\nlr.fit(x_train, y_train)\r\npredict = lr.predict(x_test)\r\n```\r\n***\r\n## K-Nearest Neighbors\r\n```\r\nclass kinertia.supervised.KNN(k=3)\r\n```\r\nK-Nearest Neighbors (KNN) is a supervised machine learning algorithm used for both classification and regression tasks. It's a simple and intuitive algorithm that makes predictions based on the majority class (for classification) or the average (for regression) of the k-nearest data points in the feature space. The key idea behind KNN is that instances with similar feature values are likely to belong to the same class or have similar target values.\r\n\r\n#### Parameters:\r\n`k` : This parameter defines how many neighbors will be checked to determine the classification of a specific query point.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying KNN\r\nfrom kinertia.supervised import KNN\r\nknn = KNN(k=3)\r\nknn.fit(x_train, y_train)\r\npredict = knn.predict(x_test)\r\n```\r\n***\r\n## Naive Bayes\r\n```\r\nclass kinertia.supervised.NaiveBayes()\r\n```\r\nThe \"naive\" part of Naive Bayes comes from the assumption of independence among features, given the class label. This means that the presence or absence of a particular feature is assumed to be unrelated to the presence or absence of any other feature. While this assumption is often not strictly true in real-world data, it simplifies the calculation and makes the algorithm computationally efficient.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Naive Bayes\r\nfrom kinertia.supervised import NaiveBayes\r\nbayes = NaiveBayes()\r\nbayes.fit(x_train, y_train)\r\npredict = bayes.predict(x_test)\r\n```\r\n***\r\n## Support Vector Machine\r\n```\r\nclass kinertia.supervised.SVM(learning_rate = 0.001, lambda_param = 0.01, iterations = 1000)\r\n```\r\nSupport Vector Machines (SVMs) are supervised machine learning models used for both classification and regression tasks. SVMs are particularly effective in high-dimensional spaces and are widely used in various applications, including image classification, text categorization, and bioinformatics. The primary objective of SVM is to find a hyperplane that best separates the data into different classes while maximizing the margin between the classes.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`lambda_param` : Thid parameter serves as a degree of importance that is given to miss-classifications.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Support Vector Machine\r\nfrom kinertia.supervised import SVM\r\nsvm = SVM(learning_rate = 0.0001, lambda_param = 0.01)\r\nsvm.fit(x_train, y_train)\r\npredict = svm.predict(x_test)\r\n```\r\n***\r\n## K-Means Clustering\r\n```\r\nclass kinertia.unsupervised.KMeans(k=5, max_iters=100)\r\n```\r\nK-Means Clustering is an unsupervised machine learning algorithm used for partitioning a dataset into K distinct, non-overlapping subsets (clusters). Each data point belongs to the cluster with the nearest mean, and the mean of each cluster serves as a representative or centroid of that cluster. K-Means is commonly used for grouping data points based on similarity and is widely applied in various fields, including image segmentation, customer segmentation, and anomaly detection.\r\n\r\n#### Parameters:\r\n'k' : Number of clusters\r\n\r\n'max_iters' : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Applying K-Means Clustering\r\nfrom kinertia.unsupervised import KMeans\r\nmeans = KMeans(k = 3)\r\npredict = svm.predict(x)\r\n```\r\n***\r\n# Credits\r\n\r\n## Developer\r\n**Kavish Tomar**\r\n \r\n + GitHub: https://github.com/KavishTomar4\r\n + Email: kavishtomar2@gmail.com\r\n + Instagram: https://www.instagram.com/_kavishtomar\r\n\r\n\r\n\r\n\r\n\r\n\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "K-Inertia: A User-Friendly Machine Learning Library K-Inertia or Kavish Inertia is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.",
"version": "1.0.0",
"project_urls": null,
"split_keywords": [
"machine learning",
"k_inertia",
"k-inertia",
"learning",
"ai",
"ai",
"ml",
"ml",
"k-inertia",
"machine learning"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "988cf1fa0baa33d74ede91f72b23c432061a781f90315cb3dcbd20b5c26eb6bd",
"md5": "16dc8e05c0639d51a6c28e67017657d9",
"sha256": "3e42b90e60c4cdde15bd4597d6193417662cb76acad05b73d9ad2026b17ff3b9"
},
"downloads": -1,
"filename": "k_inertia-1.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "16dc8e05c0639d51a6c28e67017657d9",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 8278,
"upload_time": "2023-12-16T07:13:16",
"upload_time_iso_8601": "2023-12-16T07:13:16.397046Z",
"url": "https://files.pythonhosted.org/packages/98/8c/f1fa0baa33d74ede91f72b23c432061a781f90315cb3dcbd20b5c26eb6bd/k_inertia-1.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "60469adb5da56b500353d3acdc60cd7080a750386cb97fe1e90e079fea750b3f",
"md5": "0f8a1f8b94489ba4cf3b8361a984acce",
"sha256": "69b974c5f6386399a2240aaf67b30d37584894c329af511ea3edc0a0b7c39861"
},
"downloads": -1,
"filename": "k-inertia-1.0.0.tar.gz",
"has_sig": false,
"md5_digest": "0f8a1f8b94489ba4cf3b8361a984acce",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 7544,
"upload_time": "2023-12-16T07:13:18",
"upload_time_iso_8601": "2023-12-16T07:13:18.219606Z",
"url": "https://files.pythonhosted.org/packages/60/46/9adb5da56b500353d3acdc60cd7080a750386cb97fe1e90e079fea750b3f/k-inertia-1.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-12-16 07:13:18",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "k-inertia"
}
