Saravanan666/pypi-org huggingface dataset:
Package: rusty
Rusty is a collection of extensions (directives and roles)
forSphinx documentation framework. While
the extensions are somewhat compatible withdocutils,
the usage ofSphinx is currently required.ContentsFeaturesexceltablerolelistincludeshregxlistxmltableInstallationDocumentationChangelogRelease 0.3.1 (2009-08-08)Release 0.3.0 (2009-07-07)Release 0.2.2 (2009-06-18)Release 0.2.1 (2009-06-16)Release 0.2.0 (2009-06-01)Release 0.1.0 (2009-03-31)FeaturesAt the moment, the Rusty contains the extensions listed beneath. Ideas for new
extension can been suggested inBitBucketexceltableInclude data from excelsheets into documentation.rolelistGenerates list from the selected set of role entires, written into document.includeshInclude shell scripts into documentation: comments as documentation and
commands as literal blocks.regxlistSimilar to rolelist directive. The main difference is the
capability to create list based on regular expression rule.xmltableSimilar functionality to csv-table - one of the docutils directives: read data
from XML/HTML file and convert it to RST-table based on given query and iterator.
Requires BeautifulSoup -module.InstallationThe easiest way to install the package is to use easy_install:easy_install -U rustyAlternative method is to download the package manually, extract it and
install it using traditional methods:sudo python setup.py installDocumentationDocumentation provides further information and examples how to use the module.
There exists two resources:Official documentationNightly build from trunkChangelogRelease 0.3.1 (2009-08-08)Changes since 0.3.0 release:Fixed issue: exceltable selector does not work with numbers containing zeroRelease 0.3.0 (2009-07-07)Changes since 0.2.0 release:Added new directive: rusty.exceltable - for including the excelsheets data
into documentationImproved XMLTable documentationFixed issue: xmltable does not stop processing even if file or query is missingFixed issue #4: setup.py and paver-minilib.zip is missing from the packageRelease 0.2.2 (2009-06-18)Maintenance release, containing following changes:Fixed issue #4 again: paver-minilib.zip is missing from the packageRelease 0.2.1 (2009-06-16)Maintenance release, containing following changes:Fixed issue #4: setup.py is missing from the packageRelease 0.2.0 (2009-06-01)Changes since previous release:New directive: xmltableNew directive: regxlistImproved unit testingImproved buildingMigrated version control from subversion to mercurialPublished the project in Bitbucket:http://bitbucket.org/jmu/rustyAdded FAQRelease 0.1.0 (2009-03-31)First release, containing following functionalityNew directive: includeshNew directive: rolelistInitial set of unit tests (see testing)Paver powered build and release management
Package: rusty-axe-bbrener1
Rusty AxeAnalyzing nested structure in data using unsupervised random forests.This package is intended to interface with one or two numpy matrices of a large size (>100 samples, >10 features), and decomposes said matrices into random forest factors (RFFs) that describe different effects at different levels of nesting and non-linear dependency. It generates HTML reports that describe the underlying data, and can also generate other kinds of feedback. This package additionally can train on one dataset and compare that dataset to another.This package is currently intended to be run on linux or osx. This package may funciton on windows but no guarantees are made.This tool is very much a work in progress, please send feedback, positive or negative, tobbrener1@jhu.eduor by opening an issue here! I want to hear how to make this tool more useable and intuitive, and also which parts are helpful.PubllicationA more complete description of this approach to understanding data is available in the form of a publication:https://www.biorxiv.org/content/10.1101/2021.09.13.460168v1Install by invokingpip install rusty_axe_bbrener1TutorialA tutorial is available within this repo in the form of an ipython notebook.Please consult this tutorial or any of the notebooks used to generate the figures of the accompanying paper.Building From SourceOptionally, you may wish to build this package from source (although installing via pypi is probably preferred) In order to build this package from source you will need the rust compiler. It is easily obtainedObtaining RustA rust compiler can be obtained and silently installed by executingcurl https://sh.rustup.rs -sSf | sh -s -- -yIf you wish to alter any aspect of the rust compiler defaults, you can executecurl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shor simply check the current recommendations athttps://www.rust-lang.org/tools/installBuilding the package and inserting it into the python pathAfter you've obtained the rust compiler I recommend you build usingpython -m buildin a cloned repo and then install viapip install dist/<tarball>
Package: rustybits
ImportantThis package is still in the planning/pre-alpha phase.OverviewTheRustyBitsapplication helps you archive files.Specifically, with files that you don’t really need anymore, that you
probably should just delete, but you don’t want to because… “what
if”. But organizing archived files is time consuming.So instead, just move them into a RustyBits folder, it will prompt for
some keywords and automatically add some metadata, and you can forget
about them. Until you need them.InstallationTL;DR:apt install python3-wxgtk4.0 libfuse-dev
pip install rustybitsUsageTL;DR:rustybits mount ~/.var/lib/rustybits ~/Desktop/RustyBits
Package: rusty-capacitance-model-core
Rusty Capacitance Model CoreQuantum Dot Constant Capacitance Simulatoris a high-performance Python package that leverages the power of Rust and Rayon to provide a fully parallelised and optimised simulation environment for quantum dots with constant capacitance.This package provides core functionality; it is not intended that the user will interact with it directly.FeaturesUltra-fast Simulation:Harnesses the speed of Rust and the parallelism of Rayon to deliver lightning-fast simulations.Constant Capacitance:Specialized for simulating quantum dots with constant capacitance, allowing precise modelling of charge dynamics.User-Friendly:Designed with ease of use in mind, making it accessible to both experts and newcomers in quantum dot simulations.Extensive Documentation:Comprehensive documentation and examples to help you get started quickly.InstallationInstall Quantum Dot Constant Capacitance Simulator using pip:pipinstallrusty-capacitance-model-coreUsageThis package exposes two functions to be called from python:ground_state_open- computes the lowest energy state of a quantum dot array with constant capacitance and which is open, such that the total number of changes is not fixed.ground_state_closed- computes the lowest energy state of a quantum dot array with constant capacitance and which is closed, such that the total number of changes is fixed.The python code to call these functions is as follows:fromrusty_capacitance_model_coreimport(ground_state_open,ground_state_closed)importnumpyasnp# the dot-dot capacitance matrixcdd=np.array([[1,-0.1],[-0.1,1]])cdd_inv=np.linalg.inv(cdd)# the dot-gate capacitance matrixcgd=np.array([[1,0.3],[0.3,1]])# define a matrix of gate voltages to sweep over the first gatevg=np.stack([np.linspace(-1,1,100),np.zeros(100)],axis=-1)n_charge=3# the number of changes to confine in the quantum dot array for the closed casethreshold=1# threshold to avoid having to consider all possible charge states, setting it 1 is always correct, however has a computatinal cost.n_open=ground_state_open(vg,cgd,cdd_inv,threshold)n_closed=ground_state_closed(vg,n_charge,cgd,cdd,cdd_inv,threshold)It is not intended the user ever call these functions directly.There is a pure Python wrapper that provides a more user-friendly interface to this core functionality.
SeeQuantum Dot Constant Capacitance Simulator. This package provides:A user-friendly interfaceto the core functionality.Plotting, charge sensing, virtual gateand gate voltage sweeping (1d and 2d) functionality.Advanced type checkingusing pydantic.Automated testingincluding for the functionality in this package.More examples.
Package: rustyfim
rustyfim enables you to run frequent itemset mining algorithm (bothFPGrowththat mines frequent itemset, andDCIalgorithm that mines closed item sets) in PythonSetuppipinstallmaturin
maturindevelopRunning FIM in pythonfromrustyfimimportfpgrowth,dcires=fpgrowth(min_support=0.3,transactions=[[1,2,3],[2,3,4],[3,4,10],[3,4,20]])# in dci algorithm, n_features is required for creating the bitmatrix in the first placeres=dci(min_support=0.3,transactions=[[1,2,3],[2,3,4],[3,4,10],[3,4,20]],n_features=21)Result:First pass took 0 ms, num_transactions=4.
Total runtime: 1 ms
[([3], 4), ([3, 4], 3), ([4], 3)]Build wheelmaturinbuildLint the projectcargo clippy
Package: rusty-img-utils
Rusty Image UtilsPort of some slow functions from Python to a Rust library with Python bindings,
mainly to experiment withrust-cpythonPublished asrusty-img-utilson pypi for Python 3.5, 3.6 and 3.7 on linux and
macosFunctionsdarken_pixelsDarkens all pixels in the image by percentage, specified byamount. Any pixel
that doesn't have a subpixel below than thecutoffwill be ignored.importimg_utilsimg_utils.darken_pixels(src_path="in_file.jpg",dst_path="out_file.jpg",amount=80,cutoff=200,)will take thein_file.jpgand lower each subpixel of the image by 80%, unless
all the subpixels are above 200.The RGB pixel100, 220, 220will be turned into20, 44, 44while210, 220, 230will be left alone.extract_bluesSelects all pixels that have the blue pixel above a certain limit and either
green or red the minimum difference blow the blue pixel. The selected pixels
will be output as completely black while any other pixel is output as white.importimg_utilsimg_utils.extract_blues(src_path="in_file.jpg",dst_path="out_file.jpg",min_diff=30,min_blue=100,)will take thein_file.jpgand any pixel that has the blue pixel 100 or higher
and either red or green pixel at 70 or lower (100 - 30) will be black, all
others will be white.Performance comparisonTesting with 100x100 and 1000x1000 random noise images on a 2018 MBPdarken_pixels*** Testing small size
Python_Darken: 12.14 ms avg (412 runs)
Rust_Darken: 1.15 ms avg (4357 runs)

