Saravanan666/pypi-org huggingface dataset:
Package: litemark
This project is part of thePyrustic Open Ecosystem.Usage|InstallationLitemarkLitemarkis a lightweightMarkdowndialect originally created to be the markup language for theCodegame Platformproject.
When you runlitemarkfrom the command line interface without any arguments, theLitemark Vieweropens and displays the rendered demo.Litemark demo rendered in the Litemark Viewerlitemark-demo.md (plain text)UsageThe nameLitemarkrefers to both the markup language and the distribution package.The distribution package comes with an API, a command line interface, and a graphical viewer.APIIt is easy to break an arbitrary plain text into a flat list of tokens:importlitemarkplain_text="""Hello *World* ! Visit the [repository](https://github.com/pyrustic/litemark) !"""fortokeninlitemark.scan(plain_text):# a token instance is a named tuple with 2 fields: name and dataprint(token)The output:Token(name='STRING', data='Hello ')
Token(name='BOLD', data='World')
Token(name='STRING', data=' ! Visit the ')
Token(name='LINK', data=('repository', 'https://github.com/pyrustic/litemark', ''))
Token(name='STRING', data=' !')The formal names of the tokens are defined inlitemark.Element:classElement:CODEBLOCK="CODEBLOCK"HEADING="HEADING"BOLD="BOLD"ITALIC="ITALIC"WARNING="WARNING"OVERSTRIKE="OVERSTRIKE"IMAGE="IMAGE"INLINK="INLINK"LINK="LINK"STRING="STRING"The token'sdatafield represents a string for all elements except the following:Element.CODEBLOCK: 2-tuple (str-title, str-content)Element.HEADING: 2-tuple (int-level, str-content)Element.IMAGE: 3-tuple (str-inline, str-path, str-alt)Element.INLINK: 3-tuple (str-inline, str-path, str-alt)Element.LINK: 3-tuple (str-inline, str-URL, str-alt)Command line interfaceTo openlitemark-demo.mdin the graphicalViewer:$litemarkTo open a specificlitemarkfile in the graphicalViewer:$cd/path/to/root
$litemarkmy-file.mdNote:Litemark is created for use in a desktop application. Thus, the Litemark Scanner assumes that the images referenced in a litemark document are relative to therootdirectory. Therootdirectory is simply the current working directory. For this reason, you must first do acd(change directory) to the root before rendering a document.Graphical ViewerIt is easy to embed aLitemark Viewerin your Python desktop app:importlitemarkimporttkinterastkroot_directory="/home/alex/demo"litemark_filename="/home/alex/demo/document.md"# your GUIgui=tk.Tk()gui.geometry("500x500+0+0")# let's embed a Litemark Viewer in this GUI# -- text widgettext_widget=tk.Text(gui)text_widget.pack(expand=1,fill=tk.BOTH)# -- the viewer instanceviewer=litemark.Viewer(widget=text_widget,root=root_directory)viewer.open(litemark_filename)viewer.readonly=True# done !gui.mainloop()This is a work in progress. A reference documentation will be released soon.InstallationInstall for the first timepipinstalllitemarkUpgradepipinstalllitemark--upgrade--upgrade-strategyeagerRelated projectsCodegame Platform: create, distribute, and run codegamesshared: library to store, expose, read, and edit collections of dataThis is a work in progress...
Package: litematica-command-gen
Litematica Command GeneratorA CLI application to generate give commands for shulker boxes full of items for litematica projects. Used by the lazy survival player :).Free software: GNU General Public License v3FeaturesConvert CSV material lists exported from theLitematicamod to give commands for chests full of shulker boxes full of items for said schematic.UsageDownload the .whl file from the latestreleaseand install it using the following command, where FILENAME is the name of the file you downloaded::pip install ./[FILENAME].whlGenerate a csv material list by holding shift while pressing the ‘Write to file’ key.Run this command::litematica-command-gen shulkerbox [PATH]PATH will be the path of the .csv file that litematica generated, ususally located in .minecraft/config/litematica.Your command will be generated, and can be copied to your clipboard.Using a command block, paste the generated command in, and the nearest player will be given a chest full of shulkerboxes with items in them.BugsThe parser does not support a large amount of items, more specifically it cannot support more items than what can fill a chest full of shulkerboxes.CreditsThis package was created withCookiecutterand theappcreatorguy/cookiecutter-pythonpackageproject template.History0.1.0 (2021-10-01)First release.
Package: litemongo
LiteMongoAboutLiteMongo provides a drop-in replacement forpymongowithout the need for a MongoDB server.
The database is stored on disk, making this an ideal tool for projects that require small MongoDB databases without wanting to go to the effort of installing the official server.
This is all made possible by building on top of the wonderfulMongomocklibrary.DevelopmentTestsSimply runpytest. For more detailed output, including test coverage:pytest-vv--cov=.--cov-reportterm-missingContributingIf you would like to contribute to the project:if you're making code contributions, please try and write some tests to accompany your code, and ensure that the tests pass.commit your changes viacz commit. Follow the prompts. When you're done,pre-commitwill be invoked to ensure that your contributions and commits follow defined conventions. Seepre-commit-config.yamlfor more details.your commit messages should follow the conventions describedhere. Write your commit message in the imperative: "Fix bug" and not "Fixed bug" or "Fixes bug." This convention matches up with commit messages generated by commands likegit mergeandgit revert.
Once you are done, please send amerge request.
Package: litenai
Liten AI Python LibraryLiten AI provides intelligent data analytics. It provides simple interface to intelligently query and analyze data. Liten API calls are exposed as python functions. It also provides a data chat app that can inspect and debug your data.InstallationLiten package is delivered using compiled files. To use the package do the following.pipinstall--upgradelitenaiPlease set LITEN_CONFIG_FILE variable to point to a valid yaml config file. Sample yaml is provided in scripts dir.DependenciesAll dependencies are installed with liten pacakge install. Liten uses python versions > 3.10UsageFirst create a new session using Session.get_or_create API. This will create a new session if it does not exist. It will return the session object. This session object can be used to call various API functions.
Liten API calls areask - These are directly used by GenAI model for answers.send - Prompt sent is first parsed by master-agent, who then orchestrates Liten agents to complete the prompt.Liten also provides a chat interface. This can be used within a python notebook or as a standalone application. To use it within a notebook use the following call.chatbot=Chatbot()chatbot.start()To start a standalone chatbot use the following command.litenchat.shUse the server IP address provided by the chatbot to connect to it from a browser.
Package: litepipeline-helper
LitePipeline HelperA distributed pipeline system, based on Python3, tornado, venv-pack, pyinstaller.All code based on Python3, do not use Python2!It still under development, so, maybe have some bugs or not stable enough!See more details athttps://github.com/fiefdx/LitePipelineInstall# install from pip$pip3install-Ulitepipeline_helper# or install from source code$cd./litepipeline_helper
$python3./setup.pyinstall
Package: lite-py
LitePyAn object relational mapper (ORM) project inspired by Laravel's Eloquent, built for Python.Tests:This is an ongoing project to develop a better, pythonic, model-based system for database manipulation,heavilyinspired by Laravel's ORM, Eloquent.The goal is to abstract away the necessity of writing SQL queries and maintaining complex relationships between tables. You can instead define readable model classes that represent tables, declare relationships between these models, and manipulate data in way that complements Python syntax.Database SupportLitePy currently supports SQLite (hence the name).Why use LitePy? A quick example.Consider a rudimentary system that maintains a database of authors and books for a library. An author may have written one book, multiple books, or none at all. We would like to be able to relate each book with an author. That way, we can ask the system for all books written by an author or for the author of a given book. Nice and simple, right?The database for this system consists of the following two tables:authors
   - id
   - name

