Saravanan666/pypi-org huggingface dataset:
Package: lazyjson
Encode existing JSON strings within new JSON documents efficiently…ishSometimes you have some existing JSON snippets which you would like to include in a new JSON document or api response. This can be achieved cleanly but inefficiently by decoding the JSON first.st=os.stat('tests/my.json')meta={"size":st.st_size,"mtime":st.st_mtime,"content":json.load(open('tests/my.json'))}returnjson.dumps(meta)The goal of this library is to provide an API which allows you to avoid ever decoding the snippet that’s being included here.JSONPassthroughEncoderThis is a subclass of the standard lib’sjson.JSONEncoderand performs the magic enablingSafeJSONto work.WARNING:Blindly wrapping untrusted JSON strings could result in JSON injection attacks.This library is not intended for everyday uses, but rather for complex proxy/file serving use cases where upstream is data you can trust. Please be careful, and only use when you’re certain this is the correct tool for the job, and you trust any data you’re embedding.WARNING:This class comes with massive performance penalties for encoding complex JSON structures from primitives.The way in which this class is forced to work by the standard lib’s json API is makes normal encoding inneficient, but the concept is otherwise simple and could be added to an existing C implementation trivially with no performance penalty.If the performance of this module is preventing you from using it but you have a valid use case please get in contact with me to collaborate on a C implementation.SafeJSONA wrapper for json-encoded strings which allows them to be output within a
JSON document by theJSONPassthroughEncoderwithout decoding first.This is a subclass ofLazyJSON.st=os.stat('my.json')doc={"size":st.st_size,"mtime":st.st_mtime,"content":SafeJSON(open('my.json').read()),}returnJSONPassthroughEncoder().encode(doc)SafeJSONFileLikeSafeJSONbut for file-like objects instead of strings. This can be used for streaming extremely large embedded json documents without ever loading them fully into memory.st=os.stat('my.json')doc={"size":st.st_size,"mtime":st.st_mtime,"content":SafeJSONFile(open('my.json'),chunk_size=5000),}fortinJSONPassthroughEncoder().iterencode(doc):socket.write(t)LazyJSONLikeSafeJSONbutwill notbe passed-through byJSONPassthroughEncoderclasses.This class can be used for untrusted JSON data for passing around your application and retaining the fact it’s JSON-encoded, if you might only want to decode it sometimes.Use themy_lazy_json.parse_json()method to parse the JSON.After validation (usually of the parsed data) you can construct aSafeJSONobject from this object to avoid re-encodingSafeJSON(my_lazy_json).
Package: lazylearn
lazy-learnis a high-level Python interface for automated machine learning (AutoML). While there are many AutoML libraries available each typically solves a niche area of the overall ML pipeline without providing a covering and approachable end-to-end system.The aim of lazy-learn is exactly that. Given a dataset, lazy-learn will analyse types and distributions of attributes, preprocess, feature-engineer and ultimately train models to be used for further evaluation or inference.Upcoming featuresCurrent stable version is 0.0.3. The upcoming updates will support:Abstract construction of model architecturesXGBoost, LightGBM, Adaboost and Catboost architecturesTime partitioning of datasets (Added in 0.0.4)Automated Hyperparameter Optimisation (HPO) (Added in 0.0.4)Text featuresAn interface to AutoGluonOutlier detection and handlingAutomated suggestions of performance metricsUsageUsing lazy-learn revolves around theLazyLearnerclass. You can think of it as a kind of project, and it is the wrapper for any experiment within lazy-learn. You can consider a simple example with the California Housing dataset:fromlazylearnimportLazyLearnerfromsklearn.datasetsimportfetch_california_housing# get some datadata=fetch_california_housing(as_frame=True)df=data["data"]df["MedHouseVal"]=data["target"]# instantiate and run the LazyLearnerlearner=LazyLearner()learner.create_project(data=df,target="MedHouseVal")learner.run_autopilot()# evaluate resultsprint(learner.leaderboard())InstallationDependencieslazy-learn requires:pandasscikit-learnxgboostUser Installationpip install lazy-learnHelp and SupportDocumentationCitation
Package: lazylfs
LazyLFSA quick way to version control data stored remotelyLazybecauseit does not eagerly fetch the data, andit does not require a lot of work up front.UsageInstall likepipinstalllazylfsUse likecdpath/to/repo