Rust is 10.58x faster for small size

*** Testing normal size
Python_Darken: 1103.74 ms avg (5 runs)
Rust_Darken: 46.41 ms avg (108 runs)

Rust is 23.78x faster for normal sizeextract_blues*** Testing small size
Python_Extract: 4.94 ms avg (1012 runs)
Rust_Extract: 1.17 ms avg (4282 runs)

Rust is 4.23x faster for small size

*** Testing normal size
Python_Extract: 392.25 ms avg (13 runs)
Rust_Extract: 47.71 ms avg (105 runs)

Rust is 8.22x faster for normal size
Package: rustylib
Rustylib or RustyRusty aka rustylib is a useful python library containing tools such as HTTP requests, mathematics, and more.RcolorRmathRrequestsRsugakuRustyRkonChangelogRusty has now the swap(list, item, item2) function, read documentation.Rusty has now the enum function, works as same as the enumerate function.Full Documentation here :https://github.com/ZeyaTsu/rustylib/wiki/Welcome-to-rustylibRkon Parser documentation here :https://github.com/ZeyaTsu/rustylib/wiki/Using:-Kon-(Parser)About rustylib's history and motivationRustylib (rusty) was first made as a fun project, to spend time etc...Indeed, at first I've just wanted to remake some built-in functions from scratch (random, requests, etc...)but more time passed, the more I wanted to add my own extensions to it.For now, I still have some ideas and extensions I want to add so let's go ! :)
Package: rustyms
Python bindings to rustymsPython bindings to therustymslibrary for proteomics
and mass spectrometry.Full documentationThe full documentation, including a quickstart guide and Python API reference is available onrustyms.readthedocs.io.Contributing and developmentSeeCONTRIBUTING.mdfor information on the development setup and how to contribute to the rustyms
Python bindings.
Package: rustypy
RustyPy is a code generator for generating binding functions between
Rust and Python files. In addition it provides a series of types for
interfacing from Python with Rust, with automatic type conversion
handling for primitives and other basic types (like vectors, hash maps
and tuples) and an API for working with those (both from Rust and
Python).FeaturesGenerate bindings in Rust targetting Python functions.Generate bindings in Python targetting Rust functions.Provides types for interfacing between Rust and Python.InstallationTo install RustyPy just use pip:pip install rustypyRustyPy requires Python 3.5 or more and works with Rust stable.To target Python from Rust the packagecpythonis required to
initialize the package.DocumentationPython in
RustRust in
PythonType
conversionsUsageRustyPy includes a command line interface to generate the code, which
you can embeed in your build chain if it’s necessary.Generate Python bindings in RustYou can execute the script writing:$rustypy -hor$python -m rustypy -hmake sure that rustypy is in your current Python path. The help command
has all the information to generate bindings succesfully.It also includes functions to generate bindings dynamically. In Python
use:from rustypy.pywrapper import bind_py_pckg_funcs
# default prefix is "rust_bind_"
optional = ["my_bind_prefix_", "other_prefix_"]
bind_py_pckg_funcs(prefixes=optional)This function will generate the bindings for the package from which is
called from (so the package must be initiated placing an __init__.py
file in one of the parents folders).More info:Python in
RustGenerate Rust bindings in PythonDue to the nature of Python this is done dynamically, so no files are
generated and the bindings are wrapped appropriately with their own
callables from Python.from rustypy.rswrapper import bind_rs_crate_funcs