books
   - id
   - name
   - author_idPython offers excellent support of SQLite out of the box, but you'll still need to get your hands dirty with some SQL queries.LitePy abstracts all that away.First, we'll define two models to represent the two tables above. These classes inherit fromLiteModel, which will later be explored in detail. They each represent a single object, or row, in their respective tables:classAuthor(LiteModel):defbooks(self)->LiteCollection:returnthis.has_many(Book)classBook(LiteModel):defauthor(self)->LiteModel:returnthis.belongs_to(Author)...And that's it. Literally.Now, we can operate on our data in a beautifully abstract way:# Create a new author in the databasejane=Author.create({'name':'Jane Doe'})# Create a new book in the databasemoneyBook=Book.create({'name':'Make Money Fast!'})# "Attach" this book to the authorjane.attach(moneyBook)moneyBook.author()# Returns the author!jane.books()# Returns a list of her books!There are a host of methods provided by LitePy for manipulating the models we've created. Methods for updating, creating, deleting, relating, and even path finding!Of course, most use cases are orders of magnitude more complex than this example. LitePy supports all common database relationship types (has_one, has_many, belongs_to, belongs_to_many), relationships that span multiple databases, nonstandard table names, and more.If this example piqued your interest, continue on for all the gritty details.InstallationTo build from source, clone this repository and install a live, development version with pip:pip3 install -e [litepy_repo_directory]Run Testscoverage run --omit="*/tests/*" -m pytest testscoverage report --show-missingDocumentationDocumentation is hosted on GitHub, right over here.