gitinit.

lazylfslinkpath/to/data/./

lazylfstrack./

lazylfscheck./

gitadd.

gitcommit-m"Adds some data"gitdiff-tree--no-commit-id--name-only-rHEAD\|lazylfscheckAlternativesThere are many existing ways to handle large files and large repositories in git.
This section explores these alternatives, their strengths, weaknesses and applicability to my use case.Common to many of them is that they have a higher barrier to entry if when migrating from something like a NAS.Git LFSDownloading a small part of files is cumbersome.
The best method I have found is toexport GIT_LFS_SKIP_SMUDGE=1,git-lfs fetchfiles selectively using the-Iand-Xarguments,git-lfscheckout files, explicitly if errors are to avoid.repeat 2 and 3 after every git operation that add, remove or modify files tracked by lfs.Reportedly, the footprint of a repo is likely to be much larger than just the files because they are stored once as objects in git and once as files in the working tree.git-annexSeems like default behavior is to store a copy of every file in.git/annex.
I made a very brief attempt at replacing the files with symlinks which seemed to make it unhappy.It also seems hard to learn and cumbersome to use in general due to its flexibility.
Admittedly this may be because I have not spent enough time with it, so that is definitely on my ToDo list.VFS for GitThe short answer is that a Linux VFSForGit client is not yet available, but we're working on it!VFSForGIT issue #1226
Package: lazylicense
Lazy LicensePython package for adding license for source files.Installation$pipinstalllazylicenseUsage:Inserts Apache v2.0 snippet at the beginning of files.Apache v2.0:Copyright [year] [author]

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.ArgumentsArgumentDescriptionDefault-e / --extensionExtension type to enter license into.py-f / --folderFolder to recursively scan.None (entire folder structure)-a / --authorAuthor to be injected into license."Author"-y / --yearYear of license.2021Examplepython-mlazylicense--extensionpy--foldersrc--author"Odd Gunnar Aspaas"--year2021CaveatsCurrently only support Apache v2.0 license.
Package: lazylights
See the GitHub repository (http://github.com/mpapi/lazylights) for more details.Example-------.. code:: pythonfrom lazylights import Lifximport timelifx = Lifx(num_bulbs=2)  # so it knows how many to wait for when connecting@lifx.on_connecteddef _connected():print "Connected!"with lifx.run():lifx.set_power_state(True)time.sleep(1)lifx.set_power_state(False)
Package: lazylines
lazylinesThis project contains a minimal method-chained API to deal with.jsonlfiles.
It's made as a personal companion for thedb-outoutput from Prodigy. The API
is inspired bydplyrand is designed to be lazy.At the moment this repo is still a work in progress. I'm using this tool from time to time in my own work to see if features are missing.Things that might be nice:some spaCy helpers that can attach specific information in the right formatsomething that can automate the docs for me
Package: lazylinks
lazylinksLinktree-style socials page for lazy peopleUsageSeeho0ber/linksfor an example of how to use this package.Command Helpusage: lazylinks.py [-h] [-s STATIC] [-o OUTPUT] [-t TEMPLATE] filename

Static links page generator

positional arguments:
  filename              Path to the yaml file of links

options:
  -h, --help            show this help message and exit
  -s STATIC, --static STATIC
                        Path to a static directory for images and css
  -o OUTPUT, --output OUTPUT
                        Path of the output directory for generated content
  -t TEMPLATE, --template TEMPLATE
                        Path of the mako template to be used
Package: lazylinop
Lazylinop philosophy – what is a LazyLinOp object?Starting from anumpy array, ascipy matrix, aFaustobject, or potentially
many other compatible linear operators with efficient implementatons, a.LazyLinOpobject follows the lazy evaluation paradigm. In short, one can aggregate
low-level.LazyLinOpobjects into higher-level ones using many  classical
operations (addition, concatenation, adjoint, real part, etc.), without
actually building arrays. The actual effect of these operations is delayed
until the resulting linear operator is actually applied to a vector (or to a
collection of vectors, seen as a matrix).The main interest of this paradigm is to enable the construction of processing
pipelines that exploit as building blocks efficient implementations of
“low-level” linear operators.LazyLinOperators are complementary to other “lazy” objects such asLazyTensorsin Kheops, or the ones oflazyarray,WeldNumpyanpylopslibraries,
which, to the best of our knowledge, primarily provide compact descriptions of
arrays which entries can be evaluated efficiently on the fly.It’s worth noting that the waypylopsexhibits scipyLinearOperator-s
in its API is different. Indeed,pylopsprovides Python classes (likeKronecker)
while lazylinop is more likely to propose Python functions in the scipy style (like
:py`.kron`).Warninglazylinop is currently in a beta stage of development. It is
thus intensively evolving and we invite you to consult this documentation
regularly.Getting started with lazylinopQuick installationUsing Anacondaconda config --add channels conda-forge
conda config --add channels pyfaust
conda config --add channels lazylinop
conda install lazylinoporUsing PIPpip install lazylinopFor a straightforward installation of lazylinop go to thisguide.
Then for a quick introduction to lazylinop go to thisnotebook. The raw notebook is
availablehere.
Package: lazylist
This small package provides a proxy list to a list-returning function:>>> from lazylist import LazyList
>>> l = LazyList(lambda: x)
>>> x = [1, 2, 3]
>>> list(l)
[1, 2, 3]More precisely, view function doesn’t have to return an exactlist,
but an any squence object e.g.str,tuple:>>> x = "hello"
>>> list(l)
['h', 'e', 'l', 'l', 'o']It satisfiescollections.abc.Sequenceprotocol:>>> from collections import Sequence
>>> isinstance(l, Sequence)
True
>>> l[-1]
'o'
>>> len(l)
5However, it doesn’t satisfycollections.abc.MutableSequenceprotocol.
In other words, it’s immutable:>>> from collections import MutableSequence
>>> isinstance(l, MutableSequence)
False
>>> l[0] = 'H'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'LazyList' object does not support item assignmentDistributed under LGPLv3 or higher.TodosLazySetLazyMap
Package: lazy_loader
lazy_loadermakes it easy to load subpackages and functions on demand.MotivationAllow subpackages to be made visible to users without incurring import costs.Allow external libraries to be imported only when used, improving import times.For a more detailed discussion, seethe SPEC.Installationpip install -U lazy_loaderUsageLazily load subpackagesConsider the__init__.pyfromscikit-image:subpackages=[...,'filters',...]importlazy_loaderaslazy__getattr__,__dir__,_=lazy.attach(__name__,subpackages)You can now do:importskimageasskiski.filters.gaussian(...)Thefilterssubpackages will only be loaded once accessed.Lazily load subpackages and functionsConsiderskimage/filters/__init__.py:from..utilimportlazy__getattr__,__dir__,__all__=lazy.attach(__name__,submodules=['rank'],submod_attrs={'_gaussian':['gaussian','difference_of_gaussians'],'edges':['sobel','scharr','prewitt','roberts','laplace','farid']})The above is equivalent to:from.importrankfrom._gaussianimportgaussian,difference_of_gaussiansfrom.edgesimport(sobel,scharr,prewitt,roberts,laplace,farid)Except that all subpackages (such asrank) and functions (such assobel) are loaded upon access.Type checkersStatic type checkers and IDEs cannot infer type information from
lazily loaded imports. As a workaround you can loadtype
stubs(.pyifiles) withlazy.attach_stub:importlazy_loaderaslazy__getattr__,__dir__,_=lazy.attach_stub(__name__,"subpackages.pyi")Note that, since imports are now defined in.pyifiles, those
are not only necessary for type checking but also at runtime.The SPECdescribes this workaround in more
detail.Early failureWith lazy loading, missing imports no longer fail upon loading the
library. During development and testing, you can set theEAGER_IMPORTenvironment variable to disable lazy loading.External librariesThelazy.attachfunction discussed above is used to set up package
internal imports.Uselazy.loadto lazily import external libraries:sp=lazy.load('scipy')# `sp` will only be loaded when accessedsp.linalg.norm(...)Note that lazily importingsubpackages,
i.e.load('scipy.linalg')will cause the package containing the
subpackage to be imported immediately; thus, this usage is
discouraged.You can asklazy.loadto raise import errors as soon as it is called:linalg = lazy.load('scipy.linalg', error_on_import=True)
Package: lazyloads
lazyloadsPython package for extra functions in builtin data types including:listdictstringintfloatInstalling lazyloadspip install lazyloadsorpython3 -m pip install lazyloadsInstall requirementsPython >= 3.6IncludeslzlistlzstrlzdictlzintlzfloatHow to importimportlzlFor more functions and docs, visithereUnexpected errorsPlease open an issue for any errors encountered.Thank you!lazyloads, a python module to make your life easier© 2020 Matthew Lam
Package: lazy_logger
[![Build Status](https://travis-ci.org/Python-Logging-For-Human/ezlogging.svg?branch=master)](https://travis-ci.org/Python-Logging-For-Human/ezlogging)# ezloggingezlogginghttps://paper.dropbox.com/doc/Logging-For-Human-0hgb3uUWhAgi4kJcU3r5X# test
py.test –capture=sys
Package: lazy-logging
Logging for lazyassUse cases:I want pretty human-readable logs in stdout:logger = logger_factory()I want json-formatted logs in stdout to use with glef docker driver:logger = logger_factory(json_stdout=True)I want to save json-formatted logs to file and collect them with filebeat:logger = logger_factory(log_dir='/var/logs', log_file='myapp')I want to do the same in django settings.py:LOGGING_CONFIG = None  # <- default django config
LOG_DIR = '/var/logs'
LOG_FILE = 'myapp'
configure_django_logging()
Package: lazy-lxd
Lazy LXDA tool for easy creatingLXDcontainers.Installing OpenSSH right from the script, for accessing into container thru SSH. And runningAnsibleplaybooks over container.Also have Russian language version ofREADMERequirementsPython >= 3.6LXDAnsible(Optionally). If you wish to run playbooks over created container.InstallJust use the packet managerpip.pipinstalllazy-lxdRequirementsLXDLXD need to be.How to install:apt:$aptinstalllxdlxd-clientsnap:$snapinstalllxdFor centos use followingarticle.
Or use snap way.For more information seeofficial guide.AnsibleIf you want to run Ansible playbooks over container, you should have installed Ansible.Python way:$pipinstallansibleUsageHelp:$lazy-lxd--helpSimple container with default OS/version (Ubuntu/18.04):$lazy-lxdExamplesContainer with given name and OS/version is Centos 6:$lazy-lxd--namecentos-container--oscentos--release6Container with OS/version is Ubuntu 20.04 and with your path to Ansible playbooks:$lazy-lxd--osubuntu--release20.04--playbooks-path$HOME/ansible/playbooksContainer with given name, default OS/version and exists SSH keys:$lazy-lxd--nameubuntu-focal--ssh-key-private$HOME/.ssh/id_rsa--ssh-key-public$HOME/.ssh/id_rsa.pubWhy script?Why not to user utilities from CLI?Needs to remember arguments of lxc, check that the container name is free,
set OpenSSH into container every time, create keys manually, doing requests by container IP.
All that this in one wrapper as script.Run Ansible playbooks from script as bonus.Why LXD?In my opinion,LXDis better as container with OS for experiments, thanDocker.
It stateful, shouldn't think about data if container went down.Docker is better choice for one service per container.
But for OS experiments LXD is better.LicenseThis project uses the following license:MIT
Package: lazymaker
Minimalistic build system for Python using memoisationFree software: MIT licenseInstallationpip install lazymakerYou can also install the in-development version with:pip install https://github.com/dougmvieira/lazymaker/archive/master.zipDocumentationhttps://lazymaker.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2020-04-25)First release on PyPI.
Package: lazymappingstorage
asdfThis is intended to provide a very simple way to manage data and store them to file.
The main design principle is to provide as many sensible defaults as possible.#UsageclassUser(LazyStorageObject):id:intname:strauthorized:bool=FalseclassUserMapping(LazyMappingStorage):object_class=Userfilename="users.yaml"users=UserMapping()u=users[1]u.name="andi"users.to_file()#Install#Development
git clone
pip install -epip install -e .[dev]
Package: lazy-model
Lazy parsing for Pydantic modelsThis library provides a lazy interface for parsing objects from dictionaries. During the parsing, it saves the raw data inside the object and parses each field on demand.Installpoetrypoetryaddlazy-modelpippipinstalllazy-modelUsagefromlazy_modelimportLazyModelfrompydanticimportvalidatorclassSample(LazyModel):i:ints:str@validator("s")defs_upper(cls,v):returnv.upper()obj=Sample.lazy_parse({"i":"10","s":"test"})# at this point the data is stored in a raw format inside the objectprint(obj.__dict__)# >>> {'i': NAO, 's': NAO}# NAO - Not An Object. It shows that the field was not parsed yet.print(obj.s)# >>> TEST# Custom validator works during lazy parsingprint(obj.__dict__)# >>> {'i': NAO, 's': 'TEST'}# The `s` field  was already parsed by this stepprint(obj.i,type(obj.i))# >>> 10 <class 'int'># It converted `10` from string to int based on the annotationsprint(obj.__dict__)# >>> {'i': 10, 's': 'TEST'}# Everything was parsed
Package: lazy-module
LazyModuleInstallpipinstall--upgradepip&&pipinstalllazy_module#orpipinstallgit+https://github.com/anhvth/lazy_moduleHow to useimporttimestart=time.time()importpandasaspdprint('Import time:',time.time()-start)Import time: 0.30898594856262207Lazy importfromlazy_module.coreimport*start=time.time()pd=LazyModule('pandas')print('Import time:',time.time()-start)# Ipython tabcomplition should work normallyImport time: 5.507469177246094e-05IssueClass import is not suported yet, assertion error will occor at
runtime when the object is being called
Package: lazynet
lazynetAre you lazy? Do you need to make lots of HTTP requests?Well, look no further. lazynet is for you!lazynet performs lazy-evaluated, asynchronous HTTP requests. It is ideal for making many HTTP requests for data at rest, fast and efficiently in a functional manner.It uses theasyncioandaiohttplibraries, using coroutines under the hood. It also hides this complexity from you, keeping you in a synchronous mindset.Usageimportlazynet# This is a generatorurls=(f'https://my.domain/object/{id}'foridinrange(10))# responses is also a generatorresponses=lazynet.get(urls)# nothing is evaluated until this loopforresponseinresponses:print(response)Performancelazynet can currently achieve a rate of about 1300 requests per second.History2019: Alpha status. lazynet was developed as an experiment and proof of concept.2023: Beta Status. Updated to use current asyncio interface.
Package: lazynovel
lazynovel介绍对接小说分销平台的接口封装方法，方便调用支持列表：常读（番茄）: open_changdu迈步书城（开放平台接口）: open_mbookcn迈步书城（非开放平台接口）: crawler_mbookcn阅文: open_yuewen网易文鼎: open_reading163点众分销平台: open_dianzhong（已升级为https协议）软件架构软件架构说明open_yuewen阅文开放平台
coop_id：合作方式代码
    1：微信分销
    9：陌香快应用（共享包）
    11：快应用（独立包）安装教程pip安装pip3installlazynovelpip安装（使用阿里镜像加速）pip3installlazynovel-ihttps://mirrors.aliyun.com/pypi/simple使用说明changelog2022-08-01 changdu模块更名为open_changdu，原模块不再维护
Package: lazynumpy
lazynumpya lazy evaluated wrapper around numpyWhat is gained?Chained matrix multiplication will be minimized by keeping the values of the other arrays in memory and solving the associative problem that minimizes the number of computations.only keeps one copy of each matrix [Memory optimization in progress]Allow partial matrix returns withou calculating the entire matrix [In Progress]If you have three matrices with dimensions as below there are two ways to do the matrix multiplication to find the answer:Either:or[1] will take1000 * 1 * 1000operations to calculateA * Bplus1000 * 1000 * 1000operations to calculate(A * B) * C. The total sum to calculateA * B * Cis equal to1000^3 + 1000^2.[2] will take1 * 1000 * 1000operations to calculateB * Cplus1000 * 1 * 1000operations to calculateA * (B * C). The total sum to calculateA * B * Cis equal to1000^2 + 1000^2which means the optimal multiplication order will be ~500 faster.If you runthe simple exampleyou should see a significant speed up. On my computer there is a 50x speedup with only three matrix calculations.
Package: lazyOfAPI
lazyOfAPI一个简单的用于请求OpenFrp API的库隧道信息相关参数名称及内容类型请参阅OpenFrp的官方文档本文档遵循CC BY-NC-SA许可.文档约定返回值类型DynamicClass代表一个动态类对象，可以用getattr()获取其中内容用户相关API登录bool示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPIapi=OpenFrpAPI()api.login("test@test.com","test@test.com")返回值释义返回一个布尔值,指示是否登陆成功.建议在程序中添加相关判断,只有返回True后才能进行下一步操作.获取用户信息str建议与上文的登录API配合使用以在登陆后显示当前用户信息.示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPIapi=OpenFrpAPI()api.get_user_info()返回值释义返回一个字符串,内容为已经经过处理的用户信息,软件可以直接读取并显示.签到str不要设计任何自动签到的功能,例如登陆后自动发送签到请求,此类行为是违反OpenFrpAPI使用条款的.示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPIapi=OpenFrpAPI()api.sign()返回值释义签到失败时的返回值固定为```签到失败````.建议程序显示时如果不是失败的返回内容,直接显示返回的内容即可.隧道相关API创建隧道Dict[str,str]示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPI,ProxyTypesapi=OpenFrpAPI()api.create_proxy(node_id="1",# 节点idname="test",protocol_type=ProxyTypes.tcp,# 隧道类型,推荐使用ProxyTypes中的枚举值local_addr="127.0.0.1",local_port=25565,remote_port=1000000# 使用随机远程端口# 其他参数)你也可以使用new_proxy方法,参数与本方法相同.但是由于new_proxy方法只会返回一个代表操作成功与否的布尔值,所以不推荐使用.返回值释义返回字典的key为欲创建的隧道的名称,value为用户隧道id
需要注意的是,如果执行中出现了任何Exception,则key固定为failed,而value中会提供traceback文本.删除隧道bool示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPIapi=OpenFrpAPI()api.remove_proxy(proxy_id="12345")# 隧道id返回值释义返回一个布尔值,指示是否成功删除.建议在程序中添加相关判断,只有返回True后才能进行下一步操作.编辑隧道bool示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPI,ProxyTypesapi=OpenFrpAPI()other_proxy_info={}api.edit_proxy(proxy_id="1",# 隧道idname="test",protocol_type=ProxyTypes.tcp,# 隧道类型,推荐使用ProxyTypes中的枚举值local_addr="127.0.0.1",local_port=25565,remote_port=1000000,# 使用随机远程端口**other_proxy_info)代码中other_proxy_info实际上是一个包含节点其他信息的字典,其会被直接解包到发送信息的json中,接受的内容详见OpenFrp官方文档获取用户隧道DynamicClass示例代码fromlazyOfAPI.OpenFrpAPIimportOpenFrpAPIapi=OpenFrpAPI()api.get_user_proxies()返回值释义正常情况下,返回的DynamicClass中应该包含两项数据:total和list.total为用户隧道总数,list为用户隧道列表.下面是list中每一项的一些常用键名/属性名:键名(属性名)释义id此隧道ID（数字）proxyName隧道名称proxyType隧道类型localIp此隧道的本地IP地址localPort此隧道的本地端口useCompression是否启用数据压缩remotePort此隧道的远程端口sk此隧道的访问密码status状态(为false时无法启动)online在线状态connectAddress链接此隧道的域名/IP地址
Package: lazyops
Lazy Op(eration)s or lazyopsLatest Version:A collection of submodules/patterns that are commonly used within personal projects.Deprecation NoticeIf you are looking for the previous version oflazyops, please see thev0.2.xtag. This is the last stable version of the previous implementation oflazyopsprior to rework of the entire project.New APIs are implemented inv0.2.xand above.InstallationInstall directory from pypipip install --upgrade lazyopsInstall from Githubpip install --upgrade git+https://github.com/trisongz/lazyopsUsageWork in ProgressDependenciesPython 3.7+pydanticloguru