source_path = "/home/user/workspace/rs_test_lib"
compiled_lib = "/home/user/workspace/rs_test_lib/target/debug/libtest_lib.so"

# default prefix is "python_bind_"
optional = ["my_bind_prefix_", "other_prefix_"]
lib_binds = bind_rs_crate_funcs(source_path, compiled_lib, prefixes=optional)

lib_binds.my_bind_prefix__ffi_function("Hello from Python!")There is no concept of ‘module’ in C (which is the language used for
interfacing) so the functions cannot be namedspaced as you would in pure
Rust. Read about Rust FFI inthe
book.More info:Rust in
Python.Rust cratedocumentation.
Package: rusty-results
Rusty resultsRusty results is a Python library for dealing with result and optional types inspired by rust standard library.Pattern matching ready!It exposes two main types with two constructors each one.ResultResult[T, E]is the type used for returning and propagating errors. It is based in the variants,Ok(T), representing
success and containing a value, andErr(E), representing error and containing an error value.OptionOption[T]represents an optional value: everyOptionis eitherSome(T)that contains a value, orEmpty()that does not.
Option types have a number of uses:Initial valuesReturn values for functions that are not defined over the entire input range (partial function)Return value for otherwise reporting simple errors, where Empty is returned on error.Optional struct fieldsOptional function argumentsInstallationUse the package managerpipto install rusty results.pipinstallrusty_resultsUsagefromrusty_resultsimportOption,Some,Empty,Result,Ok,Err,UnwrapExceptionExamples"""Example on pattern matching handling of Result"""fromrusty_resultsimportResult,Ok,Errdefdivide(a:int,b:int)->Result[int,str]:ifb==0:returnErr("Cannot divide by zero")returnOk(a//b)if__name__=="__main__":values=[(10,0),(10,5)]fora,binvalues:divide_result=divide(a,b)matchdivide_result:caseOk(value):print(f"{a}//{b}=={value}")caseErr(e):print(e)You can find more examples in the/examplesfolder.PydanticOption and Result are fully compatible withpydanticmodelsimportpydanticfromrusty_resultsimportOption,Some,EmptyclassMyData(pydantic.BaseModel):name:Option[str]phone:Option[int]if__name__=="__main__":importjson# serialize to jsonjson_data=MyData(name=Some("Link"),phone=Empty()).json()print(json_data)# deserialize json datadata=MyData(**json.loads(json_data))print(data)prints out:{"name":{"Some":"Link"},"phone":{}}name=Some(Some='Link')phone=Empty()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: rusty-rlp
Rusty-RLPRapid fast RLP serialization / deserialization for Python.As the name suggest,rusty-rlpis written in Rust and based on the battle-tested, MIT-licensedrlpimplementation that is also used byOpenEthereum.Usagefromrusty_rlpimportdecode_raw,encode_rawencoded=encode_raw(b'some_string')decoded=decode_raw(encoded)Running the testsThe library exposes a pure Python API and all tests are implemented inpython_tests.pyRun the tests:make testNote:There do exists some tests implemented in Rust that can be run withcargo testsbut those do not testthislibrary but the underlyingrlplibrary instead. They exist merely to prove some assumptions about the underlying library.BenchmarksWe provide some benchmarks againstpyrlp.Encoding (msec/loop)Decoding (msec/loop)PyRLP0.0160.014rusty-rlp0.00173 (~9x)0.00595 (~2.35x)Running the benchmarksmake benchmark
Package: rusyll
rusyllPython 3 package for dividing Russian words into phonetic syllables.AboutThis package provides algorithmic phonetic syllable division for Russian language, similar tonltk SyllableTokenizer, but adding some language-specific rules.In fact, there are no unified rules for breaking words into syllables in Russian. Therefore I've selected the most applicable rule set developed by R. I. Avanesov, professor of MSU, in 50s. In short it's based on the sonority index of the letters.This package can be useful for various Natural Language applications. However, it is not suitable for hyphenation.Installationpip install rusyllHow to use>>>fromrusyllimportrusyll>>>rusyll.token_to_syllables("черепаха")['че','ре','па','ха']>>>rusyll.word_to_syllables("черепаха-гофер")['че','ре','па','ха','го','фер']>>>rusyll.word_to_syllables_wd("черепаха-гофер")['че','ре','па','ха','-','го','фер']>>>rusyll.word_to_syllables_safe("черепаха гофер")>>>Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/home/toor_2/wonder/Python/rusyll/src/rusyll/rusyll.py",line125,inword_to_syllables_safeassertbool(AssertionError:Wordcontainsunsuitablesymbols>>>rusyll.word_to_syllables_safe("черепаха-гофер")['че','ре','па','ха','го','фер']>>>help(rusyll)#...complete description of functionsFeedbackThis is my first attempt to make proper package for PyPI, so any feedback is highly appreciated!
Package: rut-chile
rut-chilePython module that provides common functionality regarding Chilean RUTInstallationpip install rut_chileorgit clone https://github.com/gevalenz/rut-chile.git

python setup.py installUsageValidate RUTfrom rut_chile import rut_chile

rut_chile.is_valid_rut("12345678-9")
# returns False
rut_chile.is_valid_rut("6265837-1")
# returns True


# It works with the following formats

rut_chile.is_valid_rut("98685030")
# returns True
rut_chile.is_valid_rut("9868503-0")
# returns True
rut_chile.is_valid_rut("9.868.503-0")
# returns True
rut_chile.is_valid_rut("12.667.869-K")
# returns True
rut_chile.is_valid_rut("12.667.869-k")
# returns TrueGet verification digitfrom rut_chile import rut_chile

rut_chile.get_verification_digit("9868503")
# returns "0"
rut_chile.get_verification_digit("12667869")
# returns "k"
rut_chile.get_capitalized_verification_digit("12667869")
# returns "K"Format RUTfrom rut_chile import rut_chile

rut_chile.format_rut_with_dots("12667869k")
# returns "12.667.869-k"
rut_chile.format_rut_without_dots("12667869k")
# returns "12667869-k"
rut_chile.format_capitalized_rut_without_dots("12667869k")
# returns "12667869-K"
rut_chile.format_capitalized_rut_with_dots("12667869k")
# returns "12.667.869-K"
Package: ruten-crawler
Ruten Seller Product ParserThis is a repository that offers a ProductCrawler class to crawl Ruten web pages for the product information in json format.from ruten_crawler import ProductCrawler
product_crawler = ProductCrawler(seller_id = "hambergurs")
results = product_crawler.get_crawl_result()InstallationTo installthis verson from PyPI, type:pip install rutencrawlerTo get the newest one from this repo (note that we are in the alpha stage, so there may be frequent updates), type:pip install git+git://github.com/jn8029/ruten_crawler.gitOverviewclass ProductCrawlerclass handles the whole web crawling logic.  It takes optional arguments ofsleep_timeandsleep_at_each_iterationclass ProductPageParserhandles the product page information extraction. Currently the parser only extracts shipping information, urls for images and the title of the product. More info can be extracted and the logic can be added here.class ProdcutListParserhandles the parsing of product list page. The main function is to extract a list of product urls at each page, and then the urls are then used to parse product information with ProductPageParserTo-doadd more error-proof exception handlers in ProductCrawler due to the multi-threaded nature of the process.add more product info extraction features in ProductCrawler, e.g. price, remaining time, description, etc.
Package: ruterstop
ruterstopEt program som viser sanntidsinformasjon for stoppesteder i Oslo og deler av Viken.Lister 20 av de neste avgangeneBruk filtre som--direction,--groupedog--min-etaStart en HTTP server med--serverSøk etter stoppesteder med--search-stopSett når du ønsker å se klokkeslett med--long-etaBruk--helpfor full hjelpInnspill, tanker og feilmeldinger mottas med glede!InstallasjonTrenger Python >=3.6 for å kjøre.Installer fra PyPi$ pip install ruterstopBygg fra kildekodeLast ned kildekoden og installer programmet med avhengigheter fra kildekodemappen$ pip install poetry
$ poetry buildBrukerveiledningSøk etter stoppested$ ruterstop --search-stop stig
6013    Stig (Oslo, Oslo)
59445   Stige (Ålesund, Møre og Romsdal)
13479   Stigen (Ringebu, Innlandet)
18602   Stigen (Sandefjord, Vestfold og Telemark)
18605   Stiger (Sandefjord, Vestfold og Telemark)
21507   Stigen (Porsgrunn, Vestfold og Telemark)
3857    Stigen (Aurskog-Høland, Viken)
45978   Stigen (Nærøysund, Trøndelag)
54253   Stigen (Lyngen, Troms og Finnmark)
7844    Stigen (Trysil, Innlandet)Kjør programmet med et valgt stoppested$ ruterstop --stop-id 6013 --direction outbound
31 Snaroeya       naa
31 Fornebu     10 min
31 Snaroeya    20 min
25 Majorstuen  28 min
31 Fornebu     30 minEller start som en HTTP server$ ruterstop --serverStoppested og filtre velges i adressen til spørringen$ curl localhost:4000/6013?direction=outbound&long_eta=10
31 Fornebu        naa
31 Snaroeya     5 min
31 Fornebu      8 min
31 Fornebu     10 min
25 Majorstuen   20:21
31 Snaroeya     20:24
31 Snaroeya     20:36
25 Majorstuen   20:36
31 Fornebu      20:42UtviklingKjør tester$ poetry install
$ poetry run python -m unittestKjør multi-versjon tester i Docker$ make matrixSe Makefile for detaljerTag ny versjon$ ./.deploy/bump_version.pyVerktøyet hjelper til å huske å bytte versjonsnummer før tagging og sjekke
at man er på riktig branch.MotivasjonJeg vil se avganger fra mitt nærmeste stoppested mens jeg sitter ved
kjøkkenbordet, uten å måtte bruke mobilen.Dette prosjektet blir også utnyttet til å prøve ut alle ting om Python jeg
både kan og ikke kan.Jeg skrev dette programmet som en backend til en ESP8266-variant med en
OLED skjerm.
Fungerende klient-kode for en Adafruit Feather HUZZAH ESP8266 med en OLED
FeatherWing finnes ieksempel-mappen.Referanser og linkerSøk etter stoppesteder(Logg inn med guest:guest)EnTur JourneyPlanner docsEnTur JourneyPlanner IDE
Package: rutherford
Atom feed extension for Tinkerer.UsageAdd ‘rutherford’ to your list of extensions andblog_date='2013'rights="This work is licensed under a Creative Commons Attribution 3.0 United States License: http://creativecommons.org/licenses/by/3.0/us/"to your config. Then “tinker –build” and look for the feed.atom file in your
output directory.