Package: litequeue
litequeueQueue implemented on top of SQLiteWhy?You can use this to implement a persistent queue. It also has extra timing
metrics for the messages/tasks, and the api to set a message asdonelets
you specifiy themessage_idto be set as done.Since it's all based on SQLite / SQL, it is easily extendable.Messages are always passed as strings, so you can use json data as messages.
Messages are interpreted as tasks, so after youpopa message, you need to
mark it as done when you finish processing it. When you run the.prune()method, it will remove all the finished tasks from the database.Installationpip install litequeueQuickstartfromlitequeueimportLiteQueueq=LiteQueue(":memory:")q.put("hello")q.put("world")# Message object used by LiteQueue# Message(data='world', message_id=UUID('063e95f1-3d9f-7547-8000-c3eb531fff93'), status=<MessageStatus.READY: 0>, in_time=1676238611851409010, lock_time=None, done_time=None)task=q.pop()print(task)# Message(data='hello', message_id='063e95f1-3d9e-7bbc-8000-a6a18a5f65d1', status=1, in_time=1676238611851279408, lock_time=1676238623180543854, done_time=None)q.done(task.message_id)q.get(task.message_id)# Message(#     data='hello',#     message_id='063e95f1-3d9e-7bbc-8000-a6a18a5f65d1',#     status=2,                <---- status is now 2 (DONE)#     in_time=1676238611851279408,#     lock_time=1676238623180543854,#     done_time=1676238641276753673# )Check outthe docs pagefor more.Differences with a normal Pythonqueue.QueuePersistenceDifferent API to set tasks as done (you tell it whichmessage_idto set as done)Timing metrics. As long as tasks are still in the queue or not pruned, you can see how long they have been there or how long they took to finish.Easy to extend using SQLExamples and bechmarks and bechmarksYou can have a look at thetest.pyfile. The tests are short and showcase
different usage scenarios.Thebenchmark.ipynbfile contains some benchmarks comparinglitequeueto
the built-in Pythonqueue.Queue.MetaRicardo Ander-Egg Aguilar –@ricardoanderegg–ricardoanderegg.comgithub.com/polyrandDistributed under the MIT license. SeeLICENSEfor more information.Important changesIn version 0.6:The database schema has changed and the columnmessageis nowdata.Time is still measured as an integer, but now it's using nanoseconds.Messages are represented as a frozen dataclass, not as a dictionary.Message IDs are uuidv7 strings.In version 0.4 the database schema has changed and the columntask_idis nowmessage_id.ContributingThe only hard rules for the project are:No extra dependencies allowedNo extra files, everything must be insidelitequeue.pyfile.Tests must be inside thetest.pyfile.
Package: liter
literTool for automating basic python packages task.InstallationpipinstallliterFeaturesChangelog autogeneration based on git history.Changing project version recursivelyHow to useGenerating changelogsIt will separate the project versions according to the version tags added on git.To generate a basicCHANGELOG.mdfile type:literchangelogIf you want the changelog to start at a specific version type:literchangelog--start-in[VERSION]Example:literchangelog--start-in0.2.0Changing versionChanging version withliterwill find all the files in your project recursively where your current package version is written. For each line in every file where a version match is found you can choose if modify the line or not.To change project version type:literversionWhich is the same as:literversionpatchTo upgrade another version number type:literversionminoror:literversionmajorWheremajor,minorandpatchrefers to the 1st, 2nd and 3rd version numbers respectively. (SeeSemantic Versioningfor mor information).Liter config fileWhen runing any command inliteraliterconfig.jsonfile will be created with some default configuraions. You can customize this parameters as you want.Config parametersversionThis is your current package version. By defaultliterwill look for asetup.pyor apyproject.tomlto find your current version. If you do not have any of this file you must change theversionparameter inliterconfig.jsonto your current package version.version_ignoreList of patters to ignore when searching a version match in files.changelog_sectionsSections that will be included in changelog file. Each key, value pair represents the section names and a list ofkey wordsrespectively. A commit will be added to a section if the first word of the commit is any of the sections definedkey word.changelog_include_othersWheter to include or not theOtherssection in changelogs. TheOthersections contains all the commits that did not match with any of thekey wordsadded in any section ofchangelog_sections.changelog_ignore_commitsAll the commits that match with any of thesekey wordswill not be included in the changelog file.changelog_only_path_patternOnly include commits that affected files which path contains any of the patterns specified.
Package: literary
LiteraryTL;DRLiterary is a Python tool to make Jupyter (IPython) notebooks behave like pure-Python packages. This allows pure-Python packages to be generated from notebooks, and notebooks to be imported at runtime. Literary nowbootstraps itself; it is developed with Literary 🤯.This package is an exploration of theliterate programmingideapioneered by
Donald
Knuthand implemented in thenbdevpackage. Althoughnbdevlooks to be a very
mature and comprehensive tool, it resembles a significant departure from conventional package development. Literary is an
exploration of what a smallernbdevmight look like.Philosophy 📖Low mental overheadRealistically, most Python programmers that wish to write packages need to have some
familiarity with the Python package development model, including the conventional
structure of a package. For this reason, I feel that it is important to designliterarysuch that these skills translate directly to designing libraries with
notebooksMinimal downstream impactUsers ofliterarypackages should not realise that they are consuming
notebook-generated code at runtime. This means that a pure-Python package needs to
be generated from the notebooks, and it must use the conventional import model. For
this reason,literaryshould only exist as a development dependency of
the package.
Package: literary-build-hatch
literary-build-hatchA hatch plugin to build wheels from Literary projects.Examplepyproject.toml:# Include the generated lib contents in the package root[tool.hatch.build.targets.wheel.force-include]"lib"="/"# Exclude lib if it isn't ignored by VCS[tool.hatch.build]exclude=["lib"]# Ensure src is available to editable installs[tool.hatch.build.targets.wheel]dev-mode-dirs=["src"]# Use Literary build hook[tool.hatch.build.targets.wheel.hooks.literary]dependencies=["literary-build-hatch>=0.2.0"]# Specify Hatch build-system[build-system]requires=["hatchling"]build-backend="hatchling.build"This hook supports editable installs, sopdm installjust works out of the box!
Package: literate-dataclasses
This is a work-in-progress library to add documentation functionality todataclassesintroduced in Python 3.7.
The library can be used as a drop-in replacement for the standarddataclassesand can be installed fromPyPI.$pipinstallliterate_dataclassesLiterate dataclasses modify their own class docstrings and add attribute docs in [Google code style](https://google.github.io/styleguide/pyguide.html)
with the goal of removing redundant code. The docs can be written as follows:fromliterate_dataclassesimportdataclass,field@dataclass(test_arg="hello")classTest:"""My dataclass

    Some comment.

    Args:
        See dataclass signature.
    """x:int=field(default=42,doc=\"""Some value x.""")y:int=field(default=72,doc=\"""Some value x.""")name:int=field(default='foo',doc=\"""The object name.""",)test=Test(x=5,y=3)help(Test)which will generate the outputHelp on class Test in module __main__:

class Test(builtins.object)
|  Test(x: int = 42, y: int = 72, name: int = 'foo') -> None
|
|  My dataclass
|
|  Some comment.
|
|  Args:
|      x: Some value x.
|      y: Some value x.
|      name: The object name.
Package: literature-to-facts
# literature-to-facts<a rel=”license” href=”http://creativecommons.org/licenses/by/4.0/”><img alt=”Creative Commons License” style=”border-width:0” src=”https://i.creativecommons.org/l/by/4.0/80x15.png” /></a><br />This work is licensed under a <a rel=”license” href=”http://creativecommons.org/licenses/by/4.0/”>Creative Commons Attribution 4.0 International License</a>.
Package: litereval
literevalliterevalis wrapper aroundast.literal_evalwith new additional{foo='bar', key=None}dictsyntax.
Plus some helper tools to deep merge dictionaries, parseast.literal_evalpython data to*argsand**kwargs.Can be used to create wrapper command line interfaces. Seepyppdf.InstallNeeds python 3.6+condainstall-cdefaults-cconda-forgeliterevalorpipinstallliterevalAPIliterevaldeflitereval(string:str):"""Small extension of ``ast.literal_eval`` that alsoaccepts dict in a form of ``{key=100, foo='bar'}``Returns-------ret :ast.literal_eval(preprocess(string))"""mergedefmerge(source:dict,destination:dict,copy:bool=False)->dict:"""Deep merge two dictionaries.Overwrites in case of conflicts.From https://stackoverflow.com/a/20666342"""args_kwargsdefargs_kwargs(args:Any)->Tuple[Union[tuple,None],Union[dict,None]]:"""Parses ``args`` object to ``(*args, **kwargs)`` tuple.Special case when ``args`` is ``None``: returns ``(None, None)``.Otherwise tries to put not iterable object to tuple:``args`` to ``(args,)``. Examples:* ``(1, 2)`` to ``(1, 2), {}``* ``"foo"`` to ``("foo",), {}``* ``{(): ('a', 0), 'foo': None} to``('a', 0), {'foo': None}``Returns-------ret :tuple: *args, **kwargs"""get_argsdefget_args(name:str,args,default=None)->Args:"""Gets ``*args`` and ``**kwargs`` for a ``name`` functionfrom an ``args`` dict. Wrapper around ``args_kwargs`` function.Returns ``NamedTuple`` ``Args``: ``(args: tuple, kwargs: dict)``"""getdefget(key:str,dic,default=None):"""Gets key even from not a dictionary."""tuple_deftuple_(obj:Any)->tuple:"""Converts any object to tuple. ``string`` to ``(string,)``."""validateddefvalidated(args:tuple,kwargs:dict)->Tuple[tuple,dict]:"""Validates inputs and returns ``*args, **kwargs``."""
Package: literotica-dl
literotica_dlA tool to download stories from Literotica.InstallationI highly recommend you use pipxpipxinstallliterotica_dlotherwise you can use pippipxinstallliterotica_dlPyPI:https://github.com/fuzzyfiend/literotica_dlDetailsYou must specify whether to download stories (-s) or author works (-a).Stories are identified as the url stub following the /s/ directory in the urlhttps://www.literotica.com/s/a-my-name-is-alicestory flag is a-my-name-is-aliceAuthors are identified as the memberuidhttps://www.literotica.com/stories/memberpage.php?uid=36374author flag is 36374This program will attempt to resolve the author uid or story id for you.
By default this program will write stories to a new folder called output. This can be overridden by specifying the -o flag.Examples# Downloading an authors works via the author stubliterotica_dl-a36374# Downloading an authors works via member urlliterotica_dl-a"https://www.literotica.com/stories/memberpage.php?uid=36374"# Downloading an story via the story stubliterotica_dl-sa-my-name-is-alice# Downloading an story via the story stubliterotica_dl-s"https://www.literotica.com/s/a-my-name-is-alice"# Mirroring the author to a specific directoryliterotica_dl-a"https://www.literotica.com/stories/memberpage.php?uid=36374"-o"archive"CreditsThis package was created withCookiecutterand thefuzzyfiend/pythoncookieproject template.
Package: liteshort
liteshortliteshort is a link shortener designed with lightweightness, user and sysadmin-friendliness, privacy, and configurability in mind.Clickherefor a live demo(Unfortunately, I had to restrict creation of shortlinks due to malicious use by bad actors, but you can still see the interface.)Why liteshort over other URL shorteners?liteshort is designed with the main goal of being lightweight. It does away with all the frills of other link shorteners and allows the best of the basics at a small resource price. liteshort uses under 20 MB of memory idle, per worker. liteshort has an easy-to-use API and web interface. liteshort doesn't store any more information than necessary: just the long and short URLs. It does not log the date of creation, the remote IP, or any other information.liteshort focuses on being configurable. There are over 15 config options and most updates will add more. Configuration is done through the easy-to-use YAML format.InstallationLiteshort's installation process is dead-simple. Check out theinstallation pagefor info on how to install.
Package: litesimple
litesimple==========Litesimple is a simple ORM micro-library for sqlite3. It offers mappingbetween attributes (or fields as it's named here) to table columns withconversion support from different formats, querying, saving and other simpletask.Installation and dependencies-----------------------------To install litesimple, either run ``pip install litesimple`` or download [litesimple.py](https://github.com/TheThing/litesimple) directly in your browser or with wget.Litesimple has no dependancy requirements other than is included in the Python Standard Library.Example-------First create your models:``` pythonfrom litesimple import Model, FieldInteger, FieldText, FieldDateTimeclass car(Model):id = FieldInteger(is_key=True)text = FieldText()time_created = FieldDateTime(auto_now_add=True)time_updated = FieldDateTime(auto_now=True)def __str__(self):return "car (%s)" % self.make```Then play with it:``` python>>> from models import car>>> car(make="Opel").save()>>> car(make="Hyundai").save()>>> car(make="BMW").save()>>> print car.get(1)car (Opel)>>> for x in car.filter(): print xqueue (Opel)queue (Hyundai)queue (BMW)>>> c = car.get(2)>>> print ccar (Hyundai)>>> c = car.get(id=2)>>> print ccar (Hyundai)>>> c.delete()>>> for x in car.filter(): print xcar (Opel)car (BMW)>>> car.delete(make="Opel")>>> for x in car.filter(): print xcar (BMW)```